Jueves 20 de septiembre de 2018

Domingo Gomes

Domingo Gomes
NewEsc

Aplicaciones de terceros pueden acceder a tu cuenta de Gmail, según admite Google

Ahora más que nunca, usuarios y legisladores se encuentran preocupados por la privacidad de las comunicaciones a través de Gmail. El pasado mes de julio ya se había reportado en The Wall Street Journal que Google permitía a aplicaciones de terceros el ingreso a cuentas de Gmail, incluso con la posibilidad de leer los mensajes de correo, y que Google no estaba haciendo mucho para impedirlo.

Para aquel entonces, Google publicó en su blog un artículo en la que aseguraban que sus directivas de privacidad no admitían que se leyese el contenido de los correos, y que estaban vetando las aplicaciones que no se ajustaran a ello.

No obstante, esta semana el Senado citó a representantes de Google, Facebook y Twitter para que respondieran algunas preguntas sobre el manejo de la privacidad de las cuentas, cita a la que no acudió nadie desde Mountain View.

Sin embargo, The Wall Street Journal tuvo acceso a una carta enviada por una representante de Google a los senadores, en la que se admite que aunque la compañía había dejado de escudriñar los correos de los usuarios, aún permitía que aplicaciones de terceros lo hicieran, siempre y cuando fueran “transparentes” al informar a los usuarios sobre los datos a los que tenían acceso. Incluso se permitía a operadores humanos leer el contenido de algunos mensajes de correo, para ayudar a entrenar a los sistemas de IA.

Fuente | The Wall Street Journal

La entrada Aplicaciones de terceros pueden acceder a tu cuenta de Gmail, según admite Google aparece primero en NewEsc.

Asociación LiGNUx: Desactivar teclado numérico por default en XFCE (Xubuntu 18.04.1) en laptop
Domingo Gomes

Domingo Gomes
NewEsc

GoPro vuelve por sus fueros con la Hero 7

Si te gusta el mundo de las actividades al aire libre, y grabar testimonio de las mismas, esta noticia podría interesarte: GoPro vuelve al ruedo de las cámaras para estas actividades.

En la página de la tienda B&H aparece a la venta el nuevo modelo de la famosa cámara deportiva, llamado GoPro Hero 7. Y viene en tres colores, cada uno de los cuales representa una serie de características distintivas.

La más avanzada es la Hero 7 Black, que ofrece video 4K a 60 fps, con nueva tecnología de estabilización de vídeo HyperSmooth. Otros extras como entrada para micrófono, batería removible y capacidad para transmisisón en vivo, la distinguen de las otras. Se ofrece por 400 dólares (344 euros).

El escalafón medio lo ocupa la Hero 7 Silver, que permite la grabación 4K a 30 fps, no tiene entrada de micrófono ni batería removible. Su precio es de 300 dólares (258 euros). Por su parte, la más sencilla es la Hero 7 White, que no graba vídeo a 4K; además, no tiene entrada de micrófono ni batería removible. Aparece con un precio de 200 dólares (172 euros).

Las tres cámaras son a prueba de agua hasta 10 m de profudidad, todas graban vídeo en resolución 1080p y tienen control por voz. Se hallan de momento a la venta sólo en los Estados Unidos.

La entrada GoPro vuelve por sus fueros con la Hero 7 aparece primero en NewEsc.

Domingo Gomes

Domingo Gomes
NewEsc

Microsoft advierte que puedes tener problemas con la nueva Update de Windows 10

Puede que la advertencia te resulte ociosa, o que te parezca tan obvia que no te expliques por qué alguien se molestaría en hacerla, pero nunca está de más: la nueva Update de Windows 10 que viene en octubre podría hacer que tu máquina deje de funcionar si no consigue suficiente espacio de almacenamiento.

Y puede que digas: “Bueno, es cosa de sentido común. Si estás usando el sistema operativo en una PC, lo sensato es que dejes espacio de almacenamiento en disco para que cosas como las actualizaciones tengan holgura”. Sí, pero no siempre ocurre de ese modo. Primero, porque no es infrecuente que algunos usuarios tengan instalada una multitud de programas, en especial juegos, que sin darse cuenta ocupan gran cantidad de espacio de almacenamiento, consumiendo hasta los discos más grandes.

Lo otro tiene que ver con un detalle que Microsoft reconoce: la nueva actualización requiere que haya al menos 10 Gb de espacio libre de almacenamiento, para poder funcionar, pero la mencioanda Update no efectúa ninguna comprobación previa sobre si hay espacio suficiente antes de iniciarse.

Esto parece ser más crítico en las PC y laptops con sistemas embutidos que están instalados en espacios de 16 Gb, en el caso de 32 bits, y 20 Gb en el caso de 64 bits. En todo caso, revisa cuánto espacio de almacenamiento te queda, y no te lleves una sorpresa.

Vía | ZDNet

La entrada Microsoft advierte que puedes tener problemas con la nueva Update de Windows 10 aparece primero en NewEsc.

Miércoles 19 de septiembre de 2018

IPFS, el futuro de la web descentralizada

Imagina la web sin servicios centralizados. Donde puedas acceder a un vídeo o a una galería de fotos y que no haya una única manera de acceder a contenido. Eso y mucho más es IPFS. IPFS son las siglas de InterPlanetary File System y se trata de una red descentralizada de intercambio de archivos. Nos puede recordar a BitTorrent y en efecto, una buena descripción para IPFS es Torrent 2.0. No obstante IPFS implementa bastantes mejoras sobre BitTorrent, mejoras que lo hacen más útil.

En un post próximo explicaré como podemos sacar partido a IPFS ahora mismo, pero antes vamos a ver algunos conceptos fundamentales de IPFS.

Siendo más técnicos, IPFS es una red P2P inspirada en BitTorrent, Git y Kademlia. El protocolo es una red de distribución de contenido (CDN) y define un sistema de archivos donde el identificador es el propio contenido (a través de su hash). En IPFS nada desaparece sino que se versiona.

Vamos a ver como usar IPFS desde la terminal. Existen varios clientes, en diferentes lenguajes, como js-ipfs (que tendrá mucha utilidad en aplicaciones web descentralizadas usando JavaScript), pero de momento el cliente más maduro es go-ipfs. Desde la web puedes descargarlo.

Iniciar IPFS

Una vez IPFS esté instalado hay que ejecutar lo siguiente:

ipfs init
o
ipfs init --profile server

La segunda opción es para centros de datos, ya que reduce el tráfico interno.

Este comando genera las claves RSA del nodo, necesarias para la comunicación con la red IPFS. Además se nos informa de nuestro ID de nodo. Para acceder a este ID en cualquier momento podemos escribir:

ipfs id

Iniciar el nodo IPFS

Para acceder al contenido IPFS necesitamos ejecutar un nodo. Este nodo se inicia con ipfs daemon. Una cosa importante es que por ejecutar el nodo no se va a descargar nada que no pidamos. IPFS es explícito, pero necesita estar activo.

ipfs daemon

Obtener archivos

Ahora vamos a descargar nuestros primeros archivos de la red IPFS.

Para obtener un archivo existen varias formas:

ipfs cat /ipfs/QmS4ustL54uo8FzR9455qaxZwuMiUhyvMcX9Ba8nUH4uVv/readme
o
ipfs cat QmS4ustL54uo8FzR9455qaxZwuMiUhyvMcX9Ba8nUH4uVv/readme

Podemos usar el comando cat de IPFS, que funciona de forma similar a cat de Unix.

Las URL de IPFS todavía no han sido definidas de forma definitiva pero de momento siguen el siguiente formato: /protocolo (omitible)/hash/fichero (si es una carpeta). Es el hash el que identifica el bloque de contenido y es lo que sirve para encontrar el contenido en la red IPFS. Internamente usa una DHT (Distributed Hash Table). IPFS no usa trackers como las primeras versiones de BitTorrent. En cambio usa una DHT basada en Kademlia (bastante rápida).

Para obtener un fichero binario usamos el operador de redirección de Linux.

ipfs cat QmWYhH2Nac5vSgTmc6NULncakvhCXgAci33M5NXHjjBuU8 > Comuneros.jpg

También se puede acceder a IPFS por dos métodos más:

FUSE

Podemos montar un sistema de ficheros en Linux gracias a FUSE que es una puerta a IPFS.

ipfs mount

Y tendrás acceso a carpetas /ipfs/hash/ integradas en tu sistema. Muy útil si lo queremos integrar en aplicaciones.

GATEWAY HTTP

Podemos usar IPFS sin tener instalado nada, usando la puerta de acceso que alguien generosamente proporcione a la red. La puerta se encargará de llevar el contenido IPFS al mundo cliente-servidor de HTTP. Existen varias, de hecho cada nodo tiene un servidor HTTP en localhost para esto mismamente, pero aquí voy a mencionar dos: la de IPFS.io y la de CloudFare.

Esto sirve para llevar IPFS a cualquier ordenador a través de un navegador web tradicional como Chrome, Firefox o Safari. También facilita la tarea de integrar IPFS en aplicaciones que no tengan desarrollada una librería específica.

Añadir archivos

Ahora vamos a poner en la red IPFS nuevos archivos. Para ello usamos ipfs add.

Esta operación genera el hash que identifica al contenido en la red y que tendremos que enviar a las personas que queramos que accedan al contenido.

La red IPFS de este modo es semi-privada, ya que sin saber el hash no podemos acceder al contenido en cuestión.

Y ya estaría, así de simple. También podemos añadir carpetas.

El último hash que se ve en la pantalla hace referencia a la carpeta entera.

Pining

Por defecto, IPFS almacena los archivos propios del nodo (los que hemos añadido con ipfs add). Pero entonces IPFS no supone ninguna ventaja respecto a HTTP. No es distribuido, solo hay una copia de los ficheros en el universo.

Cuando descargamos un fichero, IPFS guarda en caché una copia para ofrecer a la red, haciendo que sea un sistema distribuido de verdad. No obstante si estamos realmente interesados en conservar el fichero en nuestro nodo a disposición de la red IPFS tenemos que hacer pin (ipfs add). Cuando nos deje de interesar conservar el fichero a la red, podemos quitar el pin (ipfs rm).

ipfs pin add QmWYhH2Nac5vSgTmc6NULncakvhCXgAci33M5NXHjjBuU8
ipfs pin rm -r QmWYhH2Nac5vSgTmc6NULncakvhCXgAci33M5NXHjjBuU8

Más cosas

Todavía nos quedan muchas cosas de IPFS que ver, como el versionado, el sistema de nombres IPNS, el sistema de enlazado semántico IPLD y como podemos usar IPFS para páginas y aplicaciones web.

 

La entrada IPFS, el futuro de la web descentralizada se publicó primero en Adrianistán.

Asociación LiGNUx: El gestor de torrents qBittorrent acaba de publicar su versión 4.1.3
Bruno Exposito

Bruno Exposito
Puro Linux

ReactOS – Windows de código abierto

ReactOS es un sistema operativo de código abierto escrito en C/C++ y disponible para las arquitecturas x86, x86-64 y ARM.

El proyecto nació en el año 1995 como una clon de Windows 95 y está basado en el diseño de la arquitectura de Windows NT. Es compatible (lo intenta al menos) con las aplicaciones y controladores de Windows NT 5.X (Windows XP y posteriores).

Pese a estar construido basándose en Windows, ReactOS incluye ciertas mejoras que no están incluidas en el susodicho, como un gestor de paquetes, similar al que usa GNU/Linux.

reactos_desktop

 

Auditoría

Dado que Windows es un sistema operativo de código cerrado, los desarrolladores de ReactOS emplean ingeniería inversa para comprender el funcionamiento de Window.

En enero del 2016, uno de los desarrolladores encontró código desensamblado de Windows XP, algo completamente ilegal y que afectó a la credibilidad del proyecto, sin embargo en la actualidad ese código ha sido reescrito en C y el proyecto está auditado para que no existan dudas acerca del origen del código.

Este problema ocasionó la eliminación de los enlaces de descarga, una pérdida de credibilidad y la prohibición de colaborar con WINE.

 

Demostraciones a políticos rusos

ReactOS ha despertado cierto interés entre algunos políticos rusos, en 2007 Víktor Alksnis se reunió con Aleksey Bragin “coordinador” del proyecto, para realizar una demostración y en 2012 se realizó otra demostración a Vladimir Putin.

Estabilidad

En estos momentos, y pese a llevar tantos años en desarrollo, sigue en versión alpha, por lo que no se recomienda instalarlo en máquinas de producción.

 

Look and feel

En lo relativo a su aspecto visual, es muy similar a Windows 95/98/2000, con ligeras diferencias respecto al original.

El tema ha quedado tremendamente obsoleto y el menú de inicio es poco usable.

Personalmente considero que deberían modificar la interfaz para asemejarse a Windows 7 Basic (porque tiene pocas animaciones y transparencias) o Windows 10, porque es bastante “flat”.

 

Descarga

Puedes descargar la ISO de instalación como el live CD desde su página oficial: https://www.reactos.org/es/download

Martes 18 de septiembre de 2018

Asociación LiGNUx: Mailspring, el cliente de correo electrónico que rivaliza con Thunderbird

Recupera los datos de tu disco duro, gratis

p.p1 {margin: 0.0px 0.0px 0.0px 0.0px; font: 11.0px 'Helvetica Neue'; color: #000000; -webkit-text-stroke: #000000} p.p2 {margin: 0.0px 0.0px 0.0px 0.0px; font: 11.0px 'Helvetica Neue'; color: #000000; -webkit-text-stroke: #000000; min-height: 12.0px} span.s1 {font-kerning: none} span.s2 {text-decoration: underline ; font-kerning: none} Habitualmente a la hora de gestionar nuestros

Lunes 17 de septiembre de 2018

Ramón Miranda

Ramón Miranda
Ramon Miranda

Krita’s 2018 Squash the Bugs. New fundraiser!



Wow long time no posting! beach, summer, daikiris... ? Not, something even more good!




Hi, finally is here. A new Krita fundraiser campaign  has begun and my new resources pack  " Digital Atelier" is going to be available for bakers over 50€:  \o/
You can check the new here : https://krita.org/en/item/introducing-digital-atelier-a-painterly-brush-preset-pack-by-ramon-miranda-with-tutorial-videos/

The Campaign is here: https://krita.org/es/fundraising-2018-campaign-es/

This job has been sponsored by the Krita team and done with one idea in my mind. Keep it simple, keep it versatile. What i like the most is that "is not only a resources pack but also a training pack".

Why this campaign is so important? 
We are in a very exciting moment for Krita. It is very stable but it still have bugs. A lot of them! Because code is like art, you have to polish it carefully if you want to have clean and perfect code. And that takes time. a looot of time watching the screen with python and c files in fron of you. That is what we call Debugging stage.

¿Why i would support a campaign with no features promise?
When software runs smoothly we all love it and nobody cares about how this is achieved. But when a program crash and ALL the software crashes we start to blame on them. we all do. poor coders. So to make Krita 0 Bugs, which is an absolutely amazing goal krita needs support from users and fans.
They will make a lot of work for us!

That is what this campaign is about. To give a solid as rock behavior to Krita. And not only that, but rewards as this pack "Digital Atelier".
A "solid as rock" Software can be very appealing for new users or companies. And if Krita looks great, more features will be added in future. So your little money has an invaluable value in future, you see?

If you like Krita this is going to be very interesting for you. I could tell you a lot about the project, but i am thinking to do it in a different way. maybe streaming in future? if people is interested we could do it.

Y ahora en español ;)
Wow mucho tiempo sin publicar! playa, verano, daikiris ... No, ¡algo aún más bueno!

Hola, finalmente ya  llegó, Ha comenzado una nueva campaña de recaudación de fondos de Krita y mi nuevo paquete de recursos "Atelier Digital" estará disponible para los que apoyan con más de 50 €: \o/
Puedes consultar la noticia aquí: https://krita.org/en/item/introducing-digital-atelier-a-painterly-brush-preset-pack-by-ramon-miranda-with-tutorial-videos/

La campaña y más información: https://krita.org/es/fundraising-2018-campaign-es/

Este trabajo ha sido patrocinado por el equipo de Krita y hecho con una idea en mi mente. "Mantenlo simple, mantenlo versátil". Lo que más me gusta es que "no es solo un paquete de recursos sino también un paquete de capacitación".

¿Por qué esta campaña es tan importante?
 Estamos en un momento muy emocionante para Krita. Es muy estable pero todavía tiene errores. ¡Muchos de ellos! Como el código es como el arte, debes pulirlo cuidadosamente si quieres tener un código limpio y perfecto. Y eso lleva tiempo. Un montón de tiempo mirando la pantalla con archivos python y c frente a ti. Eso es lo que llamamos Etapa de depuración.

¿Por qué apoyaría una campaña sin características prometedoras?
Cuando el software funciona sin problemas, a todos nos encanta y a nadie le importa cómo se logra esto. Pero cuando un programa falla y TODO el software falla, comenzamos a culparlos. todos lo hacemos. codificadores pobres. Entonces para hacer Krita 0 Bugs, que es un objetivo absolutamente increíble, Krita necesita el apoyo de los usuarios y fanáticos.

¡Nos harán mucho trabajo!
De eso se trata esta campaña. Para darle un comportamiento sólido como roca a Krita. Y no solo eso, sino recompensas como este paquete "Digital Atelier".

Un software "sólido como roca" puede ser muy atractivo para los nuevos usuarios o compañías. Y si Krita se ve genial, se agregarán más características en el futuro. Entonces, tu pequeño dinero tiene un valor inestimable en el futuro, ¿lo ves?

Si te gusta Krita, esto va a ser muy interesante para ti. Podría contarte mucho sobre el proyecto, pero estoy pensando en hacerlo de una manera diferente. tal vez transmisión? si la gente está interesada, podríamos hacerlo.









Hosting GRATIS (de por vida) y sin anuncios

¡¿Pero cómo puede ser esto posible?! Sí. Es normal que te hagas esa pregunta. El hosting es una de las partes más caras de mantener al tener una página web. Encontrar uno en España de calidad es más complicado de lo que parece. Por eso el equipo técnico de WebUp Hosting y yo hemos estado preparando este […]

La entrada Hosting GRATIS (de por vida) y sin anuncios aparece primero en Blog de Informática ✏ Luisi.

Academix, una distribución sólo para uso académico

