Sábado 23 de junio de 2018

Asociación LiGNUx: ¿Sabias que los dispositivos Sonos tienen un controlador abierto llamado Noson?

Viernes 22 de junio de 2018

Cómo instalar aplicaciones de Windows en Linux con Winepak

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} A día de hoy, son muchos los usuarios que siguen
Asociación LiGNUx: ¿Cómo cambiar o recuperar la contraseña en Ubuntu si nos la olvidamos?

バストアップのために運動を継続する

バストアップのために運動を継続することで、大きな胸を育てるられるでしょう。ボリュームあるバストで有名なグラビアアイドルが豊満な胸を作るための運動を公開していることもあります。エクササイズはいろいろありますので、自分にとってのベストを選び、バストを維持する筋肉を強くするように努めてください。努力し続けることが使わなくなったブランド品は置き場に困りますし、時間が経つほどにその価値も落ちるのが普通です。いっそ売却してお金にしてしまってもいいのではないでしょうか。ここのところテレビやネットの広告で知られるようになってきて世間での認知度も上昇中の、こういった買取業者の利用が手持ちのブランド品を売却したいと考えているのであればとても役に立つはずです。ブランド品を買い取ってくれる業者の利用については、最近ではわざわざ店頭まで出かけなくても、売却を希望するブランド品の査定を受けることができます。業者から示された査定額で売却したくない場合は、発送料や手数料などといった料金は不要でちゃんと返品されるようになっていますので利用しやすいのではないでしょうか。
FXの口座を初めて開設する場合、少しめんどくさく感じることもあります。必要事項を入力するだけならすぐ終えてしまえるのですが、身分証明書の送付をしないといけません。でも、近頃ではオンラインを利用しての送付が可能になり、運転免許証を携帯などで撮影して、その写真を送信するだけでいいFXの業者もあるでしょう。何回も車査定の相場を調べるのは億劫かもしれませんが、チェックしておいて損はありません。どちらかといえば、車を高く売りたいのであれば、愛車の価格を知っていた方が有利です。理由は、相場を把握しておくことで、営業さんが提示した査定額が的確なのかどうか判断可能だからです。

幸いにも、家を売りに出したところ早々に購入希望者が現れ、退去日まで時間がほとんどないなんてケースもあります。ですから、売りに出したら買い手がつかなくても荷物の整理をはじめておくと良いでしょう。居住中で売り出すつもりなら、最小限の食器や家電等を出すにとどめ、不要品や季節品を分け、段ボールに梱包しておくなり処分するなりしておくと、部屋もきれいになりますし、引越しもスムーズです。金の買取が今流行りですね。近年では、色々な店舗で貴金属の買取サービスを謳って営業しています。評判がいいのは、リサイクル・ショップでしょう。一般的には、着なくなった服などを売りに行く所ですが、金やプラチナの買取を大きく扱うお店が最近は多いようです。鑑定眼もしっかりしているので、安心して利用できます。家にある金のアクセサリーなどを手放したい人は、買取価格などを調べてみてもいいと思います。
貴金属を購入しても、盗まれるのが怖いので置き場所に困りますよね。あまり量が多くなければ自宅に保管することになるでしょうが、一定量を保管するなら金庫は必須となるでしょう。数千万円、数億円といった価値の金塊を保有する資産家の場合は、安心安全を求め、自宅には流石に置かず、銀行で大きな貸金庫を借りている場合や、金を販売している業者が保管設備を持っていて、有償で保存を受け付けているケースもあります。しかし、どんな形を取っても結局心配だという方は、金で財産を保有することを諦め、現金にしてしまうのも良い方法だと思います。
利点も多いインプラントですが、治療を受ける際に手術後に腫れてくるのではないかと心配する人もいるでしょう。腫れについては、インプラント治療を担当する歯科医師の技術のほか、本人の体調、口腔内の状態なども影響してくるため、絶対的なことは言えないのが実情であり、腫れるか腫れないかは人それぞれとしか言いようがありません。歯科で鎮痛剤の処方を受け、患部を冷やすなどの処置で痛みが引く場合が多いですが、それでも腫れや痛みが収まらない場合は、我慢せずすぐに歯医者さんに行きましょう。

不動産売却における白紙解除とは、融資利用の特約等が契約に盛り込まれていて、その条件が成就しなかったときに、契約の定めによる約定解除権が行使できることをいいます。買主から売主に支払われた手付金は、白紙解除が行われた場合、買主に対し全額返還することが必要です。通常は買主から貰った金額を額面通りに返還するのですが、「返還は無利息で行う」という旨が契約書に書かれていないときはあわせて利息も支払いが求められることがあるので、細心の注意を払いましょう。
使わない切手が多くて売りたいのですが、価格はどのくらいで買い取ってもらえるかと気になっています。全部集めてみたら、意外に多かったのでもしかしたら額面以上の価値もあるかなと、ちょっとしたお金に換えられればさて、何を買おうかと思っていつどこで売ればいいのかと困っています。希少価値があるのか、ほしい人がどのくらいいるのか、業者がみないとわかりませんよね。まとめて少しでも高くお金に換えたいと思っています。

もっと詳しく>>>>>すぱすぱ宮崎 県民共済 保険そうだ

Jueves 21 de junio de 2018

Asociación LiGNUx: ¿Cómo deshabilitar la webcam de un portátil? Lo probamos en Ubuntu 18.04

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
The Linux Alchemist

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 un pueblo llamado Villa Bug, en la calle Null Pointer Exception N° 16 y quieres llegar a la calle Internal Error N° 32. Hay dos modos de llegar a esa dirección:

– Desde tu posición actual, girar la primera calle a la izquierda y luego a la derecha (ruta relativa). El problema de seguir estas indicaciones es que solo sirven si estás en la calle “Null Pointer Exception N° 16”, si estás en otra ya no llegarás a tu destino con las indicaciones recibidas.

– Ir a la entrada de Villa Bug (¡teletransportación!) y atravesar de manera ordenada la lista de calles hasta llegar a tu destino (ruta 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…

安易にインプラント治療を

安易にインプラント治療を始めることはおすすめしません。様々な事情から、他の治療が受けられない方に適用されます。抜歯した歯が多く、クラウンやブリッジが入れられない。入れ歯では噛み心地が満足できない、などのためインプラント治療を選択するという事情を、ほとんどの患者さんが抱えています。インプラントと入れ歯との違いが気になるところですが、インプラントの場合、噛み心地は自分の歯に近く食感がしっかり伝わり、美味しく食べられるようになります。
どこの脱毛サロンを利用するかは、実際に利用したことのある人の声が聞ける口コミサイトは、とても参考になるでしょう。色々な店舗を実際に利用してみた人などの評価は他の店舗と比較をするときに大きく関わってきますが、敏感肌だったから使用していた脱毛機器が合わなかったり、サロンの雰囲気の感じ方などはその人によって違います。なので、初回0円などのキャンペーンをどんどん利用し、自分がちゃんと体験することが大切です。

抵当に入ったままの状態で土地家屋の売買は可能でしょうか。たしかに、抵当権が設定されたままで所有者移転することは禁止されていませんし、売買も自由です。ただ、物件を担保にしてお金を借りた人が債務を完済しない、あるいはできないとなると、住人がいるいないに関わらず家は競売にかけられ、やがて他人の物になってしまいます。要するに担保に入った不動産物件というのは訳あり(難あり)な存在なので、売ろうにも売れないというのが現実です。
脱毛サロンでの脱毛プロセスは即効性が高くなく、素早い効き目を期待をしていると、少し当てが外れるでしょう。というのも、脱毛サロンで使われている脱毛機器は一般的にクリニックの医療用脱毛機器よりも高い効果は出せないからで、効くまでのスピードという点でも下回ります。あまり時間をかけたくない人は、脱毛サロンの利用はあきらめ、脱毛クリニックへ行ってみることをおすすめします。費用の方が高くなるかもしれませんが、施術を受ける回数は少なくなるでしょう。葉酸の過剰摂取による副作用は、吐き気であるとか食欲不振などの症状を訴える方もいますし、体がむくんだり、不眠症のような症状が出る方も居るようです。妊娠初期というのは体もデリケートになりますし、神経質になりがちです。そのため葉酸を摂りすぎる場合がありますので、気をつけましょう。葉酸は、食事で摂ることが出来れば一番ですが、簡単に摂取したいのであれば、サプリメントがおススメです。サプリメントは、葉酸の摂取量が誰でも管理できるので、食事を気にする事無く、一日分の葉酸を摂取できますから葉酸サプリをおススメします。
脱毛サロンやエステで有名な光脱毛は妊婦の方が受けてもリスクはないのでしょうか?普通は、妊娠中は光脱毛はできないことになっているでしょう。妊娠している時は、ホルモンのバランスが崩れているため、肌トラブルが起きやすくなったり、脱毛効果が思うように得られないことがあるためです。

脇が臭いを発するわきがは良く知られていますが、すそわきがはそんなに知られていないようですね。スソワキガは陰部のワキガで、医学的な名称は外陰部臭症です。どの部位でもワキガは病気ではなく、優性遺伝で起こる体質的なものです。男女差があり女性に多く、セックスや生理のときに何時もよりも臭いが酷くなるようです。臭いのせいでパートナーを作ることをためらう人もいるほどです。

脱毛サロンには、個々のお店によって予約時間に関しての応対方法があり、特に遅刻に関してはそれぞれ違います。予約した日の施術が代替えされることなく、施術が省略されてしまう事もありますし、予約時間を守らなかった事により、千円位の金額を支払わなければならないお店もあります。事前に予約の取り消し、変更依頼をせず、サロンに行けなかったとすると、施術が一回分なくなってしまうということがよくあります。この様なことが起きないようにするためにも、予約時間は絶対厳守し、到着できるようにしておきましょう。

妊婦や妊娠を希望する女性にとって、葉酸は必要不可欠な栄養素です。実際に厚生労働省が妊娠を希望する女性や妊娠初期の女性に、積極的な摂取を推奨しているほどなのです。では、葉酸をたくさん摂った方が期待できるのでしょうか。実は葉酸は、水溶性であるため、尿とか汗で流出します。そのため、体内に蓄積するということはありません。しかし、葉酸の過剰摂取によって発熱や呼吸障害、かゆみや吐き気などを引き起こすという報告がされています。葉酸サプリ等で葉酸の補給をする場合、規定量を必ず確認しましょう。
皆さんは、妊活と言えばどのような活動をイメージするでしょうか?妊活というと、基礎体温や食事の管理など、ほとんどの活動は主に女性がするものだと考えていませんか?もちろん、女性が行うべき妊活も沢山あります。しかし、男性に出来る妊活があるのか、疑問に思いませんか?実は、男性にもお勧めしたい妊活があります。それというのも、葉酸を十分に摂るという事なんです。流産や不妊の原因因子として、女性の問題ばかりでなく、男性に原因がある事もあります。中でも、精子の染色体異常は重要な問題で、これは着床率を著しく左右します。質の高い精子をつくり、染色体異常のリスクを低減するためにも、ぜひ葉酸摂取という妊活を実践してみてください。

よく読まれてるサイト⇒すっくり借金チャラようで

Lunes 18 de junio de 2018

La nueva versión del kernel 4.17 ya está aquí

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} Como siempre Linus Torvalds ha sido el

Jueves 14 de junio de 2018

¿Cómo funcionan los sistemas basados en inodos?

Después de ver como funcionan de forma genérica los sistemas FAT, saltamos a los sistemas de inodos. Estos se han usado tradicionalmente en sistemas UNIX (UFS, ext2), así que tradicionalmente ha existido una cierta rivalidad  en las redes entre FAT e inodos similar a la de Windows/Linux. Lo cierto es que a nivel técnico cada uno tiene fortalezas y debilidades.

Partición

Tomando la base de FAT, una partición de un sistema basado en inodos también contiene un sector de arranque y un superbloque con metadatos. También es necesario un bloque dedicado al directorio raíz presente en el disco. Además es necesario espacio para almacenar todos los inodos y un mapa de bits de espacio libre que en FAT no hacía falta, ya que la propia tabla nos indicaba que bloques del disco estaban libres.

Los inodos

¿Qué es inodo te podrás preguntar? Es una estructura de datos, su nombre proviene de index node y es que los inodos no son más que índices, que almacenan los números de bloque de las diferentes partes del archivo. Además, contienen metadatos como permisos, propietario, tamaño, fecha de modificación, referencias, tipo de fichero (directorio, archivo, enlace duro, enlace blando,…) salvo el nombre del propio archivo, que en ningún sitio del inodo aparece.

Este sistema tiene una ventaja de rendimiento respecto a FAT en cuanto al acceso aleatorio a los archivos, ya que es mucho más rápido de esta forma que con FAT. En FAT para hacer lo mismo tenemos que ir recorriendo la tabla arriba y abajo siguiendo los números de bloque hasta encontrar el bloque deseado.

