Acceso visual a tareas de npm desde Visual Studio Code

18/05/2018
Artículo original

Creo que ya he dicho en más de una ocasión aquí lo mucho que me gusta Visual Studio Code y que, con el tiempo, se ha convertido en mi editor principal (y casi único). Cada mes lanzan una nueva actualización que ya estoy esperando con ansia porque siempre viene con novedades interesantes. Algunas más grandes y otras más pequeñas, como es el caso de la que nos ocupa hoy.

En la última actualización, la 1.23 de Abril, hay muchos detalles interesantes, pero hay uno que me ha llamado especialmente la atención: la posibilidad de tener una lista en el lateral con todas las tareas definidas en el archivo package.json de Node.js (tareas de npm):

Como vemos, en el explorador de archivos aparece una nueva sección llamada "npm scripts" en la que se listan todas las tareas que tienes en el package.json y puedes abrirlas para verlas, ejecutarlas o incluso depurarlas usando el menú contextual de cada una de ellas.

Cuando manejas muchas de ellas y no las usas todas a menudo, es interesante porque te evita tener que abrir el archivo y ponerte a revisarlas. Y es muy cómodo tener esas acciones ahí para editarlas, lanzarlas o depurarlas.

Esta sección está desactivada por defecto. Para poder sacarle partido hay que habilitarla desde la configuración del entorno. En concreto buscando la opción npm.enableScriptExplorer, de la manera que muestro a continuación en este vídeo muy cortito:

¡Espero que te resulte útil!

¿Seré capaz de convertirme en un buen desarrollador si no programo en mi tiempo libre?

18/05/2018
Artículo original


Foto por Ian Schneider en Unsplash

No sé cómo será en otros países de habla-hispana, pero en España existe, por lo general, la costumbre (mala, en mi opinión) de hacer más horas en la oficina que las estipuladas por contrato. Casi nadie se va a su hora del trabajo, pues está mal visto en muchas empresas y por muchos jefes. Incluso en muchas empresas de programación se espera que estés sentando en tu ordenador aunque no estés programando, porque todo el mundo sabe que es imposible estar más de 8 horas efectivas escribiendo código de calidad.

Y en aquellas pocas empresas de programación donde sí existe la cultura de salir a la hora salvo emergencias o vísperas de plazos, hay trampa. ¿En qué consiste? Pues lo normal en estos casos es que exista cierta expectativa de que mejores por tu cuenta para convertirte en un gran programador. Para ello se te invita a participar en proyectos de código abierto, a modo formativo, o a programar en proyectos de desarrollo internos como en la creación de apps móviles para los miembros de la empresa. Todo en tu tiempo libre claro.

Esto no quiere decir que tengas que dedicarle TODO tu tiempo libre, pero sí tienes que hacerte a la idea de que algo de tiempo le vas a tener que dedicar, en ocasiones mucho más que otras. Y lo normal es que te apetezca, porque llegados a ese punto sentirás curiosidad por aprender ¿o no?

En otras palabras, si te gusta la programación, pero quieres tener un horario regular, predecible, y no le quieres dedicar tiempo fuera del lugar de trabajo, te puede surgir la siguiente duda: ¿seré capaz de convertirme en un buen desarrollador si no programo en mi tiempo libre?

Esta pregunta no tiene una respuesta única, pero detrás de la misma hay muchas más cosas implícitas que debes tener en cuenta a la hora de valorar la decisión de convertirte profesionalmente en desarrollador de software.

Vayamos por partes.

La mejoría no es lineal, es logarítmica

Al igual que nadie puede programar en el trabajo 8 horas seguidas con una productividad lineal, por muchas horas que le dediques a la programación, tu mejoría tenderá a tener un rendimiento decreciente y tu curva de mejora será logarítmica. La gestión del tiempo es una las cuestiones implícitas en la pregunta anterior.

Si eres capaz de gestionar bien tu tiempo como programador de software y trabajas 40 horas a la semana, tienes suficiente tiempo para hacer tu trabajo y dedicarle unas horas a la semana a aprender a hacer cosas nuevas relacionadas con el puesto o con otros puestos de la empresa, todo en horario laboral.

Si te organizas mal y siempre vas fatal con tus plazos de entrega, lógicamente tendrás que hacer cosas fuera del horario laboral para mejorar. Si este es tu caso, te recomiendo que antes inviertas esfuerzos en mejorar la forma en la que gestionas el tiempo, incluso con formación específica para lograrlo. Para ser un buen profesional en cualquier trabajo tienes que aprender a gestionar el tiempo. Por buen programador que seas, si no gestionas bien el tiempo, profesionalmente cotizarás a la baja.

Como decía un poco más arriba, si te organizas bien, no deberías tener problemas. Tomemos el ejemplo de un músico para ilustrar esta afirmación. Muchos pianistas o violinistas practican 8 horas diarias o más, pero es en las primeras 3 ó 4 horas donde se aprecia una mejora sustancial en relación con el ensayo anterior, siempre que el ensayo se haga con la máxima concentración y dedicación plena. A esta conclusión llegó el psicólogo e investigador Anders Ericsson en un estudio llevado a cabo en Alemania en 1993.

En el estudio sobre jóvenes violinistas, el investigador sobre rendimiento descubrió que todos los mejores practicaban de la misma manera: por la mañana, en tres sesiones de ensayo de no más de 90 minutos cada una, con un descanso entre cada una de ellas. Ericsson a posteriori encontró el mismo patrón entre otros músicos, atletas, jugadores de ajedrez y escritores.

Es posible que te preguntes por qué, entonces, los músicos profesionales ensayan 8 horas diarias. La respuesta es sencilla. Supongamos que en las primeras 4 horas mejoran un 0,5% con respecto al día anterior y que en las siguientes 4 horas mejoran un 0,01%. Ese 0,01% les sigue compensando pues como músicos su trabajo es mejorar cada día.

Pero a ti, como programador profesional que además tienes que llevar a cabo tus tareas en el lugar de trabajo, esas horas de más no te compensan. En ese tiempo es mejor hacer otras cosas para desconectar y cargar energías, aficiones, ejercicio, o simplemente descansar.

Ericsson se ha hecho muy popular recientemente por un estudio, al parecer polémico, que afirma que para llegar a ser un experto en cualquier cosa, tienes que dedicarle 10.000 horas. La famosa regla que establece que llegar a ser realmente competente en algo lleva unas 10.000 horas/10 años, también proviene de los estudios hechos por el mismo investigador.