p.p1 {margin: 0.0px 0.0px 0.0px 0.0px; font: 11.0px 'Helvetica Neue'; color: #000000; -webkit-text-stroke: #000000} p.p2 {margin: 0.0px 0.0px 0.0px 0.0px; font: 11.0px 'Helvetica Neue'; color: #000000; -webkit-text-stroke: #000000; min-height: 12.0px} span.s1 {font-kerning: none} span.s2 {text-decoration: underline ; font-kerning: none} Cada día nos desbordamos porque conocemos una

Sábado 15 de septiembre de 2018

¿Qué es Windows Server Update Services (wsus) y Cómo lo uso?

Es el acrónimo de Windows Server Update Services que al traducirlo al español seria: Servicios de actualización de servidor de Windows. Este servicio es solo para el sistema operativo Windows. Teniendo en cuenta que se aplica para versiones pertenecientes al catálogo de roles superiores al año 2008. Gracias a la aplicación de estos roles dentro […]

La entrada ¿Qué es Windows Server Update Services (wsus) y Cómo lo uso? aparece primero en Blog de Informática ✏ Luisi.

Miércoles 12 de septiembre de 2018

Como reiniciar un Ordenador

Se tiende a confundir mucho con respecto a esta frase, muchas personas usan la frase “necesito reiniciar mi pc” queriendo decir que necesitan resetear o formatear la computadora. De ahí vienen muchas disyuntivas con respecto a esta necesidad. El reinicio de la pc es realmente una manera de cortar el proceso de la computadora y […]

La entrada Como reiniciar un Ordenador aparece primero en Blog de Informática ✏ Luisi.

Miércoles 05 de septiembre de 2018

Podcast: escucha y organiza tus podcast desde Linux

p.p1 {margin: 0.0px 0.0px 0.0px 0.0px; font: 11.0px 'Helvetica Neue'; color: #000000; -webkit-text-stroke: #000000} p.p2 {margin: 0.0px 0.0px 0.0px 0.0px; font: 11.0px 'Helvetica Neue'; color: #000000; -webkit-text-stroke: #000000; min-height: 12.0px} span.s1 {font-kerning: none} span.s2 {text-decoration: underline ; font-kerning: none} Cada vez es más frecuente que nuestro

Sábado 01 de septiembre de 2018

Liher Sanchez

Liher Sanchez
El blog de Liher

La web de la biblioteca y su dominio

Llevaba bastante tiempo queriendo retomar este blog, lo tenía bastante abandonado y la razón principal era mi forma de tomarme las cosas y y mi manera de pensar. Hace unos días me puse a revisar todo un poco ya que hacía mucho tiempo que no entraba. Después de ponerlo todo al día estuve pensando como intentar enfocar las cosas para poder volver a escribir. En este anterior artículo os comentaba que tenía muchas cosas que quería hacer y que no poder dedicar el tiempo necesario a todo me bloqueaba. Entonces tomé la decisión de tomármelo con mas calma e ir paso a paso con las cosas marcándome objetivos alcanzables a corto plazo para no perder la ilusión y las ganas.

Una de las primeras cosas que hice es que mi VPS soportara cifrado SSL para poner los dominios de las webs que tengo alojadas en el con el HTTPS. Recientemente Google ha sacado una actualización de su navegador web, el Google Chrome, en la cual calificaba a todas las webs que no tuviesen SSL como webs no seguras, lo cual es una puñeta para los que no lo teníamos.

 

 

Pues bien, ese tema ya está hecho. Esta web ya esta considerada una web segura por parte de Google. Gracias a esto podréis navegar mas seguros por ella. Ademas eso mejorará el SEO de la web y así podré llegar a mas personas con mis artículos.

Hecho ya el tema del SSL en el VPS y en los dominios que tengo en el, lo siguiente era crear la web de la biblioteca. Hace ya tiempo que cree una con un programa llamado Mollify pero, lamentablemente, el programa fue abandonado por sus creadores y la biblioteca dejó de funcionar.

 

 

El Mollify era como un administrador de archivos que permitía moverse por la jerarquía de directorios que tu quisieses crear y también permitía subir y bajar archivos. Todas estas opciones eran configurables y de una forma bastante sencilla. Esta era una solución temporal mientras que diseñaba la web para que pudieseis descargaros los libros y manuales pero al final quedó en el olvido. Durante un tiempo estuvo funcionado hasta que el Mollify dejo de ser un proyecto activo y fue eliminado de Internet.

Me he puesto a la tarea y estoy haciendo un diseño de una web nueva. La estoy haciendo con WordPress y un plugin para modificar plantillas. La verdad es que es muy fácil de usar y permite hacer cosas que de otra forma implicaría tocar mucho código. El plugin que uso para la biblioteca es el Page Builder de Site Origin. Con este plugin todo es mucho mas fácil y rápido y es un proyecto que lleva mucho tiempo activo y es muy usado, lo cual inspira bastante confianza, por eso lo he elegido.

Un aspecto a tener en cuenta también era si contratar o no un dominio para la web de la biblioteca. De momento y para ver si consigo el diseño y las funcionalidades que quiero tener en la web de la biblioteca estoy centrado en diseñar todas las subpáginas de la web y subir algo de contenido. Una vez que consiga esto lo mas seguro es que compre un dominio web para ella. Digamos que, por ahora, lo que estoy haciendo es una plantilla de la página principal y otra plantilla para las demás páginas de la web ya que todas serán iguales en estructura, lo único que cambiará de la página de descarga de manuales de Ubuntu a la página de descarga de manuales de Seguridad es el contenido y los archivos a descargar, el tema del diseño será igual. Una vez que vea que todo vaya bien y sea funcional solo tendré que ir subiendo los archivos para que los tengáis disponibles.

Aquí os dejo un enlace a la página principal para que veáis como va, por ahora, el diseño de la web:

 

 

Esto es lo que podréis ver cuando entréis a la biblioteca. Hay un listado con las distintas categorías disponibles. En cada categoría hay un botón que os dirigirá a otra subpágina en la cual podréis ver un listado con los archivos disponibles para descargar y allí podréis descargarlos. En el sidebar o barra lateral colocaré todo lo relacionado con las redes sociales para que podáis seguirme y compartir el contenido. Por lo demás todavía no se muy bien lo que voy a poner en esa barra lateral, acepto sugerencias.

Se que el diseño es muy sencillo pero no quiero complicarme mas la vida, mi prioridad es que funcione lo antes posible. Por supuesto que todos los archivos que pondré disponibles para descargar estarán comprimidos para que las descargas sean mas rápidas y repercutan lo menos posible en el VPS.

Otra cosa en la que estoy trabajando es en el menú, no se que poner en el ya que incluir todas las categorías en el menú creo que haría que fuese muy engorroso de usar. Por ahora solo hay unas 5 categorías, pero va a haber muchísimas mas. Respecto a este tema quiero decir algo antes de que pueda aparecer algún “simpaticote” 🙂 , en la anterior imagen de la página principal la primera categoría es “GNU/Linux” y la segunda es “Ubuntu” y esto tiene una razón de ser. Habrá muchos libros o manuales que se podrán usar en cualquier distro GNU/Linux y también habrá manuales que sean de una distribución en concreto, de ahí esas categorías. Es mas, iré poniendo categorías que serán de distribuciones en concreto e incluso de entornos de escritorio.

Se me olvidaba, casi no os pongo el enlace de la biblioteca para que lo podáis visitar y así podáis hacerme sugerencias, el enlace es:

Espero que os guste y que me ayudéis a llevarla a buen puerto. También os quiero decir que si alguno de vosotros tiene material que pueda poner en la web para descargar lo aceptaré encantado. Un saludo.

Viernes 31 de agosto de 2018

Liher Sanchez

Liher Sanchez
El blog de Liher

Problema al intentar abrir un archivo de texto plano en Ubuntu

En varias ocasiones me he encontrado con una situación un poco molesta cuando intentaba abrir un archivo de texto plano en el cual había escrito algún comando. Mas concretamente me pasaba cuando iniciaba una instalación limpia de Ubuntu o derivadas ya que los comandos necesarios que usaba después de la instalación del sistema operativo para ponerlo a punto los guardo en un archivo de texto plano para, posteriormente, ir copiando y pegando en la Terminal lo que necesitaba. Mas concretamente el problema es que al intentar abrir un archivo de texto plano con dichos comandos lo que yo quería es que se me abriese el editor de textos y, en su lugar, aparecía un mensaje mostrándome varias opciones, las cuales os comentaré mas abajo. He probado el procedimiento en Ubuntu 16.04, Ubuntu 18.04 y Linux Mint 19.

Os voy a explicar mejor lo que quiero decir. Al intentar abrir un archivo de texto plano que contiene comandos te puedes encontrar con que os salga una ventana en la cual tenéis 4 opciones a realizar. Dicha ventana la poder ver en la siguiente imagen:

 

Ventana al abrir un archivo de texto plano en ubuntu

 

Como podéis ver hay 4 opciones disponibles a realizar con el archivo. La primera es “Ejecutar en un terminal”, después “Visualizar”, “Cancelar” y “Ejecutar”. El tema es que cuando abría dicho archivo lo que yo quería es que se abriese en el editor de textos para ver su contenido y copiar o cortar algunas partir para pegarlas en la Terminal de mi Ubuntu. Me parece bastante molesto tener que estar siempre pulsando en “Visualizar” para poder ver el contenido. Vamos a ver como solucionar esto de dos formas. La primera que os voy a explicar seria una solución para un archivo en concreto y la otra opción seria para todos los archivos de texto plano que tengamos.

Si hacéis click con el botón derecho sobre el archivo con el que os pasa esto os aparecerá un menú en el cual hay una opción al final llamada “Propiedades”. Pulsáis sobre ella y os aparcerá una ventana en la cual podéis ver información sobre el archivo. La ventana en cuestión es esta:

 

ventana de propiedades de archivo en ubuntu

 

Hay que pulsar en la pestaña “Permisos” que se ve en la parte superior para ver esta sección. En la imagen, la penúltima linea, hay una opción que es “Permitir ejecutar el archivo como un programa”, en mi caso esta marcada, como podéis ver en la imagen. Esto permite que Ubuntu pueda ejecutar este archivo como si de un programa se tratara. Si desmarcamos dicha opción el mensaje con las 4 opciones que os he comentado al principio del articulo no os aparecerá mas cuando queráis abrir este archivo.

Pero, ¿si tenemos mas archivos como este? Pues con este método abría que ir uno por uno y repetir el proceso. Ahora es cuando vamos a ver como hacer para que todos los archivos de texto plano se visualicen directamente en Ubuntu. Lo primero que vamos a hacer es abrir el administrador de archivos que usemos, en mi caso tengo Linux Mint 19. En Ubuntu es Nautilus y el procedimiento es igual. Una vez abierto el administrador de archivos, en la barra de menú hacemos click en “Editar” y buscamos la opción “Preferencias” que podeis ver resaltada en la siguiente imagen:

 

 

menu preferencias ubuntu

 

Al hacer click en “Preferencias” os aparecerá una ventana con varias pestañas, tenéis que hacer click en la segunda opción llamada “Comportamiento”, esta en la parte superior. Al hacerlo veréis las opciones como en la siguiente imagen.

 

preferencias administradorarchivos de ubuntu

 

Ahora os tenéis que fijar donde apunta la flecha roja de la imagen. En la sección “Archivos de texto ejecutables” hay 3 opciones. Cuando aparece el mensaje con las 4 opciones que os indicaba al principio es que está marcada la opción que veis en la imagen “Preguntar cada vez”. Lo único que hay que hacer es marcar la segunda opción “Ver los archivos de texto ejecutables al abrirlos” y de esta manera no os volverá a salir el mensaje con las cuatro opciones si no que se abrirá con el editor de texto que uséis. Y ya está.

Ahora todos los archivos de texto plano sobre los que hagáis doble click con el ratón se abrirán con vuestro editor de texto predeterminado. Como ya he dicho al principio este procedimiento lo he probado en Ubuntu 16.04, Ubuntu 18.04 y Linux Mint Cinnamon 19 y funciona sin problemas.

Un saludo.

Lunes 27 de agosto de 2018

Liher Sanchez

Liher Sanchez
El blog de Liher

Cuanto tiempo

Hola a todos, hace mucho tiempo que no escribía nada en el blog y hoy he decidido volver a hacerlo por varias razones. Una de ellas es que varios usuarios me han preguntado por que no sigo escribiendo o si me había pasado algo, desde aquí quiero agradecerles el interés y darles las gracias. Últimamente no he tenido mucho tiempo, incluso parecía que tenia abandonado el blog pero tengo muchos planes para el. La cuestión es que tengo tantas cosas en mente para hacer que, debido al poco tiempo libre que tengo actualmente, me cuesta centrarme e ir paso a paso y eso es precisamente lo que quiero hacer a partir de ahora. Me he dado cuenta de que no puedo hacer todo a la vez y, por lo tanto, me iré marcando pequeñas metas.

Una de las primeras cosas que quiero hacer es convertir este blog en una pagina web segura, es decir, ponerle cifrado SSL. Esto es algo sencillo y espero que en los próximos días pueda llevarlo a cabo, no creo que tenga problemas.

Lo siguiente sería volver a poner en marcha la biblioteca que tenia antes en la cual se podía descargar bastantes documentos sobre informática que abarcan una gran cantidad de temas, entre ellos Linux, por supuesto. También me gustaría poner los artículos que podrían considerarse tutoriales en dicha biblioteca en formato PDF.

A pesar de no haber publicado nada en meses he estado haciendo muchas pruebas con distros, he cambiado de portátil y he aprendido cosas nuevas que quiero compartir con vosotros. Otra cosa que me gustaría hacer es empezar a hablar sobre WordPress, ya que es algo que me apasiona y así podre enseñaros las cuatro costas que sé al respecto.

En este artículo poco mas me queda por decir, simplemente es a modo de preámbulo de lo que voy a hacer a partir de ahora, los cambios los iréis viendo poco a poco. En el próximo artículo os hablaré de mi nuevo portátil y os informaré de que como es el portátil anterior por si alguien le interesa ya que lo voy a poner a la venta.

Y ya está, por ahora eso es todo, hasta el próximo articulo.

Ubuntizando.com

Ubuntizando.com
Ubuntizando.com

Cómo correr Windows 95 en tu Linux como una aplicación más

Hace la friolera de 23 se presentaba al mercado Windows 95, el producto estrella de Microsoft, destinado a revolucionar nuestros escritorios. Los que lo recordamos sabemos que aquello era una “castaña” de la buena que no resolvió sus principales problemas hasta varias revisiones después. Pero en aquel entonces era lo que había y todo el mundo hablaba de Windows 95, la multitarea y la multimedia como si no existiera mañana. Solo aquellos poseedores de un Amiga o quienes podían permitirse correr un Unix en casa o ya puestos un IBM OS/2 podían ver aquello por encima del hombro, el resto de los mortales teníamos que sufrir aquello.

La campaña publicitaria de Microsoft fue brutal llegando a comprar los derechos de Start Me Up de los Rolling Stones para su campaña principal. La multitarea había llegado y Microsoft quería dejar claro que ellos iban a ser la única referencia posible. Vale, me olvido de Apple y sus Macintosh pero esa es otra historia.

Volviendo al tema que motiva esta entrada, el desarrollador Felix Rieseberg acaba de lanzar la versión 1.0 de Windows 95 en modo aplicación bajo Linux. De este modo podemos instalar y correr Windows 95 en Linux como una aplicación más. Hoy por hoy no deja de ser una curiosidad más pero bien vale la pena descargar los 130 MB que ocupa y recordar como era trabajar con PAINT, WordPad o navegar usando un Internet Explorer de 1995.

Si tienes Debian, Ubuntu o cualquier otra distribución derivada debemos seguir los siguientes pasos abriendo el terminal:

  1. wget https://github.com/felixrieseberg/windows95/releases/download/v1.2.0/windows95-linux_1.2.0_amd64.deb
  2. sudo dpkg -i windows95-linux_1.2.0_amd64.deb
  3. sudo apt install -f

Si todo ha ido correctamente ya podemos volver a usar Windows 95 y recordar los horrores por los que nos hizo pasar. Recuerda, en 1995 era el futuro o eso creíamos, afortunadamente.

 

Ubuntizando.com

Ubuntizando.com
Ubuntizando.com

Aquí llega Steam Play para hacer compatibles todos tus juegos Windows en Linux

Steam

Steam es la más grande plataforma de distribución de videojuegos en la actualidad. En un momento donde el soporte físico casi ha desaparecido de la estantería de las tiendas en Steam podemos encontrar un inmenso catalogo de títulos que podemos “adquirir” y disfrutar en nuestros equipos.

Los usuarios de GNU/Linux hasta el momento no podíamos disfrutar de todo su catalogo. Solo de algunos títulos especialmente portados como Company of Heroes 2, Lead for Dead, Limbo, Half Life 2, etc hasta un total de cuatro mil títulos a fecha de diciembre de 2017.  Pero parece que esto está muy próximo a cambiar.  Steam Play, es el actual proyecto en el que trabaja Valve para ofrecer compatibilidad plena de juegos para Windows en Linux gracias a una versión adaptada de WINE llamada por Valve Proton.

La beta de Steam Play ya está disponible para los usuarios de Linux y para probarlo es necesario activar la modalidad beta en el cliente de Steam. Hay que decir además que actualmente la lista de juegos compatible es bastante limitada por lo que hay que darle algo de tiempo para que sea un poco más numerosa.

Así si eres el poseedor afortunado de alguno de los juegos presentes en la lista inicial de juegos compatibles enhorabuena:

  • ‘Beat Saber’
  • ‘Bejeweled 2 Deluxe’
  • ‘Doki Doki Literature Club!’
  • ‘DOOM’
  • ‘DOOM II: Hell on Earth’
  • ‘DOOM VFR’
  • ‘Fallout Shelter’
  • ‘FATE’
  • ‘FINAL FANTASY VI’
  • ‘Geometry Dash’
  • ‘Google Earth VR’
  • ‘Into The Breach’
  • ‘Magic: The Gathering – Duels of the Planeswalkers 2012’
  • ‘Magic: The Gathering – Duels of the Planeswalkers 2013’
  • ‘Mount & Blade’
  • ‘Mount & Blade: With Fire & Sword’
  • ‘NieR: Automata’
  • ‘PAYDAY: The Heist’
  • ‘QUAKE’
  • ‘S.T.A.L.K.E.R.: Shadow of Chernobyl’
  • ‘Star Wars: Battlefront 2’
  • ‘Tekken 7’
  • ‘The Last Remnant’
  • ‘Tropico 4’
  • ‘Ultimate Doom’
  • ‘Warhammer 40,000: Dawn of War® – Dark Crusade’
  • ‘Warhammer 40,000: Dawn of War® – Soulstorm’

 

Domingo 26 de agosto de 2018

Xavier Genestos

Xavier Genestos
SYSADMIT

Linux: Cambiar fecha de un archivo

En ocasiones nos podemos encontrar con la necesidad de tener que cambiar la fecha de modificación, etc... de un archivo en sistemas Linux. Antes de empezar, hemos de entender que existen 3 tipos de marcas de tiempo en los ficheros. Fijémonos en este ejemplo: Con el comando stat, al indicar como parámetro un fichero, vemos que aparece: Access: Se actualiza cuando abrimos el
Xavier Genestos

Xavier Genestos
SYSADMIT

Linux: Ver últimos archivos modificados

En ocasiones nos puede interesar obtener un listado de los últimos ficheros modificados en un sistema Linux. Para obtener este listado, utilizaremos el comando find. En este post, vimos algunos ejemplos de uso del comando find: Linux: Buscar ficheros, directorios con find (SYSADMIT.com) por otro lado, también vimos en otro post, cómo cambiar la fecha de un archivo: Linux:

Viernes 17 de agosto de 2018

Bruno Exposito

Bruno Exposito
Puro Linux

Cambiar grupo de un fichero o directorio – Comando CHGRP

El comando chgrp sirve para modificar el grupo (group) de un fichero o directorio. Está instalado en todas las distribuciones GNU/Linux, dentro del paquete coreutils.

Puedes consultar los grupos usando el comando:

cat /etc/group | cut -d ‘:’ -f1/

Sintaxis de chgrp

sudo chgrp {{opciones}} {{grupo}} {{fichero_o_carpeta}}

La sintaxis de chgrp es sencilla, tras el comando chgrp se escriben los modificaciones (opcionales), a continuación el nombre del grupo y para finalizar el nombre del fichero o carpeta.

Opciones de chgrp

-c, –changes Igual que la opción “verbose” pero solo si hay cambios
-f, –silent, –quiet Omite la mayoría de los mensajes de error
-v, –verbose Muestra el resultado de cada fichero procesado
–dereference Afecta a la referencia del enlace simbólico, en lugar del enlace simbólico en si (opción por defecto).
-h, –no-dereference Afecta al enlace simbólico, en lugar de la referencia a la que apunta.
–no-preserve-root No trata “/” de manera espacil (por defecto)
–preserve-root Falla al intentar operar recursivamente sobre “/”
–reference=RFILE use RFILE’s group rather than specifying a GROUP value
-R, –recursive Se ejecuta sobre ficheros y directorios recursivamente
-H Si es un enlace simbólico a un directorio, entra en el
-L Atraviesa todos los enlaces simbólicos a directorios que encuentre
-P No atravesar enlaces simbólicos (por defecto)
–help Muestra la ayuda
–version Muestra la versión y licencia

Cambiar el grupo de un fichero

sudo chgrp {{grupo}} {{fichero}}

sudo chgrp comerciales ventas.odt

*El fichero ventas pertenece ahora el grupo comerciales

Cambiar el grupo recursivamente

sudo chgrp -R {{grupo}} {{carpeta}}

sudo chgrp -R soporte /mnt/shared/software

*Todo el contenido de la carpeta /mnt/shared/software pertece ahora al grupo soporte

Cambiar el grupo a un fichero

sudo chgrp sistemas foto.jpg

*Estando dentro de la carpeta donde se encuentra el fichero “foto.jpg“, cambia el grupo a sistemas.

sudo chgrp comerciales /home/paco/documento.odt

*Independientemente del directorio actual, cambia el dueño de “documento.odt” a comerciales.

sudo chgrp admins “/home/juan/Música/Barón Rojo – Tierra de nadie.ogg”

*Independientemente del directorio actual, cambia el dueño del audio (que contiene espacios en el nombre) a admins.

 

sudo chgrp consultores /home/juan/Documentos -Rv

 *Cambia el grupo de la carpeta y todo su contenido de forma recursiva (-R), mostrando los detalles de cada fichero procesado (-v)

sudo chgrp -RHc grupo carpeta/

 *Cambia el grupo recursivamente atravesando enlaces a carpetas y mostrando los cambios.

sudo find . -name “*.txt” -exec sh -c ‘chgrp -v aula3 “$0″‘ {} \;

*Busca todos los ficheros con extensión txt y les cambia el grupo a “aula3” mostrando los detalles de cada operación realizada

Sábado 11 de agosto de 2018

Ubuntizando.com

Ubuntizando.com
Ubuntizando.com

El Juego de estrategia espacial “Star Ruler 2” pasa a ser open source

Star Ruler 2 es un juego de estrategia 4X (eXplore, eXpand, eXploit, and eXterminate) en tiempo real de estos que te dejan pegado al sillón durante horas antes de darte cuenta de que llevas tres días sin dar de comer al gato. Fuera bromas, Star Ruler es un juego que toma bastante de títulos como Master of Orion y tiene muy buena pinta.

Su segunda parte fue lanzada a comienzos de 2015 con una buena aceptación y de hecho todavía puede encontrarse para su compra o en Steam por algo menos de 20 euros. Por eso resulta extraño que teniendo todavía carrera comercial la (ahora difunta) compañía detrás de este impresionante juego de estrategia 4X en tiempo real ha liberado el código fuente para el juego principal y su paquete de expansión al público, de forma gratuita. ¡Toma ya!

El código fuente podemos encontrarlo en el siguiente enlace: github.com/BlindMindStudios/StarRuler2-Source

Por desgracia no podemos disfrutar de la música original del juego(salvo que tengamos el original) por motivos de derechos de autor pero hay una alternativa usando una banda sonora alternativa como por ejemplo: opengameart.org/content/star-ruler-2-replacement-music

Para instalarlo en Ubuntu tan sencillo como tener instalado el sistema snap y luego: sudo snap install starruler2

Fuente: https://www.omgubuntu.co.uk

Jueves 09 de agosto de 2018

Gorka Urrutia

Gorka Urrutia
Nideaderedes

Actualización de seguridad Laravel 5.6.30

Ayer se publicó una actualización de seguridad para Laravel. Es una vulnerabilidad relacionada con la APP_KEY. Esta variable es un valor que se usa para encriptar algunos valores como las sesiones de usuarios.

¿Es grave? Sí, pero solo debes preocuparte si alguien se ha hecho con esta APP_KEY. Eso solo puede hacerlo alguien con acceso al servidor (por ejemplo algún antiguo proveedor o un empleado resentido).

Si crees que no es el caso no deberías preocuparte aunque siempre es preferible actualizar.

La APP_KEY se usa para cifrar las sesiones de usuario, no para las contraseñas. Así que si la cambias las contraseñas no se verán afectadas pero sí las sesiones de usuario (cosa que, bueno, no es tan grave).

Laravel - el framework de los artesanos

Laravel – el framework de los artesanos

Sábado 04 de agosto de 2018

BlogDRAKE: Disponible TuningDrake 2.2.0

Jueves 02 de agosto de 2018

中古のブランド品

中古のブランド品を買取業者はどのくらいの値段で買い取ってくれるのかというと、それは全く物によりますから見当を付けるのは難しいところです。ですが査定額をともかく簡単な手段で知りたいと考えるなら、写メ査定を試してみてはいかがでしょう。対象となるブランド品を写メで業者に送って査定してもらうというものです。現物を手元に置いたまま、しかも家にいながら、簡単に業者の査定を受けることができて楽です。ところで、写メ査定での金額は暫定的なものです。というのも、最終的な買取価格は、実物の状態確認が済んでから決められるものだからです。例えば、バッグの中やアクセサリー類の裏側といったように、査定のために送った写真上では確認し辛い場所に瑕疵、欠損が見つかった時は当然、店側としては買取金額を下げることになるでしょう。
営業時間にとどまらず、一日中予約を受け付けてくれる脱毛サロンだと、今日も予約ができなかったの繰り返しで使えないなどという事態にならなくて済みます。予約も、電話に時間を費やすことなくウェブでピッとする方が楽です。大手脱毛サロンでしたら大抵は対応しているものの、たまにネット予約システムのない店舗もあるらしいので要注意です。それに、WEB予約できるといっても、店側から確認電話や返信メールがないと予約が成立しないところも少なくありません。
和服買い取り専門業者の中で迷っているなら、買取大手の「スピード買取.jp」という店は、ネット店舗ながらも、専門の査定士がいて顧客満足度も高いようです。査定や売買に関する相談は無料ですし、365日?24時間、オペレーターが待機していますから、自分の時間に合わせて相談できるんです。(スマホや携帯でもかけられます)出張査定のほかに宅配便や持込もOKで、おまけに査定やキャンセル料金は無料。気軽に相談できますね。

多くの場合、不動産の任意売却の説明においては、そのメリットのみがピックアップされがちです。でも、当然のことながら良くない点もあるのです。競売などの強制売却方式ではなく、あくまで任意で売却を行うので、どうしても手間がかかってしまいます。関係各所と交渉や手続きはしなくてはなりませんし、加えて、希望者の内覧に対して立ち会いの必要が生まれるなど、相当な手間と負担がのしかかることになります。ここまでの労力と手間をかけているにも関わらず、買い手がつかないことも珍しくありません。
転職すると決めた先が異業種である場合、転職先がなかなかみつからないことがあるでしょう。若い内の転職希望であれば未経験でも転職に成功するというパターンも考えられますが、30代後半にもなるとほぼ不可能と言っていいでしょう。まあ、人手をいつも欲しているような業種に目星をつけているのであれば労働条件という概念は放棄することになりますが転職できるかもしれません。

脱毛エステへ行って施術を受けたその後ですが、自分自身でもアフターケアは行っておくのがよいでしょう。アフターケアの手間をかけておくことで、お肌のトラブルにつながりにくくなるのです。自分で行うアフターケアの具体的な方法についてはお店で教えてもらえるはずなのですが、施術後の部位は冷やすこと、また保湿に努めること、なるべく刺激をさけること、といった点が基本になります。中でも特に保湿に関してはかなり重要だと言われています。
近頃でも脱毛サロンに行くのは高くつくとお思いの方が多いですが、現実的には大したことはありません。参考としては、両ワキやVラインを脱毛する際など主なサロンではコース料金3000円以内が一般的で、サロンがキャンペーン中であればそれ以上にお得なときもあります。さらに、競争が激しい脱毛サロン業界ですので、複数の店舗のサービス、料金設定などを比べて気に入るサロンをチョイスすることができます。

いびき治療は、原因に応じて実施します。鼻づまりがみられるときには、耳鼻科的な治療を優先して、慢性副鼻腔炎や花粉症、鼻中隔湾曲症などを治します。鼻づまりがみられないケースでは、睡眠時無呼吸症候群かどうかの検査をすることになります。ダイエット、寝具や寝姿勢、寝酒を控える、禁煙など生活習慣の見直しも大切です。いびきの重症型の閉塞性無呼吸だった場合、マウスピース治療、「CPAP(シーパップ)療法」、外科的な手術をしていくことになるでしょう。

剛毛だったり毛が太い人は脱毛サロンぐらいでは満足のいく脱毛ができないかもと懐疑的に見ているところもあるのではないでしょうか。脱毛サロンで一般的な光脱毛の光は毛や毛根の黒い部分に作用しますから、毛がしっかりした人の方が効果が発現しやすいのです。綺麗にするには毛質に関わらず何度か通うことになりますが、段階的にムダ毛が薄くなっていくはずです。最初に脱毛サロンで脱毛してもらい、様子を見てから脱毛クリニックでレーザー脱毛してもらうという考えもありだと思います。

もっと詳しく>>>>>早くも茶クマ 解決 効果 クマ専用クリームそうだ

時々、脱毛サロンで脱毛してもあまり効果を

時々、脱毛サロンで脱毛してもあまり効果を感じられないという声を聞くこともあるのですが、有り体に言って1~2回施術を受けたところで満足のいく結果を得られる、というものでもないのです。3回、もしくは4回以上の施術の後でやっとしっかりした効果が出たと感じるケースが大半で、つまるところそれなりの時間がかかるわけです。それに、脱毛サロンごとに使用する脱毛用の機器も違うでしょうから、効果にも当然差が出るものと思われます。
興信所や探偵などの調査業者が提供している浮気の行動探索は、成功報酬プランを設定しているところもあります。それって浮気の証拠を押さえない限りは無料ってことですよね。ラッキーと思うでしょうが、調査対象が浮気しているかどうか微妙な場合や、調査期間が長引くことが予想される際はお断りというパターンもあるようです。また、調査員が浮気の裏付けをしっかりとってきた際、思ってもみなかった額を請求されるケースがあるようですから、あらかじめよく確認しておきましょう。「お肌のためには、タバコは厳禁!」なんてことをよく聞きますが、それは美白に関しても言えることです。本当に肌を白くしたいと思うのなら、できるだけ早くタバコは止めるべきです。その理由として真っ先に挙げられているのが、タバコがビタミンCを破壊してしまうことです。喫煙すると、美白にとって不可欠なビタミンCが破壊されます。

借入金の返却方法にはたくさんの方法が存在しますが、店頭における支払いの他に口座自動引き落としや銀行振り込みを使ったり、キャッシング会社やコンビニエンスストアのATMでも振込むことが可能です。あまり知られていない方法としては現金書留による支払いも可能ですが、一番多い方法は現金自動預け払い機で支払う方法です。
個人個人で体質や好みというものがありますし、自分に合った脱毛サロンを探すことが大事です。洗練された内装とサービスなど、脱毛時にも優雅さを求める人には、多少高いお金を払ってでもエステサロンの脱毛を利用したほうが良いかもしれません。とりあえず安く脱毛できればというなら、毎月定額を払えば良い脱毛サロンやシーズンオフのお得なプラン、キャンペーン価格などをうまく利用すると良いでしょう。あとは通いやすさも重視したい項目のひとつですし、通勤通学のルート上や家の最寄り駅など、手軽に行ける場所にあると便利です。脱毛サロンでどれだけきれいになるのか気になるようでしたら、お店で体験脱毛してみることをお薦めしています。施術前のカウンセリングで料金体系や内容についても説明してくれるはずです。ただそれでは時間がかかりますし、細かい条件があって手っ取り早く相性の良いサロンを見つけようと思うなら、過去の評価や利用者によるレビューといった情報などが見られる比較サイトを利用して情報を集めることが良い手がかりになります。インプラントの技術が確立されてきた現在では、医療スタッフもインプラントに慣れてきて、失敗は少なくなったようですが、とはいえ、残念ながらゼロにはなりません。上部構造(義歯)が人工歯根にしっかり接続されておらず、食べ物を噛む際に義歯がグラつくなど、問題となる不具合が報告されています。これは、インプラント手術の経験が浅い歯科医が担当していることが要因となっています。インプラント手術の経験と実績のある歯科医を選ぶことが大事だといえるでしょう。

歯科治療の一環として、インプラント治療もある程度のリスクを伴う治療です。では、失敗はどのような問題を引き起こすかというと、人工歯根があごの骨となじまない、破損などというインプラント本体に生じた問題、細菌感染やアレルギー等によってあごの骨が腫れる、痛むといった身体的問題、手術によって、あるいは術後の炎症によってあごのラインが変わってしまうといった見た目を損なってしまう問題もあります。こうした失敗のリスクを最小限にとどめるためには歯科医はよく考えて決めてください。

脱毛方法の中でも人気のあるのが光脱毛だといいます。光を施術の部位に瞬間照射してムダ毛の処理を行います。これまでにあった脱毛法に比較して肌に負担がかかることなく作用するので、施術の際は痛みや肌トラブルがあまりなく済みます。脱毛の効果が強くて安心できる脱毛方法として定評があります。
同一電話番号から電話を頻回にまた、掛けているまた電話をかけ直していたりすると浮気相手と連絡をとっているという見込みはある程度間違いないと思われます。その後、その電話番号の持ち主を断定することができますね。しかしパートナーの方が一枚上手ですと、浮気相手との電話が終わったら着信や発信の履歴を必ず消すということも忘れずに行っているということもあります。
私は大手探偵社の調査員をしていますが、一番多いのは浮気の調査ですね。もちろん、その証拠を集めるには要所ごとの手際の良さと、3カン(感、観、勘)が要すると思います。想定外のことがたくさん起きますし、それをすぐ判断してベストな選択をしなければいけないので、気は抜けません。特に、調査対象やその周囲に不倫調査を悟られてしまうと、依頼人を推定しやすいということからも、最大限の用心をしつつ調査につくのは常識です。対象者になった経験のある人の追跡は、さらに注意が必要です。

よく読まれてるサイト⇒見る見る足むずむず症候群 ピクピク ピリピリ 治す 虫が這うような感覚ます

Sábado 28 de julio de 2018

Xavier Genestos

Xavier Genestos
SYSADMIT

Linux: grep ejemplos

El comando grep se utiliza para buscar texto. En este post veremos varios ejemplos de su funcionamiento. La entrada de texto hacia el comando grep puede realizarse de varias formas. Linux: grep ejemplos: Uso simple: 1) Busca la cadena: "Texto" en el fichero: fichero.txtgrep "Texto" fichero.txt2) Busca la cadena: "Texto" en los ficheros: fichero1.txt y fichero2.txtgrep "Texto" fichero1.txt
BlogDRAKE: Mejorar la carga de youtube en firefox

