Mostrando entradas con la etiqueta programación. Mostrar todas las entradas
Mostrando entradas con la etiqueta programación. Mostrar todas las entradas

lunes, 5 de septiembre de 2016

Enlaces interesantes. Agosto de 2016.

A modo de backup, vuelco aquí los enlaces interesantes que he encontrado este verano.

Cursos, MOOCs, Transparencias

Crimen, Mafia

Literatura y libros

Matemáticas

  • "This is a wiki-lab for collaborative work on Mathematics, Physics and Philosophy — especially from the n-point of view: insofar as these subjects are usefully treated with tools and notions of category theory or higher category theory.": https://ncatlab.org/nlab/show/HomePage

Juegos de rol

IoT, Microprocesadores, Electrónica

Programación

Seguridad informática

BigData, AI, NLP, Data Sets

Administración de Sistemas

Viajes

Publicado por en No hay comentarios:
Etiquetas: , , , , , , , , , ,

martes, 22 de septiembre de 2015

Mis podcasts favoritos

Un listado de los Podcasts que tengo configurados en la aplicación del móvil que uso para escucharos: Podcast Addict. También os la recomiendo encarecidamente. Los clasifico por temáticas, aunque casi todos son de programación. Pongo a mis favoritos un [*] a la derecha del nombre.




Publicado por en No hay comentarios:
Etiquetas: , , , , , ,

domingo, 20 de septiembre de 2015

Compite con los clásicos

"Hemingway advised Samuelson to avoid contemporary writers and compete only with the dead ones whose works have stood the test of time." (*)

Samuelson era un admirador de Hemingway. Lo mismo se podría aplicar hoy a los libros de programación. Hay que releer los "clásicos" ya que en ellos hay todavía mucha sabiduría encerrada que no hemos sabido interpretar bien.

(*) : Encontrado en un tweet de @MMFlint's
https://twitter.com/MMFlint/status/645489730356908032?s=09

Publicado por en No hay comentarios:
Etiquetas: , ,

viernes, 26 de diciembre de 2014

Lenguajes de alto nivel para microcontroladores

Últimamente estoy bastante interesado en la búsqueda de algún lenguaje funcional que me pueda servir para programar microcontroladores. En concreto investigo acerca de lenguajes funcionales que se puedan usar para programar las dos familias más populares de microcontroladores: los PIC y los Atmel AVR.

Hay muchas opiniones en internet sobre cuál de las dos familias es mejor que la otra. Después de leer varios post sobre este tema, mi conclusión es que ambas están muy parejas y que la elección tal vez dependa de nuevo de los gustos de cada cual. Aunque si me tuviera que decantar por alguno de los dos yo tiraría por los Atmel quizás porque últimamente son más populares que los PIC (con el apoyo de la comunidad que tiene detrás) y porque tienen algunas versiones que pueden funcionar con 0.7V de alimentación (para poder alimentarlos con una celda solar barata).

Como resultado de mi investigación (no muy fructífera) he encontrado algunos proyectos interesantes. Enumero a continuación no sólo lenguajes funcionales sino toda la variedad de lenguajes de alto nivel que he encontrado para programar microcontroladores (a parte del ensamblador del propio microcontrolador que no lo considero de alto nivel, aunque en él hay que programar las partes que requieren mayor rendimiento):
  • OCaPIC (OCaml)
  • PicoBIT (Scheme) - PIC
  • Forth: (la opción más viable, porque al menos a priori puede caber fácilmente en un micro)
    • avrforth 
    • amforth (8 a 12 KB de flash, 80 bytes de EEPROM, y 200 bytes de RAM). El amforth es muy prometedor.
    • rforth1: Un compilador de Forth para la familia 18Fxxx de microcontroladores PIC. Este mismo autor tiene también un Forth para la familia 16Fxxx de PICs.
  • .NET Micro - Aunque no investigado mucho este, parece que es sobre dispositivos más grandes.
  • uJ (Java) - PIC
  • NanoVM (Java) - Atmel.
  • B#: la "huella" en memoria es un poco grande (<24KB de flash y <2KB de RAM). Pero es un lenguaje de programación orientado a objetos específicamente diseñado para MCUs.
  • PyMite (Python): Huella de memoria grande (64KB de flash, 4KB de RAM).
  • eLua. Para MCUs muy grandes, me da la impresión.
  • ¿Alguna opción más? Seguro. Dejádmelo en los comentario y la pongo ;)
