Domingo 19 de agosto de 2018

Asociación LiGNUx: El planetario Stellarium anuncia su versión 0.18.2

Sábado 18 de agosto de 2018

Asociación LiGNUx: El gestor de torrents qBittorrent acaba de publicar su versión 4.1.2

Viernes 17 de agosto de 2018

Domingo Gomes

Domingo Gomes
NewEsc

Gmail ahora permite auto-destruir un email desde Android

Desde abril que Google había añadido el modo confidencial a su navegador, que básicamente crea un período de caducidad a un email. Es una especie de mensaje que se auto-destruye después de algún tiempo. La noticia de hoy es que esta funcionalidad está ahora en la app de Gmail para Android y en breve estará también en iOS.

Para activar este modo apenas debes tocar en el botón con los tres puntos y elegir la opción “Modo confidencial”. Dentro, podrás elegir el tiempo de caducidad del email y si es necesario o no una contraseña que será creada por Google. Los usuarios que no utilicen Gmail recibirán la contraseña por correo electrónico para que se puedan autenticar.

Es una forma de proteger información confidencial y, si te estás preguntando: “¿Qué sucede si quiero revocar el acceso?”. Lo puedes hacer viendo el email en “Enviados” y tocando en el botón “Quitar acceso”.

La entrada Gmail ahora permite auto-destruir un email desde Android aparece primero en NewEsc.

Domingo Gomes

Domingo Gomes
NewEsc

Lista de dispositivos de Sony que recibirán Android 9.0 Pie

Tal como otros fabricantes, Sony también ha anunciado la lista de dispositivos que actualizará a Android 9.0 Pie. A continuación te dejamos una lista con todos los modelos que recibirán esta actualización:

  • Sony Xperia XZ Premium
  • Sony Xperia XZ1
  • Sony Xperia XZ1 Compact
  • Sony Xperia XZ2
  • Sony Xperia XZ2 Compact
  • Sony Xperia XZ2 Premium

Los Xperia XA2 tardarán un poco más en recibir la actualización, mas precisamente en principios del 2019:

  • Sony Xperia XA2
  • Sony Xperia XA2 Plus
  • Sony Xperia XA2 Ultra

En ese mismo post también han dejado una infografia que explica de una forma resumida por qué tardan tanto en actualizar los móviles y que proceso se necesita.

An infographic showing a Sony software rollout

Fuente | Sony

La entrada Lista de dispositivos de Sony que recibirán Android 9.0 Pie aparece primero en NewEsc.

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
Asociación LiGNUx: Instalando un Entorno LAMP en Centos 7

Jueves 16 de agosto de 2018

Domingo Gomes

Domingo Gomes
NewEsc

Review Razer Huntsman, ¿los mejores switches para gaming?

razer huntsman destcada
Razer Huntsman
Switches Ergonomía Diseño
El Razer Huntsman es un teclado destino a los jugadores más exigentes y competitivos. Estos traen los nuevos switches optomecánicos diseñados por la propia marca, los cuales reducen el recorrido de accionamiento a 1.5 mm manteniendo el recorrida lineal y cliqui. Combinado con un teclado construido sobre una placa de aluminio y plástico ABS resistente con un tamaño estándar y una buena posición para las manos.
Diseño88
Rendimiento96
Calidad/Precio87
Ergonomía92
Personalización92
Lo bueno
Switches optomecánicos
Comodidad
Software
Lo malo
Extras
91
Excelente

Como estándar estamos acostumbrados a ver switches red, silent o speed para gaming, ya que ofrecen mejor tiempo de respuesta y ligereza, características esenciales para juegos tipo shooter o juegos donde 1 ms es fundamental.

Si eres uno de estos jugadores, seguro que ya habrás escuchado hablar del… ¡Razer Huntsman!, el primer teclado junto a su versión élite en montar los nuevos switches de Razer, mejorando el tiempo de respuesta hasta un 30% a través de un sensor de luz, los switches optomecánicos. Pero ¡vayamos a la review para conocer más detalles!