Martes 24 de julio de 2018

スキンケアで1番

スキンケアで1番大切にしたいのは正しい手順で洗顔を行うことです。肌を痛めてはしまう洗顔とはお肌を傷つける原因となり保水力を保てなくなります原因をもたらします。肌を傷つけないように優しく洗う綺麗にすすぐ、このようなことに注意して洗う顔を洗いましょう。
どこの脱毛サロンを利用するかは、口コミサイトの評価などが有効でしょう。色々な店舗を実際に利用してみた人などの評価はとても参考になりますが、施術に利用する脱毛機器が人それぞれ、合う合わないがあったり、スタッフの対応の感じ方なども様々でしょう。なので、体験コースなどを使ってみて、自分に合うサロンを探すのが一番です。
最近は色々なスタイルの金買取サービスが増えてきましたが、中でもお客さんの方から店に直接品物を持って行くケースが最も多いようです。お店に常駐している目利きのプロが商品を鑑定し、適切な価格で買い取ってくれるので、初めての人でも安心して利用できます。利用者のために、成約の前にしっかりと説明を設けている店舗も多いですので、その場でよく考え、本当に納得してから売却できます。安心して利用できますね。

キャッシングの借り換え先の選定のときは、まず低金利かどうかを見ることが必要です。銀行系のキャッシングは低金利なのですが、審査を通るのが厳しいうえに審査結果がわかるのも遅いのが難点です。他にも先に借り入れていた方のローンが低い金利であった場合、審査も通りにくくなりますので、気をつけて借り換えましょう。

普通、不動産査定を受ける時は、まずネットで相場を調べるのが定石ですが、そのあと詳しい査定を受けたい時には、実際に物件のチェックをしてもらうため、訪問査定を依頼します。そして、実際に見なければ確認できない建物の状態、周囲の環境や立地条件、間取りや日当たりなどから査定額を修正します。または、マンションでは共有する設備などを調べ、査定額を決定します。もちろん、業者次第で多少は査定基準が変化しますので、何社からか訪問査定を受けておいて、相場を見極めておくことをおススメします。

珍しいことですが、家を売るときに買い手がすぐについて、想定していたより早い引越しになるかもしれません。気持よく引き渡すためにも、家の掃除もかねて、早めに家財の処分や整理をしておくべきです。買い手がつくまで住むのであれば、出しておく家財道具は最小限にして、不要品や季節品を分け、ゴミに出したり梱包しておくと、部屋もきれいになりますし、引越しもスムーズです。

サプリを使用してバストアップするという方法が効果的かというと、たくさんの方が効果を実感しています。バストアップに効果的がある女性ホルモンの分泌を促進する成分がサプリに凝縮されていますから、バストアップが体の内側から可能となるでしょう。しかし、体内のホルモンバランスが乱れて、規則正しかったはずの生理周期が乱れてしまう場合も事例もあるようです。用量用法を守って細心の注意を払って使用してください。
普通は、住居人の退去をいつにして不動産売却するかは任意に売却主が決められます。ただ、住居人がいない状態で売り出した方が売値を上げられます。購入希望者がいても、内覧時に住居人がいるとマイナスの印象を持たれがちになりますので、できることなら退去を早めに済ませておいた方が有益な点が多くなると思います。
昨今では、自動売買取引でFX投資する人がたくさんいるようです。FX投資においては、買った外貨が前触れなしに大幅に安くなると平常心を失ってしまい、上手に損切りできないことがあります。少しでも損失を小さくして済ませたいという思慮が損切りする機会を逸するように働くのです。

永久脱毛を施術されてツルツルの美肌を手に入れたいと夢見る女性は大勢います。しかし、本当に永久脱毛の処置を受けるとなると脱毛料金の金額はいくらくらいなのでしょうか。永久脱毛の施術は美容クリニックなどで医療用レーザーを使用して行われます。そのため、かかるお金も高めになりますが、群を抜いた脱毛効果が得られます。予約に24時間対応してくれる脱毛サロンだったら、忙しい人でも、なかなか予約できずに行けなくなってしまったりしないからオススメです。ウェブで予約できてしまうのなら、面倒な予約電話ともサヨナラです。近頃の脱毛サロン大手なら普通ですが、まれにネット予約不可のお店もあり、注意が必要です。それと、ウェブ予約で申し込んでも、店側から確認電話や返信メールがないと予約成立にならないケースが少なくないです。

不倫の行き着く先って色々ありますよね。配偶者や職場に浮気がバレた挙句、家庭や交遊関係が滅茶苦茶になったとか、高額な慰謝料を要求されることも考えなければなりません。また、元の鞘に収まったり、浮気を成就させて(?)結婚したりする例もないわけではありません。やっとの思いでゴタゴタを片付けても、不倫では失うもののほうが多く、幸せな結末なんて金輪際ありえないのです。

詳しく調べたい方はこちら>>>>>分けてペプチア 販売店 最安値られる

Lunes 23 de julio de 2018

BlogDRAKE: Dolphin 17.12.3 con acceso para usuario root

Miércoles 18 de julio de 2018

Gorka Urrutia

Gorka Urrutia
Nideaderedes

Cómo indicarle al git la llave ssh que debe usar

Si tienes tantas llaves ssh como yo seguro que tarde o temprano tendrás problemas porque en algún sitio se quejará de “too many retries”. Si eso te pasa en git hay una forma de indicar cuál es la llave que quieres usar al conectarte vía ssh.

En mi caso yo tenía problemas al conectarme a BitBucket. Así que para solucionarlo hay que editar el fichero de configuración SSH de tu ordenador. En mi caso:

/home/gorka/.ssh/config

y añadir:

host bitbucket.org
    HostName bitbucket.org
    IdentityFile ~/.ssh/llave_publica_para_conectarme_a_bitbucket.pub
    User gorka

En tu caso deberás cambiar “gorka” por tu usuario en BitBucket y ~/.ssh/llave_publica_para_conectarme_a_bitbucket.pub por la ruta de tu llave pública (la que uses para conectarte a BitBucket).

Si el problema lo tuvieses con GitHub harías:

host github.com
    HostName github.com
    IdentityFile ~/.ssh/llave_publica_para_conectarme_a_github.pub
    User git

Martes 17 de julio de 2018

Computación cuántica para torpes: introducción para programadores

Hace ya bastante tiempo quese viene hablando de ordenadores cuánticos. ¿Qué son? ¿En qué se diferencian de los ordenadores clásicos? ¿Son de verdad tan potente como dicen?

En este largo artículo, ideal para el verano, vamos a ver los principios fundamentales de los ordenadores cuánticos más allá de lo que la típica revista o web te podría contar. Veremos qué es un qubit y algunas puertas lógicas interesantes, así como su aplicación.

Los ordenadores cuánticos actuales requieren temperaturas de funcionamiento cercanas al cero absoluto

Notación de Dirac

Lo primero antes de entrar en materia cuántica, será adaptar nuestra notación clásica, a otra más potente. Esta notación que vamos a ver, llamada notación de Dirac o Bra-ket, nos será muy útil ya que los bits clásicos no son más que un caso concreto de qubit en esta notación.

En esta notación tenemos que representar los bits como matrices. Un conjunto de N bits se representa con una matriz de 1 columna y \(2^N\) filas. En todas las posiciones existen ceros salvo para la posición que representa la combinación que representa. Veamos algunos ejemplos sencillos:

Un bit con valor 0 se representa así

\(
| 0 \rangle = \begin{pmatrix}
1\\
0
\end{pmatrix}\)

Un bit con valor 1 se representa así:

\(
| 1 \rangle = \begin{pmatrix}
0\\
1
\end{pmatrix}\)

Aquí contamos como en informática, empezando desde cero. Como ves la posición 0 del vector solo es 1 cuando representa el bit 0. Si la posición que tiene el 1 es la segunda, representa el bit 1.

La parte que va a la izquierda del igual se llama ket. En este caso hemos representado ket 0 y ket 1.

Si tenemos más bits se puede hacer de la misma forma. Vamos a representtar ket 10. 10 en binario es 2, así que estará en la posición tercera.

\(
| 10 \rangle = \begin{pmatrix}
0\\
0\\
1\\
0
\end{pmatrix}\)

Puertas lógicas como producto de matrices

¿Recuerdas el producto de matrices de tus clases de álgebra? Resulta que todas las puertas lógicas clásicas pueden representarse como producto de matrices. Por ejemplo, la puerta lógica NOT se puede implementar con esta matriz:

\(
\begin{pmatrix}
0 & 1 \\
1 & 0 \\
\end{pmatrix}
\)

Y aquí la vemos en acción

\(
\begin{pmatrix}
0 & 1 \\
1 & 0 \\
\end{pmatrix}\begin{pmatrix}
1 \\
0
\end{pmatrix}
=
\begin{pmatrix}
0 \\
1
\end{pmatrix}
\)

También podría hacerse con la puerta AND que toma como entrada dos bits.

\(
\begin{pmatrix}
1 & 1 & 1 & 0 \\
0 & 0 & 0 & 1
\end{pmatrix}
\begin{pmatrix}
0 \\
0 \\
0 \\
1
\end{pmatrix}
=
\begin{pmatrix}
0 \\
1
\end{pmatrix}
\)

Un teclado con puertas cuánticas

Juntando bits

Para formar bits más grandes ya sabemos que tenemos que tener una matriz tan grande como combinaciones haya (\(2^N\) posiciones, N bits). Existe una forma de calcular automáticamente la posición que hay que marcar y es hacer el producto tensorial. Si no sabes calcularlo no importa mucho, porque apenas lo vamos a usar, pero puedes ver un ejemplo de como funciona. En este ejemplo, queremos juntar los bits 1 y 1 (3 en decimal).

\(
\begin{pmatrix}
0 \\
1
\end{pmatrix}
\otimes
\begin{pmatrix}
0 \\
1
\end{pmatrix}
=
\begin{pmatrix}
0 \\
0 \\
0 \\
1
\end{pmatrix}
\)

Qubits

Hasta ahora no hemos visto nada realmente nuevo, solo hemos preparado el terreno para dejar paso a los qubits. Personalmente desconocía que podían usarse matrices para operar con bits y aunque no es tan práctico como otros sistemas, lo cierto es que es muy explícito y elegante.

Los qubits son bits como los que hemos visto antes pero tienen un estado indeterminado. No es que tengan un valor de forma secreta y no sepamos cuál es. Podríamos decir que son los dos valores clásicos a la vez, como el gato de Schrodinger. Cuando realizamos una observación sobre el qubit, este colapsa y podemos ver uno de los dos estados. ¿Cuál vemos? No podemos saberlo a priori, pero hay probabilidades. Los bits clásicos no son más que qubits cuyas probabilidades de colapsar a 0 o 1 es del 100%, por tanto no hay duda y su valor sí que está determinado.

¿Cómo representamos los qubits y sus estados cuánticos? Con números complejos. Si recuerdas, estos eran los que tenían una parte real y una imaginaria. No obstante, voy a tomar solo los números reales para simplificar. Los números reales son números complejos válidos, pero los complejos son mucho más extensos.

La esfera de Bloch permite representar todos los estados cuánticos (números complejos)

Para calcular la probabilidad que tiene un estado cuántico de colapsar a un valor, hacemos el módulo y elevamos al cuadrado: \(|a|^2\).

Todo qubit además debe cumplir una propiedad fundamental:

\(
\begin{pmatrix}
a \\
b
\end{pmatrix}
\text{ es un qubit}
\Leftrightarrow
|a|^2 + |b|^2 = 1
\)

Y es que la probabilidad de ser 0 y de ser 1 sumadas deben equivaler al suceso seguro, es decir, 1. 100% de probabilidades de que de 0 o 1.