En uno de los enlaces que refiero abajo también sugieren programarse un intérprete personalizado de "pcode" que interprete un conjunto de instrucciones que tú definas.

Esto último parece una idea interesante así como también suena bien eso de poder crearse una especificación de máquina virtual que pudiera correr sobre dispositivos como MCUs. Hay algunas ya, pero visto que la JVM de Oracle/Sun son unas 200 microinstrucciones en la capa de VM parece factible poder generar un estándar o conjunto de instrucciones que pudiera servir para dispositivos de recursos más limitados.

¿Existe ya ese estándar? Porque estos dispositivos tienen una serie de características hardware que se podrían abstraer para luego poder programarlos más fácilmente.

Por último, hace poco terminé de leer y entender (que son dos cosas distintas) el paper de investigación que propició la creación del lenguaje Lisp y toda la belle époque de la inteligencia artificial de los años 80 y 90. Se trata de un artículo del gran John McCarthy titulado "Recursive Functions of Symbolic Expressions and Their Computation by Machine" (¡del año 1960! y todavía hoy en día relevante, que se lo apunten algunas mentes pensantes de nuestra época).

A partir de este paper se pueden extraer las operaciones fundamentales que dieron lugar a las primeras implementaciones del lenguaje Lisp. Con este germen tan prometedor: ¿se podría definir una VM basada en estas operaciones sobre MCUs?

En resumen:
Aunque parezca contradictorio, el poder programar un microcontrolador (MCU) con un lenguaje de alto nivel diferente a C (y al ensamblador, que de por sí no se puede calificar de alto nivel) aunque pueda resultar una idea peregrina a mí al menos me resulta altamente interesante. Máxime cuando la tendencia es que haya cada vez más dispositivos "embebidos" / empotrados / móviles como son los que constituyen la "Internet de las cosas" (IoT ó Intenet of Things en inglés).

¿El futuro o el pasado? Dejo al lector elegir.

Enlaces:
Publicado por en No hay comentarios:
Etiquetas: , , , , , ,

miércoles, 4 de diciembre de 2013

Características de las diferentes versiones de Java

A partir de Java 5 (1.5 en la numeración estándar de Oracle/Sun) se añaden a este lenguaje algunas características muy interesantes que intentan acercarlo a otros lenguajes "más modernos" diseñados "para el siglo XXI". Me refiero por ejemplo a Ruby, Python, Scala, etc. Enumero a continuación cada una de ellas, con la esperanza de poder hacer un artículo de cada una en el futuro.


Java 1.5


  • Genéricos (generics)
  • Bucle "for/in" (for/in loop)
  • Autoempaquetado/desempaquetado (autoboxing/unboxing)
  • Enumeraciones seguras con tipo (typesafe enums)
  • Argumentos variables (varargs)
  • Importaciones estáticas (static imports)
  • Anotaciones/metadatos (annotations/metadata)

Java 1.6


  • Servicios web y procesado de XML (web services and XML processing)
  • JDBC 4.0
  • Programación basada en anotaciones (annotation-based programming)
  • APIs de compilación de Java (Java compiler APIs)
  • APIs de escritorio (desktop APIs)
  • Scripting


Java 1.7


Las características de Java 7 y 8 están sacadas de la página web de OpenJDK, que tiene un formato bastante interesante en plan tabla "plain text".

Category    Description
================================================================================
vm          JSR 292: Support for dynamically-typed languages (InvokeDynamic)
            Strict class-file checking
lang        JSR 334: Small language enhancements (Project Coin)
core        Upgrade class-loader architecture
            Method to close a URLClassLoader
            Concurrency and collections updates (jsr166y)
i18n        Unicode 6.0
            Locale enhancement
            Separate user locale and user-interface locale
ionet       JSR 203: More new I/O APIs for the Java platform (NIO.2)
            NIO.2 filesystem provider for zip/jar archives
            SCTP (Stream Control Transmission Protocol)
            SDP (Sockets Direct Protocol)
            Use the Windows Vista IPv6 stack
            TLS 1.2
