DEV Community: campusMVP

Java: Introducción a los tipos genéricos (vídeo)

campusMVP — Fri, 02 Oct 2020 07:51:20 +0000

Nota: este post pertenece al blog de campusMVP. Puedes ver vídeos como el que se utiliza en este contenido en nuestro canal de YouTube.

Además del polimorfismo, una característica que permite a la plataforma Java tratar homogéneamente objetos heterogéneos, de los que habitualmente no se conoce su tipo concreto, el lenguaje Java cuenta con otro mecanismo con el mismo fin: los tipos genéricos.

Al definir una clase genérica, o bien una interfaz, en realidad estamos definiendo un meta-tipo, una especie de plantilla a partir de la cual se crearán posteriormente clases/interfaces que actuarán como tipos concretos.

El objetivo principal de los tipos genéricos es evitar que tengamos que utilizar la clase Object como tipo para ciertos atributos, parámetros o valores de retorno, como se hacía tradicionalmente en las primeras versiones de Java, al ser Object el ascendiente común de todos los tipos por referencia y, por tanto, un mínimo común denominador.

Los tipos genéricos de Java son similares, en cuanto a funcionalidad se refiere, a las plantillas de C++ y lenguajes similares. El objetivo es definir una clase, una interfaz o un método cuyos tipos de datos son parametrizables. Los tipos genéricos están estrechamente vinculados a las estructuras de datos clásicas como pueden ser las colas y las listas, etc.

En lugar de definir una clase "Pila" para trabajar con números enteros, otra para trabajar con números en punto flotante, una tercera para trabajar con cadenas y así sucesivamente, es mucho más sencillo definir una clase que sea capaz de tratar con datos de diferentes tipos. En Java esto inicialmente implicaba utilizar el tipo Object, pero esto conlleva una serie de problemas.

Al definir los atributos de una clase como Object es necesario realizar posteriormente conversiones a los tipos concretos que el usuario desea utilizar. Asimismo, es un peligro, puesto que sería potencialmente posible introducir datos de diferentes tipos dentro de esa estructura de datos.

Con los tipos genéricos estos inconvenientes se evitan, puesto que el tipo concreto de dato con el que va a trabajar es un parámetro de entrada más.

En el siguiente vídeo vamos a conocer la utilidad de los tipos genéricos de Java definiendo una clase de tipo genérico y viendo cómo podemos utilizarla con diferentes tipos concretos. Nuestro tutor Francisco Charte te ayuda a conocer los aspectos esenciales sobre la definición de clases/interfaces con tipos genéricos , así como la posterior instanciación de tipos concretos. También comprobarás la utilidad de esta funcionalidad de Java:

En resumen, lo que nos permiten los tipos genéricos es facilitar una sola definición de una funcionalidad que posteriormente se aplicaría a diferentes tipos concretos, lo cual en definitiva nos ahorra mucho trabajo de codificación.

Cómo crear textos generados por Inteligencia Artificial/Machine Learning y engañar hasta a Hacker News

campusMVP — Fri, 02 Oct 2020 07:00:00 +0000

A estas alturas sería muy raro que no hubieses oído hablar aún de GPT-3, el modelo de lenguaje natural creado por OpenAI que es capaz de crear de la nada sus propios artículos, opiniones editoriales, poemas y, sí, también código. Y aunque hay ejemplos de esto último muy alucinantes como este o este otro con Excel y hay quien vaticina que acabará con los programadores, seguro que el que lo dijo no ha tenido que tomar nunca requisitos de clientes 😁

Bromas aparte, se trata de una alucinante implementación práctica de la potencia de los algoritmos de aprendizaje automático cuando tienen un "corpus" de entrenamiento lo suficientemente bueno y se afinan bien.

Aunque GPT-3 está basado en la misma tecnología de Machine Learning que GPT-2, lanzada el año pasado, esta nueva versión es un modelo muchísimo mayor. Utiliza 175.000 millones de parámetros entrenables (😱) lo que lo hace 100 veces mayor que su predecesor y 10 veces mayor que su competidor más cercano, Turing NLG de Microsoft, con "tan solo" 17.000 millones de parámetros.

Los expertos que han podido probar este modelo están impresionados. Y lo que más impresiona ya no es tanto su tamaño sino sus capacidades de generación de textos, que rivalizan con las de muchos profesionales humanos. Lo único que tienes que hacer es darle una frase inicial sobre un tema y la AI lo continúa de manera coherente y "humana". Se ha utilizado para escribir artículos, historias, canciones, entrevistas, manuales técnicos y hasta poesía. Es el sistema que más cerca está de pasar el test de Turing hasta la fecha.

Lo último que lo ha traído a la actualidad ha sido el caso de un estudiante, Liam Porr , que ha creado un blog generado 100% de forma automática con GPT-3 y que ha logrado llegar a número 1 en Hacker News, nada menos. Porr elegía los temas y ajustaba el título para lograr el mayor impacto de SEO, pero el resto de los contenidos es, tal cual, lo que generó GPT-3. Échale un vistazo al blog (en inglés, aunque la tecnología funciona en muchos otros idiomas) y te costará creer que no sean artículos escritos por una persona.

Tenemos ejemplos desde hace años sobre cómo el Machine Learning es capaz de generar contenidos automáticos (un porcentaje muy alto de los artículos de economía y de deportes ya se generan de esta forma hace tiempo), y se ha especulado mucho sobre cómo GPT-3 y similares podrían afectar al trabajo de periodistas y generadores de contenido en general.

Esta tecnología es alucinante y abre una nueva era en el engaño, las fake news y el contenido hueco, vacío de humanidad. Pero tiene muchas aplicaciones benignas también. Es por esto que Open AI no va a liberar el modelo como Open Source sino que lo expone a través de una API a la que da acceso previa petición y análisis de ésta. De esta forma pueden responder al mal uso de la tecnología, cosa que no podrían hacer si la liberasen. Aparte de esto Open AI, que nació como una organización de investigación sin ánimo de lucro a finales de 2015, se ha convertido en una empresa con objetivos comerciales en la que Microsoft ha invertido 1.000 millones de dólares para crear uno de los mayores supercomputadores que se ejecutan en Azure. Elon Musk también es uno de los inversores en la empresa.

Estamos entrando en la era del Machine Learning y el futuro será de las empresas y organizaciones que sepan seguirle el ritmo 🤖

¿Qué son Spring framework y Spring Boot? Tu primer programa Java con este framework - VIDEO

campusMVP — Tue, 31 Mar 2020 08:00:00 +0000

El autor de este artículo es Rubén Pahíno y fue originalmente publicado en el blog de campusMVP.

Si desarrollas con Java, o lo has hecho en algún momento de los últimos años, seguramente te suene Spring Framework , aunque sea de oídas.

Spring Framework es un framework Open Source que facilita la creación de aplicaciones de todo tipo en Java , Kotlin y Groovy.

Si bien es cierto que, por lo que es más conocido es por la inyección de dependencias, Spring Framework está dividido en diversos módulos que podemos utilizar, ofreciéndonos muchas más funcionalidades:

Core container : proporciona inyección de dependencias e inversión de control.
Web : nos permite crear controladores Web, tanto de vistas MVC como aplicaciones REST.
Acceso a datos : abstracciones sobre JDBC, ORMs como Hibernate, sistemas OXM (Object XML Mappers), JSM y transacciones.
Programación orientada a Aspectos (AOP): ofrece el soporte para aspectos.
Instrumentación : proporciona soporte para la instrumentación de clases.
Pruebas de código : contiene un framework de testing, con soporte para JUnit y TestNG y todo lo necesario para probar los mecanismos de Spring.

Estos módulos son opcionales , por lo que podemos utilizar los que necesitemos sin tener que llenar nuestro classpath con clases que no vamos a usar.

Razones para usar Spring

Aunque no sea una característica única de Spring, el uso de inyección de dependencias facilita la programación contra interfaz, permitiendo a los distintos componentes depender únicamente de interfaces y produciendo así un código menos acoplado. No solo eso, también permite implementar el patrón singleton de una forma extremadamente sencilla (por defecto, las dependencias que inyectamos son singletons).

