domingo, 7 de mayo de 2017

Construyendo proyectos con Gradle (instalación con SDKMAN!)

Gradle es una herramienta que nos permite construir proyectos Java, Groovy, Scala, etc. de una manera más sencilla que usando Maven.

¿Cómo instalar Gradle? 
La más sencilla es usando SDKMAN!, solo basta que escribas en la terminal:
$sdk install gradle

Así tendrás instalado la última versión, para comprobar que versión tienes instaladas tecleas:
$gradle --version o $gradle -v

Saldrá algo como esto:
------------------------------------------------------------
Gradle 3.5
------------------------------------------------------------

Build time:   2017-04-10 13:37:25 UTC
Revision:     b762622a185d59ce0cfc9cbc6ab5dd22469e18a6

Groovy:       2.4.10
Ant:          Apache Ant(TM) version 1.9.6 compiled on June 29 2015
JVM:          1.8.0_131 (Oracle Corporation 25.131-b11)
OS:           Linux 4.4.0-75-generic amd64



Ahora nos ubicaremos en una carpeta y escribiremos un archivo llamado build.gradle. Dentro del archivo escribiremos lo siguiente:

task holaMundo << {
    println "Hola, mundo!"
}


Se trata de una simple tarea (task) denominada "holaMundo".

Para ejecutar el script escribiremos lo siguiente en la terminal:
$gradle -q build.gradle
$gradle -q holaMundo

Y obtendremos:
Hola, mundo!


Listo. Nuestro primer ejemplo esta hecho. En el siguiente post se verá la estructura de un proyecto Java usando Gradle .

Links:
https://gradle.org/
https://maven.apache.org/ 
http://codemonkeyjunior.blogspot.mx/search?q=maven
http://codemonkeyjunior.blogspot.mx/search?q=gradle

jueves, 13 de abril de 2017

JDBI con Groovy (3)



Siguiendo con el tema de JDBI está ocasión veremos una pequeña aplicación del tipo CRUD (altas, bajas, consultas y modificaciones).

Necesitamos crear una base de datos;

CREATE DATABASE test;

Una vez creada procedemos a seguir con estos pasos.

  1. Crear un archivo *.sql llamado bien.sql para la creación de la tabla
  2. Crear una BD en MySQL
  3. Usar el archivo *.sql de la siguiente manera: $ mysql -u USUARIO -pCLAVE test  < bien.sql
  4. Crear un archivo froovy llamado Dao2.groovy
  5. Importar las librerías necesarias para manipular datos y crear un log: jdbi, slf4j, y mysql mediante @Grapes
  6. Crear una interface llamada BienDAO; esta interface contendrá los métodos con las declaraciones necesarias para la gestión de los datos
  7. Crear una clase serializable llamada ModeloBien
  8. Crear una clase que implemente la interface ResultSetMapper
  9. Crear una clase principal (en este caso tendrá el mismo nombre del archivo)
bien.sql
CREATE TABLE IF NOT EXISTS bien(id int auto_increment primary key,numero int, usuario varchar(45), password varchar(32), maquina ENUM('pc','macosx','laptop_pc','laptop_macosx','movil'), sistema ENUM('windows','macosx','linux','android'), area ENUM('direccion','sistemas','soporte','hemeroteca','evaluacion','investigacion'), ip varchar(15), no_bien varchar(45));
INSERT INTO bien (numero, usuario, password, maquina, sistema, area, ip, no_bien) VALUES ('39','Yuri Gagarin','5432','pc','windows','sistemas','148.215.24.39','7749'),('36','Maria Petrovska','009GT2b','pc','linux','hemeroteca','148.215.24.36','7767'),('90','Tulio Alvarez','$36@L77','laptop_macosx','macosx','investigacion','172.215.22.25','4343');
UPDATE bien SET area='investigacion' WHERE id=2;
UPDATE bien SET area='soporte' WHERE id=1;
DELETE FROM bien WHERE id=3;
SELECT * FROM bien;


$ mysql -u TUUSUARIO -pTUCLAVE test < bien.sql

 Esto nos permitirá cargar los datos contenidos en el archivo.

El programa consiste en un menú que te dará las opciones de insertar, consultar por id, consultar todos los registros, actualizar los datos por id y eliminar datos por id.


 compilar: groovyc Dao2.groovy
 ejecutar: groovy Dao2.groovy TUUSUARIO TUCLAVE