sec         Elliptic-curve cryptography (ECC)
jdbc        JDBC 4.1
client      XRender pipeline for Java 2D
            Create new platform APIs for 6u10 graphics features
            Nimbus look-and-feel for Swing
            Swing JLayer component
            Gervill sound synthesizer [NEW]
web         Update the XML stack
mgmt        Enhanced MBeans [UPDATED]

Java 1.8


 Category    JEP     Description
================================================================================
--/--       126     Lambda Expressions & Virtual Extension Methods
            138     Autoconf-Based Build System
            160     Lambda-Form Representation for Method Handles
            161     Compact Profiles
            162     Prepare for Modularization
            164     Leverage CPU Instructions for AES Cryptography
            174     Nashorn JavaScript Engine
            176     Mechanical Checking of Caller-Sensitive Methods
            179     Document JDK API Support and Stability
vm/--       142     Reduce Cache Contention on Specified Fields
vm/gc       122     Remove the Permanent Generation
            173     Retire Some Rarely-Used GC Combinations
vm/rt       136     Enhanced Verification Errors
            147     Reduce Class Metadata Footprint
            148     Small VM
            171     Fence Intrinsics
core/--     153     Launch JavaFX Applications
core/lang   101     Generalized Target-Type Inference
            104     Annotations on Java Types
            105     DocTree API
            106     Add Javadoc to javax.tools
            117     Remove the Annotation-Processing Tool (apt)
            118     Access to Parameter Names at Runtime
            120     Repeating Annotations
            139     Enhance javac to Improve Build Speed
            172     DocLint
core/libs   103     Parallel Array Sorting
            107     Bulk Data Operations for Collections
            109     Enhance Core Libraries with Lambda
            112     Charset Implementation Improvements
            119     javax.lang.model Implementation Backed by Core Reflection
            135     Base64 Encoding & Decoding
            149     Reduce Core-Library Memory Usage
            150     Date & Time API
            155     Concurrency Updates
            170     JDBC 4.2
            177     Optimize java.text.DecimalFormat.format
            178     Statically-Linked JNI Libraries
            180     Handle Frequent HashMap Collisions with Balanced Trees
core/i18n   127     Improve Locale Data Packaging and Adopt Unicode CLDR Data
            128     BCP 47 Locale Matching
            133     Unicode 6.2
core/net    184     HTTP URL Permissions
core/sec    113     MS-SFU Kerberos 5 Extensions
            114     TLS Server Name Indication (SNI) Extension
            115     AEAD CipherSuites
            121     Stronger Algorithms for Password-Based Encryption
            123     Configurable Secure Random-Number Generation
            124     Enhance the Certificate Revocation-Checking API
            129     NSA Suite B Cryptographic Algorithms
            130     SHA-224 Message Digests
            131     PKCS#11 Crypto Provider for 64-bit Windows
            140     Limited doPrivileged
            166     Overhaul JKS-JCEKS-PKCS12 Keystores
web/jaxp    185     JAXP 1.5: Restrict Fetching of External Resources

Semántica de las categorías:

vm:     comp, gc, rt, svc
core:   lang, libs, i18n, net, sec, svc
client: gui, sound
web:    jaxp, jaxb, jaxws, corba

Publicado por en No hay comentarios:
Etiquetas: ,

lunes, 9 de septiembre de 2013

Error 404 friki

Retomando un poco este mi blog, os pego un error 404 (página no encontrada) que me pasaron el otro día. Es del sitio web GitHub (para colgar código y gestionar proyectos de software libre, uno de los sitios más populares). Siesque, al final, somos todos igual de frikis :D

Error 404 friki

Publicado por en No hay comentarios:
Etiquetas: , ,

jueves, 9 de febrero de 2012

"Hello World" en Arduino

Esta tarde soldé finalmente las patas a uno de mis Arduinos Nano v3.0 (o mejor habría que decir Chi-duinos). La operación ha sido delicada, pero con el estaño de 0.5 mm de grosor que me he adquirido ha sido satisfactoria. Al menos parece que todas las patas se han soldado bien.