Hay cientos de tecnologías que Spring permite integrar. Desde bibliotecas que implementan opentracing hasta las que nos generan métricas para nuestra aplicación, pasando por serialización/deserialización a JSON y XML, seguridad con OAuth2 o programación reactiva entre otras.

En general, Spring aumenta la productividad y reduce la fricción al ofrecernos abstracciones sobre implementaciones de tecnologías concretas. Un ejemplo claro es el de spring-data, que nos permite definir el acceso a base de datos con interfaces Java. Esto lo consigue parseando el nombre de los métodos y generando la consulta con la sintaxis específica para el driver que utilicemos. Por ejemplo, cambiar nuestra aplicación de MySQL a PostgreSQL es tan sencillo como cambiar el driver: Spring se encarga de la sintaxis de forma transparente.

A pesar de "la magia de Spring" 🧙🏻‍♂️, como muchos lo llaman, Spring nos permite desactivar estos "comportamientos mágicos" en caso de ser necesario, por lo que podemos tomar el control cuando necesitemos más granularidad. Siguiendo con el ejemplo de spring-data, este control sería necesario si tenemos que realizar consultas mucho más complejas que un SELECT * BY name. En esos casos, entre otras opciones, podemos anotar nuestro método con @Query y escribir la consulta que deseemos. Ya no hay magia 😉

Por lo general, Spring no obliga a implementar ni extender nada, lo que nos permite escribir código que es "agnóstico" del framework. De esta forma, desarrolladores con cero o muy poco conocimiento de Spring pueden realizar su trabajo sin mayores complicaciones.

Spring es de código abierto y tiene una gran comunidad detrás. Si encuentras un bug, echas en falta una funcionalidad o lo que sea, siempre puedes abrir un ticket o contribuir por tu cuenta.

¿Pero no íbamos a hablar de Spring Boot?

Hasta ahora he hablado de Spring Framework en general, pero el título de esta entrada menciona Spring Boot , así que voy a presentarlo.

Si bien es cierto que Spring Framework es muy potente, la configuración inicial y la preparación de las aplicaciones para producción son tareas bastante tediosas. Spring Boot simplifica el proceso al máximo gracias a sus dos principales mecanismos.

Contenedor de aplicaciones integrado

Spring Boot permite compilar nuestras aplicaciones Web como un archivo .jar que podemos ejecutar como una aplicación Java normal (como alternativa a un archivo .war, que desplegaríamos en un servidor de aplicaciones como Tomcat).

Esto lo consigue integrando el servidor de aplicaciones en el propio .jar y levantándolo cuando arrancamos la aplicación. De esta forma, podemos distribuir nuestras aplicaciones de una forma mucho más sencilla , al poder configurar el servidor junto con la aplicación. Esto también es muy útil en arquitecturas de microservicios , puesto que permite distribuir nuestras aplicaciones como imágenes Docker que podemos escalar horizontalmente (algo muy complicado con un .war).

Nota : Spring boot permite distribuir tu aplicación como un jar, no lo impone. Si prefieres desplegar tu aplicación en un servidor de aplicaciones tradicional, Spring Boot te deja compilar el código como un .war que no incluya ningún servidor de aplicaciones integrado.

Starters

Spring Boot nos proporciona una serie de dependencias, llamadas starters, que podemos añadir a nuestro proyecto dependiendo de lo que necesitemos: crear un controlador REST, acceder a una base de datos usando JDBC, conectar con una cola de mensajes Apache ActiveMQ, etc.

Una vez añadimos un starter, éste nos proporciona todas las dependencias que necesitamos, tanto de Spring como de terceros. Además, los starters vienen configurados con valores por defecto, que pretenden minimizar la necesidad de configuración a la hora de desarrollar. Un buen ejemplo es el de spring-boot-starter-actuator : una vez que añadimos la dependencia, nuestra aplicación empezará a generar métricas tanto de la JVM como de la aplicación en sí (latencias, errores, etc).

Al igual que con Spring Framework, cualquier configuración puede ser modificada de ser necesario: desde el puerto en el que la aplicación escucha peticiones, hasta el banner que sale por consola al arrancar la aplicación.

Hola Mundo con Spring Boot

Para demostrar lo fácil que es empezar a usar Spring Boot, vamos a ver el código necesario para crear nuestro primer "Hola mundo":

@SpringBootApplication
@RestController
public class Application {

    @GetMapping("/hello")
    public String hello() {
        return "Hello Bootiful!";
    }
}

Sencillo, ¿verdad?

Un poco más abajo te explico en un vídeo práctico cómo llegar a este código y qué significa.

Bonus tip: Spring Initializr

El equipo de Spring también ha creado Spring Initializr, una herramienta web que puedes utilizar para autogenerar el esqueleto de tu aplicación Spring Boot.

Se trata de un inicializador muy útil, ya que genera el pom.xml (o build.gradle), el main de la aplicación, y un test que comprueba que la aplicación arranca correctamente.

Vídeo práctico: "Hola Mundo" con Spring Boot

PostCSS: cómo reducir hojas de estilo CSS, eliminando los selectores que sobran (vídeo)

campusMVP — Tue, 04 Feb 2020 08:00:00 +0000

Aunque todo profesional del desarrollo Web que se precie debe dominar HTML y CSS, la realidad es que en la mayor parte de los proyectos normalmente hacemos uso de alguna biblioteca o framework CSS , como por ejemplo Bootstrap (que es la más utilizada) o herramientas similares.

Utilizar un framework CSS nos permite maquetar muy rápido , dar un aspecto atractivo por defecto a las aplicaciones, y tener ya hechas muchas cosas complicadas. Pero, por otro lado, utilizar un framework implica que estamos añadiendo gran cantidad de cosas a la aplicación que jamás vamos a utilizar.

Por ejemplo, si creas una aplicación sencilla con Bootstrap utilizando tan solo la facilidad de maquetación con su rejilla (aunque hoy en día con CSS Grid y Flexbox no lo necesitarías) y tomando el aspecto por defecto de botones y cuadros de texto, estarás añadiendo a la aplicación unos 156KB de tamaño con la versión minimizada del CSS de Boostrap. Sin embargo, si analizas el uso real que estás haciendo de las reglas incluidas, verás que es mínimo y te llegaría con un porcentaje pequeño del contenido de ese archivo.

Lo puedes ver en este mini-vídeo en el que tengo una página muy sencilla con unas cuantas secciones para maquetar texto e imágenes, abro la página en Chrome y empleo su herramienta para análisis de cobertura de código:

Como puedes comprobar, casi el 96% del código de la hoja de estilos de Bootstrap no se utiliza para nada. El resto, para esta página en concreto, no lo necesitamos.

Pero claro, hacer esto manualmente es una tarea propensa a errores y, además, lamentablemente las herramientas de cobertura de Chrome no nos dejan exportar a un archivo tan solo lo que se identifica como que está en uso.

En el siguiente vídeo te explico paso a paso cómo puedes sacar partido a la estupenda herramienta PurgeCSS para automatizar el análisis y limpieza de los archivos CSS que emplee tu aplicación web Front-End y acabar con aplicaciones más ligeras y más rápidas. Para ello utiliza un pequeño sitio web con algunas páginas bastante complejas, y que se apoya en el uso de diversas bibliotecas y mucho CSS.

Vamos a verlo:

Todo lo explicado se puede automatizar con npm , Gulp o Webpack e incorporarlo al proceso de desarrollo de tu aplicación.

Puedes aprender a dominar todas estas herramientas de desarrollo Front-End y muchas más, para ser mejor profesional, con nuestro curso de Herramientas modernas para desarrollo Web Front-End empresarial. Háblalo con tu empresa o invierte por tu cuenta en mejorar tu perfil profesional 😉

¡Espero que te resulte útil!

Java: Los 5 mejores frameworks para desarrollo Web

campusMVP — Mon, 23 Dec 2019 08:00:00 +0000

Post original en campusMVP