Normalmente un inodo tiene un tamaño fijo, lo que implica que el índice no se puede alargar hasta el infinito. Esto hace que haya un número limitado de bloques que puede usar un archivo y por ende, que haya un tamaño máximo de archivo que no es muy elevado. Para solventar este problema hay varias soluciones. El enfoque de UFS y de ext2/3/4 consiste en múltiples niveles de indexado progresivo.

Esto significa que los primeros bloques son números de bloque directos pero los siguientes son números de bloque que llevan a tablas de inodo secundarias que ya sí, hacen referencia al archivo real. Más adelante los números de bloque hacen referencias a tablas de inodo secundarias que a su vez llaman a tablas de inodos terciarias.

Esto provoca algo que en principio puede parecer paradójico y es que es más lento leer una zona final de un archivo que una zona del principio, aunque en una lectura secuencial no se nota demasiado.

Otra solución a esto es enlazar los inodos a modo de lista enlazada añadiendo al final de cada inodo un número de inodo al que continuar la lectura de índices.

Localización de los inodos

Los inodos se crean cuando se formatea el disco y permanecen en un estado libre. No se pueden añadir más inodos ni quitar inodos y no puede haber más archivos y directorios que inodos por esta misma razón. Esto es una desventaja respecto a FAT, ya que en FAT puede haber tantos archivos como bloques haya/entradas tenga la tabla. En sistemas de inodos como ext2/3/4 puede ocurrir que no queden inodos libres pero haya todavía bloques libres, dejando todo ese espacio inutilizado (aunque en realidad lo podrían usar los archivos existentes si creciesen).

Los inodos se pueden ubicar de dos formas distintas. Un enfoque consiste en ponerlos al principio del disco todos juntos. Otro enfoque, el que sigue ext3, consiste en dividir el disco en 4 zonas y ubicar inodos en cada inicio de zona. La idea es que los inodos de esa zona usen bloques de esa zona y de esta forma reducir los desplazamientos de las cabezas lectoras del disco (en unidades SSD esto da completamente igual como podréis suponer).

Gestión del espacio libre

Una de las grandes ventajas de FAT era que la tabla podía mantener a la vez un listado de bloques libres, listos para ser usados. Con inodos no tenemos esa facilidad y tenemos que recurrir a otros tipos de estructura. Aquí hay muchos planteamientos siendo el más común el mapa de bits. El mapa de bits es una estructura que se compone de un listado de bits. Cada bit corresponde a un bloque y dependiendo de si el bit es 1 o 0 podemos saber si el bloque está libre u ocupado.

Como veis, los sistemas basados en inodos tienen que mantener varias estructuras de datos de forma paralela. Esto aumenta las probabilidades de inconsistencias en el sistema. Por este motivo, muchos sistemas más avanzados como ext4 mantienen un journal o diario.

Fragmentación

Veamos como se comportan los sistemas de inodos ante los tres tipos de fragmentación. Respecto a la fragmentación interna, que es aquella que sucede cuando asignamos espacio de más a archivos que no necesitan tanto, tiene los mismos valores que FAT, ya que los bloques siguen pudiendo pertenecer únicamente a un archivo. Realmente, para mejorar la fragmentación interna tenemos que saltar a sistemas como XFS o JFS.

La fragmentación externa de los sistemas basados en inodos es la misma que la de FAT, 0, ya que todo se asigna mediante bloques del mismo tamaño.

Respecto a la fragmentación de datos, históricamente las implementaciones como UFS o ext2/3 se han comportado relativamente bien, aunque a nivel teórico nada impide que se comporten igual de mal que FAT, no existen mecanismos preventivos. Ext4 por contra, sí que tiene mecanismos de prevención (delayed allocation).

Directorios y enlaces duros

En los sistemas basados en inodos los directorios son más sencillos que en FAT, ya que no tienen que almacenar los metadatos del archivo en cuestión. En un fichero de directorio simplemente se almacena el nombre y el número de inodo correspondiente.

Aquí surge un concepto muy interesante, el de enlaces duros. Un enlace duro no es más que otra entrada de directorio que apunta a un mismo inodo. Realmente desde el punto de vista del sistema de archivos no existe un fichero original y su enlace. Simplemente dos entradas diferentes apuntando al mismo inodo. ¿Y cómo reacciona esto a los borrados? Imagina la siguiente situación: tengo un fichero y creo un enlace duro. Borro el fichero original y su inodo se libera. Ahora creo otro archivo y reutiliza ese mismo inodo que estaba libre. ¡Ahora el enlace duro apunta a un contenido totalmente distinto sin darse cuenta! Para prevenir esto, los inodos no se liberan hasta que no quede ninguna entrada de directorio apuntando a ellos. Para eso sirve el campo referencias dentro del inodo, para llevar la cuenta de cuántas veces se hace referencia al inodo en el sistema de archivos. Cuando el valor de referencias llega a cero, se puede liberar sin problema.

Conclusiones

Los sistemas basados en inodos son conceptualmente algo más complejos que los basados en FAT. Comparten además limitaciones comunes, usan más espacio de disco, aunque suelen ser más rápidos.

Actualmente existen sistemas basados en inodos mucho más avanzados y complejos que UFS y ext2/3/4 y que mejoran este sistema de forma sustancial. Por ejemplo en XFS los inodos tienen una estructura totalmente distinta donde se indica un bloque de inicio y una longitud en número de bloques contiguos que pertenecen al archivo. Muchos sistemas además usan estructuras de árbol B+ como pueden ser ZFS o Btrfs.

La entrada ¿Cómo funcionan los sistemas basados en inodos? se publicó primero en Adrianistán.

El navegador Falkon: lo bueno, lo malo y lo más o menos

Una de las cosas que me ha facilitado la actualización a Leap 15.0 (además de tener TeXLive 2017) es instalar con total comodidad Falkon, el nuevo navegador de internet del proyecto KDE, en su versión 3.0.1. Falkon nace cuando el proyecto Qupzilla entra, en agosto del 2017, en la comunidad KDE. Actualmente basado en QtWebEngine … Sigue leyendo El navegador Falkon: lo bueno, lo malo y lo más o menos

Miércoles 13 de junio de 2018

日常の生活の範囲内にも、金でできていたり

日常の生活の範囲内にも、金でできていたり、一部に金が使われている製品が割と色々な形であるのです。例を挙げれば、歯医者さんで付けてもらう金歯がそうですね。こういうものも金買取で値段が付くので侮れません。モノが金であれば、形状は何でもいいというわけです。タナボタ感覚でのお小遣いが入ってくることが見込めるので、金歯がもう要らなくなってしまったという方は、金買取のお店に早速持って行ってみるのをお勧めします。
第一次世界大戦後の混乱がまだ尾を引いている1921年、グッチオ・グッチが創業したのはそんな時代で当初はレザー製品で名を高めました。後にはアメリカ進出、世界的ブランドともなったこのブランドの日本上陸は1964年です。ラインナップを見ていきますと、各種バッグや靴、お財布などお約束の皮革製品をはじめとし、ウェア、フレグランス、アクセサリー類、アクセサリー類、腕時計など色々で関わる分野は多く、商品の種類は間口の広さでもあるでしょう。こういった点もグッチというブランドの特徴です。歴史を辿ると、ビッグネームらしい、大長編のドラマのような変遷を見せていますが、ブランドの柱をなす、多くのデザイナーを排出しました。高名な一人にトム・フォードがいます。ブランド品買取店なら、どこの店でもグッチはいつだって、高水準の査定価格で対応してくれることが多いはずです。
脱毛サロンまたはエステサロンで脇脱毛の処理を行ったら、跡が残ってしまうのでは?といった不安をお持ちの方もいらっしゃるのではないでしょうか。そのようなサロンでは、最新型のマシンで施術を行いますし、その後のアフターケアも万全なので、跡が残るような心配は必要ないでしょう。自分で脇脱毛を行うよりも肌に負担をかけずに、美しく処理できます。

通っている脱毛サロンがいきなり倒産した場合、前払い分のお金が返ってくることはありません。ローンの場合、受けることができていない施術分の支払いは止められますのでその点は安心です。有名大手の誰もが知っている脱毛サロンにも倒産の危機が訪れることはあるでしょうし、まして中小規模のお店ならいつ潰れてしまってもそう驚くようなことではないでしょう。そういうことも考えて料金の前払いはできればやめておく方がリスク回避になります。
キャッシング申し込み時の審査では、確認される項目として、属性情報、書類審査、在籍確認、信用情報等があります。基本となるこれらの情報を確認したうえで、返済能力を有しているか否かを決断を下すのです。虚偽の情報申告をしてしまうと、審査で不適格とされてしまいます。借金が既に、かなりの額に上っていたり、その人物に関する情報の中に事故に関するものがあると、そうした場合には、キャッシングの審査に通る見込みは薄いでしょう。大きくなってきたお腹を見ると、最近まで不妊治療に通っていたのが嘘のようです。妊活中の友人たちと同様、結婚後3年を前に不安になったんです。基礎体温でタイミングを見計らっても、出来ない時は出来ないのだと感じました。義妹や姉のところに子供ができると、焦ったり悲しかったりでした。クリニックで検査の末、多嚢胞性卵巣症候群と言われ、排卵誘発剤で様子を見ることになりましたが、三周期目で赤ちゃんを授かることができました。薬も効きましたが、原因がわかってホッとしたおかげもあるでしょう。
いびき治療は、その原因に応じて行います。鼻づまりがみられるケースでは、最初に耳鼻科的な治療を行い、花粉症、鼻中隔湾曲症、慢性副鼻腔炎などの治療をします。鼻づまりがない場合には、睡眠時無呼吸症候群かどうかの検査をすることになります。ダイエット、寝酒を控える、禁煙、寝具や寝姿勢の工夫など、生活習慣の改善を試みます。閉塞性無呼吸のケースでは、マウスピース療法、「「Continuous Positive Airway Pressure:CPAP(シーパップ)療法:経鼻的持続陽圧呼吸療法」、外科の手術を試すことになります。
成功報酬の場合、気を付けるべきなのは、例えば、調査内容が浮気についてだった場合には、調査期間が3日間あったとしてその3日間の調査期間の間に浮気をしていなければ調査は成功ということになるでしょう。本当は浮気をしているという場合でも、その3日間だけ浮気が見つからなければ、配偶者の浮気の有無をはっきりさせることができないまま、調査は完了し、成功報酬として料金を支払うのです。脱毛サロンやエステで知られている光脱毛は妊婦の方が受けても危険ではないのでしょうか?通常は妊娠しているときに光脱毛は受けられないことになっているのです。妊娠している時は、ホルモンのバランスが崩れた状態になっているので、肌トラブルが起きやすくなったり、脱毛効果が満足に得ることができないことがあるのが理由です。
参考サイト:折好くシースリー 本厚木そうで

Martes 12 de junio de 2018

Ubuntizando.com

Ubuntizando.com
Ubuntizando.com

Debian 8 Jessie dejará de recibir actualizaciones de seguridad el 17 de junio

Tengo algunos amigos que todavía usan Debian 8 Jessie en sus escritorios y proyectos, lo cual es genial. Debian 8 Jessie fue lanzado hace ya 3 años, en 2015, y en su momento supuso un importante cambio de concepto. También es, hasta la fecha, la versión más vieja con soporte LTS. Pero todo lo bueno se acaba.

Desde Debian Project ya han anunciado el cese de publicación de actualizaciones de seguridad regulares a partir del 17 de junio. Sin más actualizaciones de seguridad Esta versión dejará de contar con un soporte adecuado, aunque algunas actualizaciones podrán seguir llegando por un tiempo.

La recomendación, luego no digas que no avisamos, es actualizar tu sistema Debian 8 Jessie a Debian 9 Stretch que tendrá soporte oficial hasta junio de 2020. Aunque si lo prefieres también puedes esperar a la llegada de Debian 10 Buster que podría y digo podría llegar este verano.

Lunes 11 de junio de 2018

¿Cómo funcionan los sistemas de archivos basados en FAT?

Voy a dedicar unas entradas en el blog a hablar del funcionamiento de los sistemas de archivos, un componente fundamental en la gran mayoría de sistemas informáticos. Voy a empezar con los basados en FAT sin centrarme en ninguno en concreto (FAT16, FAT32, exFAT,…). Intentaré escribir también sobre inodos y mecanismos más raros y avanzados.

En esencia un sistema de archivos es un método ordenado que permite guardar datos sobre un soporte físico para luego poder acceder a ellos. Históricamente ha habido muchos enfoques a este problema: los sistemas más usados usan archivos, directorios y enlaces.

Bloques y sectores: la división del disco

Esta parte es común a muchos sistemas de archivos, tanto FAT como inodos, como otros. A nivel físico los dipositivos están divididos. En el caso del disco duro, el dispositivo de almacenamiento más común, los discos se dividen en sectores de N bytes, según parámetros de la fabricación. Estos sectores cuentan con código de control de errores incorporado y todo ello es manejado por la controladora de disco que opera ajena al sistema operativo. Los sistemas de archivos dividen a su vez el disco en bloques. Es importante dejar claro que bloque no es igual a sector. El bloque es una división que hace el sistema de archivos y los sectores los hace la controladora de disco. Usualmente un bloque equivale a varios sectores, aunque la equivalencia real depende del sistema de archivos en concreto.