Elementos para soldar las patas del Arduino Nano
En la foto podéis ver el estaño, un Arduino sin soldar, la fila de patas sin cortar, el soldador en medio, la protoboard con el montaje del ejemplo "Blink!" (que es el Hello World del Arduino) y el cable Mini-USB a USB.

Para soldar las patas más fácilmente conviene dejarlas pinchadas en la protoboard y soldarlas ahí.

Aquí tenéis el resultado final:

Blink Arduino Nano!!

Publicado por en No hay comentarios:
Etiquetas: , , , ,

lunes, 9 de enero de 2012

¿Cuánto dura una batería de 300mAh conectada a un Arduino?

Se me plantea la pregunta de calcular cuánto duraría una batería de 300mAh conectada a un Arduino Nano v3.0.

La capacidad de una batería se mide en mAh. Esta cifra nos da la duración de la batería, mediante la siguiente fórmula:

Capacidad(mAh) = I(mA) x t(h)
t(h) = Capacidad(mAh) / I(mA)

En nuestro caso particularizamos para el dispositivo Arduino Nano. Sabemos que este dispositivo tiene un regulador de tensión cuya corriente máxima es de 500mA:

Capacidad = 300mAh = 300mA x 1h
I = 500 mA => t(h) = 300mAh/500mA = (3/5)h = (3x60)/5 = 36 min

Por completar la explicación, según las especificaciones, podemos alimentar al dispositivo mediante una fuente de tensión no regulada en el rango de 7—12V. En otro de los pines nos deja alimentarlo con una fuente regulada de 5V (por ejemplo esta tensión nos la podría dar una fuente de PC). El microprocesador irá más o menos rápido (varían los MHz) dependiendo de la tensión de alimentación, pero seguirá funcionando. En nuestro caso lo que se propone es conectar una batería de 9V al pin de alimentación no regulada.

Retomando la reflexión sobre la autonomía de la batería hemos visto que si conectamos una batería de 300mAh a un Arduino nos va proporcionar corriente como mínimo 36 minutos. Dependiendo de los componentes que conectemos al Arduino (sobre todo, de los componentes conectados a los puertos, que "chupan" 40mA como máximo cada uno) esta duración es mayor o menor.

Si conectamos otros componentes la corriente que tiene que soltar la fuente aumentaría y la autonomía disminuiría. Hay motores más eficientes y que consumen menos corriente que otros (por ejemplo, los que iban montados en los walkman). Tengo que hacer medidas, pero me da la impresión que un motor con su circuito driver puede llegar a consumir del orden de amperios. Con lo que la autonomía de todo el sistema cae sensiblemente. A parte de los motores, hay otros tipos de sensores que también consumen corriente (sensores de ultrasonidos, micrófonos, cámaras, sensores de temperatura, etc).

Nota 12/1/2012: Leo en algún foro de por ahí que también hay que tener en cuenta otros factores, como son el tipo de batería (Ni-Cd, Li-Ion, etc), las curvas de descarga en voltaje, las veces que se puede cargar y descargar la batería, etc. Es decir, que el tema de las baterías es un asunto peliagudo. También dicen que los mAh son aproximados pero no exactos.
Publicado por en No hay comentarios:
Etiquetas: , , , , ,

jueves, 29 de diciembre de 2011

Idea — Fábricas robóticas modulares

Empezaré esta serie de artículos transcribiendo las ideas que me rondan la cabeza cuando intento dormirme. No sé si será autosugestión o qué, pero el caso es que en ese momento me parecen tan interesantes que me quedo un buen rato dándoles vueltas. Tanto que a veces pierdo el sueño y hasta que no las dejo medio-cerradas no consigo dormirme.

Albergo siempre el miedo de que a la mañana siguiente no me acuerde de ellas, como si fueran sueños que al final caerán en el olvido. Para que eso no ocurra, y como positivamente sé que ninguna de estas ideas al final llegará a materializarse... y en parte para decir de forma retrospectiva en el futuro: "ves, yo ya lo pensé en el año tal", las dejo aquí escritas para que las lea algún curioso nostálgico de los recuerdos en el futuro. ¿Quién sabe? Lo mismo estos archivos no se perderán en el tiempo y alguien los tendrá a bien en conservar. O quizás después de todo sí que se perderán.