Java es sin duda el lenguaje más demandado en el mercado laboral. Sirve para crear todo tipo de aplicaciones : desde el móvil hasta el servidor, pasando por el escritorio o la Web. Y es esto último precisamente lo que nos ocupa hoy: el desarrollo Web.

Aunque Java ofrece de serie todo lo necesario para crear aplicaciones para Internet, no sería muy inteligente ceñirse tan solo a eso, al igual que no lo haríamos así con ninguna otra plataforma. Simplemente sería demasiado complejo. Así que para abstraernos de la necesidad de bajar mucho de nivel, existe una amplia oferta de frameworks Java que nos ayudan con el desarrollo Web , ofreciéndonos ya hechas muchas de las funcionalidades que necesitamos: desde acceso a bases de datos, gestión de sesiones, creación de servicios, servir contenidos estáticos, crear vistas.... y por supuesto reutilizar código, probarlo, etc...

Para orientarte en el camino sobre qué aprender para desarrollar aplicaciones Web con Java hemos creado esta lista con los 5 frameworks más importantes , los cuales son todos gratuitos y Open Source :

1.- Spring MVC

El conocido framework Spring es seguramente el más popular y utilizado del mundo. Se trata de un framework de desarrollo de aplicaciones ligero para Java EE que en realidad se puede utilizar para todo tipo de aplicaciones, no sólo para la Web, pero que es especialmente útil para éstas.

Nos ayuda a crear cualquiera de las capas de la aplicación, cosa en la que otros frameworks son más limitados. Dispone de varios sub-frameworks como: Spring Core , que dota de funcionalidad a todo lo demás; SpringMVC , para la parte que UI que se devuelve al navegador; Spring ORM , para el acceso a datos; Spring Security , para autenticación y autorización de las aplicaciones; etc...

Aumenta la productividad, reduce los errores y hace que las aplicaciones sean más fáciles de mantener. Soporta la configuración de su comportamiento a partir de XML o mediante anotaciones en el código. Permite usar JDBC para el acceso a datos si lo preferimos. También facilita el testing del código web. Ofrece una documentación muy buena.

Lo utiliza... prácticamente todo el mundo, pero hay muchas empresas conocidas que desarrollan con Spring: Netflix , Amazon o eBay por poner algunos ejemplos.

2.- Hibernate

Vale, esto no es específico para desarrollo Web, sino para cualquier desarrollo con Java que utilice acceso a datos. Pero es el framework de datos más utilizado del mundo y en cualquier desarrollo web lo vas a acabar utilizando.

Hibernate es un ORM que nos permite crear la capa de acceso a datos de nuestra aplicación utilizando objetos en lugar de consultas, disminuyendo la fricción entre el mundo de las bases de datos relacionales y la Programación Orientada a Objetos. Vamos, como cualquier ORM. La diferencia con otros es que Hibernate es con diferencia el más utilizado y ello significa que hay mucho más soporte y comunidad que para cualquier otro y te resultará más fácil resolver cualquier problema y obtener nuevas funcionalidades.

Su mayor desventaja es seguramente su tamaño y que puede resultar complejo a veces. Pero es algo que, si programas en Java hay que conocer sí o sí.

Al igual que en el caso de Spring, Hibernate lo usa casi todo el mundo para desarrollar en Java: la propia Oracle , IBM , Accenture...

3.- Struts

Otro framework de desarrollo para Java lleno de características, mantenido en este caso por la Fundación Apache. Es bastante antiguo pero por el mismo motivo está muy probado y lo utiliza mucha gente, y sacan versiones constantemente. Es comparable en muchos sentidos con Spring, que mencionamos antes. Está basado en el patrón MVC y su enfoque es en crear aplicaciones de nivel empresarial de manera rápida y que sean fáciles de mantener.

Dispone de una arquitectura basada en plugins que permiten extenderlo fácilmente con cualquier funcionalidad que requieras y no tenga de serie. Trae muchos plugins de serie para hacer de todo (procesar JSON, crear servicios REST...) y existen muchos más creados por la comunidad.

Lo puedes combinar con otros frameworks para conseguir funcionalidad que no tenga. Por ejemplo, puedes usar inyección de dependencias a través de Spring, o Hibernate para el acceso a datos.

Su mayor pega quizá sea que es más complejo que otros y que te fuerza a seguir un determinado estilo de programación y ciertas reglas (lo cual, en muchas empresas es una ventaja).

4.- JavaServer Faces (JSF)

JavaServer Faces es en realidad una especificación "estándar" para la creación de interfaces de usuario para aplicaciones Web, aunque se puede usar también para crear aplicaciones nativas. La creó la propia Oracle y su primera versión data del año 2004, así que es algo muy estable y probado también. Al igual que otros, utiliza el patrón MVC, y está basado en componentes. El objetivo es que puedas construir componentes de interfaz de usuario que sean reutilizables, pudiendo gestionar su estado, conectarlos a orígenes de datos y atarlos a eventos para realizar acciones.

Tiene un sistema de plantillas para crear los componentes que se llama Facelets y que utilizan XML en lugar de Java para definirlas, aunque puedes usar otros métodos para lo mismo sin salirte de JSF (usando Java directamente si quieres).

Es bastante complejo y no es el más rápido, pero tiene dos ventajas fundamentales: está incluido con Java EE (y los principales IDEs dan soporte de serie para usarlo) y la documentación es muy buena ya que está creada y mantenida por Oracle.

5.- Grails

Grails es un framework de desarrollo Web que utiliza el lenguaje Groovy para la plataforma Java. Groovy es un lenguaje orientado a objetos que compila a Bytecode y que está enfocado a fondo en la productividad del desarrollador. Por ese motivo, Grails lo que te da es una productividad altísima y te permite estar produciendo código para tu aplicación de manera casi inmediata (en 1 hora puedes tener tu primera aplicación probada y en marcha).

Aunque programas con Groovy y no con Java directamente, la sintaxis es compatible con Java y además funciona de maravilla con otras tecnologías Java como Hibernate o incluso Spring. De hecho está basado en Spring Boot, por lo que incluye características como la inyección de dependencias. Sigue buenas prácticas y principios de desarrollo modernos como convención sobre configuración.

Escala bien y te servirá tanto para proyectos pequeños como muy grandes. El soporte de los diferentes IDEs es muy bueno. Tiene centenares de plugins para hacer casi cualquier cosa que se te ocurra.

La documentación de Grails es muy buena, y tiene también unas guías paso a paso de Grails muy buenas.

Post original en campusMVP

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

campusMVP — Wed, 14 Aug 2019 08:00:00 +0000

Post original escrito por Franciso Charte en campusMVP

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:

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 :

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:

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:

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.

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:

Post original escrito por Franciso Charte en campusMVP

5 motivos por los que utilizar Java para desarrollar tus aplicaciones

campusMVP — Wed, 10 Apr 2019 08:00:00 +0000

Post original: https://www.campusmvp.es/recursos/post/5-motivos-por-los-que-utilizar-java-para-desarrollar-tus-aplicaciones.aspx

Java es una plataforma de desarrollo de propósito general cuya principal oferta de valor siempre ha sido "Escribe una vez, ejecuta en todas partes". En la actualidad es prácticamente ubicua: puedes encontrar aplicaciones Java desde pequeños dispositivos conectados del "Internet de las Cosas" (IoT), hasta servidores, pasando por aplicaciones de gestión en escritorio, desarrollos para móviles, videojuegos...

Existen diversos motivos, técnicos y no técnicos, para la popularidad de Java, pero ¿cuáles son las principales propuestas de valor TÉCNICAS para desarrollar con Java?

Seguro que hay muchas más, y desde luego las siguientes no son exclusivas de Java en su mayor parte, pero la combinación de todas ellas, por lo que nos cuentan nuestros alumnos de Java, es lo que suelen valorar las empresas:

1.- Es multiplataforma

Aunque en la actualidad no es una ventaja tan grande como lo era cuando nació y hay muchas otras plataformas que ofrecen multiplataforma, lo cierto es que el hecho de que Java funcione en prácticamente cualquier dispositivo, servidor o sistema operativo, sigue siendo uno de sus principales atractivos para mucha gente.