Ejemplo de uso y salida: 
$ mysql -u root -p5432 test < bien.sql

$ groovyc Dao2.groovy

$groovy Dao2.groovy root 5432

[main] INFO jdbi - Iniciando script ...
[main] INFO jdbi - usuario: root
[main] INFO jdbi - password: 5432
    ******* Menu *******
1. Insertar datos
2. Consultar datos por id
3. Consultar total de datos
4. Actualizar datos por id
5. Eliminar datos por id
6. Salir
*******************************
Escoge una opción:2
    [Consulta por id]

Escribe el id:
2
    >> Id: 2
    >> Número: 36
    >> Usuario: Maria
    >> Password: 009GT2b
    >> Máquina: pc
    >> Sistema: linux
    >> Área: investigacion
    >> Ip: 148.215.24.36
    >> No_bien: 7767
    Búsqueda realizada
    ******* Menu *******
1. Insertar datos
2. Consultar datos por id
3. Consultar total de datos
4. Actualizar datos por id
5. Eliminar datos por id
6. Salir
*******************************
Escoge una opción:




 Dao2.groovy


domingo, 9 de abril de 2017

JDBI con Groovy (2)

En esta ocasión veremos un ejemplo del uso de JDBI con Groovy.
  1. Una clase principal llamada Dao.groovy
  2. Una interface llamada MyDAO
 MyDAO contendrá los método necesarios para crear una tabla, insertar valores, buscar un registro mediante su id y ,por último un método para cerrar.

El código viene de la página oficial de JDBI. Espero les sirva.



jueves, 5 de enero de 2017

JDBI con Groovy

En esta ocasión usaremos Groovy para crear una aplicación usando JDBI. Prácticamente es el mismo código usado la vez anterior que se dio un vistazo a JDBI. La diferencia radica en el uso de @Grapes y Grab para importar y cargar las librerías necesarias.
He aquí el código


martes, 1 de noviembre de 2016

Un vistazo a Node.js

Node.js es un entorno de ejecución para aplicaciones hechas con Javascript. Posee un ecosistema de paquetes (npm) que nos provee una manera más fácil para el desarrollo de nuestras aplicaciones.

Existen diversas maneras de instalar Node.js. Una de ellas es mediante nvm.

Para ello podemos teclear la siguiente orden en la terminal de comandos (si usas Linux, debo aclarar):

curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.32.1/install.sh | bash


Para que surja efecto hay que teclear:
source ~/.bashrc

Listo, tenemos instalado nvm:
nvm --version

Para instalar node tecleamos: 
nvm install node

Para instalar el gestor de paquetes npm:
nvm install npm

Comprobamos su instalación:
node -v
npm -v 

Ahora a crear el primer ejemplo.
1. Creamos un archivo llamado hola.js
2. Ejecutamos el script mediante node


hola.js
console.log("Hola, Codemonkeys");


En terminal tecleamos:
node hola.js
 

Ya tenemos nuestro primer ejemplo en Node.js

Links
https://github.com/creationix/nvm
https://nodejs.org/es/

sábado, 13 de agosto de 2016

domingo, 26 de junio de 2016

Instalar lenguajes JVM usando SDKMAN!

Existe una herramienta llamada SDKMAN! que nos sirve para instalar lenguajes como Ceylon, Groovy, Scala, además de otros entornos o sdks de desarrollo como Grails, SBT, etc.

Desde Linux podemos teclear en nuestra consola de comandos:
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"

Obtener ayuda:  sdk help
Que versión tenemos: sdk version
Listar lo que podemos instalar: sdk list

Comencemos instalando Ceylon, Groovy, y Scala:
sdk install ceylon
sdk install groovy

sdk install scala

Comprobemos que se instalaron adecuadamente:
ceylon --version
groovy -version
scala -version
 
Con esto tenemos instalados los lenguajes y la herramienta SDKMAN!.

Links
http://sdkman.io/

Vibe Coding y el Prompt engineering

Según san Google, la Ingeniería de prompts (prompt engineering) es: el arte y la ciencia de estructurar, diseñar y optimizar las entrada...

Etiquetas

Archivo del blog