Unboxing y características

El Razer Huntsman viene en una caja de cartón de color negro y verde con imágenes y descripciones del producto, además de una pequeña ranura desde donde podrás tocar las flechas para probar la sensación táctil de las teclas.razer huntsman caja 1A destacar, ya desde la caja nos hacen referencia a los nuevos switches optomecánicos describiendolos como “Light and clicky” ya que son de tipo cliqui como un blue y se activan a través de un haz de luz reduciendo el punto de accionamiento a los 1.5 mm.

En el interior de la caja, junto al periférico, encontramos un par de gomas laterales para protegerlo durante el transporte con un acolchado de cartón y una tapa de plástico. También verás la documentación, la carta del CEO, y unas pegatinas de la marca.razer huntsman unboxing 1El teclado en sí a primera vista no tiene ningún detalle diferente, se sobrepone la sobriedad de la cubierta superior acabada en un color mate negro, con el nombre de la marca en relieve negro brillante en la parte superior del numérico.

– Especificaciones –

Tamaño 444.5 x 140 x 36.5 mm
Peso 860 gramos
Materiales Aluminio y plástico ABS resistente
Switches Optomecánicos
Vida útil 100 millones de pulsaciones
Iluminación 16.8 millones de colores RGB
Cable De malla trenzado de 1.8 metros
Perfiles Hasta cinco almacenables en la memoria interna
Antighosting Hasta 10 teclas
Compatibilidad Windows 7 y superior
Software Synapse 3.0

Características

El Razer Huntsman tiene un tamaño ajustado de 444.5 x 140 x 36.5 mm por ser un teclado completo. Su peso es bastante ligero de unos 860 gramos, algo a tener en cuenta si vas a transportarlo.razer huntsman manoEn la parte superior vemos una placa de aluminio acabada en negro mate con el nombre de la marca encima del numérico lateral. La estructura inferior por otro lado es de plástico ABS resistente también en mate negro.

Las teclas son de tipo flotante con el dibujo de las teclas en inyección para permitir que pase bien la luz y una mayor durabilidad.  En esta ocasión no contarás con teclas especiales de función, aunque su tendrás acceso a través de la tecla fn a varias funciones extra.

Como punto positivo al apretar la tecla fn resaltan las teclas de función  con una iluminación blanca, útil pero que no resuelve el fácil acceso a través de un panel multimedia, que hubiera resultado ideal.razer huntsman teclas fnEn la parte inferior encontrarás seis almohadillas generosas con dos patas que cuentan con dos posiciones y la etiqueta del producto con el ID.

Finalmente vemos un cable mallado de 1.8 metros terminado en un USB 2.0 al que le echamos en falta el chapado en oro habitual de los alta gama. Este es un poco más grueso de lo habitual sin resultar grande y ligeramente flexible.razer huntsman cable

Switches ágiles y ligeros

Aunque fuera de los switches poco podemos hablar de la experiencia de usuario, sí que podemos decirte que este teclado queda a una buena altura sin reposamuñecas, no lo echamos en falta pero hubiese sido un detalle que lo incluyera.

El ángulo y altura del Razer Huntsman son bastante buenos, sin olvidar la doble posición de las patas para una mayor adaptación a cada usuario.razer huntsman traseroAhora sí vayamos ya al “quid” de la cuestión, los switches Optomecánicos, y es que si algo define este teclado son los switches. Estos incluyen como novedad el uso de la luz como punto de accionamiento en vez del típico contacto físico.

Este switch tiene una fuerza de accionamiento de 45 gramos con un punto de accionamiento a 1.5 mm y utiliza aparte de la típica cruz, unos estabilizadores metálicos para un comportamiento más uniforme de la tecla a la pulsación, algo que notarás sobre todo en la barra espaciadora.razer huntsman switchLa sensación al uso ha sido muy ligera y ágil como la de un switch red, y no es de extrañar ya que tienen una fuerza de pulsación igual, además este también es de tipo lineal.