Algunos bloques especiales: boot y superbloque y raíz

Antes de entrar en el mecanismo específico de FAT es necesario comentar que en un disco existirán dos bloques de vital importancia ajenos a FAT. El primero es el bloque de boot o arranque (también llamado MBR). Normalmente situado en el sector 0 del disco duro, contiene código para iniciar el sistema operativo. El superbloque suele ser el bloque siguiente, contiene metadatos del sistema de archivos (por ejemplo, puede decir que usamos FAT con bloques de 32KiB, etc). Además en FAT es necesario que exista un fichero siempre, el fichero del directorio raíz.

Directorios

Los directorios o carpetas son archivos como otros cualquiera, solamente que en sus metadatos se indica que es un directorio y no un fichero corriente. Los ficheros de directorios son los encargados de almacenar los metadatos de los ficheros (paras saber si son ficheros, otros directorios, su fecha de modificación, propietario y tamaño entre otros) que se encuentran en el directorio así como una referencia al bloque.

Un fichero en FAT

Vamos al asunto. Supongamos que en un determinado bloque N tenemos un fichero. Este bloque es de 64 KiB. Si un fichero ocupa menos de 64 KiB, perfecto, todos los datos entran en el bloque. Simplemente ajustamos los metadatos de tamaño con el valor correcto y el resto del espacio que queda en el bloque queda inutilizado.

Este espacio perdido se denomina fragmentación interna y dependiendo de los datos que se almacenen en un disco duro, el porcentaje de pérdida puede ser mayor o menor. Evidentemente si tenemos bloques muy grandes y ficheros muy pequeños perderemos mucho espacio debido a la fragmentación interna. Tener bloques muy pequeños y ficheros muy grandes también es problemático pero por otros motivos.

Tipos de fragmentación

En un sistema de archivos existen 3 tipos de fragmentación: interna, externa y de datos. La interna se refiere al espacio perdido en bloques asignados a ficheros que no están llenos por completo. La externa se refiere al espacio que perdemos por no tener un espacio libre contiguo lo suficientemente grande como para guardar el fichero allí. Ningún sistema FAT o de inodos tiene fragmentación externa al usar todos bloques de tamaño predefinido. Por último la fragmentación de datos, o fragmentación a secas, se refiere a que los bloques asignados estén contiguos o no. Esto tiene implicaciones a nivel de rendimiento pero no al número de bytes que se vuelven inútiles como los otros dos tipos de fragmentación.

¿Pero qué pasa si el contenido de nuestro fichero no puede entrar en el tamaño de bloque? Aquí viene la gracia de FAT, la File-Allocation-Table. La FAT es una tabla compuesta por entradas que indican el siguiente bloque del archivo. La tabla está indexada por bloque y además de indicar cuál es el siguiente bloque del archivo también indica si el archivo acaba ahí o si ese bloque está libre y puede usarse para un archivo nuevo.

En la foto el archivo /home/user/hola.txt tiene una longitud menor al tamaño de bloque. Así que miramos en la FAT la entrada 150 y efectivamente comprobamos que no hay bloque siguiente ya que es un End-of-File.

Pongamos un ejemplo con un archivo largo. Cada celda de la tabla correspondiente al índice del bloque actual indica el siguiente bloque a leer. Estos bloques pueden estar en cualquier parte. Si en un disco duro muchos ficheros tienen los bloques muy dispersos, se dice que necesita ser desfragmentado.

Conclusiones

FAT es muy rápido si la tabla FAT consigue ser cargada en memoria, ya que obtener los datos necesarios de ella será muy rápido. Desgraciadamente, dependiendo del tamaño del disco duro y del tamaño de los bloques, esta tabla puede ocupar mucho y ser impráctico.

El mecanismo FAT como vemos es simple pero efectivo. Dispone de una fragmentación interna limitada y carece de fragmentación externa. Un inconveniente es que FAT cuando busca un archivo necesita empezar siempre desde el directorio raíz. Esto implica accesos cada vez más lentos a medida que vayamos haciendo carpetas, aunque con sistemas de caché se puede reducir.

El esquema FAT tampoco impone restricciones propiamente dichas al número archivos de un sistema ni a su tamaño. Sin embargo en la práctica suelen existir límites.

Edito: He explicado mejor que significa la fragmentación y sus tipos

La entrada ¿Cómo funcionan los sistemas de archivos basados en FAT? se publicó primero en Adrianistán.

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.

Actualiza el kernel sin reiniciar el ordenador con Ubuntu 18.04

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} Cada vez son más los parches en el kernel que hay disponibles que nos obligan a reiniciar nuestro

Domingo 10 de junio de 2018

Xavier Genestos

Xavier Genestos
SYSADMIT

Linux: RedHat: No package subscription-manager available

Si disponemos de sistemas operativos Linux RedHat Enterprise, hemos visto que el sistema de subscripción :RedHat Network (RHN) para acceder a nuestro repositorio ha cambiado y el nuevo sistema pasa a llamarse: Red Hat Subscription Management (RHSM). Para realizar la migración de un sistema a otro, necesitaremos el comando: subscription-managerEl problema que nos podemos encontrar es que no

Jueves 07 de junio de 2018

Bindings entre Rust y C/C++ con bindgen

Rust es un lenguaje con muchas posibilidades pero existe mucho código ya escrito en librerías de C y C++. Código que ha llevado mucho tiempo, que ha sido probado en miles de escenarios, software maduro y que no compensa reescribir. Afortunadamente podemos reutilizar ese código en nuestras aplicaciones Rust a través de bindings. Los bindings no son más que trozos de código que sirven de pegamento entre lenguajes. Esto es algo que se ha podido hacer desde siempre pero dependiendo de la librería podía llegar a ser muy tedioso. Afortunadamente tenemos bindgen, un programa que permite generar estos bindings de forma automática analizando el código de la librería de C o C++.

En este post veremos como usar SQLite desde Rust usando bindgen.

Instalando bindgen

En primer lugar necesitamos tener instalado Clang 3.9 o superior. En Ubuntu o Debian necesitamos estos paquetes:

sudo apt install llvm-3.9-dev libclang-3.9-dev clang-3.9

Para el resto de plataformas puedes descargar el binario desde la página de descargas de LLVM.

Bindgen permite dos modos de uso: línea de comandos o desde el código Rust. El más habitual es desde código Rust pero antes veremos el modo en línea de comandos.

Modo línea de comandos

Para bindings sencillos podemos usar el modo línea de comandos. Instalamos binden con Cargo:

cargo install bindgen

Su uso es muy sencillo:

bindgen /usr/include/sqlite3.h -o sqlite.rs

Simplemente indicamos el fichero de cabecera que queremos traducir y su correspondiente fichero de salida en Rust. Este fichero será el pegamento. Vamos a crear un programa que use este pegamento:

mod sqlite;

use sqlite::{sqlite3_open, sqlite3_exec, sqlite3_close, SQLITE_OK};
use std::ffi::CString;
use std::ptr::{null_mut,null};