Por todo lo anterior empiezo esta serie de artículos de mis locas ideas y proyectos. Algunos intentan ser originales como podría ser este. Otros están basados en cosas que he leído por ahí y que he modificado y/o adaptado (lo que llaman ahora los "modesnos" innovación).

Esta idea se me ocurrió hace unos días, al intentar dormirme una noche en la que me costó conciliar el sueño. Me planteaba la pregunta de por qué la fabricación de muchos productos occidentales se realiza en países emergentes mientras que el diseño se queda en occidente. Pasa con todas las empresas de tecnología ahora: Apple, HP, IBM, etc. La respuesta que encontraba era que en esos países, al haber muchos menos derechos laborales y la gente no reclamarlos por o no haberlos conocido nunca o tener miedo de las represalias, la mano de obra es mucho más barata y los países occidentales son incapaces de competir con eso. ¿Qué solución puede tener esto? ¿Cómo salimos de la encruzijada?

Entonces pensé en la definición del término "robot". Es un término que popularizó el dramaturgo checo Karel Čapek. Sin embargo, el inventor de la palabra fue su hermano Josef. Éste le sugirió el término "roboti" para una novela que estaba escribiendo. Literalmente "robota" en checo significa labor o trabajo y figuradamente "trabajo duro" (Wikipedia). Así que también se podría traducir en cierto sentido como esclavo.

Mi idea consiste en sustituir esta mano de obra barata por robots para que tanto el diseño como la fabricación se puedan realizar en los países occidentales a un coste comparable al que ahora se tiene en los países emergentes sin derechos laborales. No es una idea nueva esta, ya que en la industria automovilística por ejemplo se viene haciendo algo parecido desde hace muchos años.

Mi aportación a esta idea, sin embargo, es que la fábrica sea modular. Es decir, en vez de tener una línea de fabricación lineal como su propia palabra indica, que sea más una línea de fabricación en 2 dimensiones, incluso en 3 dimensiones.

¿Qué quiere decir esto? Limitándonos por ejemplo a una planta de fábrica, quiere decir que la diferente maquinaria se tendría que repartir en módulos. Cada módulo tendría que estar especializado en una tarea en concreto. Por ejemplo tendríamos un módulo que podría ser de troquelado, otro de impresión de piezan en una impresora 3D, otro módulo dedicado al pulido de las piezas, etc. Todos los módulos tendrían que tener además de la maquinaria específica, un par de brazos robóticos al menos con los que se manipularan las piezas y se aplicaran los procesos correspondientes a esa fase de la fabricación. La maquinaria no tendría que controlarse físicamente con botones o mandos, sino telemáticamente mediante una API. Esto ahorraría el tiempo en la realización de cada proceso.

Este planteamiento tendría varias ventajas:
  • Se podría escalar más fácilmente este sistema. Desde unos pocos módulos podríamos escalar a toda una planta, incluso podríamos escalar en altura a una fábrica de varias plantas. La inversión sería progresiva. 
  • Cuando un módulo necesitase reparación se podría sacar de la "línea de producción" o planta de producción en nuestro caso para reparar. Mientras se podría introducir otro módulo de las mismas características.
  • Mediante un programa de inteligencia artificial se podría intentar optimizar el proceso de fabricación para que fuera más óptimo, moviendo por ejemplo módulos de un sitio a otro de forma que el tiempo de producción de un producto se minimizara.
  • Si en vez de un control totalmente automático de los diferentes módulos se optase porque un operario especializado manipulase el proceso, se podría dar responsabilidad a ese operario sobre un módulo en concreto.

La comunicación entre los diferentes módulos se podría hacer mediante cintas móviles mecanizadas o mediante plataformas móviles que se pudieran mover libremente por los pasillos de servicio entre los módulos. Estos movimientos también serían susceptibles de optimización.

He hablado antes del control automático de todo el proceso de fabricación. Pero debido a que hay fases del montaje que son complejas sería deseable que los operarios también tuviesen alguna forma de grabar cada fase del proceso de fabricación. Se podrían grabar varias veces al operario para tener una muestra más significativa. De esta forma, si las condiciones iniciales son similares esa fase se podría reproducir de forma automática y la inteligencia artificial lo que tendría que hacer es ocuparse de los cambios sutiles en cada caso.