La mayor diferencia la vemos en el recorrida de activación que se reduce a 1.5 mm comparado con los 2 mm de los red y que los optomecánicos son cliqui. Este no tiene un ruido tan molesto como el de los blue, también lo acompaña un sonido metálico muy leve casi inapreciable.

El switch optomecánico de Razer ofrece una experiencia diferente a la de los de toda la vida

A pesar de que es un switch diseñado para gaming, no ha resultado desagradable a la hora de escribir. Al principio pensaba que al tener características muy similares al red presionaría teclas sin querer, pero se ha acercado bastante a la experiencia de un blue ligero sin ser tan cómodo como la de un brown.

Iluminación y software

Uno de los puntos fuertes de los productos Razer es siempre la iluminación, y esta vez no es una excepción. Esta es por tecla con leds RGB, acompañado de una buena intensidad sin ser molesta en su máxima potencia. La podrás graduar a través de las teclas fn + f11/f12.razer huntsman iluminado 1En esta ocasión no encontramos una base blanca bajo las teclas para reflejar el color y dando así una mayor vividez como por ejemplo el Razer Cynosa o su versión Elite que además incluye iluminación extra alrededor del teclado y la almohadilla.

Otro de los puntos fuertes de los productos Razer lo encontrarás en el software Synapse 3.0 el cual también cuenta con iluminación personalizada en algunos juegos, por ejemplo Fortnite entre muchos otros que podrás consultar en el siguiente LINK.

Podrás crear macros, personalizar la iluminación, diseñar tus propios perfiles y guardar hasta cinco en la memoria del teclado para poder activarlos sin necesidad del software, además de ligar perfiles y guardarlos en tu cuenta o que se activan al abrir ciertos programas.razer huntsman synapseUn detalle que nos ha gustado es que ahora el software de Razer incluye nuevos apartados para monitorizar los fps en tus juegos o optimizar el equipo así como acceso a ofertas de juegos y varios sorteos.

Conclusión

El nuevo switch optomecánico de Razer supone una innovación indudablemente, la incorporación de la luz al mecanismo es una gran idea para recortar los tiempos de activación, en este caso un 30% sobre la media. Además nos encontramos una estructura con aluminio que le dará una mayor rigidez así como una de las mejores iluminaciones del mercado, sin olvidar el software que la compañía.razer huntsman unboxing 2El diseño del teclado es muy minimalista con un tono mate negro que le da un toque sereno al dispositivo, con el cable mallado terminado en un USB 2.0 al que echamos en falta el chapado en oro.

Aunque muy probablemente estos switches lo convierten en el mejor teclado del mercado para FPS o cualquier juego donde el tiempo de respuesta es esencial, no encontramos ningún extra fuera de las teclas combinadas con fn.

Para tener todos los extras tendrás que comprar el modelo Razer Huntsman Elite el cual incluye nuevas zonas de iluminación, reposa muñecas con led RGB alrededor, control multimedia y un dial multifunción.razer huntsman set upLa versión del análisis tiene un precio de 159.99€ en amazon, mientras que la versión élite tiene un precio de 209.99€. No lo vemos un precio elevado por el desarrollo que hay detrás, pero nos hubiese gustado que el modelo normal incluyera reposa muñecas aunque no fuera con led, el modelo más recomendado es el élite sin duda.

Sello Recomendado NewEsc

La entrada Review Razer Huntsman, ¿los mejores switches para gaming? aparece primero en NewEsc.

Bot Twitter e instagram python GRATIS

Un bot no es más que un programa que hace tareas por nosotros. Los lenguajes de programación preferidos para crear estos programas son principalmente: NodeJs, Python, JavaScript y C#. Siendo Python el lenguaje preferido por su "sencillez" a la hora de crearlo. También su uso aunque más limitado no tiene gran complicación. Y como realmente […]