Como todos sabemos, puedes tener 1 año de experiencia multiplicado por 10, pero estar calentando la silla todo ese tiempo no cuenta. Lo que sí cuenta es lo que Ericsson llama el ensayo deliberado, es decir, practicar y ensayar con intensidad, concentración y dedicación plena.

Él ha concluido que esta forma de ensayar también se aplica en atletismo, música, escritura, ajedrez, y matemáticas. Además, define la práctica deliberada como un esfuerzo tan grande, que incluso en los niveles más altos de pericia sólo se puede ejercitar alrededor de 4 horas al día. De lo contrario, se sufre un agotamiento a corto plazo. En otras palabras, tras 4 horas de dedicación plena a la práctica de cualquier actividad, se empiezan a obtener rendimientos decrecientes. El principio de los rendimientos decrecientes en el mundo empresarial es muy conocido, pero quizás no se aplica del todo en relación con los horarios de oficina en las empresas.

En este punto podemos concluir que una buena gestión del tiempo te permite guardar algunas horas semanales para dedicarle a la mejora continua dentro la propia jornada laboral, y te permite tener tiempo libre, que puedes invertir en aprender y en trabajar cuando el trabajo te lo exija, pero también en tus aficiones y en desconectar del trabajo para afrontarlo con mayor motivación.

La curiosidad como activo

Otro concepto que subyace bajo la pregunta "¿seré capaz de convertirme en un buen desarrollador si no programo en mi tiempo libre?" es el de la motivación por descubrir cosas nuevas y ver cómo funcionan.

A muchos programadores entusiastas y motivados precisamente lo que les gusta es explorar, experimentar, hacerse sus propias ideas sobre las cosas. Es así como aprenden y obtienen sus destrezas y su visión de las cosas. Si sale una nueva tecnología y les pica la curiosidad, tienen que probarla, no les basta con leer un artículo de un blog.

Por lo general, los programadores tienen curiosidad por tecnologías que no están directamente relacionadas con las herramientas de desarrollo que usan en su trabajo. Si vas muy sobrado puedes dedicarle tiempo con el permiso de tu jefe, pero no es lo habitual. Si te sobra tiempo en el trabajo, haces lo que se menciona anteriormente en este artículo: formarte en tecnologías que sean útiles para la empresa.

Algunos programadores a medida que adquieren experiencia acaban por tener muy claro con qué tecnologías quieren trabajar y qué tipo de proyectos les gusta hacer. En ese punto estás en una posición de poder elegir, pero cuando empiezas no tienes esa suerte, ni tampoco sabes muy bien qué es lo que de verdad te gusta en la mayoría de los casos. Cuando llegas a ese punto en tu carrera, ya no distingues muy bien qué es trabajo y qué es afición, puesto que se confunden.

Por lo tanto, si no estás haciendo nada extra porque no sientes curiosidad ni motivación, no estás desarrollando todo tu potencial. Y quizás ese sea el problema.

El hecho de no programar en tu tiempo libre no te convierte en un mal desarrollador. Sin embargo, programar en tu tiempo libre te puede hacer sin duda alguna un mejor desarrollador.

Dedicarle tiempo a la programación en tu tiempo libre lógicamente mejorará tus habilidades, pero no tienes que sentirte obligado a hacerlo siempre. La verdad es que la programación parece ser un campo profesional como pocos, porque para muchas personas es su trabajo y su afición, por lo que disfrutan de la programación en su tiempo libre.

Conclusión

Desde mi punto de vista, si quieres llegar a ser buen programador, la flexibilidad junto con una buena gestión del tiempo son fundamentales.

Tienes que estar dispuesto a sacrificar tu tiempo libre tanto para sacar un proyecto de desarrollo en plazo como para aprender nuevas tecnologías y trastear con ellas. Si no "amas" la programación lo suficiente para adaptar tus horarios al trabajo y a la formación continua (en la oficina cuando se pueda y en casa cuando no), quizás este oficio no sea para ti.

Claro que puedes ser un buen programador si solo programas en la oficina, sobre todo si sabes gestionar bien tu tiempo y tomas buenas decisiones para tu carrera profesional. Sin embargo, los mejores desarrolladores también hacen cosas en su tiempo libre.

De todos modos, si eliges buenos puestos de trabajo en cada momento de tu vida profesional, con muchas oportunidades de aprendizaje, gestionas bien tu tiempo en el trabajo y demás, puedes incluso llegar a ser mejor programador que alguien que programa mucho en su tiempo libre porque no consigue buenos puestos o no está en entornos que promuevan el aprendizaje continuo o que no estimulen la curiosidad y la motivación para aprender cosas nuevas. Pero a la larga una cosa lleva a la otra, y al final siempre le dedicas tiempo libre porque te gusta.

Los grandes programadores aprenden tanto en la oficina como en casa, y siempre muestran buenas destrezas de aprendizaje y hacen en muchos casos de mentores de programadores más inexpertos.

Configurar Eclipse/Java para programadores de Visual Studio/C#

16/05/2018
Artículo original

Los que venimos del mundo C++ primero, y C# después, estamos muy acostumbrados a Visual Studio. Así que, cuando nos toca trabajar en Eclipse con Java, nos sentimos como un cerdo en una piscina de barro: nos suena familiar y es divertido, pero no estamos cómodos del todo.

Este post es un resumen de todos los cambios y personalizaciones que he realizado a mi Eclipse en los últimos años para que el desarrollo con Java sea lo más parecido posible a C# con Visual Studio.

Nota: algunos de los cambios que se mencionan son meramente estéticos, mientras que otros afectan al estilo y el formato del código, y pueden entrar en conflicto con directrices de cada equipo de desarrollo.

Colores

Lo primero que un desarrollador Visual Studio suele querer cambiar, son los colores que se utilizan para formatear el código.

Para establecer una configuración de colores similar a la de Visual Studio, lo más fácil es utilizar uno de los temas de color disponibles en el Eclipse Marketplace (Eclipse -> Help -> Eclipse Marketplace).

Allí se pueden buscar temas de color relacionados con Visual Studio e instalar el que más convenga (Windows -> Preferences -> General -> Appearance -> Color Theme):

Si se desea cambiar algún color individual, puede hacerse en: Windows -> Preferences -> Java -> Editor -> Syntax Coloring:

Otros colores no incluidos en el tema