Existe una implementación de la máquina virtual de Java para casi cualquier sistema que se nos ocurra.

Además no debemos olvidar que Java se diseñó inicialmente para ejecutarse en dispositivos embebidos, con muchas limitaciones de memoria y potencia, por lo que, dependiendo de dónde lo ejecutemos, puede resultar de gran ayuda apoyarse en el lenguaje.

2.- El código Java es robusto

Hay otros lenguajes como C++ que ofrecen más rendimiento y mayor control, pero que son mucho más difíciles de manejar sin meter la pata. Java es un lenguaje que ofrece manejo automático de la memoria y cuyos objetos no hacen referencia a datos fuera de sí mismos o de otros objetos de Java. Esto hace imposible que una instrucción de Java pueda corromper la memoria, ni "pisar" o comprometer los datos de otras aplicaciones o del propio sistema operativo. La máquina virtual realiza todo tipo de comprobaciones para asegurar la integridad que impiden que pueda romper el sistema operativo u otros programas.

También gestiona la liberación de memoria de manera automática, por lo que la usa eficientemente sin que el programador tenga que preocuparse de nada.

Nuevamente, esto no es exclusivo de Java, ya que otras plataformas, como .NET, disponen de las mismas protecciones, pero es una ventaja frente a plataformas más tradicionales.

3.- Es orientada a objetos

Otra cuestión que no llama la atención por especial en la actualidad, pero a mediados de los años 90, cuando se lanzó Java, no era algo tan frecuente como lo es ahora. Gracias a su orientación a objetos es más fácil crear aplicaciones modulares y reutilizar partes de las mismas, además de que permite implementar mejores patrones de diseño probados que contribuyen a la robustez que se comentaba en el apartado anterior.

También es uno de los motivos de que la propia plataforma sea tan extensible y disponga de tantas funcionalidades nativas o añadidas.

Lo cual nos lleva a...

4.- Funcionalidad de base y mucho código Open Source

Aparte de la enorme cantidad de funcionalidad base que ya incluye la propia plataforma listo para ser utilizado, con Java dispones de muchísimo código de terceros listo para ser utilizado.

Entre que lleva bastante más de dos décadas entre nosotros y que la comunidad es enorme, existen infinidad de bibliotecas y utilidades creadas para extender la funcionalidad y mejorar la plataforma Java.

Casi cualquier cosa que puedas necesitar seguro que la encuentras ya creada en algún proyecto de código abierto. No solo eso: mucha de las bibliotecas más conocidas y utilizadas las han creado y las mantienen grandes organizaciones como Google, Facebook o la fundación Apache, lo cual siempre es una garantía adicional.

Esto facilita mucho la vida de los programadores y no existen muchas otras plataformas que puedan aportar la misma exuberante variedad de código utilizable.

5.- Java es relativamente fácil de aprender

Comparado con lenguajes clásicos como C o C++, desde luego. En general se puede decir que Java no es un lenguaje más difícil de aprender que cualquier otro, especialmente otros modernos como C# o Swift, pero sí que es más fácil de aprender que muchos otros.

Gracias a herramientas especializadas (¡y gratuitas!) como NetBeans y otros editores o entornos de desarrollo, la compilación, depuración y despliegue es muy sencillo y comenzar con él muy fácil.

Como cualquier plataforma compleja y de propósito general como esta, tienes dos retos al aprenderla:

Hay tanta funcionalidad que es difícil saber por dónde empezar y cuáles de las, literalmente, miles de clases disponibles debes aprender.
A medida que aprendes y profundizas la cosa se vuelve más compleja y necesitas dominar mejor los fundamentos para poder salir adelante.

Ninguna de estas ventajas es exclusiva de Java y se puede aplicar a otras plataformas, especialmente a .NET y el lenguaje C#. Sin embargo, la combinación de lo que hemos dicho con el hecho de llevar tanto tiempo en el mercado, la enorme comunidad de desarrolladores que hay por todo el mundo y la gran demanda existente en empresas e instituciones, crea un "círculo virtuoso" que hace que Java sea desde hace muchos años la plataforma de desarrollo más importante.

Post original: https://www.campusmvp.es/recursos/post/5-motivos-por-los-que-utilizar-java-para-desarrollar-tus-aplicaciones.aspx

Contenedores: cómo es el ciclo de vida de una aplicación en Kubernetes

campusMVP — Thu, 21 Mar 2019 08:00:00 +0000

Post original escrito por Eduard Tomás en campusMVP

Hace poco os explicaba en un artículo qué es Kubernetes, cuál es su arquitectura y su funcionamiento básico. Léelo antes de continuar si no tienes claros estos conceptos.

En esta ocasión voy a continuar con aquella explicación analizando cómo es el ciclo de vida de una aplicación que está desplegada con Kubernetes.

Lo primero que debemos tener claro es que en Kubernetes nunca se ejecutan contenedores de forma directa. Es decir, no se puede desplegar un contenedor o parar un contenedor. En su lugar se opera con lo que se llaman pods.

Un pod es la unidad mínima de despliegue y operación en Kubernetes. Es decir, desplegamos pods, escalamos pods y son los pods los que se ejecutan en los distintos nodos.

La relación entre pod y contenedor no tiene por qué ser de uno a uno: es decir, en un único pod se pueden ejecutar varios contenedores. Solo recuerda que en este caso se escalarán y desplegarán de forma conjunta (ya que se escala o despliega todo el pod).

Aunque es posible, teóricamente, desplegar en un pod una web y su API en dos contenedores, eso no es lo que suele hacer. En la gran mayoría de casos las relaciones entre pod y contenedor son, efectivamente, de uno a uno. Pero que un pod pueda ejecutar varios contenedores habilita ciertos escenarios avanzados como p. ej. tener un contenedor que ofrezca servicios a otro contenedor (como podría ser hacer de proxy, de logger o similar).

Es importante tener presente que todos los contenedores que se ejecutan en un mismo pod comparten espacio de red. Es decir, se comunican entre ellos usando localhost y no pueden abrir los mismos puertos. También comparten el espacio IPC por lo que pueden usar cualquier técnica de IPC (como semáforos) para comunicarse entre ellos.

Los distintos estados de un pod

Un pod pasa por varias fases a lo largo de su ciclo de vida:

Pending : el pod ha sido creado, pero aún no se han creado sus contenedores ni se ha decidido qué nodo lo va a ejecutar.
Running : los contenedores del pod han sido creados y el pod ya se está ejecutando en un nodo. Al menos un contenedor del pod se está ejecutando o está en proceso de creación.

Esto es importante : que un pod esté en estado running no significa que sus contenedores estén ejecutándose. P. ej. se pueden estar iniciando o reiniciando.

Succeeded : los contenedores del pod han finalizado (todos) su ejecución de forma satisfactoria.
Failed : los contenedores del pod han finalizado (todos) su ejecución y al menos uno de ellos lo ha hecho con error.
Unknown : el estado del pod no se puede saber. Esto suele indicar un error de comunicación con el nodo minion que está ejecutando el pod.
CrashLoopBackOff : el pod está corriendo, pero uno de sus contenedores se está reiniciando debido a que ha terminado (generalmente de forma errónea).

Es importante separar el ciclo de vida del pod del ciclo de vida de sus contenedores. Un pod puede estar en la fase de running pero uno de sus contenedores puede no estar ejecutándose. Cuando un pod _está en fase de _CrashLoopBackOff eso significa que uno de los contenedores está en proceso de reinicio, pero otros contenedores del pod pueden estar ejecutándose.

Muchas veces se dice que Kubernetes reinicia un pod pero esa expresión no es estrictamente cierta: Kubernetes reinicia contenedores de un pod, pero el pod en sí mismo sigue ejecutándose durante todo este tiempo. Que Kubernetes decida reiniciar o no los contenedores de un pod (y en qué casos) depende de la configuración del pod. Es decir, para ciertos pods no hay posibilidad de que entren nunca en fase de Succeeded ya que su misión es estar ejecutándose permanentemente (p. ej. una API), por lo que si un contenedor termina será reiniciado por Kubernetes.