La entrada Bot Twitter e instagram python GRATIS aparece primero en Blog de Informática ✏ Luisi.

Martes 14 de agosto de 2018

Proyecto Smart TV con una Raspberry Pi 2 o 3 y Kodi

Como hacer una smart tv con una Raspberry Pi y Kodi Para instalar Kodi en nuestra Raspberry Pi tenemos que elegir el sistema operativo que mas se adapte a nuestras necesidades. Para los usuarios básicos hay tres principalmente: LibreELEC, OSMC y XBian. La mejor es LibreELEC ya que tiene mayor rango de dispositivos compatibles. Anteriormente usábamos Openelec […]

La entrada Proyecto Smart TV con una Raspberry Pi 2 o 3 y Kodi aparece primero en Blog de Informática ✏ Luisi.

Desarrollo de aplicaciones ANDROID apk WEBVIEW app gratis

Como he dicho en otros artículos todo el mundo necesita tener su propia App. Ya seas un escritor independiente o una gran empresa. Pero no siempre tenemos los medios económicos para contratar a un programador. Por eso vamos a ver hoy como crear una WebView App para poder visualizar nuestra página desde dispositivos móviles y […]

La entrada Desarrollo de aplicaciones ANDROID apk WEBVIEW app gratis aparece primero en Blog de Informática ✏ Luisi.

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

Ubuntizando.com

Ubuntizando.com
Ubuntizando.com

Hollywood se pasa al software libre

Hollywood

La relación entre Hollywood y el software libre viene de lejos. Ya en Toy Story se uso Linux de manera intensiva pues suponía un importante ahorro de costes sobre las carísimas soluciones Unix de la época. Actualmente más del 80% de los estudios de Hollywood usan este tipo de software de una forma u otra.

Es tanto así que los principales estudios acaban de crear su propia organización centrada en el uso y promoción de código abierto, esto ha sido gracias a que la la Academia de las Artes y las Ciencias Cinematográficas se ha asociado con la Fundación Linux para lanzar la Academy Software Foundation. 

Entre sus miembros fundadores, nombres tan relevantes como DreamWorks, Epic Games,  Google, Intel, Walt Disney Studios, Cisco, Autodesk o Animal Logic.

Sin duda una gran noticia y un importante salto. Quien sabe si en algún momento este será el año de Linux en el escritorio, pero sin duda este parece que será su año en las producciones de Hollywood. ¿Acabaremos por ver a Linus Torvalds en el paseo de la fama?

Imagen: Wikipedia

Ubuntizando.com

Ubuntizando.com
Ubuntizando.com

Ya puedes comprar tu Chuwi Hi 9 Pro por tan solo 139,9 dólares por tiempo limitado

Todavía falta un poco para que se acabe el verano y para que todos pensemos en la “vuelta al cole” pero si lo que quieres es comprar una nueva tablet a un precio de escándalo quizá no tengas que esperar mucho. CHUWI es un fabricante que presume de productos con unas muy buenas características técnicas y una cada vez mejor calidad gracias al feedback que sus usuarios le ofrecen a través de las diversas campañas de financiación vía crowdfounding. Es por eso que con el inminente lanzamiento de la CHUWI HI9 Pro vamos a poder ahorrarnos unos cuantos euros.  Chuwi nos ofrece la Hi9 Pro por tan solo 139,99 dólares entre los días del 6 al 12 de agosto,

La Hi9 Pro es una tablet todo terreno pensada para ocupar muy poco en nuestras mochilas y ofrecer una buena experiencia de usuario al mejor precio.No sé vosotros pero cada vez observo dos líneas más claras en los diferentes lanzamientos que se van produciendo. Por un lado tablets con una gran pantalla y potencia y por otra modelos con pantallas más reducidas y prestaciones modestas pensando en un mercado poco exigente. La Chuwi Hi9 Pro ofrece una alternativa.  Los más beneficiados sean estudiantes o personas que busquen una tablet que lo tenga todo sin costar una gran fortuna.