Además, alguno de los muros de la fábrica servirían como entrada de materias primas (por ejemplo una o dos fachadas del edficicio) y los otros muros como salidas (las fachadas restantes).

Como conclusión, si este sistema funciona sería un posible sustituto a la fabricación que actualmente se hace por operarios humanos en condiciones de trabajo precarias. La dificultad estriba en conseguir brazos robóticos lo suficientemente hábiles y fiables para poder sustituir la eficiencia que actualmente tiene el cuerpo humano (que sabemos que es una de las máquinas más perfectas que existen).
Publicado por en No hay comentarios:
Etiquetas: , , ,

martes, 27 de diciembre de 2011

Neuromante, de William Gibson

Hace mucho que quería dejar aquí algún comentario sobre esta novela. Desde que la leí la primera vez en cierto sentido es una de mis novelas de referencia. Dicen los estudiosos de estos temas que es una de las primeras novelas del estilo ciberpunk.

De hecho mi primer contacto con ella fue en el tren, de camino a casa después de haber pasado el día en la universidad. Era mi época de estudiante, cuando todavía tenía mucho tiempo para leer (y más ganas de leer que de estudiar). Tampoco me había acomodado tanto como hoy e iba casi todos los días en tren a la universidad. Por aquel entonces, todo hay que decirlo, esta situación tampoco me agradaba mucho.

Había un chico enfrente mío con un ejemplar de la novela, en la edición española de la editorial Minotauro. La portada era curiosa: un dibujo más o menos abstracto que nunca he llegado muy bien a saber qué simboliza. Sobre fondo oscuro se ve una especie de esfera brillante y por detrás unos cilindros también de colores oscuros la rodean. He visto portadas de esta novela mejores, en la que se puede ver a Molly (un personaje de la novela) posando desafiante.

También recuerdo que pocos días después entré en el FNAC de Callao y me la compré. La primera lectura que hice de la novela fue tan rápida como poco fructífera. No me había enterado de nada.

Sólo después de dos o tres lecturas comprendí el sentido de lo que tenía entre manos. Una obra inspiradora, con un lenguaje propio y eléctrico. Yo que siempre estoy pensando en frases que se pueden citar cuando leo algo, esta novela sin duda es un filón. Casi toda se podría citar, frases enteras rellenarían mi pared si tuviera el espacio suficiente.

En cuanto al tema, sin destriparlo mucho, trata sobre un vaquero (hacker) del ciberespacio que ha caído en desgracia y que de buenas a primeras se ve embarcado en una operación que no sabe muy bien en qué acabará. El universo es parecido al de esa película que también nos gusta tanto: Blade Runner.

Así que si te gusta Blade Runner yo creo que puedes darle una oportunidad a Neuromante. Eso sí, la lectura en inglés se hace un poco ardua, tanto por el léxico como por el ritmo propio de la novela.
Publicado por en No hay comentarios:
Etiquetas: , , , ,

lunes, 28 de noviembre de 2011

Un gestor de descargas programado en bash


El gestor de descargas favorito de todo sysadmin debería de ser un script programado en bash. Perl también sería otra opción, pero soy menos hábil en ese lenguaje. Lo único que necesita el script son los comandos básicos (echo, awk), uno para comprimir (gzip) y el que vamos a usar para descargar (wget).

El script es el siguiente:

Pastie | Mystic Paste
-----------------[ descarga.sh ]-----------------
#!/bin/bash

WGET_OPTS="-c"

graba_msg_error() {
  ERRORNO=$1
  case $ERRORNO in
    0) MSG_ERR="No problems occurred." ;;
    1) MSG_ERR="Generic error code." ;;
    2) MSG_ERR="Parse error --- for instance, \
when parsing command-line options, the .wgetrc \
or .netrc..." ;;
    3) MSG_ERR="File I/O error." ;;
    4) MSG_ERR="Network failure." ;;
    5) MSG_ERR="SSL verification failure." ;;
    6) MSG_ERR="Username/password authentication \
failure.";;
    7) MSG_ERR="Protocol errors." ;;
    8) MSG_ERR="Server issued an error response." ;;
    *) MSG_ERR="Unknown." ;;
  esac

  echo "(**) RESULTADO DEL COMANDO: $ERRORNO -- \
$MSG_ERR" >>$NOMBRE.log

}