Los pods se consideran "objetos transitorios", en el sentido de que hay determinados eventos del clúster a los cuales no sobreviven. P. ej. si el nodo minion se cae, todos los pods que se estén ejecutándose en él se caen también. Los pods no se mueven de nodo ni se reinician (sí se reinician sus contenedores como se ha comentado antes).

En general no se suele crear nunca pods de forma directa , en su lugar usamos lo que llamamos un controlador. Un controlador es el responsable de garantizar que en todo momento se cumple una cierta condición al respecto de los pods que controla, como que en todo momento haya N instancias de este pod.

Hago aquí un inciso de nomenclatura: cuando digo "N instancias de un pod" me refiero a N pods _idénticos (ejecutando los mismos contenedores y con la misma configuración) pero son N _pods.

Si estamos usando un controlador y deseamos tener en todo momento 2 instancias de un determinado pod y uno de los dos pods se muere (porque se muere su nodo p. ej.), el controlador creará otro pod para asegurar de que siga habiendo dos instancias.

Cuando tenemos N instancias, los N pods se consideran todos "idénticos". Si por algún motivo (p. ej. debe desescalarse) debe eliminarse algún pod, el controlador eliminará uno cualquiera, sin preferencias. Eso encaja con el modelo stateless de aplicación en el que los contenedores encajan perfectamente. Es decir, como desarrollador debes asegurar que tus contenedores sean stateless, ya que en cualquier momento Kubernetes puede decidir eliminar el pod (y por lo tanto el contenedor) y recrearlo en otra parte.

Este modelo stateless no siempre aplica: a veces, si tenemos N instancias de un pod hay alguno que juega un rol especial y por lo tanto se requiere que estos tengan identidad. Un ejemplo es una configuración de base de datos en modo maestro/esclavo. Si uno de los pods se cae, el nuevo que se cree debe ser del mismo tipo, y no solo eso, sino que debe recibir el estado que tenía el pod caído. Kubernetes es capaz de gestionar estos casos mediante un controlador específico (llamado StatefulSet), pero lo ideal es que nuestras aplicaciones sean stateless.

Post original escrito por Eduard Tomás en campusMVP

10 Diferencias entre .NET Core y .NET Framework

campusMVP — Tue, 19 Mar 2019 08:00:00 +0000

Post original escrito por José María Aguilar en campusMVP

Seguro que todos los desarrolladores que trabajáis normalmente usando herramientas Microsoft habéis oído hablar bastante de .NET Core en los últimos tiempos. Incluso quizás muchos de vosotros habéis tenido oportunidad de trabajar con este nuevo framework y ya conocéis sus principales características y las bondades (e incluso algún que otro inconveniente) que ofrece sobre el ya clásico .NET Framework.

Pero probablemente sois muchos también los que sólo lo conocéis de oídas, pues vuestro día a día está más enfocado al mantenimiento de sistemas existentes, o quizás trabajáis sobre tecnologías que están ancladas a versiones determinadas del framework .NET, o simplemente el fragor de la batalla diaria no os deja tiempo para explorar nuevos horizontes.

Si este último es tu caso, lo mínimo que debes saber es que .NET Core es una implementación del estándar .NET que , al igual que otras implementaciones como .NET Framework o Mono, incluye todo lo necesario para crear y ejecutar aplicaciones : como los compiladores, las bibliotecas de clases básicas o la máquina virtual o runtime que proporciona el entorno donde se ejecutan las aplicaciones.

En otras palabras, con .NET Core puedes crear una aplicación con lenguajes como C# o VB.NET, utilizar en ella clases básicas como las habituales string, int o List<T>, compilarla a bytecode CIL y ejecutarla en tu ordenador.

Entonces, ¿qué diferencia a .NET Core de .NET Framework? Pues precisamente eso es lo que vamos a ver en este artículo 😉

1. NET Core es nuevo, y escrito prácticamente desde cero

.NET Core es, en muchos sentidos, un reboot de .NET Framework y ha tenido que ser reescrito desde cero. Obviamente se han aprovechado las APIs, ya estandarizadas y conocidas por todos los desarrolladores, pero internamente se han vuelto a implementar muchos componentes para poder lograr los ambiciosos objetivos que se plantearon en su diseño y que veremos en algunos puntos siguientes.

2. .NET Core es open source

Aunque determinados componentes del stack clásico, como ASP.NET MVC o Entity Framework, habían sido publicados bajo licencias open source, .NET Framework no era un marco de trabajo abierto en su totalidad y aún tiene piezas distribuidas bajo licencias propietarias.

.NET Core es un proyecto completamente open source desde sus orígenes. De hecho, aunque dirigido y soportado oficialmente por Microsoft, el proyecto pertenece a la .NET Foundation y en su desarrollo están involucrados activamente cientos de desarrolladores de todo el mundo, que pueden participar en su diseño y realizar contribuciones de cualquier tipo al framework.

3. .NET Core es multiplataforma

Sin duda, una de las características .NET Core que más lo diferencian respecto a sus predecesores es su capacidad real de funcionar en múltiples plataformas , incluyendo algunas impensables hace sólo algunos años, como Linux o macOS.

Los SDK y runtimes están disponibles para una gran variedad de sistemas operativos y distribuciones (Windows, macOS, Ubuntu, RHEL, Debian, Fedora, CentOS...), lo que hace que sea posible desarrollar aplicaciones sobre cualquiera de las plataformas soportadas y ejecutarlas también sobre cualquiera ellas. De esta forma, ahora sería totalmente posible, por ejemplo, programar una aplicación en Windows y ejecutarla en un Mac, o desarrollarla en Mac y ejecutarla en una distribución Debian de Linux.

De la misma forma, es compatible con distintas arquitecturas de procesador , como x64, x86 o ARM, lo que posibilita su uso en diversos tipos de dispositivo.

4. .NET Core es modular

.NET Framework es un bloque monolítico que ha ido creciendo con el tiempo hasta convertirse en algo difícil de manejar. Por ejemplo, las distintas versiones o revisiones actualizan el framework completo, muchas veces sobrescribiendo las versiones anteriormente instaladas (con los problemas que esto podría provocar). También, suelen estar bastante distanciadas en el tiempo, porque se trata de actualizaciones completas del marco de trabajo.

En cambio, .NET Core está formado por distintas piezas distribuidas a través de paquetes NuGet. De esta forma, las correcciones a bugs o mejoras en componentes concretos pueden distribuirse y actualizarse de forma independiente al resto, sólo actualizando el paquete correspondiente. Sin duda, un modelo mucho más ágil y eficiente que el anterior, y que permite un ritmo de evolución mucho más rápido.

5. Las operaciones principales de .NET Core se realizan desde línea de comandos

Para conseguir ser cross platform real, era absolutamente imprescindible que las herramientas de .NET Core estuviesen disponibles en Windows, Linux y Mac. ¿Y cómo conseguirlo de la forma más sencilla? Pues acudiendo al denominador común: la línea de comandos.

A diferencia de .NET Framework, donde a veces nos encontrábamos casi obligados a utilizar Visual Studio, para compilar, ejecutar, testear o publicar aplicaciones .NET Core basta con tener a mano la línea de comandos de cada sistema operativo y utilizar las órdenes de la CLI (Command Line Interface) proporcionada por el framework.

Aquí tienes algunos ejemplos de comandos en acción:

C:\Test>dotnet new console
Preparándose...
La plantilla "Console Application" se creó correctamente.

Procesando acciones posteriores...
Ejecutando "dotnet restore" en C:\Test\Test.csproj...
  Restaurando paquetes para C:\Test\Test.csproj...
  Generación de archivo MSBuild C:\Test\obj\Test.csproj.nuget.g.props.
  Generación de archivo MSBuild C:\Test\obj\Test.csproj.nuget.g.targets.
  Restauración realizada en 147,78 ms para C:\Test\Test.csproj.

Restauración correcta.

C:\Test>dotnet build
Microsoft (R) Build Engine versión 15.9.20+g88f5fadfbe para .NET Core
Copyright (C) Microsoft Corporation. Todos los derechos reservados.

  Restauración realizada en 23,44 ms para C:\Test\Test.csproj.
  Test -> C:\Test\bin\Debug\netcoreapp2.2\Test.dll