Su pantalla de 8,4 pulgadas puede resultar pequeña en comparación a otros modelos pero con un ratio de 16:10 acompañada de una resolución de 2.560 x 1.600 píxeles es más que suficiente para poder disfrutar de películas y juegos con una buena calidad. En su interior, para mover el conjunto, cuenta con el procesador de MediaTek X20, acompañado de 3 GB de memoria RAM y 32 GB de almacenamiento interno, almacenamiento que puede ser considerado el estándar en la actualidad y que podemos ampliar hasta 128 GB gracias a la uso de tarjetas microSD.

El CHUWI Hi9 Pro lleva además una cámara trasera de 8MP y una cámara frontal de 5MP, respectivamente. La tableta viene configurada con Android 8.0 Oreo, que puede parecer una tontería pero en realidad nos ayuda a poder disfrutar de todas las funciones de nuestras aplicaciones favoritas con total seguridad. ¿Todavía usas Android 5.0? Tienes que dar el paso. 🙂

Ya por último, la batería integrada 5000mAh proporciona una duración moderada pero más que suficiente para nuestro uso diario.

Viernes 10 de agosto de 2018

Taskbook ya está disponible en Ubuntu, ¡organízate sin salir de la consola!

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} Los amantes de las aplicaciones ejecutadas desde consola, ya tienen un motivo más para no salir de ella ni

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カン(感、観、勘)が要すると思います。想定外のことがたくさん起きますし、それをすぐ判断してベストな選択をしなければいけないので、気は抜けません。特に、調査対象やその周囲に不倫調査を悟られてしまうと、依頼人を推定しやすいということからも、最大限の用心をしつつ調査につくのは常識です。対象者になった経験のある人の追跡は、さらに注意が必要です。

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

Miércoles 01 de agosto de 2018

Redream, juegos de Dreamcast en HD y 4K en 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} Si eres uno de los muchos entusiastas de Sega

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

Miércoles 25 de julio de 2018

Nueva versión de ReactOS 0.4.9

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} Son muchos los amantes del software libre los que

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

Viernes 20 de julio 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: Servicios systemd systemctl

Muchas distribuciones de Linux actuales han pasado del modelo de SystemV a SystemD y por tanto se cambia la forma de administrar los servicios del sistema. En el caso de distribuciones Linux RedHat o CentOS: - Versiones anteriores a la 7: SystemV - Versión 7: SystemD Siguiendo con las distribuciones RedHat/CentOS, en las versiones que funcionan con SystemV, la administración de los

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.

Martes 10 de julio de 2018

La perlificación de Python

You know, FOX turned into a hardcore sex channel so gradually I didn’t even notice

Marge Simpson, Los Simpson

Recientemente ha salido Python 3.7, con interesantes novedades. También han salido los primeros artículos hablando de las novedades que podrá traer Python 3.8. Como muchos ya conoceréis, y si no es así explico, Python funciona a base de PEPs (Python Enhancement Proposal). Cualquier persona puede abrir un PEP, que es un documento que describe la funcionalidad que se quiere añadir/modificar/eliminar. Estas PEPs se discuten y finalmente Guido, creador de Python, las aprueba y se codifican.

Dentro de las PEP relacionadas con Python 3.8 hay algunas bastante controvertidas que han hecho saltar la voz de alarma. No ha faltado gente que ha opinado que cada vez Python se parece más a Perl. Este proceso habría empezado con Python 3 pero se habría ido haciendo más evidente hasta llegar a hoy. Cada vez con más sintaxis poco utilizada, con más elementos, más cómodo de escribir para el experimentado aunque menos legible si no dominas el lenguaje.

Y resulta curioso, porque Python es en parte una respuesta a la excesiva complejidad que podían tener los programas hechos en Perl. Su popularidad se debe a que es fácil de aprender y eso parece que ya no está tan claro.