Con esto ya podemos definir algunos qubits.

\(
\begin{pmatrix}
\frac{1}{\sqrt{2}} \\
\frac{1}{\sqrt{2}}
\end{pmatrix}
\)

Este es mi qubit preferido. Representa el estado de superposición cuántica. Cada valor tiene el 50% de probabilidades de salir. \(|\frac{1}{\sqrt{2}}|^2 = \frac{1}{2}\). Cuando colapsemos el qubit al observarlo será como lanzar una moneda al aire.

Otro detalle que a veces se nos pasa por alto es que los qubits pueden contener valores negativos. Estos qubits son físicamente diferentes a los positivos, pero tienen las mismas probabilidades de colapsar en los mismos valores que los positivos.

\(
\begin{pmatrix}
-1 \\
0
\end{pmatrix}
\)

Es un qubit válido, que colapsa con 100% de probilidad a 0.

¿Cómo se representan los qubits en notación de Dirac? Representando la probabilidad que tiene cada combinación de bits de aparecer. Para un qubit sería algo así:

\(
\alpha | 0 \rangle + \beta | 1 \rangle
\)

Siendo \(\alpha\) y \(\beta\) las probabilidades de colapsar a cada estado.

Puertas cuánticas

Ahora vamos a ver cuáles son las puertas lógicas más importantes del mundo cuántico.

Negación (Pauli X)

Esta es exactamente igual que en el mundo clásico, con la misma matriz que hemos visto antes. Su símbolo es el cuadrado con una X.

Aquí vemos una imagen del simulador IBM Q usando la puerta X cuántica. IBM nos deja ejecutarlo en ordenadores cuánticos reales. Veamos los resultados.

¡Terrible! La mayoría de casos, el ordenador cuántico responde 1, el valor correcto, pero un 13% de los casos no. Teóricamente había una probabilidad del 100% y en la práctica solo es del 86.3%. ¡Y solo es una puerta X! Es por ello que los procesadores cuánticos todavía necesitan mejorar mucho. Google, Microsoft e IBM están investigando de forma independiente en ordenadores cuánticos. Veremos quién consigue tener antes ordenadores cuánticos precisos (aunque hay expertos que piensan que nunca se podrá lograr).

CNOT

Esta puerta es muy interesante. Toma dos qubits, uno de control, que permanece invariable al traspasar la puerta y otro de datos. Al qubit de datos se le aplica la puerta X si el qubit de control está activo. Su matriz es la siguiente:

\(
CNOT = \begin{pmatrix}
1 & 0 & 0 & 0 \\
0 & 1 & 0 & 0 \\
0 & 0 & 0 & 1 \\
0 & 0 & 1 & 0
\end{pmatrix}
\)

Se reprensenta de esta forma:

O similar, porque los símbolos de computación cuántica no están todavía muy estandarizados. El punto grande es el qubit de control y el punto pequeño está sobre el qubit de datos.

HADAMARD

Esta puerta es quizá la más famosa del mundo cuántico. Veamos su matriz:

\(
\begin{pmatrix}
\frac{1}{\sqrt{2}} & \frac{1}{\sqrt{2}} \\
\frac{1}{\sqrt{2}} & -\frac{1}{\sqrt{2}}
\end{pmatrix}
\)

Esta puerta permite poner un qubit clásico en estado de superposición cuántica. Y también deshacerlo. Es muy usada en algoritmos cuánticos. Se representa con un cuadrado y una H.

Los resultados en el ordenador cuántico real de IBM Q son:

Cuando debería de ser bastante más cercano a 50% en los dos valores.

Con esto ya tenemos las puertas más usadas. Básicamente con Hadamard, X y CNOT se pueden implementar casi todos los circuitos cuánticos. Solo nos faltarían las puertas que operan entran en números complejos para poder implementar todos los circuitos.

Algoritmo de Deutsch-Jozsa

El algoritmo de Deutsch-Jozsa es uno de los algoritmos cuánticos más sencillos de entender y que mejoran drásticamente el rendimiento respecto a un algoritmo clásico.

El planteamiento básico es que tenemos una caja negra que aplica una función sobre un bit. Estas funciones pueden ser: set-to-0, set-to-1 (ambas constantes), identidad (no cambiar nada) y X (ambas dinámicas) . Si queremos saber que función contiene la caja negra, ¿Cuántas veces tenemos que pasar valores? En una CPU clásica tendríamos que hacerlo dos veces para poder determinar que función contiene la caja negra. En una CPU cuántica… también. No hay diferencia. Pero, si cambiamos la pregunta a ¿de qué categoría es la función de la caja negra?, la cosa cambia. En una CPU clásica seguiríamos necesitando 2 pruebas, pero en una CPU cuántica y con un circuito por el exterior, podemos aprovechar la superposición cuántica para realizar una sola prueba y determinar si en el interior hay una función constante o dinámica.

Vamos a ver estas 4 funciones de la caja negra como son:

¿Se te ocurre como puedes crear un circuito fuera de la caja negra que con una sola prueba, ya sepa si estamos ante las funciones Set-0, Set-1 o Identidad, Negación?

El circuito es el siguiente:

Tal y como está diseñado si en q[1] medimos 0, la función es de tipo constante y si medimos 1, es de tipo dinámica. Un desarrollo matemático de los productos de matrices, como el que hay en Wikipedia, te mostrará como siempre es cierto. Este también es un ejemplo de como los ordenadores cuánticos pueden dar resultados totalmente deterministas.

Esta idea, se puede generalizar y extrapolar a otros problemas, generando una colección muy interesante de algoritmos que se ejecutan en tiempo exponencialmente menor que en una CPU clásica.

Algoritmos de Shor y de Grover

Estos dos algoritmos han sido llamados los killer apps de la computación cuántica, ya que son algoritmos que mejoran sustancialmente (uno de forma exponencial, otro de forma cuadrática) los tiempos de problemas reales.

El algoritmo de Shor fue el primero en ser descubierto, en 1994 por Peter Shor. Sirve para factorizar números (es decir, sacar los números primos que multiplicados generan el número original). Lo puede hacer en \(O((\log{n})^3)\). De este modo, los algoritmos tipo RSA que se basan en la factorización de números podrían romperse en tiempo polinómico, por lo cuál RSA ya no serviría como protección. El algoritmo de Shor no da siempre los resultados correctos, pero tiene una probabilidad de éxito superior a la de fracaso, por lo que con repetir múltiples veces la ejecución podríamos estar casi seguros del resultado.

El algoritmo de Grover fue descubierto en 1996 por Lov Grover y permite buscar en una lista no ordenada de datos en \(O(\sqrt{n})\) mientras que en una computadora clásica sería \(O(n)\).

Estos dos algoritmos sin duda marcan lo que se ha llamada la supremacía cuántica y que ocurrirá cuando los ordenadores cuánticos puedan ejecutar con suficiente precisión estos algoritmos y su utilidad en el mundo real supere a la de los algoritmos clásicos.

Entrelazamiento cuántico

Ya hemos visto las bases de los circuitos cuánticos. Ahora veamos algunas consecuencias de todo lo anterior. Cosas cuánticas que parecen hasta cierto punto fuera de la lógica. ¿Qué ocurre si tenemos varios qubits en un estado como este?

\(
\begin{pmatrix}
\frac{1}{\sqrt{2}} \\
0 \\
0 \\
\frac{1}{\sqrt{2}}
\end{pmatrix}
\)

En este estado solo puede colapsar a 00 o a 11. ¿Esto qué significa? Significa que los qubits están entrelazados entre sí, uno depende de otro, si los separamos y uno colapsa a 0, el otro colapsa a 0. Si uno colapsa a 1, el otro colapsa a 1.

Es importante destacar que los qubits pueden separarse en este estados. Los qubits alejados a millones de kilómetros siguen entrelazados y el valor al que deciden colapsar se decide de forma instantánea. Esto quiere decir que se sincronizan a una velocidad superior a la de la luz. El truco es que no se transmite información, por eso el universo lo permite, pero esto permite realizar la teletransportación cuántica.

La forma de entrelazar qubits es muy sencilla, con una puerta Hadamard y una CNOT.

IBM Q todavía tiene que mejorar, pero se aprecia claramente el entrelazamiento cuántico.

Teletransportación cuántica

La teletransportación existe, al menos entre qubits. Y es instantánea (más o menos). La teletransportación cuántica la podemos provocar usando varios qubits entrelazados. Necesitamos 3 qubits. El qubit que va a ser teletransportado, un qubit del emisor y un qubit del receptor. La idea es entrelazar el emisor con el receptor (qubit de destino) y posteriormente el qubit del emisor con el qubit que va a ser transportado.

No he sido capaz de hacer que IBM Q haga una teletransportación, así que aquí viene un esquema distinto. T es el qubit a transportar, A es el emisor y B el receptor. En este ejemplo se usa la puerta Pauli Z, cuya matriz es la indicada.

El truco de la teletransportación instantánea tiene que ver con que A y B tienen que estar entrelazados, por tanto, han tenido que ser transportados a sus respectivos lugares anteriormente a velocidad inferior a la luz.

Esto teletransporta qubits pero no hace copias. Esto es debido al Teorema de No Clonación.

Lenguajes de programación

Mientras esperamos a que los ordenadores cuánticos sean lo suficientemente estables, ya existen lenguajes de programación que podemos usar en simuladores. Quizá el más conocido sea Q# de Microsoft (funciona en Linux, tranquilos), que guarda similitudes con C#. Otro bastante usado es OpenQasm de IBM, algo más parecido a ensamblador.

namespace Quantum.Bell
{
    open Microsoft.Quantum.Primitive;
    open Microsoft.Quantum.Canon;

    operation Set (desired: Result, q1: Qubit) : ()
    {
        body
        {
            let current = M(q1);
            if (desired != current)
            {
                X(q1);
            }
        }
    }
    operation BellTest (count : Int, initial: Result) : (Int,Int,Int)
    {
        body
        {
            mutable numOnes = 0;
            mutable agree = 0;
            using (qubits = Qubit[0])
            {
                for (test in 1..count)
                {
                    Set (initial, qubits[0]);
                    Set (Zero, qubits[1]);

                    H(qubits[0]);
                    CNOT(qubits[0],qubits[1]);
                    let res = M (qubits[0]);

                    if (M (qubits[1]) == res) 
                    {
                        set agree = agree + 1;
                    }

                    // Count the number of ones we saw:
                    if (res == One)
                    {
                        set numOnes = numOnes + 1;
                    }
                }

                Set(Zero, qubits[0]);
            }
            // Return number of times we saw a |0> and number of times we saw a |1>
            return (count-numOnes, numOnes, agree);
        }
    }
}

Este es un ejemplo de lanzar la moneda con entrelazamiento cuántico en Q#, el lenguaje cuántico de Microsoft.

Referencias

Quantum Computing for Computer Scientists
Cats, Qubits, and Teleportation: The Spooky World of Quantum Algorithms
Microsoft Quantum Development Kit: Introduction and step-by-step demo
Qubit

La entrada Computación cuántica para torpes: introducción para programadores se publicó primero en Adrianistán.

Domingo 15 de julio de 2018

Usar AVA para tests en una API hecha en Node.js y Express

Testear nuestras aplicaciones es algo fundamental si queremos garantizar un mínimo de calidad. En este breve post, explicaré como he usado AVA para crear tests para mis APIs: tanto unitarios como de integración con AVA.

AVA es una herramienta de testing, que nos permite describir los tests de forma muy sencilla. De todas las herramientas que he probado, AVA es muy preferida. Es muy sencilla, ejecuta los tests en paralelo y permite escribir código en ES6 (usa Babel por debajo). Además tiene bastante soporte siendo el framework de testing usando por muchos proyectos ya.

Instalamos AVA de la forma típica:

npm install ava --save-dev

A continuación creamos un fichero cuya terminación sea .test.js, por ejemplo, suma.test.js. El lugar da igual.

Una opción de diseño es poner los test unitarios al lado de las funciones en sí, otra opción es crear una carpeta para todos los tests, ya que los de integración van a ir casi siempre ahí. Para ejecutar los tests, simplemente:

ava

El interior de suma.test.js debe importar la función test de AVA y las funciones que quiera probar.

Los tests se definen como una llamada a la función test con la descripción del test y a continuación un callback (asíncrono si queremos) con el objeto que controla los tests (llamado t normalmente). Veamos un ejemplo simple:

import test from "ava";
import {suma} from "./operaciones";

test("Suma",t => {
    t.is(suma(1,2),3);
});

El objeto t soporta múltiples operaciones, siendo is la más básica. Is pide que sus dos argumentos sean iguales entre sí, como Assert.Equal de xUnit.

Veamos que más soporta Ava.

  • t.pass(): Continúa el test (sigue)
  • t.fail(): Falla el test (no sigue)
  • t.truthy(val): Continúa el test si val es verdaderoso (usando la lógica de JavaScript) o falla el test
  • t.true(val): Continúa el test si val es verdadero (más estricto que el anterior) o falla.
  • t.is(val1,val2): Continúa el test si val1 y val2 son iguales (superficialmente) o falla.
  • t.deepEqual(val1,val2): Continúa el test si val1 y val2 son iguales (profundamente) o falla.
  • t.throws(funcion): Ejecuta la función especificada esperando que lance una excepción. Si no lo hace, falla el test. Se puede especificar el tipo de excepción que esperamos en el segundo argumento.
  • t.notThrows(funcion): Exactamente lo contrario que la anterior.

Y algunas más, pero estas son las esenciales.

import test from "ava";

function sum(a,b){
    return a+b;
}

function login(username,password){
    if(username === null || password === null){
        throw new Error("Missing username or password");
    }
}

test("Test example: Sum",t => {
    t.is(sum(1,2),3);
});

test("Login fail username null", t => {
    t.throws(()=>{
        login(null,"123456");
    });
});
test("Login fail password null", t => {
    t.throws(()=>{
        login("username",null);
    });
});

También podemos definir funciones que se ejecuten antes y después de nuestros tests, y una sola vez o con cada test. Podemos usar test.before, test.beforeEach, test.after y test.afterEach en vez de test. Por ejemplo, si tienes una base de datos que necesita inicialización, puedes definir ese código en test.before y la limpieza en test.after.

import test from "ava";
import db from "../db";

test.before(async () => {
    // Iniciar el ORM Sequelize
    await db.sync();
});

 

Con esto ya podemos hacer tests unitarios, pero no podemos probar la aplicación web al 100%. Entra en acción supertest que nos permitirá tener un servidor Express simulado para que los tests puedan probar la aplicación al completo.

Supertest

Instalamos supertest

npm install supertest --save-dev

En el fichero de test necesitamos crear un objeto de tipo aplicación de Express. Este objeto puede ser el mismo que usas en tu aplicación real o ser una versión simplificada con lo que quieras probar.

import test from "ava";
import request from "supertest";
import auth from "http-auth";
import express from "express";

function setup(){
    const app = express();

    let basic = auth.basic({
        realm: "Upload Password"
    }, function (username, password, callback) {
        callback(username === "admin" && password === "123456");
    });

    app.get("/upload",auth.connect(basic),function(req,res){
        res.sendFile("upload.html");       
    });
    return app;
}

test("Página upload requiere autenticación HTTP Basic", async t => {
    let res = await request(setup())
        .get("/upload")
        .send();
    t.is(res.status,401);
    t.true(res.header["www-authenticate"] !== undefined);
});

Aquí la función de test es asíncrona, AVA es compatible con ambos tipos. Supertest es muy completo y permite probar APIs enteras con su sencilla interfaz que junto con AVA, se convierte en algo casi obligatorio para una aplicación que vaya a producción.

La entrada Usar AVA para tests en una API hecha en Node.js y Express se publicó primero en Adrianistán.

Gorka Urrutia

Gorka Urrutia
Nideaderedes

Mi Libro de programación en C ahora es gratuito

A partir de hoy, 16 de Julio de 2018, mi libro de programación en C para principiantes estará disponible de manera gratuita. Hace ya tiempo que lo escribí y considero que ya he ganado lo suficiente con él. Así que he decidido regalarlo.

Por ahora estará disponible gratuitamente en Amazon. Como Amazon no me deja ponerlo a precio cero hasta septiembre lo voy a deshabilitar y crearé uno nuevo esta vez gratuito y sin drm (esa cosa que no te deja copiarlo ni nada).

Ahora voy a maquetarlo de nuevo en formato PDF y, posiblemente en epub o algo así. Cuando termine lo pondré disponible gratuitamente para descarga en el Rincón del C.

Si quieres me puedes echar una mano maquetando el libro. Voy a ir poniendo el código fuente del libro disponible en GitHub para que todo el mundo pueda colaborar.

Si lo ves a la venta en algún sitio avísame, que se trata de un timo.

Jueves 05 de julio de 2018

Mayúsculas iniciales en WordPress

Ciertamente si tenemos un sitio propio, con dominio propio y acceso como administrador a sus «entrañas» podremos crear nuestros propios estilos CSS y con ellos construir cualquier formato que queramos en nuestras páginas. Pero eso solo si «tenemos el poder» (y queremos utilizarlo). Ahora bien, esto no quiere decir que no podamos hacer «cosas extrañas» … Sigue leyendo Mayúsculas iniciales en WordPress

Miércoles 04 de julio de 2018

Gaspar Fernández

Gaspar Fernández
Poesía Binaria

Píldora: Utilizar arrays con nombre dinámico en Bash

Arrays con nombre dinámico en Bash

Una de las grandes ventajas de los lenguajes interpretados es que podemos almacenar en una variable el nombre de otra variable y trabajar con su valor. ¿Punteros? Bueno, al final es parecido a la utilización de punteros en C, aunque aquí podemos hacer referencia por el mismo nombre de la variable incluso, previo filtrado y con mucho cuidado, preguntarle al usuario el de la variable para trabajar con ella.

Esto nos puede dar mucha flexibilidad en nuestro código. Por ejemplo, yo lo he utilizado para perfeccionar mi script de lectura de ficheros de configuración al que le podemos pasar también el nombre de la variable donde almacenar la configuración.

Arrays con nombre dinámico

En Bash, acceder a una variable cuyo nombre está contenido dentro de otra variable es sencillo, podemos hacerlo llamando a ${!NOMBREDEVARIABLE}. Podemos ver un ejemplo en el post referenciado.
El problema es que cuando son arrays no es tan inmediato. El objetivo es que, teniendo una variable que contiene el nombre del array podamos acceder a su información de una forma sencilla. Y El problema aquí viene en la versión de Bash que estemos utilizando. En este caso debemos hacerlo de una forma u otra dependiendo de si utilizamos una versión inferior a la 4.3 (más o menos salió en 2014) o si tenemos una versión posterior.

Ejemplo para Bash < 4.3

Lo siento, mira que no me gusta utilizar eval, pero claro, para estas versiones del intérprete necesitamos crear una cadena de caracteres con la llamada que vamos a hacer y luego evaluar dicha cadena de caracteres. Esto nos dará el valor que buscamos. Por ejemplo:

1
2
3
4
5
6
MIARRAY=("cero" "uno" "dos" "tres")
REFERENCIA="MIARRAY"

# Lo que necesitamos es acceder a cada uno de los elementos de MIARRAY a través de REFERENCIA.

eval echo \${$REFERENCIA[2]}

Si os fijáis, al construir la cadena. El primer símbolo de dólar ($) lo escapamos con la barra para que no se interprete. El que sí tiene que interpretar es el segundo, para que $REFERENCIA se transforme en el nombre del array.

Lo podemos hacer con arrays asociativos también sin problema, pero es algo complicado y realizamos demasiadas tareas para hacer referencia a una variable. Además no queda muy elegante o intuitivo tener que escapar un dólar y otro no.

Ejemplo para Bash >= 4.3

Para estas versiones, disponemos de un modificador en la orden declare (también llamada typeset) a través del cual podemos crear una variable de referencia que se comportará exactamente igual que nuestro array:

1
2
3
4
MIARRAY=("cero" "uno" "dos" "tres")
declare -n REFERENCIA="MIARRAY"

echo ${REFERENCIA[2]}

Además, de esta forma, el nombre de la variable puede venir dado en otra variable, con lo que podemos permitir que el usuario especifique el nombre de variable. Eso sí, con mucho cuidado.

Foto principal: unsplash-logoRuben Ortega

The post Píldora: Utilizar arrays con nombre dinámico en Bash appeared first on Poesía Binaria.

Jueves 28 de junio de 2018

“El paciente” a descompilar es un exe de msdos en formato MZ

Posts in this series
  1. Compilar C en m$dos en nuestros tiempos
  2. "El paciente" a descompilar es un exe de msdos en formato MZ

Aunque voy despacio, voy a ir poniendo mis avances, que supongo que es poquito, pero bueno por seguir la Método de depuración del patito de goma o el refrán oriental que dice “El que enseña aprende dos veces.” .

La verdad es que en los primeros palos de ciego y análisis creí que “el paciente” era un ejecutable de tipo COM o algo así, pero ahora volviendo a analizarlo he encontrado el famoso:

MZ

0x4D 0x5A

Eso ayuda un montón porque si queridos mios, los ejecutables también tienen formato y no es estándar, hay muchos muchos estándares (en m$-dos hablamos…en otros sistemas operativos…pues habrá los suyos).

Como dice en el foro de ubuntu: Learning how to disassemble dos binaries

If actual DOS executables disassembly is the thing you are searching for, then search for disassemblers, that can handle the MZ magic [$4D 5A] (the default DOS 16bit header) or elf, coff, xcoff, ecoff, mach and such …

Bueno pues ahora entender la estructura de fichero de el formato DOS MZ .

Si alguno tiene alguna pista, estaré agradecido.

KDE-Plasma: Agregar una plantilla al menú «Crear nuevo»