while read LINEA;
do


  NOMBRE=$( echo $LINEA | awk '{print $1}' )
  URL=$( echo $LINEA | awk '{print $2}' )
  echo -n "Descargando $NOMBRE desde $URL..."
  wget $WGET_OPTS -o $NOMBRE.log -O $NOMBRE "$URL"
  N_ERROR=$?
  graba_msg_error $N_ERROR
  gzip -v9 $NOMBRE.log >>$NOMBRE.log 2>&1



  if [ $N_ERROR == "0" ]; then
    echo "OK"
  else
    echo "ERROR!"
    echo "=> N_ERROR = $N_ERROR, ver el log para \
mas informacion."
  fi

done <$1


-----------------[ descarga.sh ]-----------------







El modo de empleo es:






./descarga.sh <fichero_urls.txt>





El parámetro <fichero_urls.txt> es un fichero con líneas, donde en cada línea pones el nombre del fichero y la URL que quieres descargar. Por cada descarga se genera un fichero .log con la salida del comando wget (además de grabarse el fichero de la descarga si esta ha sido correcta). El flag "-c" que se pasa a wget sirve para continuar las descargas que estuvieran a medias. Como característica adicional, se ha programado una función (graba_msg_error) para el control de errores de wget.












Publicado por



en





No hay comentarios:
  























Etiquetas:
,
,







Ubicación:
Madrid, España










          

        

          

        

martes, 11 de octubre de 2011


          

        









Tutorial: Tomcat7 + Struts2 + VIM "à la" sysadmin











    

  1. Nos bajamos las últimas versiones de Tomcat y de Struts. Para este tutorial suponemos que Tomcat está instalado y arrancado, de forma que podemos desplegar las aplicaciones en la URL /manager (esa parte de la complejidad es para nosotros transparente ya que la gestiona Tomcat).
    2. 

  2. Creamos la estructura de directorios siguiente (los ficheros los iremos creando más adelante):
    3. 
+-webapp_template/
    
  | make.sh
    
  +-versions/
    
  +-src/
    
    | index.jsp
    
    +-jsps/
    
    | | HelloWorld.jsp
    
    +-WEB-INF/
    
      | web.xml
    
      | struts.xml
    
      +-lib/
    
      | | [librerías.jar, ver más adelante]
    
      +-classes/
    
        | [ficheros .java dentro de su paquete]
    

  3. Grabamos las últimas versiones de las siguientes librerías (todas son o de Struts o de se pueden encontrar en la web de Apache) en el directorio lib, que es donde va a buscar los .jar el servidor Tomcat. Las librerías son:
    4. 

      

    • struts2-core
      • 

    • xwork-core
      • 

    • ognl
      • 

    • freemarker
      • 

    • commons-fileupload
      • 

    • commons-io
      • 

    • commons-lang
      • 

    • commons-logging
      • 

    • javassist
      • 

    

  4. El script en bash make.sh tiene el siguiente contenido (este realmente es el paso más "sysadmin"):
    5. 
----------- make.sh ------------------------------------
    
#!/bin/bash
    
TIMESTAMP=$( date "+%Y%m%d%H%M%S" )
    
RUTA_DIR_ACTUAL=$( dirname `pwd` )
    
NOMB_DIR_ACTUAL=$( basename `pwd` )
    
HOME_APP="`pwd`"
    
ROOT_LIB="$HOME_APP/src/WEB-INF/lib"
    
LIBRERIAS="."
    
for i in $( ls -1 $ROOT_LIB ); do
    
  LIBRERIAS=$LIBRERIAS:$ROOT_LIB/$i
    
done
    
#echo LIBRERIAS=$LIBRERIAS
    
rm -rf compiled
    
cp -a src compiled
    
cd compiled
    
find . -name "*.java" -exec javac -verbose -classpath $LIBRERIAS {} \;
    
find . -name "*~" -exec rm -v {} \;
    
find . -name "#*#" -exec rm -v {} \;
    