Con la introducción de operadores como := o ?? o anotaciones como @dataclass se va, en cierta medida, perdiendo el espíritu original de Python. Y es cierto que otros lenguajes tienen algo similar, pero precisamente Python había sido muy selecto en incluir un conjunto bastante reducido de características, que todo el mundo pudiese dominar. Al final se sacrifica legibilidad y facilidad de aprendizaje por una ergonomía que beneficia a unos pocos en unos casos concretos.

Lenguajes de programación barrocos

Universidad de Valladolid, ejemplo de barroco civil. Foto: https://artevalladolid.blogspot.com

Python lleva un tiempo entrando en un proceso de perlificación pero en mi opinión no es el único lenguaje que ha entrado en una espiral parecida. Cada vez más lenguajes han pasado del renacimiento, donde se buscaba la consistencia, la simetría, la sencillez sin perder la funcionalidad, hacia el barroco, donde los lenguajes son más recargados, con más elementos sintácticos, que cubren mejor casos concretos, pero que de por sí no son tan esenciales, no cambian aspectos fundamentales del lenguaje y normalmente introducen diversas formas de hacer algo en un mismo lenguaje.

Veamos más ejemplos: en C++20 se propuso añadir funcionalidad de dibujado 2D a la librería estándar (propuesta que fue rechazada en una historia bastante larga para este post) y se han propuesto conceptos, módulos, comparación de tres vías, reflexión, metaclases,… En C# 8.0 se han propuesto también bastantes cosas como records, tipos non-nullable, interfaces con métodos ya implementados (traits) y rangos. Y eso sin contar con las características que estos dos lenguajes ya tienen, que son bastante más extensos que Python.

Retablo lateral de la Iglesia de San Miguel y San Julián (Valladolid). Barroco puro. Foto: https://commons.wikimedia.org/wiki/File:San_Miguel_-_retablo_relicario.jpg

Hay un horror vacui, horror al vacío, a funcionalidades. Siempre se añade y casi nunca se elimina. ¿Pero es realmente necesario? Es evidente que durante mucho tiempo, los lenguajes evolucionaban de forma muy lenta y muchos de los cambios que han hecho eran necesarios. Desde hace unos años, se ha aumentado la velocidad de los cambios, pero esto no puede seguir así eternamente, porque el ritmo que llevan muchas veces es superior al de los avances en lenguajes de programación y la retrocompatibilidad impide ir quitando cosas al mismo ritmo que se añaden. De este modo, todos los lenguajes que entran en esta espiral crecen y crecen. No se llegan a pulir, simplemente crecen.

La perfección no se alcanza cuando no hay nada más que añadir, sino cuando no hay nada más que quitar

Antoine de SaintExupéry

Uno podría comparar esto con lenguajes naturales, como el español o el inglés. En estos idiomas, pese a existir reglas, existen numerosas excepciones. Es posible que lenguajes como Python se estén viendo influenciados por las mismas mecánicas humanas que rigen los lenguajes naturales y que han hecho que existan excepciones. Tendría bastante sentido que ocurriese así. Pero personalmente, me gustaría que aprender Python no costase tanto como aprender alemán o francés.

Los procesos comunitarios

Para mí, gran parte de esta sobrecarga viene dada por los procesos comunitarios. En un proceso comunitario como PEP, comité de C++ o similares es mucho más fácil añadir que eliminar. En C++ la situación ha llegado a un punto en el que Bjarne Stroustrup, creador de C++, ha pedido que se relajen con las propuestas en Remember the Vasa!, en honor a un bonito barco sueco que se hundió por exceso de carga. No tanto por su peso, sino por su disposición y las reformas que hubo que hacer para que todo encajase.

El Vasa fue recuperado después de su naufragio y se expone en Estocolmo. Foto: https://rachelannsblog.wordpress.com/2016/08/03/set-sail-set-at-the-bottom-of-the-sea/

Es por ello que las personas encargadas de elegir que se añade al lenguaje o no deben de ser muy conscientes de lo que supone, ya que una vez se introduzca, va a ser casi imposible eliminarlo.