Cuando hacemos clic derecho en Dolphin, tenemos la opción «Crear nuevo» lo que nos permite crear una carpeta, un archivo de texto, enlace a aplicación, etcétera. Hoy veremos cómo agregar una nueva entrada a ese menú. Usaré como ejemplo el crear un documento Writer con una plantilla definida por nosotros. Primero, claramente, tenemos que crear … Sigue leyendo KDE-Plasma: Agregar una plantilla al menú «Crear nuevo»

Videojuegos libres que se han ido de github después de ser fagocitada por Microsoft

Después de la mala noticia (gracias capitalismo) de el canibalismo salvaje de Micro$oft comiendose a github. Ya hablamos por los tomates de eso en Github ha muerto…bueno lo han asesinado.

Muchos proyectos de software libre han migrado a otras forjas/repositorios de software, y de entre estos tenemos los videojuegos libres…junto con respirar, una de las cosas que mas me ocupa la cabeza…me gustaría algún día intentar conseguir vivir de hacer videojuegos libres…pero bueno…

Bueno pues conocidos por mi, he encontrado los siguientes videojuego libres que se han ido de github:

Solarus, un clon libre del Zelda de SNES/GBA/GB con editor de mapas y todo en plan RPGmaker. Solarus has moved to Gitlab

Y OpenMW que es un clon libre del videojuego de rol en 3D Morrowin. OpenMW code, bug tracker, and wiki are now on GitLab!

Y seguro que hay mas. Amable lector…¿Conoces algún otro videojuego libre que se haya pirado de github?

Domingo 24 de junio de 2018

Compilar C en m$dos en nuestros tiempos

Posts in this series
  1. Compilar C en m$dos en nuestros tiempos
  2. "El paciente" a descompilar es un exe de msdos en formato MZ

La verdad es que para escalar una montaña, primero hay que tener la montaña.

Mi montaña es descompilar un videojuego (de momento uno)  y liberarlo, pese a la polémica que hay con esta forma de liberar videojuegos como podéis leer en: Devilution – Decompiled Diablo 1 en el subreddit de videojuegos libres.

El juego en cuestión, ya os lo contare si lo consigo, pero como ya he empezado con los problemas, he querido ir paso a paso, y me he buscado un montecito, descompilar un C de un hola mundo.

Todo este gusanillo viene los articulos del Fanta: mierda.tv (cosas de dosbox que no tiene tags y hay que tirar de busqueda).

A ver, quiero ser perro mordedor y poco ladrador, por eso no voy a ponerme grandes metas y voy a ver hasta donde llego.

Y lo primero que hay que hacer es tener un m$-dos entre manos, como no me apetece llamar al tito Gates y decirle que me venda unos disquetes de su apestoso sistema operativo, he encontrado el viejo y querido dosbox  (no os asustéis con ese web de los dosmiles).

En casi todas las distribuciones de GNU/Linux viene en el repositorio de paquetes oficial por lo que no sera difícil instalarlo. Aunque cosa distinta es si queréis ver la matrix de m$-dos que hay que seguir el tutorial que hizo Fanta para poner el debug heavy.

Una vez instalado hay que descargar el djgpp, que es la versión del compilador libre por excelencia el Gcc para m$-dos, el proyecto tiene un formulario web para darte una lista de crípticos ficheros zip para tener el gcc funcionando según gustos personales, básicamente tienes que seleccionar:

  • compilar y ejecutar programas
  • C y ensamblador
  • Por frikeo el Rhide
  • Depurador gdb

Como podéis ver en la captura de pantalla:

 

Y tendrás de la descarga los siguientes ficheros zip con nombres bastante crípticos, pues tienes que descomprimirlos a una misma carpeta todos, en mi caso le puse el nombre tan original como djgpp y tendrás algo tal que así (donde todos las carpetas bin de cada zip estarán fusionadas y el resto de tipos de carpetas al igual con sus respectivos nombres):

Ahora como enganchamos el dosbox para que coja ese directorio en el path de ejecutables (si, por si no lo recordabais m$-dos tenia un invento parecido a los Unix), pues aunque se puede cambiar la configuración de dosbox para hacerlo, voy a enseñaros vía parámetros de la shell…porque así explico una parte el señor Fanta y seguir el hilo de su trabajo.

$ dosbox -c "keyb sp" -c "mount c: ." -c "C:" -c "set PATH=C:\DJGPP\BIN;%PATH%" -c "set DJGPP=c:/djgpp/djgpp.env"

Y después puedes probar cosas tan frikis como usar rhide para editar un fichero c con un hola mundo.

Recuerda, para sacar al ratón del dosbox es: ctrl + F10

Y aquí tenéis el holamundo en C para m$-dos:

En cuanto puedo os sigo mostrando los siguientes paso hasta escalar mi montaña personal.

Jueves 21 de junio de 2018

DAE-18: El texto ya está en su lugar (mayormente)

Bueno, parece que después de todo es posible que la edición 2018 de «domando al escritor» no se convierta en la edición 2019… El texto está, mayormente, «en su lugar». De hecho el índice ya ha llegado a las siete páginas. No hay aún diagramas ni capturas de pantalla, solo texto y dos tablas. Hay … Sigue leyendo DAE-18: El texto ya está en su lugar (mayormente)

Martes 19 de junio de 2018

Bruno Exposito

Bruno Exposito
Puro Linux

Diferencia entre ruta relativa y absoluta

Para acceder a un fichero o carpeta (ya sea en Windows, Linux o Mac) utilizamos lo que se llama una ruta, una ruta es algo así como la dirección de una casa.

Hay dos tipos de rutas:
– Relativas
– Absolutas

La diferencia entre una ruta relativa y una absoluta radica en que la relativa depende del directorio en el que te encuentras actualmente, mientras que la absoluta no.

Pongamos un ejemplo, imagina que estás en el directorio “F” y quieres llegar hasta el directorio “H”.

estructura

 

Hay dos modos de llegar a la carpeta destino:

Ruta relativa

– Desde tu posición actual (F), subir hasta “B”, luego subir al directorio “A”, luego bajar al directorio “D” y a continuación llegas a tu destino, el directorio “H”. El problema de seguir estas “indicaciones” es que solo sirven si estás en “F” o en “E”, si estás en otro directorio no llegarás a “tu destino” con las indicaciones recibidas.

relativa

Ruta absoluta

– Desde el directorio raíz entras en “D” y luego en “H”. En este caso la ruta absoluta es mas corta, si el origen fuera “G” y el destino “H” sería mas larga.

absoluta

 

Volvamos a Linux. Suponiendo que estás en tu carpeta home (cd ~) y que quieres mostrar el contenido de un fichero txt, puedes usar:

cat Documentos/informe.txt (relativo)
cat /home/bruno/Documentos/informe.txt (absoluto)

 

¿Cuando usar uno u otro? Depende de lo que estés haciendo.

Por ejemplo, tengo un script que ejecuto usando un alias que está en el fichero ~/.bashrc y que uso para compilar varios proyectos con maven.

El script lo ejecuto desde la primera terminal que tenga a mano, independientemente del directorio en el que esté la terminal en ese momento.

En este caso el script usa la ruta absoluta hacia la carpeta con el código, pues no puedo confiar en estar en el directorio correcto.

 

Otro ejemplo, estoy desarrollando una web en HTML y quiero enlazar una imagen.

En este caso tengo que usar una ruta relativa, ¿por que? Porque si uso una absoluta solo va a funcionar en mi ordenador, si le paso el código a otra persona la imagen no se verá a menos que tenga la imagen exactamente el mismo sitio.

Dentro del directorio hay una carpeta llamada imgs y dentro la foto. Es correcto.
<img src”imgs/foto.jpg” alt=”foto”>

En el directorio padre del actual (../) hay una carpeta llamada imágenes y dentro la foto. Correcto también.
<img src”../imagenes/foto.jpg” alt=”foto”>

En mi carpeta imgs que esta en mi home tengo la foto. Incorrecto.
<img src”/home/bruno/imgs/foto.jpg” alt=”foto”>

Yo me voy por mi izquierda…

Lunes 11 de junio de 2018

Gaspar Fernández

Gaspar Fernández
Poesía Binaria

Programación de tareas en segundo plano para nuestras aplicaciones web (Introducción. Parte 1 de 3)

Tareas programadas en segundo plano

Las aplicaciones web se van complicando cada vez más. Es un hecho y es algo bueno. Los ordenadores tienen más potencia, y los creadores cada vez más opciones e imaginación para destacar sobre la competencia. Una práctica interesante es la posibilidad de realizar tareas en segundo plano o en un momento concreto del tiempo sin que exista una mediación por parte del usuario.

Tenemos varias posibilidades y en estos posts vamos a centrarnos en cada una de ellas. Por otro lado, aunque este post es más general e independiente del lenguaje, quiero centrarme en PHP. Por un lado, es un lenguaje con el que he trabajado mucho, por otro, aunque es posible que diferentes partes de un proyecto estén realizadas en diferentes lenguajes, y PHP no sea un lenguaje pensado a priori para esto, en ocasiones, es más fácil y barato para una empresa pequeña recolocar a alguien en otro módulo de la apliación si todo está desarrollado en el mismo lenguaje. Como quiero hacer este post más o menos completo y relatar mi experiencia en cada uno de los puntos, se me ha alargado mucho, por eso he decidido dividirlo en tres partes, incluso puede que algún ejemplo dé para una cuarta.

¿Qué podemos hacer con estas tareas?

Bueno, ¿para qué vale todo esto? Es cierto que una web que tenga sus usuarios, envíe correos y sirva cierta información al usuario no tiene por qué ejecutar nada en segundo plano. Todo se servirá y se realizará al ritmo que los usuarios lo pidan. Eso está bien, en principio. Pero claro, imaginad que la web empieza a ganar visitantes. Lo primero que puede darnos problema es el envío de correo.

Puede que si se registran 10 usuarios por hora no pase nada pero, ¿10 usuarios por segundo? A los que debemos enviar confirmaciones de registro (no son muchos), pero luego enviaremos alertas para ciertos eventos, recordatorios de contraseña, avisos de que están intentando entrar con esa cuenta de correo… en definitiva, nuestra aplicación deberá establecer varias conexiones por segundo con el sistema de correo, sistema que muchas veces es externo y seguro que se cabrea (y nos expulsa por establecer tantas conexiones). Seguro que estaría bien coger cada 10, 15 o 20 segundos, y ejecutar una tarea que envíe todos los mensajes que tenga pendiente, lo que se llama un spool de correo, incluso enviar todos los correos pendientes aprovechando una misma conexión al servidor de correo, de manera mucho más eficiente y ordenada.

Supongamos que queremos tener un control de la llegada de dichos mensajes, o al menos comprobar que el e-mail sigue siendo válido para determinar si nuestros usuarios son legítimos o tenemos algún problema con sus datos. En este caso, cuando el servidor de correo de destino está recibiendo el mail normalmente contestará. Puede que el correo se entregue bien, o puede que estemos en una lista negra, el servidor de destino puede aplicar listas grises, nuestro correo puede ser tachado como Spam, o incluso que el servidor de destino no funcione ahora mismo. En caso de fallo, nuestro servidor de correo nos enviará un mensaje con el motivo por el que no se ha podido entregar el correo. Dichos mensaje podemos leerlos periódicamente y asignar un código de estado a los mensajes que hemos enviado a modo de diagnóstico, o para hacer un reintento pasados unos minutos, desactivar usuarios, etc.

Una web actual, normalmente también descarga contenidos de otros lados, y los procesa. Puede que descarguemos tweets, una captura de una web, extraigamos una imagen o una descripción de un post, la cotización del euro o de alguna criptomoneda. Esto son tareas que no dependen de nosotros. Así que no podemos controlar que el tiempo que tardamos en ellas sea fijo, o que nos pueda echar por tierra una página. También tenemos que pensar en que si cada vez que un visitante requiere alguno de estos datos desde nuestro sitio tenemos que acceder a otro lado para sacarlo, tal vez el otro lado se harte de nosotros, o que no responda en algún momento debido a una caída. Lo que podemos hacer es acceder periódicamente a esos sitios sin que exista mediación por parte de nuestros usuarios y guardar esos contenidos en una memoria o base de datos, de modo que nosotros podamos acudir a esos datos de forma muy rápida. Nuestro dato tal vez no sea el más actualizado, en el caso de las cotizaciones, tal vez tengamos un cierto desfase (aunque podemos aplicar otras técnicas), pero si se trata de tweets, posts y demás, esos contenidos no van a variar con el tiempo.

Otro uso muy útil es la importación, exportación y cálculo de datos. En sistemas de estadística, puede que nuestra aplicación deba importar gran cantidad de datos procedente de diversas fuentes (webs externas, ficheros de usuario, APIs, etc). Esta tarea puede ser muy rápida o llegar a ser muy lenta en su ejecución. ¿Por qué no hacerla en segundo plano y avisar al usuario cuando terminemos? Por un lado, evitamos que el usuario esté eternamente esperando una respuesta (y que se estrese poniéndose a pedir los mismos datos una y otra vez), por otro, si la tarea hace un uso muy intensivo de CPU, podemos limitarlo (la tarea puede realizarse de forma más lenta, pero al menos no nos tira el servicio). Tanto si estamos introduciendo datos, generando un fichero de reporte, realizando cálculos, que también puede ser convirtiendo un vídeo u obteniendo una miniatura de un vídeo, son tareas que pueden estresar al usuario y no deberían influir en la carga de nuestras páginas.

También puede que nos interese eliminar sesiones de usuarios inactivos, invalidar o generar cachés de contenidos complicados. El objetivo es que el usuario final de nuestra página tenga que esperar lo menos posible para la realización de las tareas antes de ver un resultado en la página web. Por supuesto, luego podemos consultar por Ajax si una tarea ha finalizado para avisar al usuario o, como es el caso del envío de correos, es algo que al usuario no le importa, pero a nosotros sí.

Escalabilidad

Algo que tenemos que tener en cuenta cuando estamos inmersos en un proyecto es su escalabilidad. En un primer momento, y si no nos queda otra, cuando empezamos a tener visitas a nuestros servicios podremos optar por una escalabilidad vertical. Es decir, utilizar máquinas más potentes para servir nuestros contenidos. Aunque pronto empiezan a surgir más problemas si hacemos de esta práctica algo común. Los costes suelen dispararse, es más barato comprarse 4 ordenadores pequeños que uno cuya potencia englobe a los cuatro. Vale, no siempre es así, pero si nos ponemos a mirar presupuestos de ordenadores llega un momento en el que sí se cumple. Por otro lado, si tenemos nuestro servicio alojado únicamente en una máquina, sólo hace falta que se rompa una máquina para echar todo al traste. Parece una frase tonta pero es así, mientras que si tenemos nuestro servicio replicado en cuatro máquinas, si se rompe una nos fastidia, pero no nos pillamos los dedos. Bueno, tras todo esto tendríamos que pensar qué parte debemos escalar y cómo, porque puede que escalar toda una aplicación mastodóntica no sea la solución, debemos analizar los cuellos de botella y optar por una solución inteligente.

El caso es que muchas veces este tipo de tareas pueden pasarse a otra máquina. Es decir, nuestra máquina principal (o máquinas), como punto de entrada servirán webs y punto. Pero para las tareas programadas, que puede que algunas requieran mucha CPU vamos a utilizar otra máquina, que incluso será privada y funcionará de forma independiente, incluso si vemos que las tareas son muy exigentes podemos dividirlas en varias máquinas a nuestro gusto. De esta manera podremos hacer crecer nuestra aplicación.

Informes de errores

Aunque muchos programadores dejan esto para el final, en mi opinión es lo primero que deberíamos implementar. Cada vez que ejecutamos una de estas tareas deberíamos escribir en algún lado (base de datos, fichero log, servicio de logs externo, etc) que estamos empezando a realizar la tarea. Deberíamos escribir los errores que nos encontramos y los pasos que damos a la hora de ejecutar tareas, así como su finalización. Con esto tendremos un seguimiento que nos puede ayudar a corregir errores o saber si alguna tarea se ha quedado bloqueada. Más tarde podremos desactivar mensajes para que solo muestre inicio de tarea, fin de tarea y errores, así sabemos que nuestro programa hace su trabajo.

Tareas tras la carga de la web

Una técnica que se ha utilizado durante mucho tiempo es que tras la carga completa de la web se ejecute cierto código de mantenimiento. Es cierto que durante mucho tiempo, una vez se ha cargado la web, se comprueba si se deben realizar tareas y se realizan en caso afirmativo. Muchos sitios lo hacen cuando carga una web, otros sitios hacen una petición Ajax para ejecutar tareas… el problema es que en cualquier caso, estamos haciendo que el usuario intervenga en el disparo de dichas tareas. Eso puede causar que la página cargue más lenta, que haya demasiadas peticiones innecesarias al sistema de tareas, que si la tarea tarda mucho en ejecutarse se cancele debido a los timeouts de PHP o del servidor web, o que, si ningún usuario entra a la web en un tiempo, no se lance ninguna tarea. En cualquier caso, yo soy de la idea de que “son cosas que al usuario no le interesan“, incluso en algunos sistemas, podemos ver tras la petición (sobre todo las Ajax), si se ha ejecutado la tarea y cómo ha ido dicha ejecución, cosa que interesa mucho menos al usuario.

El origen de todo esto es porque muchos servidores (sobre todo los compartidos), históricamente no nos dejaban hacer llamadas a otras aplicaciones de gestión de tareas o incluso la creación de tareas programadas (cron jobs). Actualmente, hasta los hospedajes compartidos nos dejan hacer cosas así, de todas formas, yo te recomiendo montarte por lo menos un VPN para tener más libertar con estas cosas. Aún así, las necesidades de ejecución de tareas en nuestras aplicaciones están creciendo.

Cron jobs

Reloj
Son las tareas programadas de toda la vida, de esta forma le podemos decir al sistema ejecuta este programa cada x días, h horas y m minutos. Normalmente un servidor ejecuta muchas tareas en segundo plano como pueden ser mantenimiento de logs, sincronización del reloj, comprobación de actualizaciones, envío de informes de salud, generación de estadísticas y algunas más. Así que, ¿por qué no introducir nuestras propias tareas?

Por un lado podríamos utilizar un script para cada tarea, por ejemplo invalidación de cachés o limpieza de base de datos, consulta de webs externas y envío de e-mails incluso introducir diferente periodicidad para cada una de ellas. Pero en muchas ocasiones podemos incluso centralizarlo todo en una única llamada. Si hablamos de PHP, podremos ejecutar un único archivo PHP o Python, o Java y que éste se encargue de revisar las tareas pendientes y ejecutar las que crea pertinentes. Habrá ejemplos en PHP en el siguiente post. Incluso si lo hacemos de forma centralizada, podremos introducir tareas que solo deban lanzarse una vez en el juego. Por ejemplo cuando exista una tarea que no tiene por qué ser periódica, como puede ser la obtención de los últimos posts de un blog que acaban de introducir en nuestra web (no es periódico, se realiza cuando un usuario da de alta su blog). Luego este cron job lo podemos ejecutar cada minuto o cada dos minutos, como lo creamos necesario. Basta con ejecutar:

crontab -e

Y luego añadir
1
2
# m h  dom mon dow   command
*/2 * * * * php /ruta/del/archivo/archivo.php

Con esto ejectaremos la tarea cada dos minutos. Seguro que buscando por la red encontramos mucha información sobre los cron jobs.

En nuestro script podremos hacer una consulta a base de datos para determinar las tareas que hay pendientes (periódicas o no) y ejecutar la que toque, incluso cada tarea podrá realizar llamadas a otros procesos, y todo sin que el usuario tenga que intervenir y sin costarle tiempo a él.

Lo malo es que los cron jobs de Unix no pueden alcanzar una resolución de segundos por lo que si queremos lanzar una tarea cada segundo, cada dos, o cada quince segundos tenemos que andar ejecutando tareas con sleep delante, aunque podríamos tener problemas si una tarea tarda más de lo normal en ejecutarse.

Programador de tareas en ejecución

Otra opción es crear nosotros un programador de tareas en el lenguaje en el que estemos trabajando. Por un lado, si utilizamos una base de datos para el control de nuestras tareas no tendremos que iniciar conexiones cada vez que ejecutamos la tarea, lo que gasta tiempo y recursos, sino que podremos tener una conexión abierta todo el tiempo. Y, por otro lado, podemos mirar si tenemos una tarea pendiente cada menos tiempo, por ejemplo cada dos segundos. En este caso, si, en el caso de una tarea de envío de correo electrónico, comprobamos si tenemos que enviar e-mails cada minuto, en el peor de los casos, el mensaje tardará un minuto (más o menos en salir). Mientras que si comprobamos cada dos segundos, al usuario prácticamente le da tiempo a cambiar de ventana, acceder a su correo y comprobar si tiene algo nuevo cuando ya ha recibido el mensaje. Parece que no, pero da una mejor sensación a los usuarios.

Por otro lado, si utilizamos un programador de tareas de este estilo podremos tener varias instancias del programador corriendo en una misma máquina. En caso de que no sean tareas muy intensas computacionalmente, como son enviar e-mails, descargar información de webs externas, etc podríamos tener varias tareas en ejecución a la vez. Eso sí, deberíamos controlar muy bien que no se lance la misma tarea por dos programadores a la vez, lo que puede ser un problema. Así como determinar qué tareas pueden ejecutarse en varios sitios a la vez y cuáles no.

Como el artículo me ha quedado muy largo, he decidido dividirlo en tres. Así que para el próximo incluiré ejemplos de código fuente. La segunda parte estará disponible el día 18 de Julio.

Foto principal: unsplash-logoEstée Janssens

Foto (reloj): unsplash-logoÁlvaro Bernal

The post Programación de tareas en segundo plano para nuestras aplicaciones web (Introducción. Parte 1 de 3) appeared first on Poesía Binaria.

Martes 05 de junio de 2018

Gaspar Fernández

Gaspar Fernández
Poesía Binaria

Ejecutando tareas desde consola simultáneamente con GNU Parallel