Compilación correcta.
    0 Advertencia(s)
    0 Errores

Tiempo transcurrido 00:00:00.52

C:\Test>dotnet run
Hello World!

C:\Test>_

6. .NET Core puede distribuirse de varias formas

Como seguramente sabes ya, .NET Framework se distribuye a través paquetes descargables que se instalan en el equipo de forma única, es decir, sólo puede existir una copia a nivel de equipo. Además, determinadas versiones (principalmente actualizaciones) sobrescriben la versión instalada anteriormente, por lo que puede dar lugar a problemas si tenemos aplicaciones que dependen de versiones específicas.

.NET Core es mucho más flexible en este sentido : el framework puede estar instalado a nivel de equipo, como .NET Framework, pero también podemos hacerlo a nivel de usuario o incluso a nivel de aplicación (es decir, que cada aplicación incluya su propia copia de .NET Core).

Además, distintas versiones y revisiones pueden convivir sin problemas en el mismo equipo. Por ejemplo, la siguiente traza de consola muestra el resultado de invocar el comando dotnet --info, donde aparecen las distintas versiones del SDK y runtimes instalados en mi equipo:

C:\>dotnet --info
SDK de .NET Core (reflejando cualquier global.json):
 Version: 2.2.102
 Commit: 96ff75a873

Entorno de tiempo de ejecución:
 OS Name: Windows
 OS Version: 10.0.17763
 OS Platform: Windows
 RID: win10-x64
 Base Path: C:\Program Files\dotnet\sdk\2.2.102\

Host (useful for support):
  Version: 2.2.1
  Commit: 878dd11e62

.NET Core SDKs installed:
  1.1.11 [C:\Program Files\dotnet\sdk]
  2.1.202 [C:\Program Files\dotnet\sdk]
  2.1.503 [C:\Program Files\dotnet\sdk]
  2.2.102 [C:\Program Files\dotnet\sdk]

.NET Core runtimes installed:
  Microsoft.AspNetCore.All 2.1.7 [C:\Program Files\dotnet\shared\Microsoft.AspNetCore.All]
  Microsoft.AspNetCore.All 2.2.1 [C:\Program Files\dotnet\shared\Microsoft.AspNetCore.All]
  Microsoft.AspNetCore.App 2.1.7 [C:\Program Files\dotnet\shared\Microsoft.AspNetCore.App]
  Microsoft.AspNetCore.App 2.2.1 [C:\Program Files\dotnet\shared\Microsoft.AspNetCore.App]
  Microsoft.NETCore.App 1.0.13 [C:\Program Files\dotnet\shared\Microsoft.NETCore.App]
  Microsoft.NETCore.App 1.1.10 [C:\Program Files\dotnet\shared\Microsoft.NETCore.App]
  Microsoft.NETCore.App 2.0.9 [C:\Program Files\dotnet\shared\Microsoft.NETCore.App]
  Microsoft.NETCore.App 2.1.7 [C:\Program Files\dotnet\shared\Microsoft.NETCore.App]
  Microsoft.NETCore.App 2.2.1 [C:\Program Files\dotnet\shared\Microsoft.NETCore.App]

To install additional .NET Core runtimes or SDKs:
  https://aka.ms/dotnet-download

C:\>_

7. .NET Core no soporta todos los modelos de aplicación ni todos los frameworks

Lo más habitual es que a la hora de construir aplicaciones lo hagamos subidos a hombros de gigantes, es decir, utilizamos frameworks que nos ayudan a desarrollar más rápidamente y con menos errores. Por ejemplo, si vamos a crear una aplicación web, lo habitual es usar ASP.NET, si nuestra aplicación es de escritorio podríamos usar WinForms o WPF, o si vamos a acceder a datos, una opción razonable es Entity Framework.

Pues bien, muchos de estos frameworks sólo funcionan sobre las plataformas para las que han sido creados. Por ejemplo, SignalR, ASP.NET MVC o Entity Framework 6 sólo funcionarán sobre .NET Framework porque es el framework para el que han sido construidos.

Como consecuencia, a día de hoy, con .NET Core 2.x sólo podemos crear determinados tipos de aplicaciones : consola, web (ASP.NET Core) y Xamarin. Esto limita algo las posibilidades de uso de este framework, pero, afortunadamente, esto va a cambiar en un futuro próximo: previsto para 2019, .NET Core 3.0 incluirá soporte para WPF y Windows Forms , que se beneficiarán de algunas de las ventajas que aportan este nuevo marco de trabajo.

En definitiva, a la hora de desarrollar con .NET Core debemos utilizar marcos de trabajo específicos para esta plataforma , como ASP.NET Core, Entity Framework Core o SignalR Core.

8. En .NET Core el rendimiento es algo prioritario

Desde sus orígenes, en .NET Core el rendimiento ha sido siempre una prioridad , y esto se pone de manifiesto en los benchmarks que demuestran que este framework supera a su predecesor con creces en este aspecto.

Por dar algunas cifras, algo tan simple y recurrente como utilizar los métodos IndexOf() o StartsWith() sobre una cadena son un 200% más rápidos en .NET Core que en .NET Framework. Un ToString() sobre el elemento de un enum gana un 600% de rendimiento. LINQ es hasta un 300% más eficiente en determinados puntos. Lazy<T> es un 500% más rápido...

Beneficiarios directos de estas mejoras son los frameworks específicos como ASP.NET Core o Entity Framework Core. Por ejemplo, el primero de ellos se ha situado ya sólidamente en los top ten de los marcos de trabajo más rápidos para la web según las pruebas TechEmpower soportando más de 7 millones de peticiones por segundo , algo impensable en ASP.NET 4.x.

9. .NET Core ha sido creado pensando en los tiempos modernos

Cuando se creó .NET Framework, hace más de quince años, una nube era simplemente un agregado visible de minúsculas gotitas de agua, de cristales de hielo o de ambos, suspendido en la atmósfera y producido por la condensación de vapor de agua (RAE dixit), los contenedores se usaban exclusivamente para almacenar cosas diversas, como mercancías o residuos, y probablemente al hablar de microservicios sólo podíamos pensar en cuartos de baño pequeñitos 😆

Hoy en día, el cloud está presente en casi cualquier aspecto del desarrollo, sobre todo en aplicaciones que, de alguna u otra forma, hacen uso de Internet. Los contenedores se han consolidado como una forma simple, ágil y escalable para desplegar aplicaciones, y los microservicios se han demostrado como arquitecturas apropiadas en múltiples escenarios.

.NET Core y los frameworks construidos sobre él han sido creados teniendo en cuenta todos estos aspectos. Sus componentes están diseñados con el enfoque cloud-first en mente, por lo que se integran a la perfección en infraestructuras de nube. Se trata además de una tecnología especialmente recomendada para la construcción de microservicios, entre otros aspectos, por la facilidad con que pueden ser creados y distribuidos en contenedores.

10. Se pueden desarrollar aplicaciones .NET Core con cualquier editor o IDE

Ni a nuestros más acérrimos enemigos le desearíamos algo tan terrible como crear aplicaciones para .NET Framework sin Visual Studio. De hecho, aunque técnicamente era evitable, en muchos modelos de aplicación (por ejemplo, WinForms, WPF o ASP.NET) era prácticamente obligatorio utilizar el IDE de Microsoft.