No estoy en contra de añadir nuevas características (¡al contrario!) pero se debe respetar la visión de conjunto del lenguaje, que todo cuadre y esté cohesionado. No siempre tener más es mejor.

¿Te ha gustado el artículo?

Si es así, puedes ayudar al blog. Dentro de unos días es el Amazon Prime Day. Como muchos de vosotros seguro que os compraréis algo, no quiero dejar la oportunidad de deciros que este blog tiene enlace de referidos y que por cada cosa que compréis con el enlace, me llevo una pequeña parte (a vosotros no os va a costar más caro).

Enlace Amazon.es

Será muy bien recibido

 

La entrada La perlificación de Python se publicó primero en Adrianistán.

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

Lunes 19 de febrero de 2018

Emiliano A. González Salgado

Emiliano A. González Salgado
El blog de Emi

BITDEFENDER ANTIVIRUS SCANNER EN FEDORA 27

BitDefender Antivirus Scanner for Unices, un antivirus de BitDefender y que se puede utilizar gratuitamente.

La página de descarga es:

https://www.bitdefender.es/business/antivirus-for-unices.html

Después deberemos solicitar una licencia gratuita por un año, esta parte si que está visible desde el enlace Solicite licencia gratuita, que nos mandará una clave a nuestro email.

Una vez descargado, simplemente ejecutamos (sin olvidarnos de hacerlo ejecutable), como root:

sh BitDefender-Antivirus-Scanner-7.7-1-linux-amd64.rpm.run

Seguimos las instrucciones de la terminal, incluyendo escribir la palabra accept e indicando que queremos instalar también la interfaz gráfica.

El software ha sido discontinuado desde principios de 2016. Esta versión 7.7.1, data de noviembre de 2014, que en software antivirus es un mundo, las firmas siguen actualizándose diariamente, esencialmente son las mismas que usan otros productos de BitDefender, así que ningún problema.

Como habéis podido ver, además tiene versión nativa de 64 bits, que es de las cosas que más me gustan en BitDefender.

Si te has registrado con anterioridad y tienes licencia, puedes descargarlo directamente de:
https://download.bitdefender.com/SMB/Workstation_Security_and_Management/BitDefender_Antivirus_Scanner_for_Unices/Unix/Current/EN_FR_BR_RO/Linux/

Para evitar errores y que se carguen los motores antivirus, una vez instalado hay que ejecutar estos dos comandos, como root:

ln –force –symbolic /opt/BitDefender-scanner/var/lib/scan/Plugins /opt/BitDefender-scanner/var/lib/scan/Plugins/plugins
(todo lo anterior en la misma linea, pues es un único comando)

ll /opt/BitDefender-scanner/var/lib/scan/Plugins/plugins

Con ello ya se puede arrancar el programa, proceder al cambio de licencia (la consta es la de evaluación), actualizar las firmas y comenzar el escaneo.

Martes 13 de febrero de 2018

Ramón Miranda

Ramón Miranda
Ramon Miranda

Round 2. Visual Experiment for Krita 4.0 new layout proposal

Round2.

Virtual Deleted (for now) 44 brushes,  88 left.

virtual deleted bruhes.

How i decide what to remove? well i have tried to get the more visual pleasant and useful combination. My focus is what people could expect the first time krita opens. and make the experience as much comfortable as possible. No knowledge of tools or brushes are needed.
So if you like the idea here we go.

This is a document with lot of info, not for begginers even when they can learn some tips here and there, but lot of terminology is present.