Los ordenadores cada día son más potentes. Y una de las formas de poder ejecutar tareas de forma más rápida, es simultanearlas. Por un lado, es lógico que si una tarea está esperando un dato (ese dato puede venir del disco, del usuario por medio del teclado o el ratón, o descargándoselo de Internet), es normal que el ordenador decida ejecutar otras cosas para no perder el tiempo. Y de hecho se ha aprovechado esto para tener varios programas en ejecución, constantemente dando y quitando el acceso al procesador. Aunque, con la evolución en el mundo del hardware, ahora es común tener ordenadores que comprenden varios núcleos de procesador y son capaces de disponer de varios hilos de ejecución simultáneos. Lo que quiere decir, que pueden hacer realmente varias cosas a la vez, por lo que tiene más sentido incluso ejecutar tareas en paralelo.

Ejecución concurrente en la shell

Normalmente, si queremos ejecutar varias tareas al mismo tiempo, o concurrentes desde una terminal Unix. Basta con ejecutar un programa de la siguiente manera:

programa &
19238
… ejecuto más cosas …

Con un ampersand (&) al final. De esta forma, el terminal nos devolverá el control a nosotros como usuarios, permitiéndonos ejecutar otras cosas mientras la tarea que le hemos pedido que ejecute lo hace de fondo (en background). Es conveniente que la tarea no escriba muchas cosas en pantalla, porque si no va a ser un jaleo.
También podemos ejecutarla de forma normal, y en mitad de la ejecución pulsar Control+Z (Representado por ^Z). Control+Z enviará una señal SIGSTOP al programa en cuestión, por lo que la ejecución se detendrá, permitiéndonos ahora ejecutar otras cosas, y luego continuar la tarea anterior tanto en el frente (foreground), escribiendo fg o, de fondo (como hacíamos antes, en background), escribiendo bg.
programa
^Z
[1]+ Stopped   programa
… ejecuto más cosas …
fg
programa
… programa sigue ejecutándose …
^Z
[1]+ Stopped    programa
bg
[1]+ programa &
… puedo ejecutar lo que quiera …

Generalmente, si tenemos un ordenador con varios núcleos y capaz de ejecutar varias tareas al mismo tiempo. El núcleo del sistema operativo se encargará de repartir estas tareas entre los núcleos disponibles para que la ejecución global sea más rápida. Si tenemos 2 tareas que se ejecutan en un solo hilo y nuestro ordenador puede ejecutar dos hilos de forma simultánea, ¡vamos a ejecutar los dos al mismo tiempo y terminarán antes!
Concretamente, si tenemos dos programas:

  • pi : Calcula el número PI con 4000 decimales, y tarda 10 segundos.
  • color : Corrige el color de una imagen jpg enorme, y tarda 14 segundos.

Si ejecutamos los dos programas de forma secuencial (primero uno y luego otro), tardaremos 24 segundos en realizar las dos tareas. Pero si las ejecutamos a la vez, como nuestro procesador tiene dos núcleos y no está haciendo nada más, tardaremos en completar las dos tareas 14 segundos (lo que tarda la más lenta de las dos).

Cuando se nos queda corto…

Cuando hablamos de paralelizar tareas, podemos hacerlo en casi cualquier lenguaje o entorno. Es más, justo con la información de antes podemos aprovechar para lanzar varias tareas. Incluso con algo de programación, establecer algún que otro bloqueo para guardar el orden de las ejecuciones. O incluso para poder ejecutar las tareas de dos en dos, o de tres en tres… aunque tratándose de Bash puede ser un poco duro programar ciertas cosas, sobre todo cuando tenemos prisa.

GNU Parallel nos permite ejecutar tareas de forma simultánea, agrupar tareas, ordenar la salida, e incluso nos evita tener que pelearnos con aquellos conceptos de concurrencia que a más de uno nos han traído de cabeza. Como extras, nos permite jugar con los argumentos de entrada de los programas de forma muy divertida a la par que útil.

Instalación

GNU Parallel suele venir en los repositorios de las distribuciones de GNU/Linux más populares, así que podemos hacer:

sudo apt install parallel

En caso de Debian/Ubuntu y derivados

dnf install parallel

Si estamos en Fedora.

pacman -S parallel

El programa no tiene muchas dependencias y es totalmente multiplataforma, ya que está escrito en Perl. Podremos ejecutarlo en nuestro ordenador, un servidor, un móvil, una Raspberry PI o cualquier cacharro que corra GNU/Linux.

Es importante saber la versión que tenemos instalada. Podemos averiguarlo con:

parallel --version
GNU parallel 20161222

Aunque casi todos los ejemplos del post corren con versiones anteriores, para algunas cosas necesitaremos como mínimo la versión 20161222. Si tu distribución no la tiene por defecto, siempre podemos descargarlo de la página oficial.

Calcular el número PI

Un programa que suelo utilizar para este tipo de ejemplos es el cálculo del número Pi. Sobre todo porque es una tarea que tarda un rato y utiliza intensamente el procesador. Sólo necesitamos tener bc instalado. El script es muy sencillo y lo he llamado pi:

1
2
#!/bin/bash
echo "scale=4000; a(1)*4" | bc -l

Ahora debemos dar permiso de ejecución a dicho archivo:

chmod +x pi

Y podemos hacer una prueba sin concurrencia ni nada para ver lo que tarda en ejecutarse en nuestro ordenador:
time ./pi
3.141592653589793238462643383279502884197169399375105820974944592307\
….
66983895228684783123552658213144957685726243344189303968642624341077\
3226978028073189154411010446823252716201052652272111660396
real 0m10.800s
user 0m10.792s
sys 0m0.008s

Si quieres seguir esta guía y ves que la ejecución de pi tarda mucho, puedes bajar el número de dígitos (donde pone scale=4000, puedes bajar el número). El objetivo es no eternizarnos, pero darnos cuenta de cómo se está ejecutando todo.

Varias ejecuciones de un programa

GNU Parallel está diseñado para pasar argumentos de forma variable a cada una de las instancias que ejecutemos del programa. Siempre tendremos que pasar argumentos al programa a ejecutar aunque, en este caso, solo queremos ejecutar varias veces pi, sin argumentos. Una forma fácil es generar una secuencia de números del 1 al total de veces que queremos ejecutar el programa, lo podemos hacer con seq (por ejemplo con 10):

seq 10
1
2
3
4
5
6
7
8
9
10

Una vez que tenemos esta entrada, se la podemos pasar a GNU Parallel. En este caso, le diremos que a pi no le pase argumentos (-n0):
seq 10 | parallel -n0 ./pi

Esta ejecución tardará un tiempo. Eso sí, mientras se ejecuta, estaría bien que investigáramos un poco qué está haciendo el programa. En mi ordenador, puedo ejecutar hasta 8 hilos de forma simultánea. Eso quiere decir que, como pi es una tarea que tira mucho de CPU, ejecutar las 10 instancias del programa al mismo tiempo no haría que la ejecución global fuera más rápido que una ejecución secuencial puesto que dos procesos se pelearían por utilizar la CPU y el sistema operativo tendría que dar y quitar el paso a CPU de los procesos. La situación se agravaría si en lugar de 10 ejecuciones hiciéramos 100 o más, incluso podríamos tener otros problemas si intentamos ejecutar una tarea muy complicada demasiadas veces al mismo tiempo.

Podemos ver qué está haciendo la CPU en cada momento ejecutando top, un gestor de tareas o un monitor de CPU.
Uso de CPU
Lo que quiero que observemos es el número de procesos que estamos utilizando en cada momento. En este caso, la ejecución se hará de 8 en 8 porque GNU Parallel ha detectado que mi sistema puede correr 8 hilos simultáneamente. Podemos comprobarlo si mientras ejecutamos el comando anterior, en otro terminal ejecutamos:

pidof bc | wc -w
8

Veremos ese 8 todo el tiempo. Ya que parallel controla ese número de ejecuciones.

Alternativamente, podemos especificar nosotros cuántas ejecuciones simultáneas tendrá el programa con el argumento -j. De la siguiente manera:

seq 10 | parallel -j2 -n0 ./pi

En este caso, ejecutaremos las tareas de 2 en 2. Podemos especificar el número de tareas simultáneas que necesitemos. Incluso puede exceder el número de núcleos o hilos disponibles en nuestro sistema. El objetivo es que da igual lo que dure la ejecución de pi, mantendremos el número de ejecuciones que le digamos a parallel hasta que ya no haya más instancias por lanzar.

Cambiando los argumentos de entrada

La gracia de ejecutar tareas en paralelo es que podamos variar los argumentos de entrada de dicho programa. Es más, un programa podrá tener argumentos fijos y argumentos variables. Esto lo podemos poner en práctica ejecutando echo de forma concurrente con diferentes parámetros. Vale, ejecutar echo no es ninguna tarea intensiva, pero nos vale para ver cómo se están produciendo las ejecuciones y algunas cosas curiosas más.

Argumentos desde teclado (entrada estándar)

Una forma muy sencilla de pasar argumentos de entrada a parallel es de forma interactiva, escribiéndolos por teclado y pulsando Control+D al finalizar:

parallel echo
parallel: Warning: Input is read from the terminal. Only experts do this on purpose. Press CTRL-D to exit.
Jaén
Córdoba
Sevilla
Huelva
Cádiz
Málaga
Granada
Almería
Jaén
Córdoba
Sevilla
Huelva
Cádiz
Málaga
Granada
Almería

Argumentos desde pipe

Estos argumentos podemos pasarlos desde una pipe o desde un archivo, pero tiene que haber uno por línea. Podemos introducir las provincias en un archivo o hacer lo siguiente (con tr estamos convirtiendo los espacios en retornos de carro), además, estamos introduciendo un argumento fijo “Saludos desde”:

echo “Jaén Córdoba Sevilla Huelva Cádiz Málaga Granada Almería” | tr ‘ ‘ ‘\n’ | parallel echo “Saludos desde”
Saludos desde Jaén
Saludos desde Córdoba
Saludos desde Sevilla
Saludos desde Huelva
Saludos desde Cádiz
Saludos desde Málaga
Saludos desde Granada
Saludos desde Almería

Argumentos desde pipe en orden

Pero claro, no todos los programas aceptan los argumentos en el mismo lugar, imaginemos que queremos decir algo más tras el nombre de la provincia andaluza, para ello tendremos que introducir alguna cosa más:

echo “Jaén Córdoba Sevilla Huelva Cádiz Málaga Granada Almería” | tr ‘ ‘ ‘\n’ | parallel echo “Saludos desde” {}”, una bonita provincia andaluza.”
Saludos desde Jaén, una bonita provincia andaluza.
Saludos desde Córdoba, una bonita provincia andaluza.
Saludos desde Sevilla, una bonita provincia andaluza.
Saludos desde Huelva, una bonita provincia andaluza.
Saludos desde Cádiz, una bonita provincia andaluza.
Saludos desde Málaga, una bonita provincia andaluza.
Saludos desde Granada, una bonita provincia andaluza.
Saludos desde Almería, una bonita provincia andaluza.

Varios argumentos variables por ejecución

Ahora, vamos a crear un archivo, en el que introduciremos un número (el número de letras que tiene la provincia) y la provincia, de forma alternativa en cada línea. Lo llamaremos andalucia.txt:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
4
Jaén
7
Córdoba
7
Sevilla
6
Huelva
5
Cádiz
6
Málaga
7
Granada
7
Almería

Con este archivo podríamos hacer lo siguiente:

cat andalucia.txt | parallel -n 2 echo “Dame {1} letras para {2}”
Dame 4 letras para Jaén
Dame 7 letras para Córdoba
Dame 7 letras para Sevilla
Dame 6 letras para Huelva
Dame 5 letras para Cádiz
Dame 6 letras para Málaga
Dame 7 letras para Granada
Dame 7 letras para Almería

Con -n2 estamos indicando que echo llevará dos argumentos, por lo que cada ejecución de echo tomará dos líneas del fichero como argumentos. Con {1} y {2} indicamos el número de parámetro que estamos colocando. También podríamos hacer lo siguiente:
cat andalucia.txt | parallel -n 2 echo “{2} tiene {1} letras.”
Jaén tiene 4 letras.
Córdoba tiene 7 letras.
Sevilla tiene 7 letras.
Huelva tiene 6 letras.
Cádiz tiene 5 letras.
Málaga tiene 6 letras.
Granada tiene 7 letras.
Almería tiene 7 letras.

Argumentos de parallel como argumentos del programa

Otra forma de incluir argumentos variables es la siguiente:

parallel echo ::: Ávila Burgos León Palencia Salamanca Segovia Soria Valladolid Zamora
Ávila
Burgos
León
Palencia
Salamanca
Segovia
Soria
Valladolid
Zamora

Argumentos y combinaciones

Cuando tenemos que lanzar muchas tareas, a veces es útil que los argumentos hagan combinaciones de parámetros. De esta manera no tendremos que generar un fichero que reúna las combinaciones y luego pasárselo a Parallel. Por ejemplo, si queremos hacer una operación lógica AND, podemos hacer lo siguiente:

parallel ‘echo -n {1} \&\& {2} = ; (({1}&&{2})) && echo 1 || echo 0’ ::: 0 1 ::: 0 1
0 && 0 =0
0 && 1 =0
1 && 0 =0
1 && 1 =1

O, mucho más sencillo, si queremos todas las combinaciones que podemos hacer con 3 bits, podemos hacer lo siguiente:

parallel echo ::: 0 1 ::: 0 1 ::: 0 1
0 0 0
0 0 1
0 1 0
0 1 1
1 0 0
1 0 1
1 1 0
1 1 1

Un paso más, ahora queremos averiguar con bc su valor en decimal:

parallel echo -n {1}{2}{3} = \;’echo “ibase=2;{1}{2}{3}” | bc’ ::: 0 1 ::: 0 1 ::: 0 1
000 =0
001 =1
010 =2
011 =3
100 =4
101 =5
110 =6
111 =7

Datos desde un fichero separado por columnas

Podemos utilizar un archivo cuyo contenido pueda ser determinado por columnas, como un CSV (Comma Separated Values) o TSV (Tab Separated Values). Podríamos coger el archivo de provincias y hacer lo siguiente (andalucia2.csv):

1
2
3
4
5
6
7
8
4,Jaén,jiennense
7,Córdoba,cordobés
7,Sevilla,sevillano
6,Huelva,onubense
5,Cádiz,gaditano
6,Málaga,malagueño
7,Granada,granadino
7,Almería,almeriense

En este caso descartaremos el primer valor. No tenemos por qué utilizarlo si no queremos.

parallel --colsep ‘,’ echo “Un habitante de {2} se llama {3}” :::: andalucia2.csv
Un habitante de Jaén se llama jiennense
Un habitante de Córdoba se llama cordobés
Un habitante de Sevilla se llama sevillano
Un habitante de Huelva se llama onubense
Un habitante de Cádiz se llama gaditano
Un habitante de Málaga se llama malagueño
Un habitante de Granada se llama granadino
Un habitante de Almería se llama almeriense

El orden de ejecución

Como se lanzan varios procesos a la vez y no todos tienen por qué tardar lo mismo. El orden en el que vemos los resultados puede variar. Lo podemos comprobar de la siguiente forma:

parallel sleep {}\; echo {} ::: 4 8 2 6
2
4
6
8

De esta forma hemos ejecutado 4 procesos que generarán esperas de 4, 8, 2 y 6 segundos, eso sí, la salida se irá generando por el orden en el que los procesos lleguen al echo. Aunque el orden de salida no es el orden de los argumentos que le hemos pasado. Es más, si queremos, podemos hacerlo más enrevesado:
parallel -j2 sleep {}\; echo {} ::: 4 8 2 6
4
2
8
6