Aunque el tema de color configura la mayor parte de aspectos relacionados con el código, para que Eclipse se parezca aún más a nuestro Visual Studio, hay otras configuraciones que es necesario cambiar. En Windows -> Preferences -> General -> Editors -> Text Editors -> Annotations:

  1. Color de los puntos de ruptura en modo depuración

    Los desarrolladores de Visual Studio estamos muy acostumbrados a esas horribles líneas con fondo rojo para los puntos de ruptura. Aunque en Eclipse también se puede configurar el fondo de un breakpoint en rojo, el color del texto permanece intacto por lo que su lectura se complica. Una buena alternativa es la siguiente:

  2. Color de línea activa

    Del mismo modo, cuando la depuración está parada, estamos también acostumbrados a esa horrible línea con fondo amarillo que denota la siguiente línea que será ejecutada. Podemos configurarla en la misma ventana:

Estilo de código

El segundo aspecto que suele resultar más incómodo para desarrolladores C#, es el estilo de código.

Aquí, es más que probable que cada empresa tenga su propia guía de estilo que habrá que respetar, pero si tu prioridad es que tu código Java se parezca lo más posible a C#, puedes lograrlo en la ventana: Window -> Preferences -> Java -> Code Style -> Formatter.

En lugar de ir cambiando cada valor automáticamente, lo mejor es descargar un profile ya creado que configure todo por nosotros. Te dejo para descarga mi profile personal (en formato ZIP, dentro tiene el XML necesario) que contiene gran parte de lo que se menciona en este apartado.

Con respecto a los profiles que suelen encontrarse por Internet, suelen ser necesarios algunos retoques adicionales. Algunos ejemplos:

Deshabilitar Wrapping

Ésta es otra de esas opciones que puede resultar útil en algunos contextos, pero que yo prefiero desactivar.

Hoy en día las pantallas tienen la suficiente resolución como para que las líneas puedan ser largas y a mí personalmente no me importa que se salgan por el margen derecho de la pantalla.

Si hay casos extremos donde eso resulte un problema, prefiero escoger manualmente cuándo y cómo bajar partes de las sentencias a la siguiente línea. Por eso, personalmente prefiero deshabilitar todo tipo de Wrapping.

Se puede ir categoría por categoría activando y desactivando según tus preferencias en la ventana: Window -> Preferences -> Java -> Code Style -> Formatter -> Edit -> Line Wrapping:

Controlar cómo y cuándo se añaden Nuevas Líneas

Para conseguir un comportamiento lo más parecido posible a C# en lo referente a la inserción de nuevas líneas, debemos ir a Window -> Preferences -> Java -> Code Style -> Formatter -> Edit -> New Lines y marcar las opciones de la siguiente imagen:

Establecer los TABS como método de indentación

La indentación por defecto en Eclipse es bastante confusa, y fácilmente terminas con métodos que están “un espacio” más a la derecha o a la izquierda de donde deberían.

Para mejorar esto, suelo preferir indentar únicamente con TABS completos, en: Window -> Preferences -> Java -> Code Style -> Formatter -> Edit -> Indentation

Atajos de teclado

Toda la personalización del mundo no servirá de mucho si los atajos de teclado no son los que tienes costumbre de utilizar.

Un programador necesita esos atajos como respirar. La buena noticia es que Eclipse ya incluye un mapa de atajos que imita el comportamiento de Visual Studio. Puedes configurarlo en: Window -> Preferences -> General -> Keys, seleccionando el esquema “Microsoft Visual Studio”.

Aun así, el mapeo no es perfecto y será necesario retocar algunos atajos a mano.

Hacer que el asistente de contenido se comporte como Intellisense

En Visual Studio, estamos acostumbrados a que Intellisense nos ofrezca alternativas nada más pulsar el punto (.) y continúe ofreciéndolas según vamos tecleando.

Podemos lograr un comportamiento parecido en Eclipse activando y configurando la siguiente opción en Windows -> Preferences -> Java -> Editor -> Content Assist:

Los valores que tenemos que poner son:

  • Auto Activation Delay (ms): 0

  • Auto activation triggers for Java: .(abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ

  • Auto activation triggers for Javadoc: @#

Deshabilitar la navegación de cursor con varios pasos por palabra

Supongo que es cuestión de gustos y que incluso esta opción puede resultar atractiva para mucha gente, pero personalmente estoy muy acostumbrado a que cuando pulso Ctrl+Izda estando sobre el nombre de una variable, el cursor salte hasta el comienzo del nombre completo de la variable.

Eclipse, por defecto, activa una opción que en algunos sitios se conoce como CamelHumps, según la cual el cursor va deteniéndose dentro de la palabra, cuando detecta mayúsculas, como en el siguiente ejemplo:

|LongCamelCaseWrittenWord -> CTRL+RIGHT_ARROW

Long|CamelCaseWrittenWord -> CTRL+RIGHT_ARROW

LongCamel|CaseWrittenWord -> CTRL+RIGHT_ARROW

LongCamelCase|WrittenWord -> CTRL+RIGHT_ARROW

LongCamelCaseWritten|Word -> CTRL+RIGHT_ARROW

LongCamelCaseWrittenWord|

Dicho comportamiento puede desactivarse en la ventana: Windows -> Preferences -> Java -> Editor, desmarcando la opción “Smart caret positioning in Java names”.

Hacer que la tecla Inicio te lleve al comienzo real de la línea

De forma similar al punto anterior, cuando en Eclipse pulsamos la tecla Inicio o Home, el cursor saltará al inicio de la línea, pero con un comportamiento distinto en función de la línea en la que estemos. Por ejemplo, si la línea es un comentario, el cursor se posicionará a la derecha de las barras que inicia el comentario //.

Este comportamiento puede desactivarse en Window -> Preferences -> Editors -> Text Editors, desmarcando la opción “Smart caret positioning at line start and end”:

Habilitar Folding

Lamentablemente, Eclipse no soporta regiones de forma nativa como Visual Studio y C#. Android Studio sí incorpora esta funcionalidad, pero para lograr algo parecido en Eclipse tendríamos que recurrir a plugins (y la mayoría están descontinuados).

Lo que sí podemos habilitar es un folding básico para comentarios, métodos, etc., en la ventana: Window -> Preferences -> Java -> Editor -> Folding

Formato e indentación automática

Visual Studio incorpora una funcionalidad que me encanta: siempre que cerramos una llave, aplica un formateo automático a todo el bloque de código que comprende dicha llave.

No he encontrado una funcionalidad equivalente en Eclipse. Lo más parecido que he visto es la opción de formateo automático al grabar un archivo, en la ventana: Window -> Preferences -> Java -> Editor -> Save Actions.

Se puede aprovechar para activar también otra opción interesante: Organize Imports, que ahorra trabajo a la hora de gestionar los molestos imports de Java.

Configurar cierres automáticos

Al igual que Visual Studio¸ Eclipse permite configurar cómo y cuándo cerrar automáticamente paréntesis, llaves, cadenas de texto y comentarios. En la ventana: Window -> Preferences -> Java -> Editor -> Typing

Configurar comportamiento de Strings

Por defecto, Eclipse realiza algunas tareas cuando se “pegan” cadenas de texto en el código, como wrapping automático o escapar los caracteres que haya en la cadena.

Son opciones que pueden resultar útiles en algunos casos, pero que por lo general resultan incómodas para un desarrollador de Visual Studio. Pueden desactivarse aquí en: Window -> Preferences -> Java -> Editor -> Typing

Desactivar comprobaciones ortográficas

Esto es algo que Visual Studio no hace por defecto y que, aunque puede resultar de gran utilidad para mucha gente, a mí personalmente no me gusta.

Además, y aunque es poco probable que se note, me parece un gasto innecesario de recursos. Prefiero que Eclipse dedique la CPU a reaccionar con la mayor velocidad posible (por ejemplo a la hora de proponer contenidos con su Intellisense) en lugar de a analizar la ortografía de mi código. Podéis desmarcar la opción en: Window -> Preferences -> General -> Editors -> Text Editors -> Spelling:

En resumen

Eclipse y Visual Studio son entornos muy diferentes, pero se puede conseguir que se parezcan bastante con unos cuantos ajustes estratégicamente aplicados. En este caso hemos visto cómo hacer que Eclipse se parezca a Visual Studio, de modo que si eres fundamentalmente programador de C# o C++ y debes empezar a trabajar con Java, no solo te sentirás mucho más cómodo, sino que además tu productividad aumentará al encontrarte como en casa desde el principio.

Recuerda que puedes descargar el siguiente archivo XML para configurar un nuevo profile de estilo de código que imita el utilizado por Visual Studio en C#.

Espero que te resulte útil.

Ruby 2.2.9 publicado

14/05/2018
Artículo original

Ruby 2.2.9 ha sido publicado. Esta versión incluye diversas correcciones a fallas de seguridad. Por favor revise los temas siguientes para ver detalles.

Ruby 2.2 ahora está en la fase de mantenimiento de seguridad, hasta finales de Marzo de 2018. Después de esa fecha, terminará el mantenimiento de Ruby 2.2. Le recomendamos comenzar a planear la migración a una versión más nueva de Ruby, como 2.4 o 2.3.

Descargas

  • https://cache.ruby-lang.org/pub/ruby/2.2/ruby-2.2.9.tar.bz2

    SIZE:   13371232 bytes
    SHA1:   773ba9b51bde612866f656c4531f59660e2b0087
    SHA256: 5e3cfcc3b69638e165f72f67b1321fa05aff62b0f9e9b32042a5a79614e7c70a
    SHA512: 2a8c8770fda20a22b79c9115b6f468f8e7ea1092c84a5089af7a3122163e5ad298b493e6637e4d93ba02d899d8a619c94064dda8ac98cf3b93f64f45d5401085
    
  • https://cache.ruby-lang.org/pub/ruby/2.2/ruby-2.2.9.tar.gz

    SIZE:   16681209 bytes
    SHA1:   cbeb1b892ffcaca8728c1cb8d513e1b485bc5eba
    SHA256: 2f47c77054fc40ccfde22501425256d32c4fa0ccaf9554f0d699ed436beca1a6
    SHA512: 34e440d529b3bb6b2a7c0e68e64c66c903b96b736ca527398d4493e7451353c08f7cc68b83c55011b53d76411c118fcb3c9e70c1a08439a591eeee98c430c297
    
  • https://cache.ruby-lang.org/pub/ruby/2.2/ruby-2.2.9.tar.xz

    SIZE:   10511456 bytes
    SHA1:   1144e19b4cdc77ee036847d261013c88fc59b5f8
    SHA256: 313b44b1105589d00bb30b9cccf7da44d263fe20a2d8d269ada536d4a7ef285c
    SHA512: c4ef84cd00f72f60d6c168f0726d9d7e9573549c2bbae83893e1a9d5e64fc7938f4c9d50a47147b28b37cbf36263f95e10a810c0797bad941775a48d75a8c933
    
  • https://cache.ruby-lang.org/pub/ruby/2.2/ruby-2.2.9.zip

    SIZE:   18523114 bytes
    SHA1:   ebc8ba0ae1178bf4a84b38dd0fdd97de82406cf4
    SHA256: c3055ef4f985079d392dddebb1eab1e91851bfc19c0e8a11779872647d89b3b1
    SHA512: 41de195641bc8cca43a726c1d707720dc9d3b8a853002548a31d171508b78dc353328c9a526dfbbc76493307c0e9e5fce669cc9fc3efc9626f84f2af5aca1a55
    

Comentarios de la versión

Gracias a todos los que ayudaron con esta versión.

Publicado por usa el 2017-12-14
Traducción de vtamara

Ruby 2.5.0-rc1 Publicado

14/05/2018
Artículo original

Nos complace anunciar la publicación de Ruby 2.5.0-rc1.

Ruby 2.5.0-rc1 es el primer candidato de publicación de Ruby 2.5.0. Introduce algunas características nuevas y mejoras al desempeño, por ejemplo:

Nuevas características

  • Imprimir trazas y mensajes de error en orden inverso si no se ha cambiado STDERR y es un tty. [Feature #8661] [experimental]

  • Se ha eliminado la búsqueda de constantes en el nivel superior cuando no se encuentran en una clase. [Feature #11547]

  • rescue/else/ensure se permiten al interior de bloques do/end. [Feature #12906]

  • Agregado yield_self. [Feature #6721]

Mejoras en desempeño

  • Instrumentación dinámica para ganchos TracePoint en lugar de usar la instrucción “trace” para evitar costos. [Feature #14104]

  • El desempeño al pasar bloques usando parámetros de bloque se ha mejorado empleando localización de Proc retardada. [Feature #14045]

  • Se ha vuelto a escribir mutex para que sea más pequeño y veloz. [Feature #13517]

  • SecureRandom ahora prefiere fuentes proveidas por el sistema operativo en lugar de OpenSSL. [Bug #9569]

Otros cambios notables desde la versión 2.4

  • Actualizado a Onigmo 6.1.3. Añade el operado ausente. Note que Ruby 2.4.1 también incluía este cambio.
  • Bundler agregado a las librerías estándar.
  • Actualización a RubyGems 2.7.0.
  • Actualización a RDoc 6.0.0.
    • Cambiado el analizador léxico de IRB por uno basado en Ripper; esto mejora considerablemente la velocidad de generación de la documentación. [https://github.com/ruby/rdoc/pull/512]
    • Resuletas muchas fallas de la última docena de años aproximadamente.
    • Soporta las nuevas sintaxis de Ruby de los últimos años.
  • Actualizada versión soportada de Unicode a 10.0.0.

Ver detalles en NEWS o en la bitácora de commits.

Con esos cambios, 6162 archivos cambiados, 339744 inserciones(+), 28699 eliminaciones(-) desde Ruby 2.4.0!

Disfrute Ruby 2.5.0-rc1!

Descargas

  • https://cache.ruby-lang.org/pub/ruby/2.5/ruby-2.5.0-rc1.tar.gz

    SIZE:   31049529 bytes
    SHA1:   15df7e8ff99f360a14f7747a07a3021447d65594
    SHA256: 46c11b347522de174566503d35d2b46e1529b979d292b1f7f7019cfedcd4b07f
    SHA512: 41cd298e99d7a25fe5f2ec42946ae5dbc4421bb18f39350ba8a1b02e999541ec1b21b5f6ce0489b3a159f47e37d409178ba7c21c00e177b0fdb410ca6e9d6142
    
  • https://cache.ruby-lang.org/pub/ruby/2.5/ruby-2.5.0-rc1.zip

    SIZE:   35579788 bytes
    SHA1:   b7ae42eb733d4a0e3a2d135c9f8d4af043daa728
    SHA256: 9858e39fd2e7bf207cc9f8846197b11ada5f4424f433ff4df149fe3d48be8e36
    SHA512: 86c93791d312fd2175909020e448a44892740feb809a532ed706c6d850cb92722fb7ca02ecbdf7a1fbeb5b4f42f1338ce9a15b7c0a41055937bd1fdfb4be6f11
    
  • https://cache.ruby-lang.org/pub/ruby/2.5/ruby-2.5.0-rc1.tar.bz2

    SIZE:   29238901 bytes
    SHA1:   6aad74ed3d30de63c6ff22048cd0fcbcbe123586
    SHA256: 862a8e9e52432ba383660a23d3e87af11dbc18c863a19ef6367eb8259fc47c09
    SHA512: bf0eb114097f9e505ff846f25e7556a2fb393573b4e8b773f94cf5b47998e221f3962a291db15a3cdbdf4ced5a523812937f80d95f4ee3f7b13c4e37f178d7a7
    
  • https://cache.ruby-lang.org/pub/ruby/2.5/ruby-2.5.0-rc1.tar.xz

    SIZE:   26096412 bytes
    SHA1:   05cacd0341b7a23cc68239c2061640643a30da38
    SHA256: a479a1bce69b2cf656821f10104dcb8b426922b56d3d6cbdf48318842fae752c
    SHA512: 9f9040abf69337439a3f31b80d440d97736555b0df6533d9d34c141ce52226bc40c3f4f7e596e74b080c879e933649c17a073c893be1a304d9a883bab02e9494
    

Publicado por naruse el 2017-12-14
Traducción de vtamara

Publicado Ruby 2.4.3

14/05/2018
Artículo original

Ruby 2.4.3 ha sido publicado.

Esta versión incluye la corrección a una falla de seguridad.

También hay algunas correcciones a otras fallas. Ver más detalles en la bitácora de commits.

Descargas

  • https://cache.ruby-lang.org/pub/ruby/2.4/ruby-2.4.3.tar.bz2

    SIZE:   12615068 bytes
    SHA1:   3ca96536320b915762d57fe1ee540df6810bf631
    SHA256: 0a703dffb7737f56e979c9ebe2482f07751803c71e307c20446b581e0f12cf30
    SHA512: fb4339e30c04d03b1422b6c32ede45902e072cd26325b36f3fc05c341d42eea6431d88718242dcc9ce24d9cad26f3d26772f2e806bd7d93f40be50268c318409
    
  • https://cache.ruby-lang.org/pub/ruby/2.4/ruby-2.4.3.tar.gz

    SIZE:   14178729 bytes
    SHA1:   787b7f4e90fb4b39a61bc1a31eb7765f875a590c
    SHA256: fd0375582c92045aa7d31854e724471fb469e11a4b08ff334d39052ccaaa3a98
    SHA512: e6859cee49f74bbfbcfc9dd583aa0f1af007354f9b56ec09959d24764e69ed6ea3d1d59a229ad25b451161a1ea2ac60e0621dbbcc484ad219eed9e55f3825e05
    
  • https://cache.ruby-lang.org/pub/ruby/2.4/ruby-2.4.3.tar.xz

    SIZE:   10040072 bytes
    SHA1:   f0a49dddb4e7903a11a80554fd7a317a854cd365
    SHA256: 23677d40bf3b7621ba64593c978df40b1e026d8653c74a0599f0ead78ed92b51
    SHA512: 8bcf60c994a96787da5d743c66f5609a5a6d834d6d61243cdea7fd059197c3b10da43c99e5649be85e2f2329eedcbb1dd76e89ce3ac586be9056348f7449ed09
    
  • https://cache.ruby-lang.org/pub/ruby/2.4/ruby-2.4.3.zip

    SIZE:   15649173 bytes
    SHA1:   19744d7673914804b46f75b374faee87b2ea18d9
    SHA256: a4cd07af2cef121582b8bf7ec57fb9a916d99556c713538bc4469be68bfc1961
    SHA512: 5e51b4337ee12041925dd6b91df6d0c7fc5bf19846c1c8d5aa43823f5410d1291cd428bdb5245f08a399051d06c2cb59fde73a7d3da379cbbd24f9c2b60fcc8c
    

Comentario de la versión

Muchas personas que contribuyeron, desarrolladores y usuarios que proveyeron reportes de fallas nos ayudaron a lograr esta versión. Gracias por sus contribuciones.

Publicado por nagachika el 2017-12-14
Traducción de vtamara

Ruby 2.3.6 Publicado

14/05/2018
Artículo original

Ruby 2.3.6 ha sido publicado.

Esta versión incluye cerca de 10 correcciones a fallas posteriores a la versión anterior, y también incluya diversas correcciones a fallas de seguridad. Por favor revise los temas siguientes para ver más detalles.

Vea detalles en el archivo ChangeLog.

Descargas

  • https://cache.ruby-lang.org/pub/ruby/2.3/ruby-2.3.6.tar.bz2

    SIZE:   14429114 bytes
    SHA1:   07c3b66d544dd22c22fbae3f16cfb3eeb88b7b1e
    SHA256: 07aa3ed3bffbfb97b6fc5296a86621e6bb5349c6f8e549bd0db7f61e3e210fd0
    SHA512: bc3c7a115745a38e44bd91eb5637b1e412011c471d9749db7960185ef75737b944dd0e524f22432809649952ca7d93f46d458990e9cd2b0db5ca8abf4bc8ea99
    
  • https://cache.ruby-lang.org/pub/ruby/2.3/ruby-2.3.6.tar.gz

    SIZE:   17840901 bytes
    SHA1:   4e6a0f828819e15d274ae58485585fc8b7caace0
    SHA256: 8322513279f9edfa612d445bc111a87894fac1128eaa539301cebfc0dd51571e
    SHA512: 104553d888f7d49d1b8df0cff0a3e8aee3086183d75e1a88289730e34c2da669874d7abe83e84bf1b3be9a3337a34f19ea9f9dcfbf1f7fc1136bb8f922776ea4
    
  • https://cache.ruby-lang.org/pub/ruby/2.3/ruby-2.3.6.tar.xz

    SIZE:   11445628 bytes
    SHA1:   55e97913180a313f161d2e4e541dd904a477c31d
    SHA256: e0d969ac22d4a403c1204868bb9c0d068aa35045bb3934cf50b17b7f66059f56
    SHA512: a09c8715097d16190ee17ee39e7a74438cefc9013add350217b7e3fb4d60aa9dcb30595adf832b0d67a5c45b1fe9d4effb767c995af2759420859f8d763c693a
    
  • https://cache.ruby-lang.org/pub/ruby/2.3/ruby-2.3.6.zip

    SIZE:   19892406 bytes
    SHA1:   0d631f32e7b360dcbfb9f8f46dfff2445f0a6a51
    SHA256: 6fee49a2099d49a1b98bf0637fe974fd87af3ae64978392c802ba4d10ac70fb5
    SHA512: c6dc2ee01a4ef84850b0ca4d1e60841f07fbff263ebbbc44c8bd0f72ced3172c2e0b9c883496bfc4f5a42f4827a061f8f479d05bda5f693a274c451914e0b03e
    

Comentario de la versión

Gracias a todos los que ayudaron con esta versión.

El mantenimiento de Ruby 2.3, incluyendo esta versión, se basa en el “Acuerdo por una versión estable de Ruby” de la Asociacioń Ruby.

Publicado por usa el 2017-12-14
Traducción de vtamara

Aprendizaje no Supervisado y Detección de Anomalías: Reglas de Asociación Avanzadas

14/05/2018
Artículo original

Este articulo forma parte de una serie de artículos sobre clustering, detección de anomalías y reglas de asociación. Originalmente forman parte de un trabajo para el Máster Universitario Oficial en Ciencia de Datos e Ingeniería de Computadores de la Universidad de Granada en la asignatura Aprendizaje no supervisado y detección de anomalías. El resto de artículos son:

Uno de los problemas de las reglas de asociación es la interpretabilidad, estos pueden venir derivados de los datos en sí, de los usuarios o de las propias medidas de evaluación.

Los problemas derivados de los datos residen en que hay varias formas de interpretar que si A \(\rightarrow\) B en función de las medidas de calidad usadas. Al ser patrones en los datos, la calidad de la regla dependerá de igual modo de la calidad de los datos. Algunos problemas derivados de los datos son:

  • falta de variabilidad, items muy frecuentes no aportan nada (Todos los clientes compran papel) o al contrario, items poco frecuentes tampoco aportan nada.
  • La representabilidad de los datos, es decir, que no haya suficientes datos.
  • Sesgos muestrales, es necesario escoger los items de forma aleatoria, no sesgarlos seleccionado compras de un periodo determinado, como las compras de enero, por ejemplo.

Por otra parte, los problemas derivados del usuario pueden deberse a que no se dispone de un experto en el dominio del problema para interpretar y valorar las reglas. Aún cuando se dispone de un experto, pueden ocasionarse confusiones semánticas en las que se interpretan mal las reglas o los valores de confianza etc.

Los problemas derivados de las medidas, las reglas con soportes muy altos tienden a ser dudosas, ya que su valor tan elevado puede deberse a una falta de variabilidad en los datos. De igual modo, la confianza no siempre es fiable, una regla con una confianza del 84% puede parece buena, pero aún teniendo una regla con máxima confianza (conf = 1) puede que los items de A \(\rightarrow\) B sean independientes.

Para tratar de resolver estos problemas es necesario poder comparar la confianza de la regla con el soporte de su consecuente, dada A \(\rightarrow\) B, \(p(B|A)\) la confianza, \(p(B)\) el soporte de B, es necesario comprar ambas medidas, ya que \(p(B)\) es la probabilidad a priori, mientras que \(p(B|A)\) es solo la probabilidad de las reglas en las que aparece A. Si la $Conf(A \(\rightarrow\) B) = Sop(B)$ A y B son independientes y la regla no es representativa. Aunque la confianza por sí sola no vale para determinar si una regla es buena, sí que vale para descartar una regla mala.

Medidas de calidad

Existen dos grupos de medidas de Interés, objetivas y subjetivas. Las primeras tienen fundamento estadístico, mientras que las subjetivas solo tienen en cuenta los datos.

Entre las medidas objetivas se encuentran La Confianza Confirmada, establece hasta qué punto es útil A para predecir la presencia de B, la medida se da en un rango [-1, 1], donde 0 significa que son independientes, 1 dependencia total y -1 dependencia inversa (A predice ¬ B). Lift mide el nivel de interés, pero al ser simétrica mide asociaciones, no implicaciones, por lo cual no es buena para realizar comparaciones. Convicción detecta la independencia estadística entre items, al igual que lift no está acotada en su salida, por lo que no es muy fiable. El factor de certeza mide la incertidumbre del conocimiento, tiene su origen en los sitemas expertos, la ventaja frente a las dos medidas anteriores es que está acotada en rangos [-1,1], donde 0 significa independencia estadística. Existen más medidas, estas son solo unas pocas. Por lo general, el análisis de la regla depende de la medida a usar. Es necesario usar medidas en función de la semántica que se quiere medir.

Las medidas subjetivas miden el interés de las reglas, suele ser necesaria la presencia de un experto que valore el interés de las mismas. Una de ellas es la Utilidad, en ella hay que tener en cuenta:

  • Restricciones: ¿Qué condiciones o qué contexto es necesario para que el patrón se cumpla?
  • Tiempo de vida: ¿Durante cuánto tiempo será útil la información dada por el patrón?
  • Esfuerzo: ¿Qué debemos hacer para actuar según nos muestre el patrón?
  • Efectos laterales: ¿Se puede prever algún efecto lateral?
  • Impacto: Desde la obtención del patrón, ¿se han producido cambios en la actualidad?
  • Prontitud: ¿Cuándo podemos actuar y utilizar la información que nos brinda el patrón?

Las reglas inesperadas son otro tipo de medida subjetiva, son aquellas que contradicen las creencias del usuario, pueden ser interesantes o no.

Interpretaciones

Esta sección se corresponde con el marco formal de las reglas de asociación, es decir, la definición teórica de las reglas, de forma abstracta. Para ello hay que asociar dicha abstracción con los datos, crear una asociación entre datos y reglas, es esto lo que genera una interpretación.

La forma más común es tabular los datos en una estructura, por ejemplo (salario, alto) \(\rightarrow\) (estudios, superiores), pero no es la única manera de representación. Se puede, por ejemplo, considerar la ausencia de datos con negaciones (¬ A), esta representación es útil para el análisis de grupos de reglas.

Otra forma de representación son las reglas jerárquicas, en esta representación se consideran grupos de items a distintos niveles. Por ejemplo, si los items son artículos de compra, un análisis a nivel de artículos individuales puede no dar información alguna. Sin embargo, a un nivel más alto se puedan extraer conclusiones útiles, un nivel más alto consiste en agrupar los distintos artículos según algún criterio (por marcas, por tipo de producto, tipos de pan, tipos de leche etc). De esta forma se establece una jerarquía en la que un item está compuesto por los items básicos y todas las categorias a las que pertenece, por ejemplo: $$\text{(zumo, naranja, marca, comida)}$$ donde marca y comida son categorías del zumo. En la figura 1 muestra un ejemplo.

Ejemplo de reglas jerárquicas. *Créd. Apuntes de clase*
Ejemplo de reglas jerárquicas. *Créd. Apuntes de clase*

Las reglas secuenciales se usan cuando existe un orden prefijado en los items de las transacciones. Ejemplos de reglas de este tipo son, si A,B y C aparecen en este orden específico \(\rightarrow\) X. Este tipo de reglas son útiles para analizar textos, ya que se extraen reglas como {Minería}{de} \(\rightarrow\) {Datos}, es decir, si se encuentra la palabra Minería seguida de De es muy probable que la siguiente palabra sea datos.

Otro tipo de reglas son las Cuantitativas, usadas con datos estructurados, con dominios numéricos, el problema de estos dominios es su valor semántico y soporte bajo. Para ello, se comentó que es útil dividir el dominio en intervalos y generar pares (atributo, intervalo) en lugar de (atributo, valor), estos items deben estar ordenados. Los intervalos pueden se definidos por el experto para que puedan ser correctamente interpretados, o generarlos automáticamente.

Las dependencias aproximadas definen patrones en bases de datos relacionales, corresponden a dependencias funcionales con excepciones, es decir, si se sabe que V se encuentra en una fila se sabe que W está en la misma fila. En esta interpretación las reglas extraidas tienen la semántica de la dependencia funcional, es decir, los items son del tipo: Igualdad de variables en un par de tuplas.

La última interpretación son las dependencias graduales, representan asociaciones entre la variación (incrementos o decrementos) en los valores de los atributos, representando así correlaciones positivas o negativas. Se puede comparar con las dependencias aproximadas en cuanto a que esta en lugar de determinar si los valores son iguales, determina si son mayores o menores.

Reglas de Asociación difusas

Se usan para representar conceptos, por ejemplo, ¿cuando es una persona alta?, si consideramos 180cm como alto, ¿una persona que mida 179,99 ya no es alta?, este es el problema que tratan los conjuntos difusos, la pertenencia o no de un elemento a un conjunto viene dada por un grado de certeza. La figura 2 muestra un ejemplo en el que se define el rango en el que aumenta si una persona es alta o no, pero presenta el problema comentado anteriormente. Otra forma de representarlo es mediante una función discontinua, como muestra la figura 3, pero tampoco es ideal, lo mejor es una función gradual, como muestra la figura 4

Rango en la que una persona se considera como alta
Rango en la que una persona se considera como alta
Rango en la que una persona se considera como alta
Rango en la que una persona se considera como alta
Rango en la que una persona se considera como alta. Cuando la línea empieza a subir, aumenta el grado en el que se considera a una persona alta.
Rango en la que una persona se considera como alta. Cuando la línea empieza a subir, aumenta el grado en el que se considera a una persona alta.

Las reglas difusas aparecen solo cuando se consideran conjuntos difusos para definir algún concepto con items, transacciones etc, son conjuntos continuos. En este tipo de reglas el soporte depende mucho de dónde se establecen los cortes que definen los intervalos. Semánticamente los intervalos no corresponden con el concepto (30 años es joven, pero 31 no). Para dar solución a este problema se usan conjuntos difusos con funciones de pertenencia, como muestra la figura 5

Particiones difusas con función de pertenencia. Cabe destacar que pueden existir solapamientos (Región roja)
Particiones difusas con función de pertenencia. Cabe destacar que pueden existir solapamientos (Región roja)

Evaluación de reglas por grupos

El análisis de las reglas de asociación suele realizarse de forma individual, estudiando su novedad y potencial utilidad en base a los itemsets que la componen, las medidas objetivas y subjetivas realizadas sobre ellas, y el conocimiento previo del experto. Sin embargo, el análisis de conjuntos de reglas definidos según ciertos criterios puede proporcionar más información, con ciertas ventajas. Por ejemplo, ¿qué ocurre si aparecen ambas reglas A \(\rightarrow\) C y A \(\rightarrow\) ¬ C? o A \(\rightarrow\) C y ¬ C \(\rightarrow\) ¬ A (contra recíproca), la última es lógicamente equivalente. Sin embargo, la logica formal y el conocimento de datos no son lo mismo, al buscar reglas en un conjunto de datos se puede deducir A \(\rightarrow\) B, pero no se sabe nada sobre ¬ B \(\rightarrow\) A. El motivo es que ¬ B \(\rightarrow\) A no aparece en las transacciones, es decir, las transacciones de A \(\rightarrow\) B son distintas a ¬ B \(\rightarrow\) ¬ A, aunque sean lógicamente equivalentes, por ello es necesario mirarlas por separado. En el caso de que ambas aparezcan se proporciona más soporte empírico de que el patrón se cumple, lo cual ocurre siempre que existen reglas lógicamente equivalentes.

Bibliografía

Forzar la descarga de un archivo desde Azure Blob Storage

14/05/2018
Artículo original

Hoy un truco rápido pero muy útil en ciertas ocasiones.

Azure Blob Storage nos permite almacenar archivos de todo tipo accesibles desde la Web a un coste ridículo y con altas prestaciones de velocidad y ancho de banda. Es una buena manera de poner a disposición de la gente todo tipo de archivos, especialmente si son grandes, de modo que si se descargan mucho no acaparen el ancho de banda del servidor de nuestra web, por ejemplo.

Si por ejemplo subimos imágenes o vídeos, lo habitual es que queramos que se descarguen bajo demanda, mostrándose en el navegador. De este modo los enlazamos desde una web, como recursos de la página, y se obtienen desde Azure, que actúa como una especie de caché externa para no ocuparnos ancho de banda.

Sin embargo, a veces querremos que si alguien usa la dirección del recurso en Azure de manera directa, que en lugar de abrirse en el navegador se le descargue el archivo al disco duro. Un ejemplo: un archivo PDF que queremos que se puedan descargar.

Si subimos a Azure Storage un PDF, cuando lo enlacemos se descargará y se abrirá directamente en el navegador. Si preferimos que no sea así y que directamente pregunte al usuario dónde se lo quiere descargar en el disco duro ¿cómo podemos conseguirlo?

Cabeceras de disposición del contenido

La diferencia entre un archivo que se ve en el navegador y uno al que se fuerza la descarga es tan solo una cabecera que devuelve el servidor y que se llama Content-Disposition. Si en esta cabecera ponemos el valor attachment le estamos indicando a los navegadores que queremos que el archivo se descargue. Además le podemos indicar el nombre que le queremos dar a dicho archivo si le añadimos la propiedad filename. Algo así:

content-disposition: attachment;filename=MiArchivo.pdf

O sea, que en realidad lo único que necesitamos es añadir esta cabecera a nuestro archivo. Pero ¿es posible hacerlo?

Hace ya unos años (a finales de 2012) Microsoft añadió a azure la posibilidad de establecer cabeceras personalizadas a los archivos que se almacenaban en Blobs. Lamentablemente la única manera de hacerlo, incluso hoy en día, es mediante código. Es decir, no hay una manera desde el portal de Azure de establecerlas manualmente. Una pena y una dejadez por parte de Microsoft en mi opinión.

Sin embargo hay una manera rápida y sencilla de hacerlo utilizando una herramienta externa. Se trata de la indispensable Azure Storage Explorer, una app gratuita y multi-plataforma de la propia Microsoft, que permite gestionar de manera rápida y sencilla todo el almacenamiento que tenemos en Azure.

En esta herramienta, si navegas hasta tu Blob y pulsas sobre el botón de "Propiedades":

se abre un cuadro de diálogo en el que, entre otras cosas, te permite establecer algunas cabeceras comunes para el archivo. Ente ellas, por suerte, está la de la disposición del contenido, como podemos ver en esta figura:

En este caso le indico que sea un archivo para descarga y además le cambio el nombre original para que, por defecto, el que nos ofrezca en el cuadro de diálogo sea el que me interese.

También podemos cambiar otras cabeceras comunes como por ejemplo el tipo de caché que queremos que se haga del archivo, la codificación de éste, el idioma o incluso el tipo MIME que le queramos asociar (¡podríamos mentir!).

Gracias a esta herramienta podemos obtener un mayor control sobre el comportamiento de los archivos que almacenemos en Azure Blob Storage.

¡Espero que te sea útil!

 

Aunque instalo Web Deploy en IIS, no me aparece en la interfaz de gestión

14/05/2018
Artículo original

Web Deploy es una extensión muy interesante para Internet Information Server. Este paquete lo que te permite es sincronizar aplicaciones entre diferentes instalaciones de IIS, aunque no sean de la misma versión y migrar aplicaciones web entre versiones de IIS. Básicamente lo que hace es añadir un par de opciones a la aplicación de gestión de IIS que te dan la oportunidad de exportar e importar aplicaciones (pulsa para aumentar):

De este modo, cuando exportamos, elegimos exactamente qué aspectos de la aplicación queremos exportar (archivos, permisos, certificados, configuraciones... incluso la base de datos) y se nos genera un paquete ZIP que podemos transportar a otro servidor que también lo tenga instalado. Una vez allí abrimos el ZIP con la opción de importar aplicación y podríamos regenerar la aplicación completa y sus propiedades de un solo golpe. Muy cómodo. Además permite gestionar la tarea desde la línea de comandos y con Powershell, por lo que puedes automatizarlo si lo necesitas. Finalmente, y esto es un pequeño plus, soporta incluso versiones muy viejas de IIS, como IIS 6 (con Windows Server 2003!!) por lo que te ayuda a migrar aplicaciones antiguas de manera sencilla.

El caso es que si instalas Web Deploy en Windows Server 2012 R2 (IIS 8.5) o Windows Server 2016 (IIS 10) parece que no ha funcionado. No aparecen las opciones de exportar e importar en el IIS Manager. Por más que desinstales y vuelvas a instalar, como dicen en muchos sitios de Internet, siguen sin aparecer.

Si te encuentras con este problema, te voy a contar la forma de solucionarlo.

Y es que las últimas versiones de Web Deploy, en concreto la 3.6, añaden un requisito que antes no existía, pero que no está documentado en ningún lado (que yo sepa). En estas versiones modernas de Windows Sever Web Deploy necesita que tengas instalada la opción de "Management Service" o no te funcionará.

Para instalarla o asegurarte de que la tienes, debes ir al menú de inicio y buscar la gestión del servidor ("Server Manager"):

y una vez dentro elegir la opción de "Añadir roles o características" del menú "Gestionar" que hay arriba a la derecha:

En el asistente que aparece, vas hasta el paso de "Roles de servidor" y despliegas hasta que veas la opción "Servicio de administración" dentro del nodo de "Servicio Web":

(en la imagen anterior yo ya la tengo instalada, pero en tu caso si no la tienes te la dejará marcar).

Sigues el asistente hasta el final y cierras.

Ahora desinstala Web Deploy si lo tienes ya instalado y vuélvelo a instalar. O instállo si no lo habías hecho aún. ¡Tadaaa! Te aparecerán las opciones.

¡Espero que te resulte útil!

Página Siguiente