Por el contrario, con .NET Core tenemos libertad completa a la hora de elegir el editor que utilizaremos en el desarrollo de nuestros proyectos. Si trabajamos sobre Windows, muchos preferimos seguir utilizando Visual Studio en el día a día (al fin y al cabo, es el mejor IDE 😜, pero hay quien prefiere trabajar con Visual Studio Code, o con editores alternativos como Atom, Brackets o Sublime Text. Y si trabajamos desde Linux o Mac, podemos utilizar cualquier editor disponible en dichos entornos.

Corolario: .NET Core es tu próximo framework

Lo queramos o no, .NET Core se convertirá en algún momento en la herramienta que usaremos en nuestro día a día. Aunque en principio .NET Framework seguirá existiendo y Microsoft continuará dándole soporte, la tendencia actual indica que todo está confluyendo en .NET Core : Xamarin, WPF, WinForms, Entity Framework, SignalR o MVC son sólo algunos ejemplos de frameworks que ya están o van a estar pronto basados en la nueva infraestructura.

Además, es lógico pensar que estos marcos de trabajo continuarán evolucionando exclusivamente sobre .NET Core. Sólo hay que mirar un poco hacia atrás y ver que en los últimos dos años han aparecido ya varias versiones completas de frameworks como Entity Framework Core o ASP.NET Core, mientras que EF o ASP.NET MVC "clásicos" apenas han lanzado pequeñas actualizaciones.

En nuestro curso de ASP.NET Core MVC se estudia a fondo la creación de aplicaciones Web con el nuevo framework de Microsoft. ¿A qué esperas para dar el salto?

Post original escrito por José María Aguilar en campusMVP: https://www.campusmvp.es/recursos/post/10-diferencias-entre-net-core-y-net-framework.aspx

SAP hace Open Source su herramienta de análisis de vulnerabilidades para Java y Python

campusMVP — Fri, 15 Mar 2019 08:00:00 +0000

SAP recientemente ha hecho Open Source y ha liberado por tanto el código de su herramienta de evaluación de vulnerabilidades de código VAT (Vulnerability Assesment Tool).

La herramienta sirve para analizar código de Java y de Python , y ha sido probada durante dos años internamente, realizando más de 20.000 análisis en unos 600 proyectos de la compañía.

Se centra en la detección de componentes Open Source que utilice tu proyecto y que sean vulnerables, y utiliza tanto análisis estático como testeo automatizado para determinar el contexto en el que se ejecuta el código y mejorar la precisión de los resultados. Así:

Detecta si hay dependencias de componentes de código abierto que tengan vulnerabilidades conocidas y además te informa de novedades de seguridad relacionadas con ellos.
Recaba evidencias sobre la ejecución del código vulnerable en diversos contextos de la aplicación
Da soporte a los desarrolladores para que puedan arreglar los problemas.

Trata de abordar todos los problemas especificados en el Top10 de OWASP A9, que suelen ser las causas de la mayor parte de las brechas de seguridad. Utiliza las bases de datos de vulnerabilidades del gobierno estadounidense, y la lista CVE. Funciona tanto en desarrollo como en producción.

Según SAP, la mayor parte de los problemas de seguridad que se producen en las aplicaciones expuestas a Internet son causadas por no actualizar componentes que se sabe que son vulnerables. Muchas empresas tardan meses en hacerlo y otras no lo hacen nunca. Con VAT la idea es que puedas arreglarlas a las pocas horas o como mucho, días.

Se puede usar directamente como un contenedor Docker para ponerlo a funcionar de manera rápida y sencilla. Y por supuesto se puede descargar el código fuente y compilarlo.

Aquí te dejamos la página en Github del proyecto.

Post original: https://www.campusmvp.es/recursos/post/sap-hace-open-source-su-herramienta-de-analisis-de-vulnerabilidades-para-java-y-python.aspx

Descifrando Java: lenguaje, plataforma, ediciones, implementaciones...

campusMVP — Wed, 13 Feb 2019 10:17:20 +0000

El lenguaje Java se utiliza para programar aplicaciones que pueden ser ejecutadas en distintas plataformas, entre ellas las distintas ediciones de la propia plataforma Java. Esta se encuentra disponible para los sistemas operativos más extendidos, como son Microsoft Windows, Apple OS X y GNU/Linux, así como para otros con un uso más minoritario, como es el caso de Solaris.

En realidad una aplicación estándar Java, una vez compilada, puede ser ejecutada sobre cualquier sistema para el que haya disponible alguna versión del entorno de ejecución de Java, conocido como JRE (Java Runtime Environment). Asimismo, también es posible compilar para una plataforma diferente.

Es necesario distinguir claramente entre dos partes muy diferenciadas dentro de la plataforma Java:

JRE (Java Runtime Environment): su objeto es aportar el entorno necesario para ejecutar una aplicación Java. Forman parte del JRE la máquina virtual Java o JVM (Java Virtual Machine), encargada de ejecutar el bytecode Java, así como las bibliotecas que ofrecen los servicios definidos en la plataforma.
JDK (Java Development Kit): es el paquete de herramientas precisas para llevar a cabo el desarrollo de dicha aplicación. Este JDK es un superconjunto del JRE, al que agrega herramientas como el compilador Java. Este toma el código fuente Java y genera como resultado bytecode, un formato de código objeto independiente del sistema operativo y el hardware.

La siguiente figura ilustra de manera visual la relación existente entre los diferentes componentes de la plataforma Java (pulsa para aumentar):

Tanto las herramientas aportadas por el JDK como los servicios ofrecidos por el JRE dependerán fundamentalmente de la edición de Java que esté utilizándose.

Ediciones de la plataforma Java

La configuración de una plataforma Java afecta fundamentalmente a los servicios que esta ofrece, las herramientas adicionales que incorpora y también a aspectos menos visibles, como el modo de funcionamiento de la JVM. De acuerdo a la documentación actual de Oracle podemos distinguir las siguientes cuatro plataformas Java:

Java SE: la conocida como Standard Edition es la edición más difundida de la plataforma Java. Incorpora los elementos necesarios para crear aplicaciones de escritorio con o sin interfaz gráfica de usuario, acceso al sistema de archivos, comunicación a través de redes, concurrencia y otros servicios básicos.
JavaFX: originalmente JavaFX era una alternativa a Java SE para el desarrollo de proyectos de tipo RIA (Rich Internet Applications), con un núcleo más ligero y fácil de distribuir, capacidad de aceleración 3D aprovechando la GPU, servicios avanzados para producción de gráficos y animaciones, y un mecanismo simplificado para el diseño de interfaces de usuario. JavaFX forma parte de Java SE desde la versión 7 de dicha edición de la plataforma.
Java EE: es la Enterprise Edition de la plataforma Java, dirigida al desarrollo de soluciones software que se ejecutarán en un servidor de aplicaciones. A las capacidades de Java SE, la edición EE agrega servicios para gestionar la persistencia de objetos en bases de datos, hacer posible la invocación remota de métodos, crear aplicaciones con interfaz de usuario web, etc.
Java ME: esta edición de la plataforma, Micro Edition, está enfocada a la creación de programas que se ejecutarán en sistemas con recursos limitados, tales como teléfonos móviles, electrodomésticos y dispositivos de domótica o equipos para entornos empotrados como la Rasperry Pi y similares.

Nota: Java SE, EE, ME, la JVM y otras partes de Java son en realidad especificaciones abstractas de los servicios y modos de funcionamiento de los distintos elementos de la plataforma. Encontraremos múltiples implementaciones de dichas especificaciones. Por ejemplo, HotSpot es la implementación de Oracle de la JVM, existiendo implementaciones alternativas de esa misma especificación como la de OpenJDK o la de IBM.

Por regla general, salvo que tengamos alguna necesidad más específica de desarrollo, partiremos siempre de la Java SE, procediendo después a instalar plataformas adicionales en caso de que precisemos algún servicio no disponible en la edición estándar.

Java y sistemas operativos

Para ejecutar aplicaciones desarrolladas en Java sobre un sistema operativo es necesario que exista para el mismo una implementación concreta de la plataforma.

Además de la implementación de cada plataforma procedente de Oracle, que podría considerarse la oficial o de referencia y que está disponible para múltiples sistemas, podemos encontrar otras alternativas:

OpenJDK, la organización respaldada por Oracle cuyo objetivo es mantener una versión de código abierto de la plataforma Java, ofrece Java SE para múltiples distribuciones de GNU/Linux.
Si queremos utilizar OpenJDK en otros sistemas, como Windows u OS X, podemos recurrir a Zulu.
IBM también ofrece su propia implementación de la plataforma Java, conocida como IBM J9, para GNU/Linux, así como para varios de sus sistemas operativos para mainframes y derivados de UNIX, como AIX y z/OS.

Nota: La implementación de Java SE de Oracle está basada en el código de OpenJDK, por lo que estas dos variantes comparten un núcleo funcionalmente idéntico.

Si nuestro objetivo es desarrollar para dispositivos embebidos, tales como Smart TV o dispositivos tipo Raspberry Pi, encontraremos versiones específicas de la plataforma Java para tal fin. Un ejemplo de ello son las versiones Embedded de Java SE y Java ME de la propia Oracle. También derivadas de OpenJDK, se están preparando versiones de Java SE para iOS, Android y Windows Mobile.
Android es un sistema operativo algo especial en cuanto a la ejecución de aplicaciones Java, ya que incorpora un entorno de ejecución propio, llamado ART (Android RunTime), en lugar de la correspondiente implementación del JRE. Las aplicaciones para Android se desarrollan usando el JDK de Java SE, pero el código se compila posteriormente para ART.

Espero que esto te ayude a tener clara la diferencia que existe entre Java, la plataforma Java, sus componentes y sus diferentes implementaciones.

Post original por Francisco Charte en el blog de campusMVP

Los 5 lenguajes de programación más fáciles de aprender

campusMVP — Fri, 08 Feb 2019 08:00:00 +0000

Post original: https://www.campusmvp.es/recursos/post/los-5-lenguajes-de-programacion-mas-faciles-de-aprender.aspx

Aprender a programar puede ser una tarea ardua, en cambio, no es tan difícil como parece. El acceso a la información es prácticamente ilimitado: hoy en día existen una gran cantidad de recursos tanto online como offline, además de comunidades de desarrolladores y expertos en programación que comparten su conocimiento.

Sin embargo, a la hora de aprender a programar es tan importante escoger el lenguaje adecuado como el proceso de aprendizaje. En un post anterior os hablamos de cómo aprender a programar. En este artículo encontraréis los 5 lenguajes de programación más fáciles de aprender.

Antes de continuar conviene aclarar a qué nos referimos con la palabra fácil , pues su significado varía de un lenguaje a otro, es decir, lo que hace que un lenguaje de programación sea "fácil" de aprender cambia de uno a otro. Por ejemplo: algunos lenguajes cuentan con una sintaxis intuitiva; otros, si bien pueden ser teóricamente más complejos, el hecho de tener una comunidad muy activa puede compensar esa dificultad. Además, se trata de una cuestión bastante subjetiva, pero creemos que la selección es interesante ya que contempla lenguajes que no tienen sintaxis complicadas ni requieren grandes conocimientos previos para arrancar con ellos.

JavaScript

JavaScript es el lenguaje más utilizado y con más demanda actualmente, y se encuentra integrado en numerosas aplicaciones. Si deseas dedicarte al desarrollo web, aprender JavaScript es un indispensable ya que se ejecuta nativamente en cualquier navegador, por lo que no necesitas compilarlo. Solo necesitas un bloc de notas para empezar.

Se trata de un lenguaje débilmente tipado, lo hace que resulte más fácil de aprender, aunque también más fácil que puedas meter la pata. Su sintaxis es similar a la de otros lenguajes, como C, C++, Java o C#, por lo que también sirve como puerta de entrada para luego seguir estudiando lenguajes de programación más complejos.

Nota : no confundir JavaScript con Java. Nuestro experto tutor de JavaScript te lo aclara en este post, básico pero necesario.

Usos

Desarrollo web
Desarrollo backend
Aplicaciones IoT
Otros

Pros

Sencillo
Múltiples posibles aplicaciones
Multiplataforma
Es un estándar
Puerta de entrada hacia otras tecnologías

Contras

Débilmente tipado
Más difícil detectar bugs de tipo lógico

Java

Java se utiliza tanto en aplicaciones web como de escritorio, en servidores, etc... No en vano su eslogan siempre fue "Escribe una vez, ejecuta en todas partes" cuando esto no era ni mucho menos lo habitual como ahora. Este lenguaje de programación orientado a objetos basado en clases, está siempre en los primeros puestos en las clasificaciones de popularidad y de demanda de empleo.

Su inmensa popularidad se refleja en que:

Java dispone de una de las comunidades de desarrolladores más grandes y activas, por lo que nunca te sentirás solo.
Especialmente las grandes empresas siempre están buscando gente con conocimientos de Java.
Existen más de 15.000 millones de dispositivos que ejecutan Java

Aprender Java entraña más dificultad que JavaScript porque tiene muchos tipos de datos y miles de clases en sus paquetes. Pero, al fomentar una base sólida de conocimientos de programación analítica, Java sigue siendo un lenguaje de programación fantástico, aunque un poco más difícil, para principiantes.

Usos

Desarrollo web backend
Desarrollo de escritorio
Desarrollo móvil

Pros

Popularidad y demanda
Lenguaje estable
Gran comunidad de apoyo

Contras

Perdona mucho menos los fallos.
Hay que aprender también la plataforma Java, con decenas de miles de clases, lo que puede ser desafiante
Precisa mayor capacidad de pensamiento analítico.

Python

Python es un gran lenguaje de programación fácil para principiantes. Utilizado en aplicaciones web y de escritorio, Python ha aumentado mucho en popularidad en los últimos años gracias a ser el lenguaje más utilizado en Machine Learning e Inteligencia Artificial. Este lenguaje dinámico es compatible con programación orientada a objetos, procedimientos y programación funcional.

Además, es un lenguaje open-source y, al igual que Java, dispone de una devota comunidad.

Gracias además a su flexibilidad y versatilidad, Phyton es un lenguaje recomendado para principiantes.

Usos

Aplicaciones web
Aplicaciones de escritorio.
Machine Learning e Inteligencia Artificial

Pros

Sintaxis sencilla
Avanzas enseguida
Gran comunidad

Contras

No es indicado para ciertos tipos de desarrollo, por ejemplo, para aplicaciones móviles

C

C# es una opción increíble para principiantes. Hay una manera muy rápida y sencilla de probarlo: basta descargar Visual Studio Community. C # se puede usar para una gran variedad de propósitos, desde el desarrollo web hasta las aplicaciones de consola y gracias a la plataforma .NET se puede crear prácticamente de todo: apps de escritorio, servidores, cloud, móviles...

La sintaxis de C# se base en C++ (y en Java), por lo que a priori podría parecer un lenguaje complejo para principiantes. Sin embargo, las opciones de autocompletado de Visual Studio, la auto-creación de proyectos y la facilidad de uso de su entorno de desarrollo en general, son aspectos que hacen que este lenguaje sea una buena opción para las personas que se inician en la programación.

Usos

Aplicaciones web backend
Aplicaciones de escritorio
Aplicaciones móviles
Aplicaciones Cloud

Pros

Ampliamente usado
Visual Studio allana mucho el aprendizaje y disminuye los fallos
IDE fácil de usar

Contras

Hay que aprender también la plataforma .NET con decenas de miles de clases, lo que puede ser desafiante
El despliegue en ciertos entornos puede ser complejo

Ruby on Rails

Ruby on Rails es fácil de leer, ya que está diseñado para parecerse al inglés, lo cual supone una gran ventaja para cualquier persona sin experiencia de programación. Ruby es un lenguaje orientado a objetos dinámico que se usa mucho en el desarrollo web.

Aprender Ruby on Rails (Ruby es el lenguaje de programación y Rails es un framework de aplicación web que funciona con dicho lenguaje) es muy, muy fácil ya que no es necesario aprender cientos o miles de clases. Y además facilita mucho enlazar a datos y otras operaciones normalmente complejas.

Es el lenguaje elegido por muchas empresas que empiezan ya que se puede decir que no tiene barreras de entrada.

Usos

Desarrollo web

Pros

Curva de aprendizaje casi plana
Gran rapidez de desarrollo de aplicaciones web, ves resultados rápido

Contras

Ha caído bastante en desuso en los últimos años ante nuevas opciones
La comunidad es menor que la de otros lenguajes

Post original: https://www.campusmvp.es/recursos/post/los-5-lenguajes-de-programacion-mas-faciles-de-aprender.aspx