En este caso ejecutamos dos hilos de forma simultánea, por lo que se lanzan los procesos que tardan 4 y 8 segundos a la vez. El de 4 segundos termina, y se lanza el de 2 (ahora están trabajando el proceso que tarda 8 (que va por su cuarto segundo) y el que tarda 2. Lógicamente acaba primero el que tarda 2 segundos y se lanza el de 6, pero al de 8 le quedan 2 segundos, por lo que acaba antes que el de 6.
El caso es que puedo forzar a parallel para que muestre la salida en el mismo orden en el que le paso los argumentos de entrada con el argumento -k:
parallel -k sleep {}\; echo {} ::: 4 8 2 6
4
8
2
6

Da igual qué hilos esté lanzando y cómo termine, la salida generada me la mostrará parallel en el orden que yo le he dicho, lo cual es útil para nuestros scripts si necesitamos controlar la salida generada.

Ejecutando funciones de Bash

Como hemos visto parallel nos permite ejecutar echo, palabra reservada de Bash, pero también es posible crear nuestras propias funciones y ejecutarlas. De esta forma, no solo podemos ejecutar un programa, podremos crear funciones y ejecutarlas también. Solo tenemos que exportarlas:

1
2
3
4
5
6
7
8
function distancia() {
  local ORIGEN="$(echo -n $1 | jq -s -R -r @uri)";
  local DESTINO="$(echo -n $2 | jq -s -R -r @uri)";
  curl -s  "http://maps.googleapis.com/maps/api/directions/json?origin=${ORIGEN}&destination=${DESTINO}&sensor=false" 2>/dev/null | tee "${ORIGEN}_${DESTINO}.txt" | jq '.routes[0].legs[0].distance.text';
}

export -f distancia
parallel echo -n "De {1} a {2} =\> " \; distancia {1} {2} ::: "La Coruna" "Lugo" "Orense" "Pontevedra" ::: "Alicante" "Castellon" "Valencia"

Con este ejemplo sacaremos muchas distancias entre ciudades con la ayuda de la API de mapas de Google. Es un ejemplo donde podemos ver que cada petición tarda un tiempo diferente, los resultados salen en orden de llegada.

Reemplazos de argumentos

Parallel permite no solo pasar los argumentos a los programas que ejecuta tal cual, sino que podemos hacer alguna operación de reemplazo por si no queremos el parámetro tal cual nos lo pasan. Algunos parámetros comunes pueden ser nombres de archivo (a los que podremos quitarle rutas o extensiones), cadenas de caracteres (que podremos recortar), o incluso extraer información de las tareas. Incluso podremos cambiar las cadenas si nos resulta incómodo utilizar estos caracteres en nuestros scripts. Esto podría ser muy extenso, así que voy a extraer algunos ejemplos rápidos:

Convertir imágenes de JPG a PNG

Con esta orden podremos buscar todas las imágenes jpg que hay en el directorio actual y convertirlas a png. Eso sí, utilizando toda la potencia de nuestro ordenador, iniciando tantos procesos convert simultáneos como núcleos tenga nuestra CPU. Podemos ver que {} muestra el argumento tal cual, pero {/.} extrae la ruta y la extensión. Si queremos investigar, {/} solo extrae la ruta y {.} solo extrae la extensión. En este caso guardamos las imágenes convertidas en el directorio convertidas.

find -maxdepth 1 -name ‘*.jpg’ | parallel convert -verbose {} convertidas/{/.}.png

Slots y tareas

Podemos saber qué número de tarea estamos ejecutando en cada momento. Es muy útil si por ejemplo cada tarea tiene que repartirse un tamaño muy grande y estas deben saber qué trozo de tarea les corresponde. Pensad en una imagen, divididla en cuadros numerados secuencialmente y cada tarea que lancemos debe atacar a uno de los cuadros. En este caso cada una de las tareas debe saber a qué cuadro tienen que ir. Por otro lado, los slots son grupos, como si fueran “cajas” en las que se ejecutan las tareas. Es decir, si vamos a ejecutar 3 tareas simultáneamente, tendremos 3 cajas y una tarea en ejecución ocupará una caja. De tal forma que nunca tendremos dos trabajos corriendo al mismo tiempo en el mismo slot. Podemos ver cómo funciona esto de los slots así:

parallel -j2 sleep {} \; echo {%} {#} --- {} ::: 5 2 1 3 4
2 2 --- 2
2 3 --- 1
1 1 --- 5
2 4 --- 3
1 5 --- 4

Reemplazo con funciones

Parallel también soporta funciones (casi todas las funciones están disponibles a partir de la versión 20161222. Por ejemplo podemos decirle a una tarea el número total de tareas que vamos a ejecutar. Aunque {= ‘$_=total_jobs($_)’ =} podemos sustituirlo por {##}:

seq 100 | parallel echo Job {#} of {= ‘$_=total_jobs($_)’ =}

Aunque algo muy útil es la implementación de condiciones dentro de la propia ejecución, de la siguiente manera:

seq 50 | parallel echo Hola Mundo {%} ‘> {= $_= $job->seq() % 2 == 0 ? “/dev/tty” : “/dev/null” =}’

Con esto le decimos que la salida se produzca por /dev/tty si el número de la tarea (job->seq()) es par (si su división por dos da resto cero), y si no, mandamos la salida a /dev/null.

Hay muchos más reemplazos

Progreso

Como siempre, el usuario se desespera, y muchas veces necesita que le demos algo de información para que no se desespere. Una buena idea es mostrar un progreso para que sepa por dónde va la ejecución. Como parallel está pensado para ejecutar muchas tareas, puede medir el progreso mirando todas aquellas tareas que han finalizado y midiendo tiempos. Podemos utilizar el mismo ejemplo de antes para convertir fotos de la siguiente manera:

find -maxdepth 1 -name ‘*.jpg’ | parallel --progress convert {} convertidas/{/.}.png

O también podemos utilizar –bar. O incluso mejor, pasarle la salida del progreso a un programa como zenity, para ver la salida de forma bonita:
find -maxdepth 1 -name ‘*.jpg’ | parallel --bar convert {} convertidas/{/.}.png 2> >(zenity --progress --auto-kill)

También podemos utilizar –eta para que nos indique el tiempo estimado de finalización de la tarea.

Muchas más opciones

Las utilidades de este programa no han terminado. El propio parallel nos permite ejecutar tareas simultáneas en servidores desde nuestra máquina cliente. Además, junto con GNU Parallel encontramos utilidades para acceso a base de datos y para la realización de operaciones. Es un programa muy flexible que nos permite realizar multitud de operaciones muy útiles y muy interesantes.

Sobre GNU Parallel

El autor nos pide que le citemmos si utilizamos este programa para una publicación. Sólo hay que mencionar al autor, además, en el enlace encontramos un manual muy completo y actualizado:

Encontramos otras formas de mención muy útiles si estamos escribiendo en LaTeX:

parallel --bibtex

Foto principal: unsplash-logoJonathan Pendleton

The post Ejecutando tareas desde consola simultáneamente con GNU Parallel appeared first on Poesía Binaria.

Emiliano A. González Salgado

Emiliano A. González Salgado
El blog de Emi

Migración a LibreOffice 6.1 Base

Hace unos días se ha publicado la beta1 de LibreOffice 6.1.
He descargado el paquete y lo he instalado en Fedora 28.
Al ser una versión de desarrollo, al ejecutarse, crea sus propios directorios de usuario, distintos de los de la versión estable.

El motor de base de datos que viene implementado por defecto es Firebird, aunque HSQLDB sigue funcionando normalmente.

Al abrir una base de datos realizada con HSQLDB, que puede ser cualquier base realizada con una versión menor (salvo que se hubiera activado Firebird anteriormente) siempre solicita convertirla a Firebird.

Esto se puede obviar presionando el botón “latest” en vez de “yes”.

Para convertirla a la versión de Firebird hay que tener presente varias cuestiones, pues el sistema de conversión aún tiene fallos:

Realizar un copia de seguridad de la base de datos que queremos abrir y trabajar con la copia.

Comprobar si tenemos alguna vista de tabla. Es decir en el menú “tablas” están las tablas propiamente dichas y la vistas, que no son mas que una consulta, que puede ser de tablas combinadas.

En caso de que existan vistas de tablas hay que abrirlas y comprobar que no haya campos calculados o campos concatenados que no estén realizados de manera que puedan ser correctamente interpretados por la nueva versión, pues en caso contrario la vista se elimina en la conversión.

Si hay campos calculados o campos concatenados en la vista lo mejor es crear una nueva consulta en modo SQL, copiar la instrucción SQL que nos muestra la vista y guardar la nueva consulta que hemos realizado con esta instrucción SQL copiada.

El error mostrado venía dado por un campo concatenado, que no se ajustaba a Firebird. En la consulta cambié la instrucción y conseguí que funcionara.
Usaba: “Prenom” + SPACE( 1 ) + “Nom”
Rectifiqué: “Prenom” || ‘ ‘ || .”Nom”

A continuación tendríamos que comprobar todos las consulta que tenemos. En la que figure la vista de tabla habría que cambiar todos los datos por los de la consulta.

Un método puede ser con un editor de texto y la edición SQL de consultas.

En mi caso la vista de tabla de llamaba vMovimientos y la consuta creada con la misma instrucción c_vMovimientos. Copiaba el resultado de la salida de la consulta en un editor de texto (kate) y con buscar y remplazar ya tenía la nueva sintaxis. Volvía a copiar y pegar. Guardaba la consulta y la base. Resuelto parcialmente.


La consultas con parámetros, si en criterio se hace referencia a un campo de una tabla, poniendo <= [tabla].[campo] muestra error.

Los campos numéricos y con decimales dan problemas.
Tengo en una tabla “Movimientos” que tiene, entre otros, tres campos “DECIMAL” con dos decimales.
Al importar los campos INTEGER, DATE, VARCHAR Y BOOLEAN no han dado problemas, pero los DECIMAL sí.

Había cantidades que no daban problemas, pero en otras el resultado era desastroso.
Números positivos los convertía en negativos que no tenía relación alguna, las cantidades con decimales terminados en 00 las dividía por 100. 9000,00 pasaba a ser 90,00, un 9xx,xx lo pasaba a -16xx,xx.

Para solucionarlo copio desde la base guardada y, abierta con una versión antigua, la tabla en Calc:
Crear tres nuevas columnas,
Multiplicar el resultado por 100.
Cambiar a formato numérico y sin decimales.
Transponer a sus antiguas columnas.

Con esto ya puedo realizar la exportación de datos a la tabla Movimientos de la nueva base convertida.

Parece un proceso muy engorroso, pero si se hace con tranquilidad, en poco tiempo se ha finalizado.

Por ahora, en la comprobación que he realizado, tanto los datos de fecha como los numéricos están correctos, sin que haya diferencia entre una y otra tabla.

NOTA.- En una comprobración posterior, y en un campo calculado, el resultado del mismo es el que he importado de la hoja de cálculo, no de lo que figura en la tabla.

Es decir, está multiplicado por 100 con respecto a lo que figura en la tabla.

El bug ha sido reportado por Xisco Fauli @x1sc0    https://bugs.documentfoundation.org/show_bug.cgi?id=118043 .

 

Jueves 31 de mayo de 2018

José María Morales Vázquez

José María Morales Vázquez
tecnología – Un lugar en el mundo…

WordPress. El misterioso caso del cuelgue diario a las 9 de la mañana

icono de wordpress Los blogs están muertos. Por fin. Bueno, no todos. Hay alguno que resiste hoy y siempre a la invasión de las redes sociales. A ratos me gusta pensar que este es uno de ellos… pero si soy sincero conmigo mismo ciertamente está un poco desnutrido. No le presto mucha antención, no… Hace meses, por ejemplo, que se cuelga durante aproximadamente media hora todas las mañanas y ni siquiera me he preocupado de ver que le pasa. Bueno, ya no. Ya está arreglado. Los malos hados subestiman el poder de esas tareas tediosas y desagradables que hacen que hasta te den ganas de ponerte a planchar o a limpiar los baños. Bueno, yo me he conformado con arreglar por fin este problemilla. Los baños otro día. 🙂

¿Síntomas mi querido Watson? Apenas nada: la indisponibilidad se producía por un elevado consumo de CPU y mirando con htop resulta que la responsable es mariadb (aunque en el pantallazo aparezca mysql ya sabéis que son compatibles a nivel binario).

htop - mysql se come todo el tiempo de proceso de ambos cores

Alguna pista mas: conéctandome a mariadb observo que lo que se están ejecutando son consultas aparentemente bastante simples sobre la tabla wp_options:

MariaDB [unlugar]> show processlist;
+-------+---------+-----------+---------+---------+------+--------------+------------------------------------------------------------------------------------------------------+----------+
| Id    | User    | Host      | db      | Command | Time | State        | Info                                                                                                 | Progress |
+-------+---------+-----------+---------+---------+------+--------------+------------------------------------------------------------------------------------------------------+----------+
| 29462 | unlugar | localhost | unlugar | Query   | 1043 | Sending data | DELETE a, b FROM wp_options a, wp_options b
			WHERE a.option_name LIKE '\\_transient\\_%'
			AND a. |    0.000 |
| 29552 | root    | localhost | unlugar | Query   |    0 | init         | show processlist                                                                                     |    0.000 |
| 29559 | unlugar | localhost | unlugar | Query   |   40 | update       | INSERT INTO `wp_options` (`option_name`, `option_value`, `autoload`) VALUES ('jetpack_nonce_15275779 |    0.000 |
| 29560 | unlugar | localhost | unlugar | Query   |   22 | updating     | UPDATE `wp_options` SET `option_value` = '1527578481.1030609607696533203125' WHERE `option_name` = ' |    0.000 |
| 29561 | unlugar | localhost | unlugar | Query   |    7 | updating     | UPDATE `wp_options` SET `option_value` = '1527578505', `autoload` = 'yes' WHERE `option_name` = 'jet |    0.000 |
| 29562 | unlugar | localhost | unlugar | Query   |    0 | updating     | UPDATE `wp_options` SET `option_value` = '1527578503.1177010536193847656250' WHERE `option_name` = ' |    0.000 |
+-------+---------+-----------+---------+---------+------+--------------+------------------------------------------------------------------------------------------------------+----------+

Así que le echamos un vistazo a esa tabla y resulta que tiene la friolera de más de 40.000 registros y consume cerca de 38 Megas de espacio ¿Qué tiene dentro?¿Los casos de corrupción del PP? Porque la estructura de la tabla también es bastante simplona:

MariaDB [unlugar]> describe wp_options;
+--------------+---------------------+------+-----+---------+----------------+
| Field        | Type                | Null | Key | Default | Extra          |
+--------------+---------------------+------+-----+---------+----------------+
| option_id    | bigint(20) unsigned | NO   | PRI | NULL    | auto_increment |
| option_name  | varchar(191)        | NO   |     | NULL    |                |
| option_value | longtext            | NO   |     | NULL    |                |
| autoload     | varchar(20)         | NO   |     | yes     |                |
+--------------+---------------------+------+-----+---------+----------------+
4 rows in set (0.01 sec)

Un último dato: la exactitud en la periodicidad me escamaba también. Incluso uno de esos días de puentes con un tiempo maravilloso donde no queda ni el friki más irredento paseándose por algo donde no despachan cerveza el blog también se caía. Y a la misma hora, así que le eché un vistazo al cron del sistema y no había nada que se lanzara a esa hora. ¿Y? De repente recordé que wordpress viene con su propio planificador de tareas y que estas se pueden inspeccionar fácilmente. Por ejemplo a través del plugin WP Cron Cleaner. Bingo. Ahí la tengo: Justo a las 9.04 y todos los días hay una tarea que se llama delete_expired_transients. Y eso de “transient” ya era algo que habíamos visto por ahí arriba en la consulta que se estaba realizando en mariadb.

El proceso que se lanza diariamente alrededor de las 9 realiza una limpieza de transients

Tocaba googlear a ver que es eso de los transients pero ya teníamos datos suficientes para reunir en la biblioteca a todos los implicados y desvelar quien es el asesino.

Los transients, al parecer, son registros con información temporal que proviene de los plugins que tenemos instalados. ¿Sirven para algo? Pues una vez que caducan no, para nada. De hecho precisamente por eso está ahí esa tarea que elimina los caducados. ¿Qué es lo que ocurre entoces? Pues que es evidente que muy bien no funciona porque la mayoría de esos 40.000 registros son transients. Más de 35.000, de hecho. Y la búsqueda se realiza a través del campo wp_options que como vemos no está indexado. Fatal. La primera aproximación al problema pasa, pues, por crear un índice sobre esa columna:

MariaDB [unlugar]> alter table wp_options add index (option_name);
Query OK, 0 rows affected (3 min 47.86 sec)         
Records: 0  Duplicates: 0  Warnings: 0

Mano de santo, oigan. Al día siguiente a las 9.04 por primera vez en meses el blog no se colgó. ¿Lo dejo así?¿Con una tabla diez veces mas grande que el contenido de todo lo escrito en el blog?¿Hasta donde la dejo crecer entonces? Toca hacer otra búsqueda y por ahí me encuentro con mucha mas gente que ha tenido problemas similares y que asegura que se puede hacer tábula rasa y borrarlos todos. Así que hago un backup rápido, los elimino… y parece que todo va bien. Fantástico 🙂

¿Cómo eliminarlos? Pues a través de línea de comando es fácil:

MariaDB [unlugar]> DELETE FROM `wp_options` WHERE `option_name` LIKE ('%\_transient\_%')

Puestos a buscar una solución más cómoda y permanente para no llegar de nuevo aquí dentro de 10 años encontré otro plugin (Transient Cleaner) que te permite borrarlos puntualmente y/o programar una tarea para hacer una limpieza mas efectiva que la de wordpress de forma periódica.

Y listo. O eso parece. Mañana los baños. Sin falta 🙂

Artículo Original: .

Este artículo pertenece a Un lugar en el mundo... Si quieres ver actualizaciones y comentarios interesantes visita el texto original en: WordPress. El misterioso caso del cuelgue diario a las 9 de la mañana || Hospedado en un Cloud VPS de Gigas.

Martes 22 de mayo de 2018

Pedro L. Lucas

Pedro L. Lucas
Cartas de Linux

Cuenta oficial en Twitter de LXQt y LXQt 0.13.0

Con el nuevo lanzamiento de LXQt, ya van por la versión 0.13.0, el proyecto lanza su cuenta oficial en Twitter: https://twitter.com/LXQtOfficial Y luce así de bien:

¿Qué trae de nuevo LXQt? Pues según sus notas, muchas correcciones a errores: https://blog.lxqt.org/2018/05/release-lxqt-0-13-0/

Combinaciones de teclas útiles

Un par de combinaciones de teclas útiles que trae por defecto son:

  • Ctr + Alt + i  Abre el navegador web por defecto (¡utilísima!)
  • Ctr + Atl + e  Abre el explorador de ficheros
  • Ctr + Atl + t  Abre el terminal

Control de brillo y contraste

De entre la aplicaciones disponibles de LXQt, voy a hablaros de una que me ha hecho gracia, la posibilidad de controlar el brillo de pantalla.

¿Qué es lo que me gusta de esta aplicación? Permite cambiar el brillo de pantalla tanto por hardware como por software. En un portátil puedes cambiar el brillo de la pantalla modificando la intensidad luminosa de los LED que hay detrás de la pantalla. En un ordenador de sobremesa esto no se puede hacer, pero te permite cambiar el brillo de la pantalla por software y es algo muy agradable a la vista. ¡Sobre todo con pantallas excesivamente brillantes!

Aprovechando el espacio de la pantalla eliminando las barras de título

Otra curiosidad, si pulsáis sobre una barra de menús con el clic derecho del ratón y seleccionáis “Decorar”, se eliminan las barras de título. Muy útil para aprovechar todo el espacio disponible de la pantalla. Por ejemplo:

Es esta captura de pantalla, he puesto el panel a la izquierda y he eliminado la barra de título del terminal. Como se puede ver la pantalla se aprovecha mejor.

Para volver a decorar las ventanas, pulsamos Atl + espacio. Aunque, yo las gestiono pulsando con el botón derecho del ratón sobre su icono en el panel.

Y Wayland… ¿Para cuándo?

Los desarrolladores están teniendo ardientes debates sobre el tema: https://github.com/lxqt/lxqt/issues/1011

La postura que están adoptando es mantenerse independientes del gestor Wayland usado, de forma que se puedan usar las herramientas LXQt en cualquier gestor de composición Wayland. Parece que tienen claro que no van a reescribir otro compositor Wayland más habiendo opciones disponibles. Aunque hay voces que apuntan a que finalmente, por la estructura de Wayland, no va quedar más remedio.

Martes 03 de abril de 2018

Ramón Miranda

Ramón Miranda
Ramon Miranda

A new dawn, alegory . The Making off


Hi all, today I am going to show you my latest painting done in Krita 4.0 while i was collaborating to provide resources like brushes, brushtips, and patterns.
I think Krita deserves a good promotional images (at least finished images) and this was also a good testing canvas for that. My 2 cents ;)
This image reflects the emotional state that makes me feel this new release. So here you have...
"A new dawn, alegory" i hope you like it.

The process. (click on the images to see big-res images)

Step 01. First i start with the background, the mood itself of the image. I focus my attention on color and overall emotion. You can see there is no texture but i define where the figure must be placed.

Step 02. Then i continue working with brushes and wet paint.Here i am testing how to get the Oil or at least the painterly effect on some brushtrokes and i remove some coldness on the background. I start to add a bit of glow, this is an easy way to get more corlors to play with. Also you can see some primitive structures on the BG.

Step 03. I feel i need more color, why not! and i start to define better the path of viewers eye. I use very often the contrast to catch the attention. You can see a lot of brushtrokes , some are from 3.3 brushes and others are testing brushes for 4.0. Not too much detail here but i feel i like the red color and movement on clothes

Step 04. After some crazyness, lot of fun and exploration, is time to define a bit the image, the message and planes. You can see now arcs, rocks and a more defined pose for the woman. But at the moment i have only big spots of color.

Step 05. Time for block stage defining more and more.  

Step 06. I sketch a better figure in paper with pen, I love strong characters and strong women so i decide to give her a powerful pose, dominant but a bit humble holding her clothes with bare hands.


Step 07. I change the scale of figure to emphasize the environment and movement on the folds. Now you can see the folds and better idea o what the final image is going to be.

Step 08. Is time to detail a bit more all the scene. Structures on background, the ruins in midplane, the ground, adding a bit of texture and the main arc in the foreground with the woman in focal point. The folds are well stablished and is time to see if everything works. I am not sure with the arm pose so i delete it for the moment.

Step 09. I redefine a bit the mood, to be not so pictoric but more actual looking. I focus my attention on bg and add glow to the gate, wich is the symbol of "how krita is seeing a new light and how reborns from the ruins. (you know the history) I block the main shapes of arm and detail lot of parts.

Step 10. So... what i miss oh yes! more details ;) . I left this image posted because you can see how i use temporary swatches (in this case for the folds) you can see also this for the hair and how the strands starts to appear more realistic.

Step 11. And now a dramatic light change because the lighting was not coherent. Final details in hair, texture, folds, folliage, and fx. All done with krita 4 brushes.

I  hope you enjoy this new release as I do. Remember Krita it can be amazing but you are the artist.
If you have qustions or want to know more about my work, check my social media.



Viernes 23 de marzo de 2018

José María Morales Vázquez

José María Morales Vázquez
tecnología – Un lugar en el mundo…

Bootstrap 4. Primeros pasos

icono de php Bootstrap es una colección de elementos, plantillas y componentes HTML, CSS y Javascript para crear rápidamente páginas web con un aspecto moderno y “responsivo” (¡menudo palabro!) al tamaño de pantalla de cualquier dispositivo. Su versión 4 se liberó hace un par de meses y aporta algunos cambios significativos como, por ejemplo, la inclusión de Popper como librería javascript para “tooltips” y otros elementos emergentes y la eliminación de las tipografías Glyphicons para introducir símbolos y pictogramas.

Podemos trabajar con Bootstrap bien descargandonosla en nuestro propio servidor web, o bien usando sus librerías directamente desde los CDN que nos ofrecen. Aquí usaremos este segundo método por sus evidentes ventajas de cara a montar una primera plantilla para pruebas. Necesitamos incluir simplemente el siguiente tag en :

<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css" />

Si vamos a usar los elementos javascript necesitamos incluir también las librerías correspondientes y, ademas, las de jquery y popper en nuestro proyecto las cuales también tienen disponible la posibilidad de enlazarlas directamente sin necesidad de descargarlas en local:

<script src="https://code.jquery.com/jquery-3.3.1.slim.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.1/umd/popper.min.js"></script>
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/js/bootstrap.min.js"></script>

IMPORTANTE: los enlaces anteriores corresponden a las versiones estables más recientes en el momento de escribir esto. No suelen eliminar las versiones anteriores, pero conviene que te cerciores si llegas a este texto en un futuro lejano.

Con todo esto, la plantilla mínima de HTML para empezar a trabajar (incluyendo los enlaces correspondientes a las librerías javascript comentados) sería esta:

<!DOCTYPE html>
<html lang="es">
    <head>
    	<meta charset="utf-8" />
    	<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no" />
    	<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css" />
    	<title>Plantilla Bootstrap</title>
  	</head>
  	<body>
		<h1>Plantilla Bootstrap</h1>

    
		<!-- Javascript opcional -->
		<!-- <script src="https://code.jquery.com/jquery-3.3.1.slim.min.js"></script>
    	     <script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.1/umd/popper.min.js"></script>
    	     <script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/js/bootstrap.min.js"></script> -->
  	</body>
</html>

Sosa, verdad? Claro, aún no hemos empezado a trabajar… Si quieres ver algo más impactante, bootstrap dispone de plantillas con algo mas de chicha para tus diseños. Las tienes disponibles en este enlace. Si prefieres empezar desde cero, tienes disponible un montón de La documentación bastante fácil de seguir que incluye multitud de ejemplos prácticos para empezar a trabajar desde el primer minuto.

Artículo Original: .

Este artículo pertenece a Un lugar en el mundo... Si quieres ver actualizaciones y comentarios interesantes visita el texto original en: Bootstrap 4. Primeros pasos || Hospedado en un Cloud VPS de Gigas.

Jueves 22 de marzo de 2018

Ramón Miranda

Ramón Miranda
Ramon Miranda

Krita 4.0 ya está aquí


"Un nuevo amanecer, una nueva versión de Krita que cambia muchas cosas como la luz cuando va iluminando poco a poco lo que la rodea." Alegoría.

Hola, muy buenas. ¿Será la primavera? ¿será mi espiritu ñoño haciendo de las suyas? Pues no!
Es que hoy estamos de enhorabuena. Ya ha salido la nueva versión de Krita, la 4.0 donde vamos a poder encontrar muchas novedades. Y si no conoces este programa pues te estás perdiendo una muy buena herramienta que además es completamente gratuita gracias a ser software libre.

Durante la fase de desarrollo he podido colaborar aportando ideas, pinceles, y patrones para usar como texturas. En un post futuro puede que hable de la experiencia en general. Cómo lo he vivido a nivel personal, pero hoy me voy a centrar en Krita.

Lo primero de todo, dar las gracias por ese duro trabajo que hacen los desarrolladores. Y no pienses que Krita es sólo pinceles a nivel de código, es mucho más, y encima multiplataforma. Imagínate todo ese trabajo de depuración de código.

Pero ¿qué es lo que me ha gustado a mí personalmente? Como sabes, si me sigues en el blog o redes, soy un fanático de los pinceles y herramientas digitales. Así que allá voy.
  • Un Nuevo set mejor organizado y más versátil. Pero lo bueno es que se mantiene el set antiguo con lo cual si estabas muy acostumbrado a los pinceles de krita 3 pues no hay problema.
  • El set principal tiene su propia etiqueta así que se puede aislar.
  • Krita ahora soporta el multithread para las pinceladas, con lo cual deberiamos notar una mejora en el rendimiento de krita. Y eso siempre es bueno ¿no? con Shift+ L o desde el menú View/Instant preview mode.
  • Previsualización del trazo en el editor de pinceles. Eso hace más fácil la creación de pinceles. 
  • Krita te ayuda con un nuevo asistente al salvar un nuevo pincel donde puedes añadir imágenes prediseñadas e incluso cambiar cosas como el color de algunas partes del icono.
  • Masked brushes o dual brush como se llama en Photoshop. Permite a los pinceles tener una doble punta que le da más realismo. Fíjate como tenemos un trazo duro en el contorno pero hay utilizamos una doble punta que usa lineas para simular ese efecto útil para fondos o suciedad.
  • El tamaño máximo del pincel puede sobrepasar los 1000px. Pero ojo esto requiere potencia.
  • Curvas prediseñadas para no andar continuamente moviendo puntos en las curvas o simplemente para hacer pruebas.
  • Ahora se puede cambiar el tamaño de los iconos de pinceles más fácilmente con un slider.(Yo sigo usando el Ctrl+Rueda de ratón arriba o abajo.)
A parte de todo esto, muchas mejoras se producen bajo el capó o en funcionalidades no tan usadas. Algo muy bueno va a ser el uso de Python scripts. Y si no preguntádselo a Blender y todo su ecosistema de plugins. De momento hoy mismo ya he visto que alguien está haciendo un plugin para publicar en Mastodon a través de Krita. Pruébalo bajo tu responsabilidad que esto no es de los desarrolladores, que conste. https://github.com/spaceottercode/kritatoot

También si te interesan los videojuegos que seguro que sí ;)

  • Pixel grid si lo que haces se relaciona con el pixelart
  • Normal map si estás más orientado a cosas realistas.
Y luego cosillas que tengo pendiente de probar. 

  • Colorize mask tool para amantes del comic que necesitan dar un color plano a sus imágenes de manera más rápida.
Estabilidad
Personalmente no he tenido, si recuerdo bien, ningún cuelgue mientras pintaba. He notado un buen comportamiento con imágenes de 6000px de ancho, como la que encabeza este post. También tengo que decir que ahora uso tanto Windows 10 como Linux con kde neón o sea que es una gozada poder tener Krita en los dos sistemas.  
Al final del artículo te dejo 2 enlaces. 1º A la noticia oficial de lanzamiento donde puedes ver mucha más info y 2º un enlace las release notes o en spanish las "cosillas guenas que han metido en la saca"

Ahora la última palabra la tienes tú. Si te gusta y lo ves útil para tu trabajo pues dale duro y exprime Krita. Seguro que me dejo algunas cosas por enseñar :D. Y tú? ¿Para que vas a utilizar Krita 4.0? ¿Qué es lo que más te ha gustado de esta nueva versión?

Lunes 19 de marzo de 2018

Baltasar Ortega

Baltasar Ortega
KDE Blog

Presenta tu charla para Akademy-es 2018 de Valencia

Hace tiempo que se anunció la sede y desde ese momento el blog va dando los detalles necesarios para ir abriendo boca.. Y es que en poco más de mes y medio se celebrará en Valencia la reunión anual en España de usuarios y desarrolladores de KDE, Akademy-es 2018. Concretamente se celebrará del 11 al 13 de mayo y es el momento de seguir preparando el programa. Como el evento es una celebración comunitaria se abrió en el momento del anuncio de la sede la posibilidad de que todo el mundo, además de acudir,  participara de forma activa. Así que presenta tu charla para Akademy-es 2018 de Valencia y muestra a toda el mundo tu proyecto personal o comunitario.

Presenta tu charla para Akademy-es 2018 de Valencia

Recordemos que en Akademy-es se realizarán las típicas charlas que presentan las novedades tanto de las aplicaciones como de las herramientas de programación, sin olvidar de los proyectos activos o de aquellos de los que se quieren lanzar en un futuro cercano.

En anteriores ediciones en estas charlas (extraído del programa de Akademy-es 2017 de Almería) descubrimos KDE,  nos pusimos a colaborar con KDE, conocimos la asociación KDE España, aprendimos más de Plasma 5, vimos pinceladas de un posible futuro de KDE, aprendimos como colaborar con KDE sin ser programador, conocimos mejor la relación de Slimbook co KDE, aprendimos a hacer aplicaciones para el móvil y recibimos las primeras leccions de Qt.

¿Y qué encontraremos en esta edición? Pues depende de ti, ya que si tienes algún tema que crees que interesará a la Comunidad KDE y sus simpatizantes, no lo dudes a y presenta tu charla para Akademy-es 2018. Estaremos encantados en escuchar tu propuesta.

Si quieres más información, basta con que leas el siguiente texto oficial o que visites la web oficial de Akademy-es 2018, no obstante aquí te lo puedo contar yo:
Para proponer actividades se deberá enviar un correo a akademy-es-org@kde-espana.es antes del 31 de marzo con un resumen breve de la presentación.

Presenta tu charla para Akademy-es 2018Es importante tener en cuenta las siguientes consideraciones:

  • Se puede elegir entre dos formatos de charlas:
    • Charlas de 30 minutos.
    • Lightning talk de 10 minutos.
  • Si la duración de las charlas propuestas no se ajusta a ninguno de estos dos esquemas (por ejemplo, si se necesita más tiempo), esto debe indicarse claramente en la comunicación.
  • Se permitirá a KDE España la distribución bajo una licencia libre de todo el material utilizado para la realización de la actividad, así como de la grabación de la misma.
  • La charla puede ser tanto a nivel de usuario como de nivel técnico.

Se trata de una gran oportunidad de darte a conocer en el mundo KDE y en el mundo del Software Libre en general.

Más información: Akademy-es 2018

¿Qué es Akademy-es?

Akademy-es (#akademyes, que es la etiqueta para las redes sociales) es evento más importante para los desarrolladores y simpatizantes de KDE, que se ha ido celebrando desde el 2006 con éxito creciente.

En general, las Akademy-es son el lugar adecuado para conocer a los desarrolladores, diseñadores, traductores, usuarios y empresas  que mueven este gran proyecto.

En ellas se realizan ponencias, se presentan programas, se hace un poco de caja para los proyectos libres (camisetas, chapas, etc) pero sobre todo se conoce a gente muy interesante y se cargan baterías para el futuro.

Podéis repasar las anteriores ediciones en estas entradas del blog:

Domingo 18 de marzo de 2018

Baltasar Ortega

Baltasar Ortega
KDE Blog

Noticias linux 02, tercer domingo de marzo de 2018

Esta semana sigue la sección que inicié de forma no oficial ya hace más de un mes y que se dedica a mostrar las novedades del mundo GNU/Linux que no aparecen en el blog por falta de tiempo y que deberían aparecer. Así que os doy la bienvenida a Noticias linux 02, correspondiente tercer domingo de marzo de 2018 con Firefox, Kubuntu, Plasma 5.12.3 y editores multimedia GNU/Linux

Noticias linux 02, tercer domingo de marzo de 2018

La semana de las mil actividades ha llegado a su fin, dejándome a las puertas de otra un poco más relajada en cuanto a obligaciones laborales, pero llena de tareas que hacer para poder sobrevivir a este tercer trimestre que llega.

Así que aprovecho la tranquilidad de este domingo para seguir con la nueva sección de Noticias Linux, que llega a su segunda edición, compartiendo noticias que han aparecido en otros blogs o webs y que hubiera estado genial que aparecieran en éste.

Firefox lanza su versión 59

Mientras esperamos que madure Falkon, los usuarios de la Comunidad KDE podemos seguir utilizando Firefox, el gran explorador web, que sigue mejorando y evolucionando.

Según podemos leer en Genbeta, el pasado 13 de marzo fue lanzado Firefox 59, una nueva versión del excelente explorador (disponible ya en las principales distribuciones GNU/Linux) que nos ofrece las siguientes novedades:

  • Tiempos de carga de página más rápidos.
  • Posibilidad de arrastrar y soltar nuestros “sitios favoritos en Firefox Home (la pantalla que aparece si creamos una nueva pestaña)
  • Posibilidad de desactivar la notificación que indica que una web está intentando acceder a la cámara.

Más información: Firefox

Plasma 5.12.3 ya disponible para Kubuntu 17.10

Noticias linux 02Los usuario de Kubuntu 17.10 están de enhorabuena. Según leemos en Ubunlog, ya está disponible la versión de Plasma 5.12.3 para sus escritorios.

Para hacerlo debéis activar los repositorios backports, abriendo una konsola y escribiendo los siguientes comandos:

sudo add-apt-repository ppa:kubuntu-ppa/backports -y
sudo apt update && sudo apt full-upgrade
Pero alerta, como dicen en el Ubunlog “Si tenemos una versión anterior a Kubuntu 17.10, no solo se actualizará el escritorio sino también la distribución
Más información: Kubuntu

Los 10 mejores editores Multimedia

Y finalizo esta entrada de Noticias Linux 02, con otra mención a un blog que se ha convertido en imprescindible para cualquier simpatizante del Software Libre: Maslinux.

En esta ocasión nos ha obsequiado con un recopilatorio de los 10 mejores editores multimedia GNU/Linux:  A modo de resumen, los mejores editores en orden de aparición son: Shotcut, VidCutter, FlowBlade, Kdenlive, Blender, Openshot, Cinelerra, Pitivi, Ardour y Rosegarden.
Y como siempre digo, son todos los que están, pero no están todos los que son. ¿Qué noticia os ha llamado la atención esta semana? Ponedlo en los comentarios y mejores esta entrada.

 

 

 

 

Sábado 17 de marzo de 2018

Baltasar Ortega

Baltasar Ortega
KDE Blog

Helium 8, un nuevo tema para Plasma

Volvemos a tema de diseño al blog con Helium 8, un nuevo tema para Plasma de tono grisáceo y ligero. Una gran creación de David Linares, conocido como @mcder3 que sigue ofreciéndonos diseños muy cuidados.

Helium 8, nuevo tema para Plasma

Los temas para el escritorio Plasma de la Comunidad KDE son sutiles pero importantes. La verdad es que todos se parecen mucho inicialmente, pero una vez instalados y tras un poco tiempo de uso ves las diferencias y decides si te gusta o no.

Y esto es así porque aunque los cambios son sutiles, abarcan a todo el sistema: iconos de la bandeja del sistema, pantalla de apagado, reinicio o cambio de usuario, animaciones al ejecutar aplicaciones, decoraciones de plasmoide, etc.

Es por ello, que me complace presentaros la nueva creación de David Linares (aka @mcder3) con la que tendremos un Plasma, como con todos sus diseños, elegante y ligero, con transparencias adecuadas y con un tono grisáceo.

Helium 8

 

También es de detacar su pantalla de salida y las animaciones con toques azulados cuando se ejecutan aplicaciones y se colocan en la barra de tareas. Todo muy sencillo pero visualmente muy atractivo.

 

Y como siempre digo, si os gusta el tema Helium 8 para Plasma podéis “pagarlo” de muchas formas, desde donaciones a mcder pasando por todo tipo de acciones en la página de KDE Store, que estoy seguro que el desarrollador lo agradecerá: puntúale positivamente, hazle un comentario en la página o realiza una donación. Ayudar al desarrollo del Software Libre también se hace simplemente dando las gracias, ayuda mucho más de lo que os podéis imaginar, recordad la campaña I love Free Software Day 2017 de la Free Software Foundation donde se nos recordaba esta forma tan secilla de colaborar con el gran proyecto del Software Libre y que en el blog dedicamos un artículo.

Más información: KDE Store

Martes 13 de marzo de 2018

TutorialesLinux.com: Herramientas de análisis de tráfico

Domingo 11 de marzo de 2018

José María Morales Vázquez

José María Morales Vázquez
tecnología – Un lugar en el mundo…

Laravel 5.6. Estructura y primeros pasos: Autenticación de usuarios

icono de php Ya yenemos Laravel 5.6 instalado en alguno de los dos entornos que hemos visto antes. ¿Qué sigue? Lo primero, entender un poquito la estructura de directorios que nos ha creado composer. Sólo lo imprescindible. El resto lo iremos viendo a medida que avanzamos.

josemaria@valeria /var/www/html/prueba $ ls -la
total 236
drwxr-xr-x 12 root www-data   4096 mar  9 19:31 .
drwxr-xr-x  3 root www-data   4096 mar  9 18:29 ..
drwxr-xrwx  6 root www-data   4096 ene  3 17:52 app
-rwxr-xrwx  1 root www-data   1686 ene  3 17:52 artisan
drwxr-xrwx  3 root www-data   4096 ene  3 17:52 bootstrap
-rw-r--rw-  1 root www-data   1413 ene  3 17:52 composer.json
-rw-r--rw-  1 root www-data 143565 mar  8 07:37 composer.lock
drwxr-xrwx  2 root www-data   4096 ene  3 17:52 config
drwxr-xrwx  5 root www-data   4096 ene  3 17:52 database
-rw-r--r--  1 root www-data    612 mar  9 19:31 .env
-rw-r--r--  1 root www-data    565 ene  3 17:52 .env.example
-rw-r--r--  1 root www-data    111 ene  3 17:52 .gitattributes
-rw-r--r--  1 root www-data    146 ene  3 17:52 .gitignore
-rw-r--rw-  1 root www-data   1125 ene  3 17:52 package.json
-rw-r--rw-  1 root www-data   1040 ene  3 17:52 phpunit.xml
drwxr-xrwx  4 root www-data   4096 ene  3 17:52 public
-rw-r--rw-  1 root www-data   3550 ene  3 17:52 readme.md
drwxr-xrwx  5 root www-data   4096 ene  3 17:52 resources
drwxr-xrwx  2 root www-data   4096 ene  3 17:52 routes
-rw-r--rw-  1 root www-data    563 ene  3 17:52 server.php
drwxrwxrwx  5 root www-data   4096 ene  3 17:52 storage
drwxr-xrwx  4 root www-data   4096 ene  3 17:52 tests
drwxr-xrwx 36 root www-data   4096 mar  8 07:38 vendor
-rw-r--rw-  1 root www-data    549 ene  3 17:52 webpack.mix.js

El directorio public ejerce de DocumentRoot. Allí encontraremos el index.php que da entrada a nuestra aplicación web así como las hojas de estilos, etc. El fichero .env que vemos aquí arriba en el directorio raiz de nuestra aplicación es el fichero de configuración principal. De hecho, puesto que vamos a empezar a trabajar con bases de datos en este momento podemos aprovechar para editar las siguientes directivas:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=laravel
DB_PASSWORD=secreto

Importante: aunque usemos mariadb la directiva DB_CONNECTION debe de ser mysql porque Laravel no entiende otra y, a fin de cuentas, ambas son compatibles a nivel binario. Para que Laravel sea capaz de hacer uso de esa base de datos debemos de crearla. A ella y al usuario que le hemos dicho que va a usar para manejarla. Entramos en nuestro gestor (mysql o mariadb) y ejecutamos lo siguiente:

CREATE DATABASE laravel;
CREATE USER laravel@localhost IDENTIFIED BY 'secreto';
GRANT ALL ON laravel.* TO laravel@localhost;

Vamos ahora a crear nuestro sistema de autenticación. Laravel viene ya con un módulo llamado User.php que reside en el directorio app. Para generar el resto de lo que necesitamos ejecutamos lo siguiente:

php artisan make:auth
php artisan migrate

La primera línea crea el código y rutas necesario para la gestión de usuarios. En particular, creará o modificará los siguientes ficheros:

routes/web.php
resources/views/auth/login.blade.php
resources/views/auth/register.blade.php
resources/views/auth/passwords/email.blade.php
resources/views/auth/passwords/reset.blade.php

La segunda instrucción crea la estructura de tablas necesaria en la base de datos que hemos configurado previamente. Si ahora volvemos a cargar la web de nuestro aplicación veremos que en la esquina superior derecha tenemos dos nuevos enlaces correspondientes a las funcionalidades de Login y Registro:

Laravel 5.6 con la funcionalidad de login y registro

Las pantallas de registro y login por defecto son estas:

Pantalla de registro en Laravel 5.6
Pantalla de login en Laravel 5.6

Y una vez hecho login vemos que en la barra de menú se nos identifica con nuestro nombre de usuario y tenemos la posibilidad de cerrar sesión:

Logout en Laravel 5.6

Si le echamos un vistazo a “las tripas” vemos que nos ha creado dos tablas una de las cuales, la de usuarios, es la que guardará la información relativa a los registros de usuarios.
Tablas creadas por Laravel 5.6 para la autenticación de usuarios

Además, tal y como está mandado, vemos que no almacena las contraseñas en claro sino un hash de las mismas:

hash de las passwords en Laravel 5.6

La castellanización de los recursos es tan sencilla como editar alguno de los ficheros php que hemos indicado anteriormente. Por ejemplo, el fichero login.blade.php es el que contiene la ventana de login y register.blade.php la de registro. Con muy poco esfuerzo tendremos las ventanas anteriores en perfecto castellano. Pero eso ya os lo dejo a vosotros 😉

Artículo Original: .

Este artículo pertenece a Un lugar en el mundo... Si quieres ver actualizaciones y comentarios interesantes visita el texto original en: Laravel 5.6. Estructura y primeros pasos: Autenticación de usuarios || Hospedado en un Cloud VPS de Gigas.

Jueves 01 de marzo de 2018

TutorialesLinux.com: Vulnerabilidad en Memcached (DDoS), cómo solucionarla.

Sábado 24 de febrero de 2018

Pedro L. Lucas

Pedro L. Lucas
Cartas de Linux

Viendo la degradación de la batería de un portátil

Las baterías de los portátiles, móviles y otros dispositivos van perdiendo capacidad con el tiempo. Esta pérdida de capacidad la podemos comprobar con diversas herramientas.

Por ejemplo, con la aplicación de gestión de la batería de LXQt se puede ver la siguiente captura:

En esta captura se puede comprobar que en el diseño original tenía una capacidad de 51.50Wh. Actualmente tiene 45.44Wh, por lo que su capacidad total se ha reducido, está al 88% de su capacidad inicial, es decir ha perdido un 12% en los 4 años que lleva en uso. Realmente si la batería estuviera totalmente vacía o totalmente llena se degradaría más rápido, por lo que la electrónica no debería dejar que la batería se llene o vacíe totalmente.

En siguiente parámetro es “Energy rate”. Muestra la energía que está entrando o saliendo de la batería en el momento actual. Según se ve, el portátil está consumiendo 10.22W en el momento de hacer la captura. Cuando el portátil está cargando, muestra la energía que está entrando en la batería y es fácil ver valores de 30W, aunque esta potencia que entra en la batería va bajando según se va llenando.

En la siguiente captura se puede ver que el “Energy rate” vale 0W:

En esta situación la batería está cargada y el portátil conectado a corriente eléctrica, por lo que no entra ni sale energía de la batería.

Consultar la degradación vía terminal

Usando el terminal del Linux es posible consultar la degradación de la batería y otras características visitando la carpeta /sys/class/power_supply/. Dentro de esta carpeta hay archivos que se pueden consultar para ver la capacidad, el voltaje o la intensidad eléctrica que está entrando o saliendo la batería.

Evolución de la degradación y tratando de evitarla

En teoría las baterías nuevas se degradan un poco, luego bajan linealmente para, finalmente, morir rápidamente. Más información se puede encontrar en el siguiente enlace:

http://batteryuniversity.com/learn/article/how_to_prolong_lithium_based_batteries

La primera conclusión que se obtiene del artículo anterior es: no se puede evitar la degradación de la batería. Lo que sí se puede hacer es que esta degradación vaya más despacio.

Dentro de la batería se producen multitud de reacciones químicas. La mayoría de ellas interesan, pero hay otras que no. Se suele recomendar no cargar la batería más allá del 80% y no dejar que su nivel baje del 20%. Si se llena o vacía la batería completamente, comienzan estas reacciones químicas que no interesan. Es mejor pequeñas cargas y descargas que llenarla y vaciarla completamente. Si el fabricante ha sido responsable, habrá dejado un margen de la batería que no podréis usar, este margen es para evitar la degradación.

La temperatura es también un factor importante. Las temperaturas muy altas, degradan las baterías a mayor velocidad. Por esta y otras causas, siempre vais a leer que no hay que dejar los dispositivos electrónicos al Sol o bajo otras fuentes de calor.

Cuando la temperatura de la batería es baja, su desempeño empeora. Pero esta situación en un portátil va a ser difícil que se dé.

Curiosidades

En Internet se puede encontrar información de portátiles o teléfonos que han explotado. Esto ha sido investigado y se debe a que se forman dendritas dentro de la batería que acaban formando cortocircuitos y provocando que se incendien:

https://computerhoy.com/noticias/hardware/esto-es-que-provoca-que-exploten-baterias-metal-litio-52834

Otra curiosidad son las baterías de Ni-Fe que no sufren ningún tipo de degradación. Pueden llegar a durar más de 20 años y no sufrir ni el 2% de degradación. Y como extra su reciclaje es muy simple:

https://en.wikipedia.org/wiki/Nickel%E2%80%93iron_battery

Su punto débil, su peso y volumen. Pero se pueden usar para otros usos como instalaciones solares en los que los paneles recargan las baterías cuando hay Sol y se obtiene la electricidad cuando es de noche:

http://www.zappworks.com/battery_prices.htm

Como veis en el anterior enlace los precios son prohibitivos.

Ya se comienzan a escuchar otras tecnologías novedosas como las baterías de ánodo de grafeno, de electrolito sólido, Litio-azufre,…

Habrá que esperar para ver cuál de ellas acaba desarrollándose de forma definitiva.

Martes 20 de febrero de 2018

Lenin Hernandez

Lenin Hernandez
Leninmhs

Como enviar correos desde Perl usando Gmail

En esta entrada tendremos realizaremos el envió de correo desde el SMTP de Gmail usando el lenguaje de programación Perl para realizar esta tarea, específicamente usando el modulo Email::Sender. Perl es un lenguaje muy común para escribir scripts, por lo cual, es muy útil poder enviar de correos electrónico desde el. En Perl existen varias … Sigue leyendo Como enviar correos desde Perl usando Gmail