fn main(){
    let mut db = null_mut();
    let database_name = CString::new("test.db").unwrap().into_raw();
    let sql = CString::new("
    CREATE TABLE contacts (name TEXT, tel TEXT);
    INSERT INTO contacts VALUES ('Adrian','555-555-555');").unwrap().into_raw(); 
    let mut error_msg = null_mut();
    unsafe{
        sqlite3_open(database_name,&mut db);
        let rc = sqlite3_exec(db,sql,None,null_mut(),&mut error_msg);
        if rc != SQLITE_OK as i32 {
            let error = CString::from_raw(error_msg);
            println!("ERROR: {}",error.into_string().unwrap());
        }
        sqlite3_close(db);
    }
}

Como se puede apreciar, las llamadas al módulo de pegamento de hacen desde un bloque unsafe ya que se van a usar punteros al estilo C, de forma insegura. Hace tiempo escribí sobre ello así que voy a saltarme esa parte.

Compilamos enlazando de forma manual libsqlite3 de la siguiente forma:

rustc main.rs -lsqlite3

Si todo va bien, compilará aunque con numerosos warnings. En principio no son importantes.

Ahora si ejecutamos el programa resultante debería crear una base de datos nueva con una tabla contacts y los datos insertados.

¡Hemos conseguido llamar a una librería de C desde Rust y no hemos escrito ningún binding!

Build.rs

El sistema anterior funciona, pero no es lo más práctico, además no usa Cargo que es el sistema estándar de construcción de programas y crates un Rust. Lo habitual es dejar este proceso automatizado en el fichero build.rs que se ejecuta con Cargo.

Lo primero es añadir la siguiente línea al fichero Cargo.toml:

[build-requires]
bindgen = "0.26.3"

El siguiente paso consiste en crear un archivo cabecera de C que a su vez haga referencia a todos los archivos de cabecera que necesitamos. En el caso de SQLite es bastante simple.

#include <sqlite3.h>

Y lo llamamos wrapper.h

Ahora viene lo interesante. Dentro de build.rs creamos un programa que gracias a la API de bindgen haga lo mismo que la línea de comandos.

extern crate bindgen;

use std::env;
use std::path::PathBuf;

fn main() {
    // indicamos al linker que necesitamos sqlite3
    println!("cargo:rustc-link-lib=sqlite3");


    let bindings = bindgen::Builder::default()
        .header("wrapper.h")
        .generate()
        .expect("Unable to generate bindings");

    // escribir los bindings en $OUT_DIR/bindings.rs
    let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
    bindings
        .write_to_file(out_path.join("bindings.rs"))
        .expect("Couldn't write bindings!");
}

El archivo build.rs debe estar en la misma carpeta que Cargo.toml para que funcione.

Finalmente para hacer accesible nuestros bindings creamos un módulo llamado sqlite.rs con el siguiente contenido.

#![allow(non_upper_case_globals)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]

include!(concat!(env!("OUT_DIR"), "/bindings.rs"));

Lo único que hace es desactivar unos warnings molestos e incluir el texto de bindings.rs al completo.

Una vez hecho esto podemos usar desde el programa principal la librería de la misma forma que hemos visto antes.

Ahora podríamos usar estos bindings directamente en nuestro programa o rustizarlos (darles una capa segura alrededor e idiomática) y subirlo a Crates.io.

El código del post está en GitHub

La entrada Bindings entre Rust y C/C++ con bindgen se publicó primero en Adrianistán.

Usar XeTeX en LibreOffice Writer

Solo en las expresiones matemáticas, eso sí. Ya hablé de TeXMaths por aquí, pero hoy quiero volver a esta extensión ya que a partir de la versión 0.46 nos ofrece algo simplemente magnífico: ¡soporte completo para XƎTEX y el paquete unicode-math! ¡Esto quiere decir que podemos utilizar cualquier fuente matemática para construir nuestras expresiones! La … Sigue leyendo Usar XeTeX en LibreOffice Writer

Miércoles 06 de junio de 2018

Como tenía que haber hecho Microsoft con Github para demostrar su “amor al open source”

Valga por delante que es una opinión subjetiva en plan cuñado…pero tengo ganas de compartirla.

Micro$oft después de comprar Github tenía que haber hecho lo siguiente, separar en dos la compañía:

  • Por un lado la compañía github tal como está para repositorios privados y empresa, ofreciendo el mismo servicio que ahora.
  • Por el otro crear una fundación.

Vamos con la parte de fundación que es lo importante.

La fundación tenía que haber sido como la fundación Mozilla o la fundación Apache, un organismo libre y autónomo.

En la formación de la fundación tendría que:

  • Haber estado más actores en la fundación como la FSF, otras empresas competidoras como Redhat u otras por ejemplo Fundación Mozilla, para recalcar la independencia por reparto de poderes.
  • Haber liberado el código fuente github, estilo como gitlab
  • y en la fundación se quedará con los proyectos libres ya de antes como Atom, Electron y otros
  • Haber movido ahí todos los repositorios públicos.
  • Para rematar el pulpogato y la marca github (dominio y toda la pesca) se hubiera quedado en la fundación.

Así si podríamos decir que si que Microsoft está caminando fuera del lado oscuro.

Github ha muerto…bueno lo han asesinado

Github era un repositorio para proyectos usando git, comenzó antes del 15M, en el 2011. Antes de el había otros pesos pesados en terreno como viejo amado/odiado Sourceforge y otros mas o menos bizarros como Launchpad.

Poco a poco fue comiendole el terreno a Sourceforge, hasta que al final le arrebató la posición de Forja de proyecto….open source puto open source (ese es uno de los problemas que arrastraba Github antes de su asesinato).

Esta victoria sobre Sourceforge, imitó en mucho a la lucha entra Google y Yahoo, en sentido que Yahoo un viejo pesado de los buscadores de internet (bueno quien no recuerda Altavista) que la página principal era puro barroco, sobrecargada como una choni va sobrecargada de alajas, pulseras y maquillaje al botellón del parking del centro comercial, y Google que venía limpio sin ser un portal recargado, era casi una página en blanco…recuerdo una conferencia de hace años pero no recuerdo el titulo que contaba que “cuando comenzó Google recibía un misterioso email cada semana con un número que iba creciendo, hasta que supieron que era el número de enlaces en la portada”. Pues la misma lucha, el viejo Sourceforge cargado de mierdas y joyas como una vieja ppera saliendo de misa un domingo y Github limpio como un joven albino sin espinillas.

También Github marco una diferencia clave frente a SourceForge, es que cambio el concepto de forja, antes las forjas eran orientadas a Proyecto, todo se articulaba entorno al Proyecto, para empezar en Sourceforge tenias que o hacer un Proyecto nuevo o unirte a uno, donde ya aunque no se quisiera había unas dinámicas. Y Github cambio eso, ahora todo se articulaba entorno a los Repositorios y era todo mas rollo orgía y caos (amable lector recuerda caos != anarkia ) de uy yo te forkeo tu Repositorio a ti, uy yo te lo forkeo a ti este otro. Lo que daba una libertada muy interesante, sobre todo con egocentricos desarrolladores, en plan “no aceptas mi parche…pues me forkeo tu proyecto con casinos y furcias” y entonces empezaba la carrera (veías en árbol de forks) que algunas ganaba el de los casinos y furcias y el egocentrico o desaparecía o tenia que aceptar el parche.

Pero Github siempre a cojeado, primero porque nunca a liberado nada de código (importante o interesante), vamos que no ha hecho como WordPress o Gitlab en plan mira nos basamos en este proyecto libre pero te ofrecemos una solución en plan SAS en nuestros servidores para que no te compliques.

Y en otra cosa que ha cojeado es en el tipo de gente que iba a su discoteca, como iban del rollito open source en vez de software libre, mucho de los niñatos con portátil blanco de la manzanita que decían. “Oye que MacOs es Unix y tengo terminal y entonces es mejor que GNU/Linux” y que no programaban en lenguajes de verdad, les encanto la discoteca Github, ahí los veías en starbucks, bibliotecas con sus portatiles blancos con pegatinas de Facebook y el pulpogato de Github. Los hipster de la informática (e incluso hipster de verdad), gente carente de profundidad para analizar el porque del movimiento y que colaboraban con el capitalismo con la tontería del open source.

Entonces Github, se convirtió en el basurero:

  • de millones de holas mundos
  • de millones de practicas de informática
  • de millones de proyectos a medias en nodejs
  • de millones de proyectos open source de videojuegos hechos en Unity3D…tus cojones 23 eso es como hacer un software libre en Flash.
  • de millones de proyectos a medias hechos en micro$oft .Net

Tengo que decir que hace unos meses, github mejoro mucho cuando metieron “etiquetas” a los repos, por lo menos no necesitabas AwesomeLists para filtrar entre tanta mierda, y forzaba a los usuarios a que si querían aparecer en algún lado tenían que etiquetar sus repositorios.

Del interfaz de Github no tengo ninguna queja, es simple y limpio, me recuerda la vieja y cerrada forja de Google Code. Quizá el rollo la sección en los Repositorios de Projects me parece un poco forzar a usar la metodología Kanban frente a otras ni mejores ni peores, distintas.

Y bueno también hay que recordar a Atom el editor basado en Electron (un navegador con solo la página sin barras ni nada) ¿Quién recuerda de la Mozilla fundation el proyecto Prisma? Aunque no lo creáis le cogí cariño a este Editor este último año, porque estaba muy bien el rollo de los plugins que tiene (yo use mucho, uno de FTP) y el fuzzy finder para buscar y lo de que todos los atajos de teclado se podían llegar desde un menú que salía con ctrl+may+p. Aunque también hay que decir el mamoncete de Atom comía memoría y tenia lag como el solo (para mejor la velocidad lo primero que tenias que hacer era quitar su plugin estrella del mapa del fichero), me recordaba de lento al viejo y querido Eclipse. Pues la pregunta que sera de el ahora que Github esta en manos de Micro$oft.

Bueno volviendo al tema, ayer o así escribí en el twitter (a ver si me paso a las redes sociales libres):

El tema es Microsoft usa el software libre (ahora porque hace años nos acusaba de comer niños) para acercar a la gente a sus productos y estándares, ejemplo .net, su editor, su formato de office. En vez de al revés, el acercarse al software libre y a los estándares que ya existen

Este artículo en la wikipedia que explica bien la táctica de Microsoft. Adoptar, extender y extinguir.

Vamos la imagen de arriba que acompaña el articulo, porque como:

  • microsoft jodió Nokia eso fue un escandalo, encima cuando estaba apostando por el software libre con Maemo. Menos mal que se fue a la puta el puto windows phone.
  • microsoft jodió Minecraft, que originalmente el autor (el gordo friki de Notch) iba a liberar el juego cuando vendiera lo suficiente, no lo digo yo…menos mal que archive.org existe https://web.archive.org/web/20100301103851/http://www.minecraft.net:80/about.jsp y al final el gordo friki cogió la pasta y huyo. Menos mal que tenemos Minetest.
  • linkedin ya estaba jodido de antes…que vergüenza de página a nivel técnico…a otros niveles pues ya sabéis es el sitio donde la gente que ha estudiado ADE se siente importante y donde las estúpidas que han estudiado psicología y tienen la empatia de un psicópata están de recursos humanos ahí dorando la píldora y mintiendo mas que hablan para cazar a incautos ingenieros y esclavizarlos.
  • falta que dolió mucho, Sega con su última videoconsola Dreamcast, que llevaba de serie Windows CE, si bien ella se murió sola, rápido Microsoft no dejo enfriar el cadáver y cual carroñero saco lo que necesito para crear la primera Xbox….que que casualidad el sistema de ficheros de los juegos era casi igual al de la consola de Sega.

Bueno Miguel y ahora cual es la solución.

Pues no tengo respuestas en la mano, yo de momento he empezado la migración de mis proyectos a Gitlab

Como por ejemplo el solitario cutrecillo hecho en C y SDL que hice hace años.

El proceso que hago es migrar el proyecto Gitlab, y borrar todo el historial de commits (ojo que si no esta migrado pierdes todo…salvo que tengas copia) y después subir un articulo de la FSF de Upgrade from Windows.

No es la gran solución pero bueno es la que he encontrado, me gustaría ser valiente y pasarlos a Savannah.

O probar cosas tan exotéricas como Mango que es IPFS + Git, pero creo que lo importante es que sea fácil de usar para la gente y para los no iniciados. Pero mola ese rollo de un sistema de archivos distribuido en internet y sobre el Git, hay un articulo curioso sobre ello en Mango: Git completely decentralised .

Hay que seguir investigando y sacarle el dedo al puto microsoft como hizo Linus Torvals a Nvidia.

Y por cierto y como palabras finales, Microsoft si ya ha hecho daño al software libre. Porqué aunque malo era Github, mas o menos ya había crecido comunidades y proyectos entorno a el, y ahora después del bombardeo a Github con la compra, esta todo el mundo huyendo y no hay un referente claro…todavía no hay un bandle “Fork me XXX”.

Actualización: Se me olvido poner el link del análisis de la FSF del 2015 sobre Forjas de proyectos. GNU Ethical Repository Criteria Evaluations

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.

Ubuntizando.com

Ubuntizando.com
Ubuntizando.com

Dell presenta su famila de portátiles con Ubuntu

No sé si sabéis que Dell fue una de las primeras compañías en apostar por GNU/Linux en el sector de la informática doméstica. Años atrás Dell y Microsoft tuvieron un “pequeño encontronazo” que hizo a la compañía buscar alternativas encontrando en GNU/Linux una buena solución. Con el tiempo Dell ha ido aumentando su apoyo y presencia al sistema del pingüino gracias en buena parte a la buena acogida que tuvo Ubuntu en sus orígenes. Mucho tiempo atrás en una galaxia muy muy lejana…

Batallitas de abuelo a un lado. Dell acaba de anunciar la renovación de su familia de portátiles Precision, concretamente los modelos 3530, 5530, 7530 y 7730. Se tratan de estaciones de trabajo profesionales cuyo precio base es de 943 dólares y, como viene siendo habitual en Dell, que podemos personalizar en el momento de realizar nuestra compra. Así la configuración base es la siguiente:

  • 15.6″ HD (1366×768) non-touch display
  • Procesador  Intel i5-8400H (Quadcore @ 2.50GHz)
  • 4GB RAM
  • Gráfica Intel UHD 630
  • Sin teclado retroiluminado
  • Ubuntu Linux

Esta configuración puede parecer un poco de “chichinabo” pero a poco que toquemos podemos hacernos con un Dell Precision 5530 developer edition con gráfica NVIDIA Quadro P2000 o con un Dell Precision 7730 y su impresionante pantalla de 17 pulgadas.

Todos los equipos DELL cuentan con certificación RHEL para su uso con Red Hat Enterprise Linux 7.5. Este es un detalle importante porque garantiza cero problemas a la hora de instalar esta u otra distribución Linux y si eres una empresa “de las grandes” ya sabes que estos equipos están listos para comenzar a trabajar desde el primer día.

Ubuntizando.com

Ubuntizando.com
Ubuntizando.com

Cómo ejecutar varias tareas simultáneamente en el terminal con GNU Parallel

No sé si lo sabéis. En estos dos últimos meses estoy haciendo unas prácticas profesionales en Reino Unido y a veces me toca hacer de informático friki lanzando comandos a diestro y siniestro en plan nadie entiende lo que hago pero funciona. Bromas a parte lo que tengo claro es que la línea de comandos es especialmente útil para realizar todo tipo de tareas. También es la razón de que últimamente me cueste un poco más mantener el blog al día pero aquí seguimos.  😉

Muchos dirán que usar el terminal en un mundo dominado por los escritorios es un error pero lo que no saben es que es posible realizar tantas tareas como queramos simultáneamente. GNU Parallel ofrece la posibilidad de sacarle más partido a nuestro sistema ejecutando desde una misma línea varios comandos al mismo tiempo. Esto nos hará ahorrarnos una importante cantidad de tiempo.

Su funcionamiento es muy sencillo, disponible en prácticamente todas las distribuciones GNU/Linux. Por ejemplo. imagina que tienes que renombrar un montón y editar un montón de imágenes. En lugar de ir una a uno o lanzar varias ordenes podrías hacerlo siguiente:

find /home -name "*.jpg" | parallel -I% --max-args 1 convert % %.png

Con esta instrucción realizamos una búsqueda de las imágenes .jpg disponibles y gracias a parallel cambiar el nombre y tipo de nuestra imagen a otro formato. Así de simple. Una muestra del potencial que ofrece parallel para todo tipo de usuarios. Si quieres descubrir más usos en el siguiente enlace tienes algunos ejemplos. ¿Muy útil verdad?

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.

Lunes 28 de mayo de 2018

Gaspar Fernández

Gaspar Fernández
Poesía Binaria

Ejemplo para analizar y procesar expresiones matemáticas (y más) en PHP (Parsear en PHP)

Parsear expresiones en PHP

Una de las mayores armas de doble filo en cuanto a los lenguajes de programación interpretados es la función o expresión eval. Esta orden nos suele permitir escribir una cadena de caracteres con un texto en el mismo lenguaje que estamos escribiendo y ejecutarla. Es decir, si nos encontramos en Python y escribimos:

1
eval("100+23")

Devolverá 123. O si estamos en PHP y hacemos:

1
2
<?php
eval("echo 100+23;");

En la cadena de caracteres que introducimos podemos utilizar variables, bucles, condiciones… vamos, todo lo que nos permite el lenguaje de programación. Lo que ponemos en la cadena se ejecutará de forma nativa en el lenguaje. Esto puede ser muy útil a veces. Pero tendremos que pensar un poco antes de utilizarlo.

Peligros de utilizar eval

Quiero hacer una introducción más o menos rápida y sin centrarme en un lenguaje de programación. En principio, hemos visto que eval() admite una cadena de caracteres como entrada. Si pensamos un poco, que esa cadena de caracteres sea fija, es decir, que en nuestro programa tuviera algo como los ejemplos de arriba no tiene mucho sentido, porque podemos prescindir de eval y todo se ejecutaría igual. Bueno, es cierto que en algunos casos concretos nos puede interesar la pequeña pérdida de tiempo que introduce eval(), aunque hay formas más elegantes de hacerlo. O incluso podemos hacer que el lenguaje que estemos utilizando no utilice el caché de la expresión que estamos escribiendo. Pero son, de hecho casos muy raros y excepcionales.

Otro de los usos es construir una cadena de caracteres nosotros mismos, en tiempo de ejecución y pasárselo a eval(). En este caso, podemos sacar de una base de datos un fragmento de código para ejecutar o incluso el usuario puede introducir una expresión en un formulario y nosotros ejecutarlo. Imaginad que le pedimos al usuario una fórmula para calcular el precio de venta de un producto y claro, al usuario no vamos a pedirle programación. Eso sí, podemos tener un grave agujero de seguridad en nuestra aplicación. Sencillamente, porque eval() va a ejecutar todo lo que nosotros le pasemos. Lo mismo hace operaciones matemáticas, que llamada a cualquier función del lenguaje y ahí está el problema, al usuario no le podemos dar tanto control. Un gran poder conlleva una gran responsabilidad y, otra cosa no, pero el usuario, de responsable tiene poco y, sobre todo si estamos hablando de una plataforma web en la que cualquiera podría explotar una vulnerabilidad, mucho más.

Incluso si se nos ocurre filtrar lo que le pasamos a eval(), acotando el número de expresiones que le pasamos y cómo se lo pasamos, no me fiaría yo mucho de que algún usuario malintencionado fuera capaz de, incluso pasando los filtros, ejecutar código malicioso. Así que, mi consejo, es que si alguna vez ejecutamos eval() sea solo para hacer pruebas, a la hora de hacer tests de nuestro programa y algún caso contado más, pero no hacerlo con código en producción.

Expresiones del usuario

Así que, ¿qué hacemos si aún así queremos que el usuario ejecute sus propias expresiones? No nos queda otra que analizar nosotros la expresión, y evaluarla. Como si estuviéramos programando un intérprete de un lenguaje de programación nosotros mismos. Así que, manos a la obra, vamos a construir un parser que analice una expresión y luego la procesaremos. Este programa tendrá algunas expresiones internas que evaluará directamente, aunque luego tendremos la opción de añadir funciones personalizadas.

Atención: El código que voy a mostrar tiene ya un tiempo, aunque para escribir el post me he asegurado de que funciona con PHP7. Está basado en un código de hack.code.it de hace mucho tiempo, retocado y con algunas mejoras por mi parte.

No pretendo crear un lenguaje de programación, solo un sistema en el que los usuarios puedan pasar de forma segura expresiones matemáticas, pueda analizarlas, evaluarlas y dar un resultado. Aunque todo se puede complicar, podemos utilizar funciones como senos, cosenos, raíces, etc, incluso funciones creadas por nosotros. Y debemos tener una manera de decirle las funciones que admitimos.

Programando…

Vale, voy a poner un montón de código por aquí, para tener funcionando esto. El código puede tener bugs, y, por supuesto podéis enviármelos para que poco a poco vayamos mejorando el programa. Yo lo he utilizado para unos pocos casos, pero realmente son muy pocos. El script soporta funciones, variables y operaciones como suma, resta, multiplicación, división y potencia.

Primero, aunque no utilizaremos ningún paquete, vamos a configurar composer para generar el autoload de los ficheros:
composer.json:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
{
    "name": "gasparfm/simplePHPexpr",
    "keywords": ["math", "expressions", "functions"],
    "homepage": "https://github.com/gasparfm/simplePHPexpr",
    "description": "An expression parser in PHP",
    "license": "MIT",
    "authors": [
        {
            "name": "smassey",
            "homepage": "http://codehackit.blogspot.fr/"
        },{
            "name": "Gaspar Fernández",
            "homepage": "https://gaspar.totaki.com/"
        }
    ],
    "require": {
        "php": ">=5.6"
    },
    "autoload":     {
        "psr-0": {
            "spex": "src/"
        }
    }
}

Crearemos un fichero principal (main.php) en el mismo directorio que composer.json. El esquema de archivos y directorios será el siguiente

|- composer.json
|- main.php
|- src/
| |-spex/
| | |-exceptions/
| | | |- DivisionByZeroException.php
| | | |- MaxDepthException.php
| | | |- OutOfScopeException.php
| | | |- ParseTreeNotFoundException.php
| | | |- ParsingException.php
| | | |- UnknownFunctionException.php
| | | |- UnknownTokenException.php
| | |-scopes/
| | | |- Scope.php
| | | |- FunScope.php
| | |- Parser.php
| | |- Util.php

spex/Parser.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
<?php
namespace spex;

/**
 * this model handles the tokenizing, the context stack functions, and
 * the parsing (token list to tree trans).
 * as well as an evaluate method which delegates to the global scopes evaluate.
 */


class Parser {
    protected $_content = null;
    protected $_context_stack = array();
    protected $_tree = null;
    protected $_tokens = array();
    protected $_options;

    public function __construct($options = array(), $content = null) {
        $this->_options = $options;
        if ( $content ) {
            $this->set_content( $content );
        }
    }

    /**
     * this function does some simple syntax cleaning:
     * - removes all spaces
     * - replaces '**' by '^'
     * then it runs a regex to split the contents into tokens. the set
     * of possible tokens in this case is predefined to numbers (ints of floats)
     * math operators (*, -, +, /, **, ^) and parentheses.
     */

    public function tokenize() {
        $this->_content = str_replace(array("\n","\r","\t"), '', $this->_content);
        $this->_content = preg_replace('~"[^"\\\\]*(?:\\\\.[^"\\\\]*)*"(*SKIP)(*F)|\'[^\'\\\\]*(?:\\\\.[^\'\\\\]*)*\'(*SKIP)(*F)|\s+~', '', $this->_content);
        $this->_content = str_replace('**', '^', $this->_content);
        $this->_content = str_replace('PI', (string)PI(), $this->_content);
        $this->_tokens = preg_split(
            '@([\d\.]+)|([a-zA-Z_]+\(|,|=|\+|\-|\*|/|\^|\(|\))@',
            $this->_content,
            null,
            PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY
        );
        return $this;
    }

    /**
     * this is the the loop that transforms the tokens array into
     * a tree structure.
     */

    public function parse() {
        # this is the global scope which will contain the entire tree
       $this->pushContext( new \spex\scopes\Scope($this->_options) );
        foreach ( $this->_tokens as $token ) {
            # get the last context model from the context stack,
            # and have it handle the next token
            $this->getContext()->handleToken( $token );
        }
        $this->_tree = $this->popContext();

        return $this;
    }

    public function evaluate() {
        if ( ! $this->_tree ) {
            throw new \spex\exceptions\ParseTreeNotFoundException();
        }
        return $this->_tree->evaluate();
    }

    /*** accessors and mutators ***/

    public function getTree() {
        return $this->_tree;
    }

    public function setContent($content = null) {
        $this->_content = $content;
        return $this;
    }

    public function getTokens() {
        return $this->_tokens;
    }


    /*******************************************************
     * the context stack functions. for the stack im using
     * an array with the functions array_push, array_pop,
     * and end to push, pop, and get the current element
     * from the stack.
     *******************************************************/


    public function pushContext(  $context ) {
        array_push( $this->_context_stack, $context );
        $this->getContext()->setBuilder( $this );
    }

    public function popContext() {
        return array_pop( $this->_context_stack );
    }

    public function getContext() {
        return end( $this->_context_stack );
    }
}

spex/Util.php
Este archivo proporciona compatibilidad con PHP5. Podemos adaptar el código para PHP7 y eliminar esta dependencia.

1
2
3
4
5
6
7
8
9
<?php
namespace spex;

class Util {
    public static function av($arr, $key, $default=null) {
        return (isset($arr[$key]))?$arr[$key]:$default;
    }

};

spex/scopes/Scope.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
<?php
namespace spex\scopes;

class Scope {
    protected $_builder = null;
    protected $_children_contexts = array();
    protected $_raw_content = array();
    protected $_operations = array();
    protected $options = array();
    protected $depth = 0;

    const T_NUMBER = 1;
    const T_OPERATOR = 2;
    const T_SCOPE_OPEN = 3;
    const T_SCOPE_CLOSE = 4;
    const T_FUNC_SCOPE_OPEN = 5;
    const T_SEPARATOR = 6;
    const T_VARIABLE = 7;
    const T_STR = 8;

    public function __construct(&$options, $depth=0) {
        $this->options = &$options;
        if (!isset($this->options['variables']))
            $this->options['variables'] = array();

        $this->depth = $depth;
        $maxdepth = \spex\Util::av($options, 'maxdepth',0);
        if ( ($maxdepth) && ($this->depth > $maxdepth) )
            throw new \spex\exceptions\MaxDepthException($maxdepth);
    }

    public function setBuilder( \spex\Parser $builder ) {
        $this->_builder = $builder;
    }

    public function __toString() {
        return implode('', $this->_raw_content);
    }

    protected function addOperation( $operation ) {
        $this->_operations[] = $operation;
    }

    protected function searchFunction ($functionName) {
        $functions = \spex\Util::av($this->options, 'functions', array());
        $func = \spex\Util::av($functions, $functionName);
        if (!$func)
            throw new \spex\exceptions\UnknownFunctionException($functionName);

        return $func;
    }

    /**
     * handle the next token from the tokenized list. example actions
     * on a token would be to add it to the current context expression list,
     * to push a new context on the the context stack, or pop a context off the
     * stack.
     */

    public function handleToken( $token ) {
        $type = null;
        $data = array();

        if ( in_array( $token, array('*','/','+','-','^','=') ) )
            $type = self::T_OPERATOR;
        if ( $token == ',' )
            $type = self::T_SEPARATOR;
        if ( $token === ')' )
            $type = self::T_SCOPE_CLOSE;
        if ( $token === '(' )
            $type = self::T_SCOPE_OPEN;
        if ( preg_match('/^([a-zA-Z_]+)\($/', $token, $matches) ) {
            $data['function'] = $matches[1];
            $type = self::T_FUNC_SCOPE_OPEN;
        }

        if ( is_null( $type ) ) {
            if ( is_numeric( $token ) ) {
                $type = self::T_NUMBER;
                $token = (float)$token;
            } elseif (preg_match('/^".*"$|^\'.*\'$/', $token)) {
                $type = self::T_STR;
            } elseif (preg_match('/^[a-zA-Z_][a-zA-Z0-9_]*$/', $token)) {
                $type = self::T_VARIABLE;
            } else
                  echo "**".$token."**";
        }

        switch ( $type ) {
            case self::T_NUMBER:
            case self::T_OPERATOR:
                $this->_operations[] = $token;
                break;
            case self::T_STR:
                $delim = $token[0];
                $this->_operations[] = str_replace('\'.$delim, $delim, substr($token, 1, -1)) ;
                break;
            case self::T_VARIABLE:
                $this->_operations[] = array('
v', $token);
                break;
            case self::T_SEPARATOR:
                break;
            case self::T_SCOPE_OPEN:
                $this->_builder->pushContext( new namespace\Scope($this->options, $this->depth+1) );
            break;
            case self::T_FUNC_SCOPE_OPEN:
                $this->_builder->pushContext( new namespace\FunScope($this->options, $this->depth+1, $this->searchFunction($data['
function'])) );
            break;
            case self::T_SCOPE_CLOSE:
                $scope_operation = $this->_builder->popContext();
                $new_context = $this->_builder->getContext();
                if ( is_null( $scope_operation ) || ( ! $new_context ) ) {
                    # this means there are more closing parentheses than openning
                    throw new \spex\exceptions\OutOfScopeException();
                }
                $new_context->addOperation( $scope_operation );
            break;
            default:
                throw new \spex\exceptions\UnknownTokenException($token);
            break;
        }
    }

    private function isOperation($operation) {
        return ( in_array( $operation, array('
^','*','/','+','-','='), true ) );
    }

    protected function setVar($var, $value) {
        $this->options['
variables'][$var] = $value;
    }

    protected function getVar($var) {
        return \spex\Util::av($this->options['
variables'], $var, 0);
    }

    protected function getValue($val) {
        if (is_array($val)) {
            switch (\spex\Util::av($val, 0)) {
                case '
v': return $this->getVar(\spex\Util::av($val, 1));
                default:
                    throw new \spex\exceptions\UnknownValueException();
            }
        }
        return $val;
    }
    /**
     * order of operations:
     * - parentheses, these should all ready be executed before this method is called
     * - exponents, first order
     * - mult/divi, second order
     * - addi/subt, third order
     */
    protected function expressionLoop( & $operation_list ) {
        while ( list( $i, $operation ) = each ( $operation_list ) ) {
            if ( ! $this->isOperation($operation) )
                continue;
            $left =  isset( $operation_list[ $i - 1 ] ) ? $operation_list[ $i - 1 ] : null;
            $right = isset( $operation_list[ $i + 1 ] ) ? $operation_list[ $i + 1 ] : null;

            if ( (is_array($right)) && ($right[0]=='
v') )
                $right = $this->getVar($right[1]);
            if ( ($operation!='
=') && ( (is_array($left)) && ($left[0]=='v') ) )
                $left = $this->getVar($left[1]);

            if ( is_null( $right ) ) throw new \Exception('
syntax error');

            $first_order = ( in_array('
^', $operation_list, true) );
            $second_order = ( in_array('
*', $operation_list, true ) || in_array('/', $operation_list, true ) );
            $third_order = ( in_array('
-', $operation_list, true ) || in_array('+', $operation_list, true )|| in_array('=', $operation_list, true ) );
            $remove_sides = true;
            if ( $first_order ) {
                switch( $operation ) {
                    case '
^': $operation_list[ $i ] = pow( (float)$left, (float)$right ); break;
                    default: $remove_sides = false; break;
                }
            } elseif ( $second_order ) {
                switch ( $operation ) {
                    case '
*': $operation_list[ $i ] = (float)($left * $right); break;
                    case '
/':
                        if ($right==0)
                            throw new \spex\exceptions\DivisionByZeroException();
                        $operation_list[ $i ] = (float)($left / $right); break;
                    default: $remove_sides = false; break;
                }
            } elseif ( $third_order ) {
                switch ( $operation ) {
                    case '
+': $operation_list[ $i ] = (float)($left + $right);  break;
                    case '
-': $operation_list[ $i ] = (float)($left - $right);  break;
                    case '
=': $this->setVar($left[1], $right); $operation_list[$i]=$right; break;
                    default: $remove_sides = false; break;
                }
            }

            if ( $remove_sides ) {
                if (!$this->isOperation($operation_list[ $i + 1 ]))
                    unset($operation_list[ $i + 1 ]);
                unset ($operation_list[ $i - 1 ] );
                $operation_list = array_values( $operation_list );
                reset( $operation_list );
            }
        }
        if ( count( $operation_list ) === 1 ) {
            $val = end($operation_list );
            return $this->getValue($val);
        }
        return $operation_list;
    }

    # order of operations:
    # - sub scopes first
    # - multiplication, division
    # - addition, subtraction
    # evaluating all the sub scopes (recursivly):
    public function evaluate() {
        foreach ( $this->_operations as $i => $operation ) {
            if ( is_object( $operation ) ) {
                $this->_operations[ $i ] = $operation->evaluate();
            }
        }

        $operation_list = $this->_operations;

        while ( true ) {
            $operation_check = $operation_list;
            $result = $this->expressionLoop( $operation_list );

            if ( $result !== false ) return $result;
            if ( $operation_check === $operation_list ) {
                break;
            } else {
                $operation_list = array_values( $operation_list );
                reset( $operation_list );
            }
        }
        throw new \Exception('
failed... here');
    }
}

spex/scopes/FunScope.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?php
namespace spex\scopes;

class FunScope extends namespace\Scope {
    private $fun = null;

    public function __construct(&$options, $depth, $callable) {
        parent::__construct($options, $depth);
        $this->fun = $callable;
    }

    public function evaluate() {
        $arguments = parent::evaluate();
        return call_user_func_array($this->fun, (is_array($arguments))?$arguments:array( $arguments ) );
    }
}

spex/exceptions/UnknownFunctionException.php

1
2
3
4
5
6
7
8
9
10
<?php

namespace spex\exceptions;

class UnknownFunctionException extends \Exception
{
    function __construct($functionName) {
        parent::__construct('Unkown function '. $functionName);
    }
}

spex/exceptions/DivisionByZeroException.php
Todos los archivos de excecpción serán iguales, cambiando el nombre, el objetivo es diferenciar las excepciones para poder capturarlas.

1
2
3
4
5
6
7
<?php

namespace spex\exceptions;

class DivisionByZeroException extends \Exception
{
}

main.php:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
<?php
include('vendor/autoload.php');

$config = array(
    'maxdepth' => 2,
    'functions' => array(
        'sin' => function ($rads) { return sin(deg2rad($rads)); },
        'upper' => function ($str) { return strtoupper($str); },
        'fact' => function ($n) { $r=1; for ($i=2; $i<=$n; ++$i) $r*=$i; return $r; },
        'word' => function ($text, $nword) { $words=explode(' ', $text); return (isset($words[$nword]))?$words[$nword]:''; },
    )
);

$builder = new \spex\Parser($config);

while ( (fputs(STDOUT,'math > ')) && $e = fgets(STDIN) ) {
    if ( ! ($e = trim($e)) ) continue;
    if ( in_array( $e, array('quit','exit',':q') ) ) break;

    try {
        $result = $builder->setContent($e)->tokenize()->parse()->evaluate();
    } catch ( \spex\exceptions\UnknownTokenException $exception ) {
        echo 'unknown token exception thrown in expression: ', $e, PHP_EOL;
        echo 'token: "',$exception->getMessage(),'"',PHP_EOL;
        continue;
    } catch ( \spex\exceptions\ParseTreeNotFoundException $exception ) {
        echo 'parse tree not found (missing content): ', $e, PHP_EOL;
        continue;
    } catch ( \spex\exceptions\OutOfScopeException $exception ) {
        echo 'out of scope exception thrown in: ', $e, PHP_EOL;
        echo 'you should probably count your parentheses', PHP_EOL;
        continue;
    } catch ( \spex\exceptions\DivisionByZeroException $exception ) {
        echo 'division by zero exception thrown in: ', $e, PHP_EOL;
        continue;
    } catch ( \Exception $exception ) {
      echo 'exception thrown in ', $e, PHP_EOL;
      echo $exception->getMessage(), PHP_EOL;
      continue;
    }

    echo $result, PHP_EOL;
}

Probando el programa

Tras todo esto, podemos hacer una ejecución como esta:

php main.php
1+1
2
upper(“hola mundo”)
HOLA MUNDO
fact(10)
3628800
word(“Hola Mundo Mundial”, 1)
Mundo
sin(fact(3))
0.10452846326765

Publicación del código

Quiero publicar en GitHub el código tal y como ha quedado con algunos ejemplos prácticos más en las próximas semanas.

Foto principal: unsplash-logoChris Liverani

The post Ejemplo para analizar y procesar expresiones matemáticas (y más) en PHP (Parsear en PHP) appeared first on Poesía Binaria.

Sábado 26 de mayo de 2018

VPS Windows o Linux GRATIS con LuisiBlog

Estos servidores se mantienen íntegramente gracias a la publicidad de esta página web (LuisiBlog). Si quieres tener un VPS con IP de España de forma totalmente gratis tan solo sigue estos sencillos pasos: Está prohibida su venta de terceros y al usar cualquiera de nuestros recursos estas aceptando nuestras condiciones de uso. Las características de […]

La entrada VPS Windows o Linux GRATIS con LuisiBlog aparece primero en Blog de Informática ✏ Luisi.

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.

Domingo 06 de mayo 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

Sábado 05 de mayo de 2018

Como Virtualizar un Servidor y crear un Cluster

Virtualizar un servidor es básicamente crear mediante software una aglomeración de los recursos para que posteriormente se crear instancias o entornos. Mi recomendación es que si eres una empresa o no tienes conocimientos de informática (Virtualización, redes y subredes) mandes un correo o llames a una empresa especializada. En este caso hay una empresa en […]

La entrada Como Virtualizar un Servidor y crear un Cluster aparece primero en Blog de Informática ✏ Luisi.

Viernes 27 de abril de 2018

Como cumplir las leyes Españolas para tú blog o página

Lo primero es evitar los contenidos con trabas legales como nombrar o usar marcas registradas sin permiso de esta o insultar por medio de nuestra página web, por ejemplo al Rey, o alabar al terrorismo. Así que lo primero es cumplir el Código Penal, aunque estemos en Internet. Si todo esto te resulta aburrido o […]

La entrada Como cumplir las leyes Españolas para tú blog o página aparece primero en Blog de Informática ✏ Luisi.

Martes 10 de abril de 2018

Gorka Urrutia

Gorka Urrutia
Nideaderedes

¿Qué es el acoplamiento de código?

Hoy he publicado un divertido (eso espero) artículo sobre lo que es el acoplamiento de código y cómo evitarlo.

Puedes descargarlo desde la web de PHP Sensei.

Lunes 09 de abril de 2018

Como mejorar el funcionamiento del portátil HP Stream 11 (parte 2)

Posts in this series
  1. Como mejorar el funcionamiento del portátil HP Stream 11 (parte 1)
  2. Como mejorar el funcionamiento del portátil HP Stream 11 (parte 2)

Lo primero que hay que hacer en cualquier portátil o sobremesa es poder arrancar un pendrive USB con un instalador de GNU/Linux. Y para eso es necesario dos cosas: un pendrive USB con un instalador de GNU/Linux y un HP Stream 11 que arranque y se deje instalar por USB un GNU/Linux…ya os adelanto que lo primero es mas sencillo que lo segundo.

un pendrive USB con un instalador de GNU/Linux

Hay muchas alternativas para hacer un pendrive USB autoarrancable, por casualidad en uno de los últimos podcast de Birras & Bits (el titulado BYB 2×08 – Los Testigos de Godot ) el que voy a usar en este tutorial es ETCHER porque es muy muy fácil, dice que tiene soporte para Windows…pero asumo que tu lector eres una persona que ya ha pasado al otro lado del espejo y tiene un ordenador a mano con GNU/Linux, y para crear un pendrive USB autoarrancable necesitamos las siguientes cosas:

  • Un pendríve USB de 1 Gb mínimo y limpio o relleno de cosas sin valor, porque aunque no estoy seguro, pero creo que Etcher cuando pone una imagen de un instalador en un pendrive lo formatea.
  • Una ISO de Debian…¿Por qué Debian? Porque es la que voy a usar para este tutorial, pero si seguro que si te apañas con otra distribución, seguro que cambiando cuatro cosas de las recetas puedes hacer lo mismo. Para descargarla podréis en la página oficial en Installing Debian via the Internet y descargáis el link de “Small CDs or USB sticks” amd64. El cual os descargará un fichero .iso con el instalador de Debian.

Etcher viene en formato appimage (link a la wikipedia inglesa) o un tutorial en español en Cómo usar AppImage en GNU/Linux que recuerda mucho a como se instalan y usan los programas en los ordenadores de la manzana envenenada. Es un formato que viene en un solo fichero todo el programa y no necesita librerías extra ni nada, y se puede instalar.

Al ejecutarlo, salen 3 iconazo enormes en la ventana del programa, que son los pasos que hay que ir haciendo para completar el USB autoarrancable. Y se empieza de izquierda a derecha, y se van a ir iluminando según se van haciendo.

  1. Elegir la ISO en tu carpeta de descargas o donde la tengas.
  2. Elegir el pendrive USB enchufado, OJO mira bien que es un pendrive USB y no otro disco duro que tengas enchufado a la vez en el PC…y recuerda que se va formatear por lo que tenlo vacío o lleno de mierda sin importancia…sin fotos de comunión ni nada.
  3. Flashear, en este punto ya guarda en USB la ISO y la prepara para ser autoarrancable. Te pedirá la contraseña de root o sudo para hacerlo.

Mientras quema la imagen en el USB veras una barra de progreso y un tiempo de espera estimado y después chequeara si lo ha copiado bien y finalmente lo desmonta (para sincronizar como dice el señor Eugenio) para después mostrarte en ventana una bonita/hipster imagen de que lo ha completado.

un HP Stream 11 que arranque y se deje instalar por USB un GNU/Linux

Menuda metedura de pata adrede o no…me da que pensar adrede para evitar que la gente entre a la BIOS, pero para conseguir acceder a la BIOS en un HP Stream 11 necesitas un teclado USB externo, porque para entrar al minimenu previo a elegir las opciones como entrar a la BIOS, elegir sistema de arranque…Hay que hacerlo con la tecla ESC que como digo no la coge muy bien, pero con un teclado externo a la primera te la coge.

En mi caso, tenia por casa un teclado inalámbrico USB que uso para el PC de las pelis y las series en el sofá y con ese me he apañado.

Una vez llegas al minimenu tendrás que pulsar F10 como ves en la siguiente imagen:

Y ya en la BIOS hay un par de cosas que hacer:

  • Quitar el asqueroso caballo de troya de Micro$oft llamado Secure Boot: que es en moviendote a la derecha en las pestañas de arriba, comenzando por Main, vas a Security y otra vez a la derecha “System Configuration”. Ahí vas para abajo hasta “Boot options” y pulsas intro (o enter como vos lo llames), y ahí esta el satánico “Secure boot” activado vas para abajo hasta resaltar su satánica linea y le das intro y te sale un popup para activar o desactivar…si quieres continuar en el camino de la libertad, desactívalo.
  • En esa misma pantalla activa USB Boot y para mayor facilidad sube al primero la opción de arranque para “USB Diskette on Key/USB Hard Disk” con las teclas F5 para bajar y F6 para subir.
  • Y de propina en la pantalla anterior “System Configuration” activa “Virtualization Technology” que te puede venir bien para cosas como XEN o Virtualbox para algún apaño.

Y para guardar la configuración de la BIOS ve a la pestaña de arriba llamada Exit y en la pantalla de salida elige la opción “Exit Saving Changes”.

Al arrancar otra vez el miniportatil, ten enchufado el pendrive con la instalación de GNU/Linux, te saldrá un menú para instalar si todo lo anterior ha ido bien (si te da problemas ESC y después en el minimenu elige F9 para que te salga un menú de posibles opciones de arranque y elijas lanzar el instalador de USB).

La instalación de Debian desde hace años es muy muy sencilla, pero vamos a fijarnos en los siguientes puntos:

  • ¡¡OJO!! NO SE COMO TENÉIS EL HP STREAM 11, en mi caso fue sacarlo de la caja de cartón y hacer lo que os comento en estos artículos para que funcione mejor que con la basura de Windows, pero puede que vosotros lo hagáis con un portátil usado y queráis guardar las fotos de las últimas vacaciones. HACER BACKUP DE VUESTROS FICHEROS.
  • Pero señor MD yo quiero tener Windows en dualboot…PUES BÚSCATE OTRO TUTORIAL, este es para TENER UN SOLO SISTEMA OPERATIVO EN EL PORTÁTIL. A partir de este punto si seguís os va quedar un buen ordenador pero ni rastro de la mierda de windows.
  • En el particionado tenéis que elegir uso completo del disco duro y LVM.
  • Y en un par de pantallas siguientes tenéis que elegir que el directorio /home este separado en una partición.

Y con eso ya esta lo importante para en la instalación para aprovechar la magia del LVM.

Siguiendo con la instalación, en estos tiempos es tan fácil que solo hay que darle siguiente, elegir idioma, elegir claves para el usuario por defecto y usuario root, alguna cosilla mas y después elegir entorno/escritorio. En mi caso elegí Mate porque es la civilización Gnome en su máximo esplendor…después vino la edad media….

Y ya tienes un flamante netbook, ligero y potente porque tiene GNU/Linux, aunque no se vayan todavía porque tenemos para la parte 3 de esta telenovela de tutorial:

  • instalar los drivers privativos de el chip wifi, porque como siempre los cabroncetes de Realtek haciendo tarjetas wifi sin liberar los drivers para GNU/Linux, pero en Debian es fácil de instalar…los no-libres…
  • ponerle sin abrir el HP Stream 11 mas disco duro con la magía que os comente de LVM, por 17€ le he multiplicado por dos el tamaño de disco duro.
  • Y si queda pequeño, comentar como aprovechar la pantalla tan pequeña y la poca RAM de este netbook usando “escritorios frikis” y ligeros como I3 que quita mucha tonteria.

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

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
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.

Martes 27 de febrero de 2018

BlogDRAKE: Caída de Blogdrake

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.

Jueves 22 de febrero de 2018

BlogDRAKE: Dianara 1.4.1 en el repositorio de BlogDrake

Martes 20 de febrero de 2018

BlogDRAKE: Problema de Seguridad en Mageia Identity
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

Lunes 12 de febrero de 2018

Gorka Urrutia

Gorka Urrutia
Nideaderedes

Taller online gratuito de Python

¿Quieres empezar con Python y no sabes por dónde empezar? Pues apúntate a mi taller gratuito de introducción a Python para perderle miedo.

Funcionará a modo de videoconferencia y durará aproximadamente una hora. Nos veremos las caras todos los participantes y podrás preguntar dudas sobre la marcha. Los grupos serán de máximo de cinco personas.

Las fechas aún están por decidir, pero si te interesa apúntate cuanto antes que las plazas son limitadas.

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.

Gorka Urrutia

Gorka Urrutia
Nideaderedes

Taller online de refactorización en PHP

En los próximos días voy a organizar talleres online en los que refactorizaremos código PHP. Aprenderemos cómo convertir una chapuza de código espaguetti en código de calidad yendo a través de pequeñas mejoras. En el taller usaremos buenas prácticas, programación orientada a objetos, interfaces, composición, phpunit, git, etc.

Será divertido y podrás aprender un montón. Requisitos imprescindibles: participación activa, conocimientos de PHP y saber algo de programación orientada a objetos.

PHP Sensei - Nueva sección de trucos sobre PHP

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

Jueves 18 de enero de 2018

Bruno Exposito

Bruno Exposito
The Linux Alchemist

Comando chown – Cambiar el propietario

El comando chown (change owner) permite modificar el dueño de uno o varios ficheros o carpetas.

Está instalados en todas las distribuciones GNU/Linux, dentro del paquete coreutils.

Puedes consultar el listado de usuarios en el fichero /etc/passwd usando el siguiente comando:

 cat /etc/passwd | cut -d ':' -f1

 

chown

Sintaxis de chown

sudo chown {{dueño}}:{{grupo}} {{nuevodueño}} {{fichero-o-carpeta}}

Opciones de chown

-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.
–from=DUEÑO_ACTUAL:GRUPO_ACTUAL Cambia el dueño y/o grupo del fichero solo si el actual dueño y/o grupo coincide con el especificado.
Cualquiera de los dos puede ser omitido.
–no-preserve-root No trata “/” de manera especial (por defecto)
–preserve-root Falla al intentar operar recursivamente sobre “/”
–reference=RFILE Cambia la propiedad de file a la del fichero rfile.
-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)
-v, –verbose Muestra el resultado de cada fichero procesado
–help Muestra la ayuda
–version Muestra la versión y licencia

* Se utiliza junto con el modificador -R

Cambiar el dueño de un fichero

Sintaxis

sudo chown {{usuario}} {{fichero}}

Ejemplos

sudo chown jose documento.txt

El fichero documento.txt que está dentro del directorio actual pasa ser propiedad del usuario jose.

sudo chown juan /home/bruno/Documentos/Reporte.pdf

El fichero Reporte.pdf pasa a ser propiedad del usuario juan, con independencia del directorio en el que te encuentres.

sudo chown pedro ~/Imágenes/foto.jpg

El fichero foto.jpg dentro de /home/TuUsuario/Imágenes pasa a ser propiedad de pedro.

sudo chown francisco “/home/bruno/Documentos/fichero con espacios.odt”

El fichero “fichero con espacios.odt” pasa a ser propiedad de francisco. Si el fichero o alguna carpeta tienen espacios debe estar entrecomillado.

Cambiar el dueño de todos los ficheros recursivamente

Sintaxis

sudo chown -R {{usuario}} {{carpeta}}

Ejemplos

sudo chown -R juan Imágenes

La carpeta Imágenes, y todos los ficheros/carpetas que están dentro (-R) pasan a ser propiedad de juan.

sudo chown -R jose “/home/bruno/Mis Imágenes”

La carpeta Mis Imágenes y todo su contenido pasa a ser propiedad de jose

sudo chown -R vicente ~/Imágenes

Mi carpeta /home/MiUsuario/Imágenes y todo su contenido pasa a ser propiedad de vicente.

Cambiar el dueño de todos los ficheros y carpetas del directorio actual que pertenecen a un determinado usuario.

Sintaxis

 sudo chown --from={{dueñoactual}} {{nuevodueño}} *

Ejemplos

sudo chown –from=jose bruno *

Todos el contenido del directorio actual que pertenezca a jose pasa a ser propiedad de bruno.

sudo chown –from=bruno fernando *

Todo con contenido del directorio actual propiedad de bruno pasa a ser propiedad de fernando.

Cambiar recursivamente el dueño de todos los ficheros y carpetas del directorio actual que pertenecen a un determinado usuario.

Sintaxis

 sudo chown -R --from={{dueñoactual}} {{nuevodueño}} {{carpeta}}

Ejemplos

sudo chown -R –from=jose bruno Documentos

Todos los fichero y directorios dentro de la carpeta Documentos (-R) que eran propiedad de jose pertenecen ahora a bruno.

sudo chown -R –from=juan bruno /home/juan/

Todos los ficheros y directorios dentro de /home/juan (-R) que eran propiedad de juan pertenecen ahora a bruno.

sudo chown -R –from=vicente jose .

Todos los ficheros y directorios del directorio actual (.) que eran propiedad de vicente pertenecen ahora a jose.

Cambia el dueño de todo el contenido de una carpeta si el actual dueño y grupo coincide con el especificado.

Sintaxis:

sudo chown -R --from={{dueño}}:{{grupo}} {{nuevodueño}} {{carpeta}}

Ejemplos:

sudo chown -R –from=juan:consultores javi Imágenes

La carpeta Imágenes y su contenido, cuyo dueño es juan y pertenece al grupo consultores es ahora propiedad de javi.

sudo chown -R –from=bruno:administradores paco ~

Tu carpeta /home/TuUsuario (~) y su contenido, propiedad del usuario bruno y que pertenece al grupo administradores pasa a ser propiedad de paco.

sudo chown -R –from=bruno:administradores jose /home/bruno

El directorio /home/bruno y su contenido,

Búsquedas complejas: find + chown

Para búsquedas mas complejas es posible usar el comando chown con find, ya que find permite realizar búsquedas por nombre, fecha, tipo, tamaño, etc

sudo find . -iname “*.txt” -exec chown bruno {} \;

Busca todos los archivos con extensión txt y les cambia el propietario a bruno.

sudo find . -type d -exec chown bruno {} \;

Busca todos los directorios (-type d) y les cambia el dueño a bruno.

Miércoles 10 de enero de 2018

Pedro L. Lucas

Pedro L. Lucas
Cartas de Linux

Desactivando los parches para los fallos en las CPUs de Intel en Linux

Los recientes fallos de seguridad en las CPUs de Intel llamados Meltdown y Spectre, han obligado modificar los sistemas operativos. Esto causa que los procesadores afectados lleguen a perder de un 5% hasta un 30% de rendimiento en la realización de ciertas tareas.

En determinados casos es un gran inconveniente. Existen situaciones en los que el usuario puede gestionar el riesgo de forma que, a costa de perder ese extra de seguridad, gane en rendimiento. Un ejemplo, supongamos que hay un grupo de científicos realizando cálculos matemáticos. Supongamos también que este grupo de científicos realizan sus cálculos en equipos aislados, de forma que no tienen interacción con otros equipos ni conexión con Internet. Perfectamente podrían deshabilitar los parches y continuar con sus cálculos con ese extra de rendimiento.

Otra situación: disponemos de un portátil. Cuando estemos navegando por Internet es totalmente necesario tener activado las protecciones frente a Meltdown y Spectre (y todas las medidas de seguridad que se nos ocurran). Supongamos ahora que nos vamos de viaje y no tenemos red (incluso puede que no tengamos ni posibilidad de conectarnos), suponamos que tenemos totalmente controlados los programas que vamos a ejecutar en ese tiempo y su procedencia. ¿No sería lógico desactivar dichas protecciones y así, posiblemente, ganar un de un 5% hasta un 30% más de rendimiento y de batería?

Lo que vamos a buscar aquí es cómo se deshabilitan dichas protecciones y qué condiciones podemos usar un equipo, con las protecciones desactivadas de forma segura.

¿Cómo se desactivan las protecciones?

Para desactivar estas opciones, hay que arrancar el ordenador y cuando aparezca el grub solicitando el sistema que queremos arrancar, pulsaremos la tecla e. Aparecerá un editor de texto. En este editor buscamos la línea que arranca el kernel y se le añade la opción “pti=off”. Es decir, al final tendremos que tener una línea similar a:

linux   /boot/vmlinuz-4.4-x86_64 root=UUID=a56... rw  quiet pti=off

Para comprobar si la protección ha sido desactivada, se debe teclear en un terminal.

dmesg | grep 'page tables isolation'

Si aparece la respuesta:

Kernel/User page tables isolation: disabled

es que la protección está deshabilitada y se tendrá el extra de rendimiento.

Evidentemente es más cómodo introducir una nueva entrada en el Grub de forma que podamos elegir entre un sistema seguro o un sistema un poco más rápido en el momento de arrancar.

¿Cuándo se debe deshabilitar estos parches?

Respuesta corta: Nunca.

He estado haciendo pruebas en mis equipos y para las tareas de oficina, programar/compilar, navegar o juegos, no parece que haya una pérdida de rendimiento acusada.

Tened en cuenta que por el sólo hecho de visitar una página web y que tengas un fallo en el navegador, te pueden infectar y usar tu sistema para minar bitcoin, obtener tus contraseñas,…

Como conclusión final sólo decir que el hecho de conocer cómo se desactivan estas protecciones conlleva la responsabilidad de saber usarlo sabiamente.

Espero que os sea útil.

Miércoles 27 de diciembre de 2017

Emiliano A. González Salgado

Emiliano A. González Salgado
El blog de Emi

Prueba

Esto es una prueba.

Realizada con el cliente de sobremesa WordPress.

Trabajar con archivos PDF en Linux

PDF (sigla del inglés Portable Document Format, «formato de documento
portátil») es un formato de almacenamiento para documentos digitales
independiente de plataformas de software o hardware.

Los documentos son de tipo compuesto (imagen vectorial, mapa de bits y
texto).

Actualmente es de los mas usados para el intercambio de información.

En Linux existen programas para crear y editar documentos en dicho formato.

En estos momentos el sistema operativo que uso es Fedora 27 x86_64 KDE.

Mis herramientas principales son:

Visor de archivos: Okular.

Edición de documentos: MasterPDF Editor, LibreOfficeDraw y Xournal.

Creación de archivos PDF: LibreOffice(extensión pdfimport),

MasterPDF Editor y CUPS-pdf.

Formularios (principalmente cumplimentarlos): Okular. y

MasterPDF Editor.

Se pueden crear escaneando un documento o una imagen.

Para el escaneo, aunque  al instalar el driver de la multifunción ya
incorpora su programa, el que uso es Xsane,
un software bastante veterano, pero muy completo. Permite escanear desde el
alimentador automático y desde la base de escaneo. Salida en varios
formatos: PDF, jpeg, gif, png, bmp, etc. Multipágina o página
individuales.  Enviar a la impresora o al fax.

La multifunción es una Epson, y el programa de escaneo es “Image Scan! for
Linux”, que es muy simple, y efectivo, pero con un defecto, tiene una falta
de compatibilidad con el formato PDF. Lo he comprobado al aplicar un script
para comprimir ficheros de gran tamaño. Siempre me daba errores, lo que no
ocurre con Xsane.

La mayoría de los programas anteriores se encuentran en los repositorios de
gran parte de las distribuciones Linux.

Master PDF
Editor
es software propietario. Está desarrollado por Code
Industry
. En Linux se puede utilizar libremente, sin fines
comerciales, por ejemplo para propósitos educativos o personales. Para otros
fines habría que adquirir la respectiva licencia.

Para ver las características mas importantes lo mejor es consultar esta entrada
de El atareao.

Aunque ya tiene unos meses, ha habido pocos cambios.

El principal problema que nos encontramos en Linux con los archivos PDF es
el de la firma digital.

El único programa que tiene incorporado todo para la misma es Adobe Acrobat.
Para Windows y, creo que también, para Apple y Android.

En Linux, la versión que hay es antigua y de 32 bits. Discontinuada por
Adobe.

No trae soporte para firma digital.

Tengo la costumbre de escanear con alta resolución, normalmente 300 dpi, con
lo cual los archivos son de gran tamaño. Para optimizarlos suelo empelar un
scrip que encontré hace tiempo, y no me acuerdo dónde.

Lo tengo en un fichero ejecutable: comprimepdf.sh

El contenido es el siguiente:

#!/bin/sh

dpi=72

if [ $# -lt 2 ]

then

echo “usage: $0 input output [dpi]”

exit 1

fi

if [ $# -gt 2 ]

then

dpi=$3

fi

echo “Shrinking document…”

gs  -q -dNOPAUSE -dBATCH -dSAFER \

-sDEVICE=pdfwrite \

-dCompatibilityLevel=1.3 \

-dPDFSETTINGS=/screen \

-dEmbedAllFonts=true \

-dSubsetFonts=true \

-dColorImageDownsampleType=/Bicubic \

-dColorImageResolution=$dpi \

-dGrayImageDownsampleType=/Bicubic \

-dGrayImageResolution=$dpi \

-dMonoImageDownsampleType=/Bicubic \

-dMonoImageResolution=$dpi \

-sOutputFile=$2 \

$1

#sh comprimepdf.sh ~/input.pdf ~/output.pdf 150

Este último párrafo es la orden para ejecutarlo.

El modificador 150, se puede cambiar para aumentar o disminuir la
resolución.

Es muy efectivo. Archivos de mas 10 MB los reduce a 200 o 300 Kb. sin
afectar a su calidad.

Es necesario tener instalado Ghostscript
para que funcione.

Existe un script, que en Fedora se puede instalar desde los repositorios, shrinkpdf.sh,
pero después de utilizar ambos, prefiero el primero.

Trabajar con archivos PDF en Linux

PDF (sigla del inglés Portable Document Format, «formato de documento
portátil») es un formato de almacenamiento para documentos digitales
independiente de plataformas de software o hardware.

Los documentos son de tipo compuesto (imagen vectorial, mapa de bits y
texto).

Actualmente es de los mas usados para el intercambio de información.

En Linux existen programas para crear y editar documentos en dicho formato.

En estos momentos el sistema operativo que uso es Fedora 27 x86_64 KDE.

Mis herramientas principales son:

Visor de archivos: Okular.

Edición de documentos: Master
PDF Editor
, LibreOffice
Draw
y Xournal.

Creación de archivos PDF: LibreOffice
(extensión pdfimport)
, Master
PDF Editor
y CUPS-pdf.

Formularios (principalmente cumplimentarlos): Okular. y Master
PDF Editor
.

Se pueden crear escaneando un documento o una imagen.

Para el escaneo, aunque  al instalar el driver de la multifunción ya
incorpora su programa, el que uso es Xsane,
un software bastante veterano, pero muy completo. Permite escanear desde el
alimentador automático y desde la base de escaneo. Salida en varios
formatos: PDF, jpeg, gif, png, bmp, etc. Multipágina o página
individuales.  Enviar a la impresora o al fax.

La multifunción es una Epson, y el programa de escaneo es “Image Scan! for
Linux”, que es muy simple, y efectivo, pero con un defecto, tiene una falta
de compatibilidad con el formato PDF. Lo he comprobado al aplicar un script
para comprimir ficheros de gran tamaño. Siempre me daba errores, lo que no
ocurre con Xsane.

La mayoría de los programas anteriores se encuentran en los repositorios de
gran parte de las distribuciones Linux.

Master PDF
Editor
es software propietario. Está desarrollado por Code
Industry
. En Linux se puede utilizar libremente, sin fines
comerciales, por ejemplo para propósitos educativos o personales. Para otros
fines habría que adquirir la respectiva licencia.

Para ver las características mas importantes lo mejor es consultar esta entrada
de El atareao.

Aunque ya tiene unos meses, ha habido pocos cambios.

El principal problema que nos encontramos en Linux con los archivos PDF es
el de la firma digital.

El único programa que tiene incorporado todo para la misma es Adobe Acrobat.
Para Windows y, creo que también, para Apple y Android.

En Linux, la versión que hay es antigua y de 32 bits. Discontinuada por
Adobe.

No trae soporte para firma digital.

Tengo la costumbre de escanear con alta resolución, normalmente 300 dpi, con
lo cual los archivos son de gran tamaño. Para optimizarlos suelo empelar un
scrip que encontré hace tiempo, y no me acuerdo dónde.

Lo tengo en un fichero ejecutable: comprimepdf.sh

El contenido es el siguiente:

#!/bin/sh

dpi=72

if [ $# -lt 2 ]

then

echo “usage: $0 input output [dpi]”

exit 1

fi

if [ $# -gt 2 ]

then

dpi=$3

fi

echo “Shrinking document…”

gs  -q -dNOPAUSE -dBATCH -dSAFER \

-sDEVICE=pdfwrite \

-dCompatibilityLevel=1.3 \

-dPDFSETTINGS=/screen \

-dEmbedAllFonts=true \

-dSubsetFonts=true \

-dColorImageDownsampleType=/Bicubic \

-dColorImageResolution=$dpi \

-dGrayImageDownsampleType=/Bicubic \

-dGrayImageResolution=$dpi \

-dMonoImageDownsampleType=/Bicubic \

-dMonoImageResolution=$dpi \

-sOutputFile=$2 \

$1

#sh comprimepdf.sh ~/input.pdf ~/output.pdf 150

Este último párrafo es la orden para ejecutarlo.

El modificador 150, se puede cambiar para aumentar o disminuir la
resolución.

Es muy efectivo. Archivos de mas 10 MB los reduce a 200 o 300 Kb. sin
afectar a su calidad.

Es necesario tener instalado Ghostscript
para que funcione.

Existe un script, que en Fedora se puede instalar desde los repositorios, shrinkpdf.sh,
pero después de utilizar ambos, prefiero el primero.


Martes 14 de noviembre de 2017

Liher Sanchez

Liher Sanchez
El blog de Liher

Cómo crear un sitio web con un constructor de sitios web y un diseño listo

Si no eres bueno en el diseño, y tampoco eres un profesional del diseño de sitios web, podemos ofrecerte una manera más fácil de crear un sitio web. Tu sitio web nuevo no sólo será totalmente funcional, sino también atractivo, es decir, creado de acuerdo con todas las tendencias de moda del diseño web de hoy.

Un constructor web y una plantilla prediseñada te ayudarán a completar esta tarea difícil. Así pues, hoy vamos a hablar de las nuevas plantillas de sitios web de TemplateMonster que han sido desarrolladas especialmente para MotoCMS 3.0.

 

 

Las ventajas principales del constructor de sitios web de MotoCMS 3.0

La principal diferencia entre el motor de MotoCMS y otros sistemas de gestión de contenidos es la simplicidad y claridad del primero. Te permite editar plantillas simplemente arrastrando y soltando varios elementos de sus diseños.

Ahora no tienes que saber codificar, no se te obliga a programar nada o hacer otras cosas técnicas. Simplemente arrastra y suelta los elementos prediseñados, textos e imágenes y obten un diseño único y funcional.

En otros CMS normalmente se te ofrece sólo un panel de administración y una plantilla prediseñada. Y todo lo que puedes hacer en el panel es crear páginas y añadir contenidos a ellas.

Mientras tanto, MotoCMS incorpora un poderoso editor visual que te permite crear un diseño de plantilla único arrastrando y editando diferentes elementos preestablecidos.

Es decir, no tendrás que codificar nada y preocuparte por el rendimiento del sitio en caso de que algo salga mal en el código. Todas tus configuraciones y experimentos con el diseño se guardarán automáticamente y el código del sitio permanecerá perfecto y funcionará adecuadamente en cualquier navegador.

La creación de sitios web con el constructor web de MotoCMS tiene un montón de ventajas:

  • Facilidad y comodidad. Incluso un principiante inexperto no tendrá problemas con su uso.
  • No se requiere programar o codificar nada.
  • Una gran cantidad de plantillas de alta calidad.
  • Sistema de edición visual sencilla de arrastrar y soltar.
  • Selector de colores único.
  • Alta velocidad de carga de sitios web.
  • Plantillas adaptativas y creadas de acuerdo con todas las tendencias actuales del diseño web.
  • Optimización para SEO.
  • Versión de prueba gratuita de 14 días.

 

 

Presta atención al último punto. Puedes probar este constructor web completamente gratis, experimentar con los ajustes, construir tu propio diseño único y, a continuación, si te gusta el resultado, comprar el sitio web creado y transferirlo a tu propio alojamiento web. En este caso, no perderás ningún dato. Nos parece una opción muy buena y útil.

Además, el producto se te ofrece junto con el servicio de soporte técnico, por lo que siempre puedes solicitar ayuda, en caso de que te confundas en algo o no puedas entender algo. Podrás solicitar ayuda del equipo de asistencia técnica justo después del registro en el sitio y obtendrás respuesta a cualquier pregunta tuya.

Hay cinco secciones principales en el panel de control de MotoCMS 3.0:

  1. Pages/Páginas. Se te permite crear y editar fácilmente páginas del sitio, personalizar su apariencia y al mismo tiempo hacer la optimización para los motores de búsqueda (SEO).
  2. Design/Diseño. En esta sección, se te permite personalizar la parte visual del diseño, el diseño del texto, los fondos, los estilos y los widgets. Estos últimos, a su vez, tienen sus propios ajustes preestablecidos que puedes modificar fácilmente.
  3. Multimedia library/Biblioteca multimedia. Una sección especial para trabajar con todos los archivos multimedia: videos, audios, etc.
  4. Configuration/Configuración. Los ajustes principales del sitio, así como la opción de integración de las herramientas de webmaster (para usuarios avanzados).
  5. Blog. Una sección separada para las configuraciones de visualización y funciones de blog.

Estas secciones puedes editar a tu gusto y tantas veces como deseas. Crea tu propio sitio, añade los widgets y bloques necesarios, inserta archivos multimedia, textos, tablas o cualquier otra cosa. Todo esto es fácil y rápido de configurar, así que, incluso una persona que nunca ha trabajado en el desarrollo web, podrá construir su propia página web sin mucho esfuerzo.

Las categorías principales de las plantillas MotoCMS 3.0 de TemplateMonster:

  • Arte y cultura;
  • Animales;
  • Diseño y fotografía;
  • Educación y libros;
  • Negocios y servicios;
  • Autos y motos;
  • Computadoras e Internet;
  • Electrónica;
  • Entretenimiento, juegos y vida nocturna;
  • Hogar y familia;
  • Moda y belleza;
  • Comida y restaurantes;
  • Vacaciones, regalos y flores;
  • Medicina;
  • Bienes raíces;
  • Sociedad y gente;
  • Deportes, naturaleza y viajes.

Como puedes ver, hay temas para todos los gustos. Y si no has encontrado una plantilla adecuada, entonces, créala por tí mismo! 🙂 Todo esto es muy fácil de hacer con el constructor web de MotoCMS 3.0. A pesar de toda esta simplicidad, tu sitio web todavía tendrá un aspecto profesional y fiable.

Todas las nuevas plantillas creadas por TemplateMonster para MotoCMS 3.0 son 100% adaptativas. Esto significa que funcionarán perfectamente en cualquier dispositivo y se adaptarán automáticamente a cualquier tamaño de pantalla.

Por supuesto, todas las nuevas plantillas incluyen aquellas características modernas, como el efecto de paralaje, la tipografía elegante, la adaptabilidad, los iconos de alta calidad, la animación preintegrada, el diseño de alta calidad en CSS3 y HTML5 y mucho más.