find . -name "*.java" -exec rm -v {} \;
    
cp WEB-INF/struts.xml WEB-INF/classes
    
zip -r ../${NOMB_DIR_ACTUAL}.war *
    
cd ..
    
cp ${NOMB_DIR_ACTUAL}.war versions/${NOMB_DIR_ACTUAL}_${TIMESTAMP}.war
    
---------------------------------------------------------
    
    

  5. Creamos nuestra vista (jsps/HelloWorld.jsp) y nuestro controlador (WEB-INF/classes/template/HelloWord.java) con el siguiente código:
    6. 
----------- HelloWorld.jsp ------------------------------
    
<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1" %>
    
<p><s:property value="greetings" /></p>
    
---------------------------------------------------------
    
----------- HelloWorld.java -----------------------------
    
package template;
    

    
import com.opensymphony.xwork2.ActionSupport;
    

    
public class HelloWorld extends ActionSupport {
    

    
  String greetings = null;
    

    
  public String execute() throws Exception {
    
    setGreetings("Hello World");
    
    return SUCCESS;
    
  }
    

    
  public String getGreetings() {
    
    return greetings;
    
  }
    

    
  public void setGreetings(String greetings) {
    
    this.greetings = greetings;
    
  }
    

    
}
    
---------------------------------------------------------
    
    

  6. Lo siguiente es crear los ficheros de configuración de Tomcat (WEB-INF/web.xml) y de Struts (WEB-INF/struts.xml):
    7. 

----------- web.xml -------------------------------------
    
<?xml version="1.0" encoding="UTF-8"?>
    
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
    

    
  <display-name>hello</display-name>
    

    
  <filter>
    
    <filter-name>struts2</filter-name>
    
    <filter-class> org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter </filter-class>
    
  </filter>
    

    
  <filter-mapping>
    
    <filter-name>struts2</filter-name>
    
    <url-pattern>/*</url-pattern>
    
  </filter-mapping>
    

    
  <welcome-file-list>
    
    <welcome-file>index.jsp</welcome-file>
    
  </welcome-file-list>
    

    
</web-app>
    
---------------------------------------------------------
    
----------- struts.xml ----------------------------------
    
<?xml version="1.0" encoding="UTF-8"?>
    
<!DOCTYPE struts PUBLIC
    
  "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    
  "http://struts.apache.org/dtds/struts-2.0.dtd">
    
<struts>
    

    
  <package name="hello" extends="struts-default">
    
    <action name="HelloWorld" class="template.HelloWorld">
    
      <result>/jsps/HelloWorld.jsp</result>
    
    </action>
    
  </package>
    

    
</struts>
    
---------------------------------------------------------
    
    

  7. Creamos el fichero index.jsp que luego llamará al Action:
    8. 

----------- index.jsp -----------------------------------
    
<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
    
<!DOCTYPE& html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    
<%@ taglib prefix="s" uri="/struts-tags" %>
    
<html>
    
  <head>
    
    <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
    
    <title>Hello Sample</title>
    
  </head>
    
  <body>
    
    <s:action name="HelloWorld" executeResult="true"></s:action>
    
  </body>
    
</html>
    
---------------------------------------------------------
    
    

  8. ./make.sh, desplegar (en el interfaz web del Tomcat) y probar la aplicación (en http://localhost:8080/webapp_template/). Cruzar los dedos para que funcione.
    9. 




La mayor parte de este tutorial está transcrito de una página web donde lo encontré. Realmente mi aportación es el script make.sh y perfilar la estructura de directorios.



Cualquier comentario será bienvenido.












Publicado por



en





No hay comentarios:
  























Etiquetas:
,
,
,

















          

        

          

        

jueves, 23 de diciembre de 2010


          

        









Plataformas web sobre Scala










Una lista (incompleta) de las plataformas web (web frameworks) que he encontrado por ahí y que funcionan sobre el lenguaje de programación Scala:

Hay muchas otras plataformas aquí, pero arriba he resumido las que me han parecido más interesantes.

Posteriormente reseñaré algunas de ellas, a medida que las vaya probando.









Publicado por



en





No hay comentarios:
  























Etiquetas:
,
,

















        

      









Suscribirse a:
Entradas (Atom)