You are going to see lot of “IMO”( in my opinion). Of course you can disagree totally or not. I expose my ideas based on my own experience and i hope this help, if you like flames i am not you man ;)
Also you will need this image to follow the numbers.
  • 1 it can be changed by eraser soft. They do basically the same, erase softly. the Airbrush erase don´t use the Airbrush feature. Also imo is not a good idea put an eraser as the first brush in the default pack.If you(begginer) try it in a blank layer you can see nothing is happening and think the software is bad or the tool is not working.
  • 3 The “noise” size controlled by density can’t be modified In big canvas sizes. This could be make the noisy effect invisible or not perceptible.
  • 4 Airbrush pressure is a redundant term. It would be like the tipical Airbrush. Added 2 instead, Airbrush linear i would remove linear.
  • 7 we have a lot of “wetpaint” colorsmudge brushengine based brushes. 
  • 9 Gaussian term is not a common word to describe behavior in brushes. It is slow and Soft curve can do the same and more imo.
  • 12 The Soft thing is not enough for me to be as brush.
  • 14 Added 20 instead. If the tablet has no tilt options, we can use RMB to change angle.
  • 22,26, 27 Added 24 instead.I wish to control the size of bristles and the scale of them. nowadays they are always 1px width wich is nice for low res but is useless for highres images. 6000px wide.
  • 38, 39, 40 i can’t see practical uses. Maybe sketching. Added 37 to have a sample of this brushengine. I would add to the “specials” category
  • 44 added 45 instead in “ink” category. It is only to fill big areas, it could be replaced by 86 or 87. The tip can be changed to be square to be more usable in squared surfaces just changing the brush tip to square.
  • 46 Slow and nowadays we have another Blender Blur wich is soft. If DOF is what we need i would put it in FX or Distort Category
  • 51 There is a newer version for krita4. WIP
  • 55, 56, 57 Added 53, 54 instead in Texture category
  • 60 It can be replaced by 63. The ink stroke
  • 62, 64 Very small imo. Added 63 instead
  • 65 added 68 instead.
  • 69, 70, 71,72 i consider them as basic brushes. 69 or 71 can be replaced for 20. 70 can be replaced by basic brush with opacity by pressure. 72 can be replaced by ink brush just to take notes. 
  • 77 added 78 instead . Is texture controlled by pattern in Basic category
  • 94 Added 93 instead. We can control opacity by the upper menu slider or RMB. it would be great to have opacity by pressure or gradient as original Alchemy software.
  • 97,98,99,100,101,102,103,104,105. added 95, 96 as representation of the Sketchbrushengine. Shows basic features. Too much variation of the same brush engine (11 brushes). The pencil icon is not very intuitive. Size doesn’t control real size but Area to be affected and this is not usual behavior but special behavior in sketch brushengine. This can confuse some users.
  • 115 Useless imo. Only show change on color dynamics.The sorrounder brushes are very different. And the icon is related to dry technique like pastel so this could be confusing. 
  • 117 Added 120 (Blending cat. “Particle” Effect that blends color.)
  • 123 Added 118, 121 instead
  • 129 It is not related with nature neither texture. Random in rotation makes very hard to predict results. And useless imo.


That's all for the Round 2. Could i remove more brushes? could i simplify a bit more but without loosing quality and options for the user? maybe in Round 3 . Sharing and comments are apreciated as always. more feedback means better software

Jueves 01 de febrero de 2018

Curso: Gestión de proyectos Software con Git y GitHub

Independiente si te mueves por el mundo del desarrollo, la administración de servidores o simplemente eres una mente inquieta en...

La entrada Curso: Gestión de proyectos Software con Git y GitHub aparece primero en Nosinmiubuntu | Ubuntu en concreto, GNU/Linux en general.

Miércoles 31 de enero de 2018

Curso: Desarrollo en HTML5, CSS y Javascript de Apps Web, Android e IOS (8ª edición)

Retomamos las publicaciones en la web para hablaros de la próxima edición del curso gratuito Desarrollo en HTML5, CSS y...

La entrada Curso: Desarrollo en HTML5, CSS y Javascript de Apps Web, Android e IOS (8ª edición) aparece primero en Nosinmiubuntu | Ubuntu en concreto, GNU/Linux en general.

Lunes 22 de enero de 2018

TutorialesLinux.com: Borrar un volumegroup y extender el principal