Planet GNU

Aggregation of development blogs from the GNU Project

January 27, 2022

FSF Blogs

poke @ Savannah

GNU poke 2.0 released

I am happy to announce a new major release of GNU poke, version 2.0.

This release is the result of a full year of development.  A lot of things have changed and improved with respect to the 1.x series; we have fixed many bugs and added quite a lot of new exciting and useful features.

See the complete release notes at https://jemarch.net/poke-2.0-relnotes.html for a detailed description of what is new in this release.

We have had lots of fun and learned quite a lot in the process; we really wish you will have at least half of that fun using this tool!

The tarball poke-2.0.tar.gz is now available at https://ftp.gnu.org/gnu/poke/poke-2.0.tar.gz.

> GNU poke (http://www.jemarch.net/poke) is an interactive, extensible editor for binary data.  Not limited to editing basic entities such as bits and bytes, it provides a full-fledged procedural, interactive programming language designed to describe data structures and to operate on them.


Thanks to the people who contributed with code and/or documentation to this release.  In certain but no significant order they are:

  • Mohammad-Reza Nabipoor
  • Luca Saiu
  • Bruno Haible
  • Egeyar Bagcioglu
  • David Faust
  • Guillermo E. Martinez
  • Konstantinos Chasialis
  • Matt Ihlenfield
  • Thomas Weißschuh
  • Sergei Trofimovich
  • Fangrui Song
  • Indu Bhagat
  • Jordan Yelloz
  • Morten Linderud
  • Sergio Durigan Junior

As always, thank you all!

Happy poking!

--
Jose E. Marchesi
Frankfurt am Main
28 February 2022

27 January, 2022 06:25PM by Jose E. Marchesi

January 25, 2022

FSF News

Waag founder Marleen Stikker to keynote LibrePlanet 2022

BOSTON, Massachusetts, USA -- Tuesday, January 25, 2022 -- The Free Software Foundation (FSF) today announced Marleen Stikker as its opening keynote speaker for LibrePlanet 2022. The annual technology and social justice conference will be held virtually on March 19 and 20, 2022, with the theme "Living Liberation."

25 January, 2022 09:35PM

January 22, 2022

parallel @ Savannah

GNU Parallel 20220122 ('20 years') released [stable]

GNU Parallel 20220122 ('20 years') [stable] has been released. It is available for download at: lbry://@GnuParallel:4

No new functionality was introduced so this is a good candidate for a stable release.

Quote of the month:

  I'm going to make GNU parallel my new superpower this year.
    -- Christian G. Warden @xn@twitter

 

New in this release:

  • Bug fixes and man page updates.

News about GNU Parallel:

Get the book: GNU Parallel 2018 http://www.lulu.com/shop/ole-tange/gnu-parallel-2018/paperback/product-23558902.html

GNU Parallel - For people who live life in the parallel lane.

If you like GNU Parallel record a video testimonial: Say who you are, what you use GNU Parallel for, how it helps you, and what you like most about it. Include a command that uses GNU Parallel if you feel like it.

About GNU Parallel

GNU Parallel is a shell tool for executing jobs in parallel using one or more computers. A job can be a single command or a small script that has to be run for each of the lines in the input. The typical input is a list of files, a list of hosts, a list of users, a list of URLs, or a list of tables. A job can also be a command that reads from a pipe. GNU Parallel can then split the input and pipe it into commands in parallel.

If you use xargs and tee today you will find GNU Parallel very easy to use as GNU Parallel is written to have the same options as xargs. If you write loops in shell, you will find GNU Parallel may be able to replace most of the loops and make them run faster by running several jobs in parallel. GNU Parallel can even replace nested loops.

GNU Parallel makes sure output from the commands is the same output as you would get had you run the commands sequentially. This makes it possible to use output from GNU Parallel as input for other programs.

For example you can run this to convert all jpeg files into png and gif files and have a progress bar:

  parallel --bar convert {1} {1.}.{2} ::: *.jpg ::: png gif

Or you can generate big, medium, and small thumbnails of all jpeg files in sub dirs:

  find . -name '*.jpg' |
    parallel convert -geometry {2} {1} {1//}/thumb{2}_{1/} :::: - ::: 50 100 200

You can find more about GNU Parallel at: http://www.gnu.org/s/parallel/

You can install GNU Parallel in just 10 seconds with:

    $ (wget -O - pi.dk/3 || lynx -source pi.dk/3 || curl pi.dk/3/ || \
       fetch -o - http://pi.dk/3 ) > install.sh
    $ sha1sum install.sh | grep c82233e7da3166308632ac8c34f850c0
    12345678 c82233e7 da316630 8632ac8c 34f850c0
    $ md5sum install.sh | grep ae3d7aac5e15cf3dfc87046cfc5918d2
    ae3d7aac 5e15cf3d fc87046c fc5918d2
    $ sha512sum install.sh | grep dfc00d823137271a6d96225cea9e89f533ff6c81f
    9c5198d5 31a3b755 b7910ece 3a42d206 c804694d fc00d823 137271a6 d96225ce
    a9e89f53 3ff6c81f f52b298b ef9fb613 2d3f9ccd 0e2c7bd3 c35978b5 79acb5ca
    $ bash install.sh

Watch the intro video on http://www.youtube.com/playlist?list=PL284C9FF2488BC6D1

Walk through the tutorial (man parallel_tutorial). Your command line will love you for it.

When using programs that use GNU Parallel to process data for publication please cite:

O. Tange (2018): GNU Parallel 2018, March 2018, https://doi.org/10.5281/zenodo.1146014.

If you like GNU Parallel:

  • Give a demo at your local user group/team/colleagues
  • Post the intro videos on Reddit/Diaspora*/forums/blogs/ Identi.ca/Google+/Twitter/Facebook/Linkedin/mailing lists
  • Get the merchandise https://gnuparallel.threadless.com/designs/gnu-parallel
  • Request or write a review for your favourite blog or magazine
  • Request or build a package for your favourite distribution (if it is not already there)
  • Invite me for your next conference

If you use programs that use GNU Parallel for research:

  • Please cite GNU Parallel in you publications (use --citation)

If GNU Parallel saves you money:

About GNU SQL

GNU sql aims to give a simple, unified interface for accessing databases through all the different databases' command line clients. So far the focus has been on giving a common way to specify login information (protocol, username, password, hostname, and port number), size (database and table size), and running queries.

The database is addressed using a DBURL. If commands are left out you will get that database's interactive shell.

When using GNU SQL for a publication please cite:

O. Tange (2011): GNU SQL - A Command Line Tool for Accessing Different Databases Using DBURLs, ;login: The USENIX Magazine, April 2011:29-32.

About GNU Niceload

GNU niceload slows down a program when the computer load average (or other system activity) is above a certain limit. When the limit is reached the program will be suspended for some time. If the limit is a soft limit the program will be allowed to run for short amounts of time before being suspended again. If the limit is a hard limit the program will only be allowed to run when the system is below the limit.

22 January, 2022 03:43PM by Ole Tange

January 20, 2022

FSF Blogs

New year, new LibrePlanet: Register now to join us on March 19 and 20

The fourteenth edition of the Free Software Foundation's (FSF) annual conference is only a couple of months away. We're well into the preparations for the event, which will be held online on March 19 and 20, 2022. Registration is open now.

20 January, 2022 12:55AM

FSF Events

LibrePlanet 2022: Living Liberation

The fourteenth annual conference on technology and social justice, hosted by the Free Software Foundation.

20 January, 2022 12:27AM

January 19, 2022

freeipmi @ Savannah

FreeIPMI 1.6.9 Released

https://ftp.gnu.org/gnu/freeipmi/freeipmi-1.6.9.tar.gz

o Support --with-systemconfigdir build option.
o Fix build issue on musl where putmsg/getmsg are not available.
o Fix build issue when inb/outb are not available on some systems.
o Fix static build issues with gcrypt.
o Add conserver documentation in faq.
o Minor documentation updates.

19 January, 2022 07:26PM by Albert Chu

January 18, 2022

FSF News

January 14, 2022

FSF Events

Share the story of your free software journey! - January 20, 2022

14 January, 2022 10:40PM

FSF Blogs

January 12, 2022

GNU Guix

Announcing the second online Guix Days

The Guix hackers are very happy to announce the second online Guix Days Conference on 19 & 20 February 2022. This conference is open to everyone and will be held entirely online. Want to speak? Submit your proposal!

Important dates:

  1. February 8: Deadline for talks proposal.
  2. February 12: Deadline for releasing your pre-recorded talks.
  3. February 14: Release of the schedule.
  4. February 19: Conference day!
  5. February 20: Conference day!

Guix Days logo

The agenda of these two days is:

  • pre-recorded talks with live question and answer sessions
  • birds of a feather (BoF) sessions
  • lightning round talks, if possible
  • retrospective and future of Guix
  • hack together

Talks will be released before the conference day, watch them as soon as possible! And: no registration fee.

Until February 8: talk proposals

Propose your talks by sending them to guix-days@gnu.org. Feel free to drop in #guix on irc.libera.chat to discuss what you would like to talk about before submitting. :)

You can choose one of the following formats:

  • Standard talk. 15-45 minutes pre-recorded presentation and a 5 minutes lightning talk. The 5-minute presentation will be live, to refresh our minds, followed by a 30 minutes live Q&A.
  • BoF (birds of a feather, for a session with a small group who wants to talk about a specific topic) with no presentation. You may prepare something live to spark conversations.
  • Lightning talk with a 5 minutes live presentation

In addition to the format you would like to choose, please describe your session with 10 lines or more (for lightning talks, at least 1 sentence).

Once you have sent your proposal, you will be notified in the following days whether your talk will be part of the Guix Days. Submit earlier to get more time to prepare your session!

Even for live presentation, please prepare a back-up pre-recorded talk, so we can play it if you cannot attend or have a technical problem during the Guix days. The deadline for short presentations (5 minutes) is February 16.

We welcome all kinds of topics from the community, especially your own experience with Guix, your cool projects that involve Guix in some way, infrastructure around guix (translations, continuous integration, ...), and any subject you feel should be discussed during the conference.

We particularly encourage people who consider themselves part of a group underrepresented in Guix and the broader free software movement to submit a talk. Do not hesitate to get in touch with the organizers at guix-days@gnu.org if unsure or if you would like guidance on how to prepare your talk.

Please make sure your talk is accessible to a non-expert audience, for instance by explaining the general context before diving into technical descriptions, and by avoiding acronyms and jargon.

We accept talks in languages other than English provided English subtitles are included.

Have a look at the topics from the last conference for ideas, but don't hesitate to innovate in your proposals!

February 8 (or before) – 12: prepare your session

The aim of the pre-recorded talks is to demonstrate new features, what you are hacking on, introduce the subject for easing the live question and answer sessions or BoFs. These pre-recorded talks should be 15–45 minutes long. Feel free to ask if you need help with the recording.

You are free to choose whichever storage platform you want (e.g., your own website, a PeerTube instance, a Nextcloud instance, etc.), but we will need to have access to the original file so we can publish it later on audio-video.gnu.org. Your video must be released under a license that at least allows anyone to copy and share it, for any purpose.

You will have to release the video publicly before February 12, so everyone has a chance to see it before the conference. If you are not able to do so (for instance your server cannot handle a huge load), you can alternatively send us a private link to the video and we will upload it on audio-video.gnu.org. If you decide to do so, you will need to have the video ready by February 10.

February 12–18: watch the talks

But don't miss the Fosdem conference either!

Be sure to watch the pre-recorded talks before the conference. There will be no presentations on the 19 nor 20.

February 19–20: participate

Coming soon! Stay tuned.

Code of Conduct

This online conference is an official Guix event. Therefore, the Code of Conduct applies. Please be sure to read it beforehand!

About GNU Guix

GNU Guix is a transactional package manager and an advanced distribution of the GNU system that respects user freedom. Guix can be used on top of any system running the Hurd or the Linux kernel, or it can be used as a standalone operating system distribution for i686, x86_64, ARMv7, and AArch64 machines.

In addition to standard package management features, Guix supports transactional upgrades and roll-backs, unprivileged package management, per-user profiles, and garbage collection. When used as a standalone GNU/Linux distribution, Guix offers a declarative, stateless approach to operating system configuration management. Guix is highly customizable and hackable through Guile programming interfaces and extensions to the Scheme language.

12 January, 2022 12:00AM by Guix Hackers

January 11, 2022

hello @ Savannah

hello-2.11 released [stable]

I’m delighted to announce a new release of GNU hello.  This version has many minor fixes and improvements made in the last eight years.

  • Noteworthy changes in release 2.11 (2022-01-05) [stable]

Remove -h and -v short options.

Various code tidying, including avoiding forward declarations, removing dead code, new test for multibyte strings, better use of gnulib, update to more recent gnulib and add git hooks from coreutils.

11 January, 2022 08:04PM by Reuben Thomas

January 09, 2022

FSF Blogs

January 06, 2022

GNU Guix

GNU Guix maintainer rotation

For some time already, Ludovic and Marius have voiced their desire to step down from the Guix maintainers collective. An email announcing the news and calling for new maintainers was sent more than 4 months ago. We're very happy to announce that Efraim Flashner has responded to the call and accepted to join the Guix maintainers collective! Efraim has been with Guix for a long time -- the first recorded Git history of their activity goes back to 2015, and they have since authored more than 6000 commits! More importantly, Efraim has demonstrated traits we value for a co-maintainer, such as good communication and collaboration abilities, values that align well with those of the GNU project and overall a person you'd like to hang out with at FOSDEM :-).

We're sad to see Ludovic and Marius step down from their current duties, but we take comfort knowing they will remain among us for the good hacks and occasional guidance. Losing them as co-maintainers will be a difficult test for the remaining Guix co-maintainers. Ludovic's wit, relentless energy, tactful communication and wise planning have been invaluable to the Guix project throughout the years. Ludovic has mentioned this decision was at least partly based on their desire to guard Guix against the Founder's syndrome, which is something we can only applaud. Marius has served as co-maintainer since October 2019. Their calm, composed attitude has helped us navigate through at times difficult situations, and their technical wizardry has brought us the likes of ungoogled-chromium and a Ganeti service, among many others.

Let's take a moment to say thank you to Ludovic and Marius for their valuable years as maintainers, and wish they can enjoy their newfound extra time :-).

Let's also wish a warm welcome to Efraim. Thank you for stepping up to become a co-maintainer, Efraim!

The Guix co-maintainers

The Guix maintainer collective now consists of Efraim Flashner, Mathieu Othacehe, Maxim Cournoyer and Tobias Geerinckx-Rice. You can reach us all by email at guix-maintainers@gnu.org, a private alias.

For information about the responsibilities assumed by the Guix co-maintainers, you are encouraged to read a previous blog post that covered the topic.

About GNU Guix

GNU Guix is a transactional package manager and an advanced distribution of the GNU system that respects user freedom. Guix can be used on top of any system running the Hurd or the Linux kernel, or it can be used as a standalone operating system distribution for i686, x86_64, ARMv7, AArch64 and POWER9 machines.

In addition to standard package management features, Guix supports transactional upgrades and roll-backs, unprivileged package management, per-user profiles, and garbage collection. When used as a standalone GNU/Linux distribution, Guix offers a declarative, stateless approach to operating system configuration management. Guix is highly customizable and hackable through Guile programming interfaces and extensions to the Scheme language.

06 January, 2022 09:00AM by Maxim Cournoyer

January 05, 2022

parallel @ Savannah

GNU Parallel's 20th birthday

On 2022-01-06 GNU Parallel will be 20 years old. The birthday is an opportunity to take stock.

https://www.gnu.org/software/parallel/20th-birthday.html

05 January, 2022 10:19PM by Ole Tange

January 04, 2022

libunistring @ Savannah

GNU libunistring-1.0 released

Download from https://ftp.gnu.org/gnu/libunistring/libunistring-1.0.tar.gz

This is a stable release.

New in this release:

  • The license has changed from "LGPLv3+ or GPLv2" to "LGPLv3+ or GPLv2+".
  • The data tables and algorithms have been updated to Unicode version 14.0.0.
  • The functions u8_uctomb, u16_uctomb, u32_uctomb now support strings larger than 2 GiB by taking an 'n' argument of type ptrdiff_t (instead of int).
  • The functions u*_possible_linebreaks and u*_width_linebreaks now make it easier to work with strings that contain CR-LF sequences: In this case, in the returned array, it will return UC_BREAK_CR_BEFORE_LF followed by UC_BREAK_MANDATORY (instead of twice UC_BREAK_MANDATORY).
  • There are new properties for recognizing pictographic symbols and regional indicators:

    - UC_PROPERTY_EMOJI                  uc_is_property_emoji
    - UC_PROPERTY_EMOJI_PRESENTATION     uc_is_property_emoji_presentation
    - UC_PROPERTY_EMOJI_MODIFIER         uc_is_property_emoji_modifier
    - UC_PROPERTY_EMOJI_MODIFIER_BASE    uc_is_property_emoji_modifier_base
    - UC_PROPERTY_EMOJI_COMPONENT        uc_is_property_emoji_component
    - UC_PROPERTY_EXTENDED_PICTOGRAPHIC  uc_is_property_extended_pictographic
    - UC_PROPERTY_REGIONAL_INDICATOR     uc_is_property_regional_indicator

  • Fixed multithread-safety bugs on Cygwin, native Windows, and Haiku.

04 January, 2022 10:48PM by Bruno Haible

January 03, 2022

www-zh-cn @ Savannah

Best wishes for all in 2022

Dear zh-cn-translators:

Thank you all for the help in 2021. Here comes the summary of www.gnu.org translation from GNU.

Please take your time to read. We are doing almost as good as 2020.

Dear GNU translators!

This year, the total number of new translations was approximately
like in 2020, but their mean size was almost twice as large.
Nearly every third new translation was made in the Brazilian
Portuguese team; the Albanian and ("Traditional") Chinese teams
made four times more translations than in 2020.

      General Statistics

In October, we reached new maximum values of translations per file
in important directories, 9.32 translations per file (0.4 more
than in 2020) and 8.39 translations weighted with size of articles
(0.15 more than in 2020).

The percent of outdated translations was considerably higher
than in 2020, mostly due to more commits this year.

The table below shows the number and size of newly translated
articles in important directories (as of 2021-12-31) and
typical number of outdated GNUNified translations throughout
the year.

+--team--+------new-------+---outdated-+
|  es    |  17 (146.6Ki)  |  2.5 (1%)  |
+--------+----------------+------------+
|  fr    |   5 (237.0Ki)  |  3.0 (1%)  |
+--------+----------------+------------+
|  it    |   7 ( 56.0Ki)  |  50 (37%)  |
+--------+----------------+------------+
|  ja    |   0 (  0.0Ki)  |  30 (21%)  |
+--------+----------------+------------+
|  ml    |   1 ( 53.2Ki)  |  21 (63%)  |
+--------+----------------+------------+
|  pl    |   0 (  0.0Ki)  |  54 (37%)  |
+--------+----------------+------------+
|  pt-br |  49 (1227.3Ki) |  36 (17%)  |
+--------+----------------+------------+
|  ru    |   8 (238.6Ki)  |  3.0 (1%)  |
+--------+----------------+------------+
|  sq    |  34 (308.7Ki)  | 3.0 (6.6%) |
+--------+----------------+------------+
|  tr    |  21 (279.6Ki)  | 4.4 (3.5%) |
+--------+----------------+------------+
|  zh-cn |  11 (334.7Ki)  | 6.7 (4.3%) |
+--------+----------------+------------+
|  zh-tw |  10 (168.1Ki)  |  23 (51%)  |
+--------+----------------+------------+
+--------+----------------+
| total  | 163 (3049.8Ki) |
+--------+----------------+

For the reference: 5 new articles were added, amounting to 237Ki
(one of them was proprietary/all.html, about 130Ki, consisting
mostly of entries already present in other pages from proprietary/),
and there were over 1000 changes in about 300 English files
in the important directories.

Like in 2020, few translations were converted to the gettext format,
so that column is missing this year.  Among the active teams, only
the ("Traditional") Chinese team has translations to convert
(15 files, 228.6Ki), and the total number of unconverted translations
is 55 (1062.8Ki).

      Orphaned Teams, New and Reformed Teams

The ("Traditional") Chinese team changed its leader.  The Farsi
team was re-established in May, but no commits in www have followed
yet.  Korean, Serbian, Ukrainian teams were declared inactive
(no commits for more than 3 years).  The Italian team
is re-organizing.

There were unsuccessful attempts to establish or resurrect teams
for Hindi, Arabic, Malay, Finnish, Catalan.

      Changes in the Page Regeneration System

GNUN had two releases this year, 1.1 and 1.2, the most important
changes were in validation procedures: the SSI expansion was made
closer to Apache behavior, the DTD was updated to remove obsolete
elements and add new attributes.

Happy GNU year, and thank you for your contributions!

(I see nothing secret in this message, so if you think it may be
interesting to people who are not subscribed to the list, please
feel free to forward it).

Happy New Year!
wxie

03 January, 2022 12:29AM by Wensheng XIE

January 02, 2022

alive @ Savannah

GNU Alive 2.0.5 available

GNU Alive 2.0.5 is available.  Full announcement:

GNU Alive is a keep-alive program for internet connections.

02 January, 2022 06:02PM by Thien-Thi Nguyen

rush @ Savannah

Version 2.2

GNU rush version 2.2 is available for download.

New in this version:

New file system tests

New predicates, designed after options to the "test" system command, check for file types. modes and ownership.  For example

  rule
    match -d /var/lock/sd

will match if /var/lock/sd exists on diks and is a directory

transform: fix replacement of numbered pattern instance

This fixes handling of transform expressions like "s/X/@/2".

02 January, 2022 02:33PM by Sergey Poznyakoff

mailutils @ Savannah

Version 3.14

Version 3.14 of GNU mailutils is available for download.

New in this release:

  • TLS support rewritten from scratch
    • New configuration statement: tls.handshake-timeout
  • Fix idle timeout handling (imap4d and pop3d daemons)
  • New function mu_mailbox_append_message_ext
  • mail utility
    • new command: unread (U)
    • message state is preserved when copying to another mailbox
  • Build requires GNU bison and flex
  • All parsers and scanners are rewritten in reentrant form
  • Support for mimetypes incorporated to the libmailutils library
  • Maildir and MH mailboxes
    • Change the way of storing the envelope information
    • Message scanner completely rewritten
  • Bugfixes
    • Fixed some memory and fd leaks
    • Fixed corner case in mu_make_file_name_suf function

02 January, 2022 09:21AM by Sergey Poznyakoff

January 01, 2022

FSF Blogs

alive @ Savannah

GNU Alive 2.0.4 available

GNU Alive 2.0.4 is available.  Full announcement:

GNU Alive is a keep-alive program for internet connections.

01 January, 2022 05:56PM by Thien-Thi Nguyen

December 30, 2021

direvent @ Savannah

Version 5.3

Version 5.3 of direvent is available for download.

New in this version:

New event: "change"

The change event is implemented on GNU/Linux and FreeBSD.  This event is delivered when a file was modified and closed.

New configuration statement for manipulating the environment

The environ statement is now a compound statement. It can contain five kinds of substatements: clear to clear the environment, keep to retain certain variables while clearing the environment, set to set a variable, unset to unset a variable or variables, and eval to evaluate a variable reference for side effects.

Both keep and unset can take globbing pattern as their argument, in which case they affect all variables matching that pattern.

Arguments to all these statements are subject to variable expansion.

The environ block can appear in global context as well.  In this case it applies to all watchers.

The support for the old one-line environ syntax is retained for backward compatibility.

Variable expansion in arguments to some configuration statements

Both macro and environment variables are expanded in arguments to all substatements of the new environ block statement and in the argument to the command statement.  In the latter case, expansion of the environment variables is controlled by the shell option.  If the option is set, the variable will be expanded by the shell.  Otherwise, they are expanded by direvent prior to invoking the command.

Recursive watching support rewritten

In particular, this fixes the bug where recursive watchers silently assumed that the create generic event was configured for the watcher.

Changed interface for bulk closing of file descriptors

To speed up launching of the user commands, system-dependent interfaces for closing the file descriptors above the given one are used, if available.

30 December, 2021 09:20AM by Sergey Poznyakoff

December 29, 2021

serveez @ Savannah

December 27, 2021

GNUnet News

GNS Technical Specification Call for Reviews

GNS Technical Specification Call for Reviews

We are happy to announce that our GNS specification is currently under review by the Independent Stream Editor (ISE). We have already received feedback from the ISE and made significant, mostly editorial changes to the specification.

We are inviting anyone reading this to review and provide feedback to the draft and send it to gnunet-developers@gnu.org . Even better, you could write an implementation in your favourite programming language.

In other news, we are currently also working on the specification of the GNUnet DHT .

This work was generously funded by NLnet as part of their Search and discovery fund .

27 December, 2021 11:00PM

December 22, 2021

parallel @ Savannah

GNU Parallel 20211222 ('Støjberg') released [stable]

GNU Parallel 20211222 ('Støjberg') [stable] has been released. It is available for download at: lbry://@GnuParallel:4

No new functionality was introduced so this is a good candidate for a stable release.

Quote of the month:

  My favorite man page is that of GNU parallel.
    -- Jeroen Janssens @jeroenhjanssens@twitter

 

New in this release:

  • Bug fixes and man page updates.

News about GNU Parallel:

  • The first version of Parallel will be 20 years on 2022-01-06

Get the book: GNU Parallel 2018 http://www.lulu.com/shop/ole-tange/gnu-parallel-2018/paperback/product-23558902.html

GNU Parallel - For people who live life in the parallel lane.

If you like GNU Parallel record a video testimonial: Say who you are, what you use GNU Parallel for, how it helps you, and what you like most about it. Include a command that uses GNU Parallel if you feel like it.

About GNU Parallel

GNU Parallel is a shell tool for executing jobs in parallel using one or more computers. A job can be a single command or a small script that has to be run for each of the lines in the input. The typical input is a list of files, a list of hosts, a list of users, a list of URLs, or a list of tables. A job can also be a command that reads from a pipe. GNU Parallel can then split the input and pipe it into commands in parallel.

If you use xargs and tee today you will find GNU Parallel very easy to use as GNU Parallel is written to have the same options as xargs. If you write loops in shell, you will find GNU Parallel may be able to replace most of the loops and make them run faster by running several jobs in parallel. GNU Parallel can even replace nested loops.

GNU Parallel makes sure output from the commands is the same output as you would get had you run the commands sequentially. This makes it possible to use output from GNU Parallel as input for other programs.

For example you can run this to convert all jpeg files into png and gif files and have a progress bar:

  parallel --bar convert {1} {1.}.{2} ::: *.jpg ::: png gif

Or you can generate big, medium, and small thumbnails of all jpeg files in sub dirs:

  find . -name '*.jpg' |
    parallel convert -geometry {2} {1} {1//}/thumb{2}_{1/} :::: - ::: 50 100 200

You can find more about GNU Parallel at: http://www.gnu.org/s/parallel/

You can install GNU Parallel in just 10 seconds with:

    $ (wget -O - pi.dk/3 || lynx -source pi.dk/3 || curl pi.dk/3/ || \
       fetch -o - http://pi.dk/3 ) > install.sh
    $ sha1sum install.sh | grep c82233e7da3166308632ac8c34f850c0
    12345678 c82233e7 da316630 8632ac8c 34f850c0
    $ md5sum install.sh | grep ae3d7aac5e15cf3dfc87046cfc5918d2
    ae3d7aac 5e15cf3d fc87046c fc5918d2
    $ sha512sum install.sh | grep dfc00d823137271a6d96225cea9e89f533ff6c81f
    9c5198d5 31a3b755 b7910ece 3a42d206 c804694d fc00d823 137271a6 d96225ce
    a9e89f53 3ff6c81f f52b298b ef9fb613 2d3f9ccd 0e2c7bd3 c35978b5 79acb5ca
    $ bash install.sh

Watch the intro video on http://www.youtube.com/playlist?list=PL284C9FF2488BC6D1

Walk through the tutorial (man parallel_tutorial). Your command line will love you for it.

When using programs that use GNU Parallel to process data for publication please cite:

O. Tange (2018): GNU Parallel 2018, March 2018, https://doi.org/10.5281/zenodo.1146014.

If you like GNU Parallel:

  • Give a demo at your local user group/team/colleagues
  • Post the intro videos on Reddit/Diaspora*/forums/blogs/ Identi.ca/Google+/Twitter/Facebook/Linkedin/mailing lists
  • Get the merchandise https://gnuparallel.threadless.com/designs/gnu-parallel
  • Request or write a review for your favourite blog or magazine
  • Request or build a package for your favourite distribution (if it is not already there)
  • Invite me for your next conference

If you use programs that use GNU Parallel for research:

  • Please cite GNU Parallel in you publications (use --citation)

If GNU Parallel saves you money:

About GNU SQL

GNU sql aims to give a simple, unified interface for accessing databases through all the different databases' command line clients. So far the focus has been on giving a common way to specify login information (protocol, username, password, hostname, and port number), size (database and table size), and running queries.

The database is addressed using a DBURL. If commands are left out you will get that database's interactive shell.

When using GNU SQL for a publication please cite:

O. Tange (2011): GNU SQL - A Command Line Tool for Accessing Different Databases Using DBURLs, ;login: The USENIX Magazine, April 2011:29-32.

About GNU Niceload

GNU niceload slows down a program when the computer load average (or other system activity) is above a certain limit. When the limit is reached the program will be suspended for some time. If the limit is a soft limit the program will be allowed to run for short amounts of time before being suspended again. If the limit is a hard limit the program will only be allowed to run when the system is below the limit.

22 December, 2021 09:57PM by Ole Tange

poke @ Savannah

Registry of pickles for GNU poke

GNU poke allows the users to write their own descriptions of the data they want to edit or operate with.  These descriptions are written in the Poke programming language, and consist on type definitions, variables, functions, pretty-printers and so on.

We call 'pickles' to Poke source files containing definitions of types, variables, functions, etc, that conceptually apply to some definite domain. For example, elf.pk is a pickle that provides facilities to poke ELF object files. Pickles are not necessarily related to file formats: a set of functions to work with bit patterns, for example, could be implemented in a pickle bitpatterns.pk.

We have added a collection of already written pickles to Pokology: https://pokology.net/pickles.html.  This page lists the pickles by categories: compression, object formats, file systems, etc.  It lists not only pickles distributed along with GNU poke, but also those developed and distributed separately.

We hope you find this registry useful.  If you write a poke pickle that may be useful to other people, please let us know in the poke-devel mailing list and will add it to the registry.

22 December, 2021 03:58PM by Jose E. Marchesi

December 19, 2021

Luca Saiu

Jitter is now GNU Jitter

I am happy to announce that my project Jitter has been officially accepted as part of the GNU Project (https://www.gnu.org). The new Jitter home page is . The git repository is still at . — Luca Saiu, 2021-12-19 19:52 ... [Read more]

19 December, 2021 06:52PM by Luca Saiu (positron@gnu.org)

December 16, 2021

FSF News

December 15, 2021

GNU Guix

The Big Change

Making cross-cutting changes over a large code base is difficult, but it's occasionally necessary if we are to keep the code base tidy and malleable. With almost 800K source lines of code, Guix can reasonably be called a large code base. One might argue that almost 80% of this code is package definitions, which “doesn't count”. Reality is that it does count, not only because those package definitions are regular Scheme code, but also they are directly affected by the big change Guix has just undergone.

This post looks at what’s probably the biggest change Guix has seen since it started nine years ago and that anyone writing packages will immediately notice: simplified package inputs. Yes, we just changed how each of the 20K packages plus those in third-party channels can declare their dependencies. Before describing the change, how we implemented it, and how packagers can adapt, let’s first take a look at the previous situation and earlier improvements that made this big change possible.

Packages and inputs

Packages in Guix are defined using a domain-specific language embedded in the Scheme programming language—an EDSL, for the programming language geeks among us. This is a departure from other designs such as that of Nix, which comes with a dedicated language, and it gives packagers and users access to a rich programming interface while retaining the purely declarative style of package definitions.

This package EDSL is one of the oldest bits of Guix and was described in a 2013 paper. Although embedded in Scheme, the package “language” was designed to be understandable by people who’ve never practiced any kind of Lisp before—you could think of it as a parenthesized syntax for JSON or XML. It’s reasonable to say that it’s been successful at that: of the 600+ people who contributed to Guix over the years, most had never written Scheme or Lisp before. The example given in that paper remains a valid package definition:

(define hello
  (package
    (name "hello")
    (version "2.8")
    (source (origin
              (method url-fetch)
              (uri (string-append "mirror://gnu/hello/hello-"
                                  version ".tar.gz"))
              (sha256 (base32 "0wqd8..."))))
    (build-system gnu-build-system)
    (arguments
      '(#:configure-flags
        `("--disable-color"
          ,(string-append "--with-gawk="
                          (assoc-ref %build-inputs "gawk")))))
    (inputs `(("gawk" ,gawk)))
    (synopsis "GNU Hello")
    (description "An illustration of GNU's engineering practices.")
    (home-page "http://www.gnu.org/software/hello/")
    (license gpl3+)))

Of particular interest here is the inputs field, which lists build-time dependencies. Here there’s only one, GNU Awk; it has an associated label, "gawk". The ,gawk bit lets us insert the value of the gawk variable, which is another package. We can list more dependencies like so:

(inputs `(("gawk" ,gawk)
          ("gettext" ,gnu-gettext)
          ("pkg-config" ,pkg-config)))

Quite a bit of boilerplate. Unless you’re into Lisp, this probably looks weird to you—manageable, but weird. What’s the deal with this backquote and those commas? The backquote is shorthand for quasiquote and commas are shorthand for unquote; it’s a facility that Lisp and Scheme provide to construct lists.

Lispers couldn’t live without quasiquote, it’s wonderful. Still, exposing newcomers to this syntax has always been uncomfortable; in tutorials you’d end up saying “yeah don’t worry, just write it this way”. Our goal though is to empower users by giving them abstractions they can comprehend, hopefully providing a smooth path towards programming without noticing. This seemingly opaque backquote-string-unquote construct works against that goal.

Then, you ask, why did Guix adopt this unpleasant syntax for inputs in the first place? Input syntax had to satisfy one requirement: that it’d be possible for “build-side code” to refer to a specific input. And what’s build-side code? It’s code that appears in the package definition that is staged for later execution—code that’s only evaluated when the package is actually built. The bit that follows #:configure-flags in the example above is build-side code: it’s an expression evaluated if and when the package gets built. That #:configure-flags expression refers to the gawk package to construct a flag like "--with-gawk=/gnu/store/…-gawk-5.0.1"; it does so by referring to the special %build-inputs variable, which happens to contain an association list that maps input labels to file names. The "gawk" label in inputs is here to allow build-side code to get at an input’s file name.

Still here? The paragraphs above are a demonstration of the shortcoming of this approach. That we have to explain so much suggests we’re lacking an abstraction that would make the whole pattern clearer.

G-expressions and self-referential records

The missing abstraction came to Guix a couple of years later: G-expressions. Without going into the details, which were covered elsewhere, notably in a research article, g-expressions, or “gexps”, are traditional Lisp s-expressions (“sexps”) on steroids. A gexp can contain a package record or any other “file-like object” and, when that gexp is serialized for eventual execution, the package is replaced by its /gnu/store/… file name.

Gexps have been used since 2014–2015 in all of Guix System and they’ve been great to work with, but package definitions were stuck with old-style sexps. One reason is that a big chunk of the code that deals with packages and build systems had to be ported to the gexp-related programming interfaces; a first attempt had been made long ago but performance was not on par with that of the old code, so postponing until that was addressed seemed wiser. The second reason was that using gexps in package definitions could be so convenient that packagers might unwillingly find themselves creating inconsistent packages.

We can now rewrite our hello package such that configure flags are expressed using a gexp:

(define hello
  (package
    (name "hello")
    ;; …
    (arguments
     (list #:configure-flags
           #~`("--disable-color"
               ,(string-append "--with-gawk=" #$gawk))))
    (inputs `(("gawk" ,gawk)))))

The reference inserted here with #$gawk (#$ is synonymous for ungexp, the gexp equivalent of traditional unquote) refers to the global gawk variable. This is more concise and semantically clearer than the (assoc-ref %build-inputs "gawk") snippet we had before.

Now suppose you define a package variant using this common idiom:

(define hello-variant
  (package
    (inherit hello)
    (name "hello-variant")
    (inputs `(("gawk" ,gawk-4.0)))))

Here the intent is to create a package that depends on a different version of GNU Awk—the hypothetical gawk-4.0 instead of gawk. However, the #:configure-flags gexp of this variant still refers to the gawk variable, contrary to what the inputs field prescribes; in effect, this variant depends on the two Awk versions.

To address this discrepancy, we needed a new linguistic device, to put it in a fancy way. It arrived in 2019 in the form of self-referential records. Within a field such as the arguments field above, it’s now possible to refer to this-package to get at the value of the package being defined. (If you’ve done object-oriented programming before, you might be thinking that we just rediscovered the this or self pointer, and there’s some truth in it. :-)) With a bit of syntactic sugar, we can rewrite the example above so that it refers to the Awk package that appears in its own inputs field:

(define hello
  (package
    (name "hello")
    ;; …
    (arguments
     (list #:configure-flags
           #~(list (string-append "--with-gawk="
                                  #$(this-package-input "gawk")))))
    (inputs `(("gawk" ,gawk)))))

With this in place, we can take advantage of gexps in package definitions while still supporting the common idiom to define package variants, wheee!

That was a long digression from our input label theme but, as you can see, all this interacts fairly tightly.

Getting rid of input labels

Now that we have gexps and self-referential records, it looks like we can finally get rid of input labels: they’re no longer strictly necessary because we can insert packages in gexps instead of looking them up by label in build-side code. We “just” need to devise a backward compatibility plan…

Input labels are pervasive; they’re visible in three contexts:

  1. in the inputs fields of package definitions;
  2. on the build side with the inputs keyword parameter of build phases;
  3. in the Scheme programming interface since package-inputs and related functions are expected to return a list of labeled inputs.

We’re brave but not completely crazy, so we chose to focus on #1 for now—it’s also the most visible of all three—, with an plan to incrementally address #2, leaving #3 for later.

To allow for label-less inputs, we augmented the record interface with field sanitizers. This feature allows us to define a procedure that inspects and transforms the value specified for the inputs, native-inputs, and propagated-inputs. Currently that procedure reintroduces input labels when they’re missing. In a sense, we’re just changing the surface syntax but under the hood everything is unchanged. With this change, our example above can now be written like this:

(define hello
  (package
    (name "hello")
    ;; …
    (inputs (list gawk))))

Much nicer, no? The effect is even more pleasant for packages with a number of inputs:

(define-public guile-sqlite3
  (package
    (name "guile-sqlite3")
    ;; …
    (build-system gnu-build-system)
    (native-inputs (list autoconf automake guile-3.0 pkg-config))
    (inputs (list guile-3.0 sqlite))))

That’s enough to spark joy to anyone who’s taught the previous syntax. Currently this is transformed into something like:

(define-public guile-sqlite3
  (package
    ;; …
    (native-inputs
      (map add-input-label
           (list autoconf automake guile-3.0 pkg-config)))))

… where the add-input-label function turns a package into a label/package pair. It does add a little bit of run-time overhead, but nothing really measurable.

There are also cases where package definitions, in particular for package variants, would directly manipulate input lists as returned by package-inputs and related procedures. It’s a case where packagers had to be aware of input labels, and they would typically use association list (or “alist”) manipulation procedures and similar construct—this is context #3 above. To replace those idioms, we defined a higher-level construct that does not assume input labels. For example, a common idiom when defining a package variant with additional dependencies goes like this:

(define hello-with-additional-dependencies
  (package
    (inherit hello)
    (name "hello-with-bells-and-whistles")
    (inputs `(("guile" ,guile-3.0)
              ("libtextstyle" ,libtextstyle)
              ,@(package-inputs hello)))))

The variant defined above adds two inputs to those of hello. We introduced a macro, modify-inputs, which allows packagers to express that in a higher-level (and less cryptic) fashion, in a way that does not refer to input labels. Using this other linguistic device (ha ha!), the snippet above becomes:

(define hello-with-additional-dependencies
  (package
    (inherit hello)
    (name "hello-with-bells-and-whistles")
    (inputs (modify-inputs (package-inputs hello)
              (prepend guile-3.0 libtextstyle)))))

Similarly, modify-inputs advantageously subsumes alist-delete and whatnot when willing to replace or remove inputs, like so:

(modify-inputs (package-inputs hello)
  (replace "gawk" my-special-gawk)
  (delete "guile"))

On the build side—context #2 above—, we also provide new procedures that allow packagers to avoid relying on input labels: search-input-file and search-input-directory. Instead of having build phases that run code like:

(lambda* (#:key inputs #:allow-other-keys)
  ;; Replace references to “/sbin/ip” by references to
  ;; the actual “ip” command in /gnu/store.
  (substitute* "client/scripts/linux"
    (("/sbin/ip")
     ;; Look up the input labeled “iproute”.
     (string-append (assoc-ref inputs "iproute")
                    "/sbin/ip"))))

… you’d now write:

(lambda* (#:key inputs #:allow-other-keys)
  ;; Replace references to “/sbin/ip” by references to
  ;; the actual “ip” command in /gnu/store.
  (substitute* "client/scripts/linux"
    (("/sbin/ip")
     ;; Search “/sbin/ip” among all the inputs.
     (search-input-file inputs "/sbin/ip"))))

Nothing revolutionary but a couple of advantages: code is no longer tied to input labels or package names, and search-input-file raises an exception when the file is not found, which is better than building an incorrect file name.

That was a deep dive into packaging! If you’re already packaging software for Guix, you hopefully see how to do things “the new way”. Either way, it’s interesting to see the wide-ranging implications of what initially looks like a simple change. Things get complex when you have to consider all the idioms that 20,000 packages make use of.

Adapting to the new style

It’s nice to have a plan to change the style of package definitions, but how do you make it happen concretely? The last thing we want is, for the next five years, to have to explain two package styles to newcomers instead of one.

First, guix import now returns packages in the new style. But what about existing package definitions?

Fortunately, most of the changes above can be automated: that’s the job of the guix style command that we added for this purpose, but which may eventually be extended to make package definitions prettier in all sorts of ways. From a checkout, one can run:

./pre-inst-env guix style

Whenever it can be done safely, package inputs in every package definition are rewritten to the new style: removing input labels, and using modify-inputs where appropriate. If you maintain your own channel, you can also run it for your packages:

guix style -L /path/to/channel my-package1 my-package2 …

We recommend waiting until the next Guix release is out though, which could be a month from now, so that your channel remains usable by those who pinned an older revision of the guix channel.

We ran guix style a couple of days ago on the whole repository, leading to the biggest commit in Guix history:

460 files changed, 37699 insertions(+), 49782 deletions(-)

Woohoo! Less than 15% of the packages (not counting Rust packages, which are a bit special) have yet to be adjusted. In most cases, package inputs that were left unchanged are either those where we cannot automatically determine whether the change would break the package, for instance because build-side code expects certain labels, and those that are “complex”—e.g., inputs that include conditionals.

The key challenge here was making sure guix style transformations are correct; by default, we even want to be sure that changes introduced by guix style do not trigger a rebuild—that package derivations are unchanged.

To achieve that, guix style correlates the source code of each package definition with the corresponding live package record. That allows it to answer questions such as “is this label the name of the input package”. That way, it can tell that, say:

(inputs `(("libx11" ,libx11)
          ("libxcb" ,libxcb)))

can be rewritten without introducing a rebuild, because labels match actual package names, whereas something like this cannot, due to label mismatches:

(inputs `(("libX11" ,libx11)
          ("xcb" ,libxcb)))

guix style can also determine situations where changes would trigger a rebuild but would still be “safe”—without any observable effect. You can force it to make such changes by running:

guix style --input-simplification=safe

Because we’re all nitpicky when it comes to code formatting, guix style had to produce nicely formatted code, and to make local changes as opposed to rewriting complete package definitions. Lisps are famous for being homoiconic, which comes in handy in such a situation.

But the tools at our disposal are not capable enough for this application. First, Scheme’s standard read procedure, which reads an sexp (or an abstract syntax tree if you will) from a byte stream and returns it, does not preserve comments. Obviously we’d rather not throw away comments, so we came up with our own read variant that preserves comments. Similarly, we have a custom pretty printer that can write comments, allowing it to achieve changes like this:

@@ -2749,18 +2707,17 @@ (define-public debops
                         "debops-debops-defaults-fall-back-to-less.patch"))))
     (build-system python-build-system)
     (native-inputs
-     `(("git" ,git)))
+     (list git))
     (inputs
-     `(("ansible" ,ansible)
-       ("encfs" ,encfs)
-       ("fuse" ,fuse)
-       ("util-linux" ,util-linux)  ;for umount
-       ("findutils" ,findutils)
-       ("gnupg" ,gnupg)
-       ("which" ,which)))
+     (list ansible
+           encfs
+           fuse
+           util-linux ;for umount
+           findutils
+           gnupg
+           which))
     (propagated-inputs
-     `(("python-future" ,python-future)
-       ("python-distro" ,python-distro)))
+     (list python-future python-distro))
     (arguments
      `(#:tests? #f

The pretty printer also has special rules for input lists. For instance, lists of five inputs or less go into a single line, if possible, whereas longer lists end up with one input per line, which is often more convenient, especially when visualizing diffs. It also has rules to format modify-inputs in the same way we’d do it in Emacs:

@@ -171,9 +170,9 @@ (define-public arcan-sdl
     (inherit arcan)
     (name "arcan-sdl")
     (inputs
-     `(("sdl" ,sdl)
-       ,@(fold alist-delete (package-inputs arcan)
-               '("libdrm"))))
+     (modify-inputs (package-inputs arcan)
+       (delete "libdrm")
+       (prepend sdl)))
     (arguments

Overall that makes guix style a pretty fun meta-project!

“Worse is better” or “the Right Thing”?

There are several lessons here. One is that having an embedded domain-specific language is what makes such changes possible: yes package definitions have a declarative field, but we do not hide the fact that their meaning is determined by the broader Guix framework, starting with the (guix packages) module, which defines the package record type and associated procedures. Having a single repository containing both package definitions and “the package manager” is also a key enabler; we can change the framework, add new linguistic tools, and adjust package definitions at the same time. This is in contrast, for instance, with the approach taken by Nix, where the language implementation lives separately from the package collection.

Another one is that a strong, consistent community leads to consistent changes—not surprisingly in fact. It’s a pleasure to see that we, collectively, can undertake such overarching changes and all look in the same direction.

The last lesson is in how we approach design issues in a project that is now a little more than nine years old. Over these nine years it’s clear that we have usually favored “the right thing” in our design—but not at any cost. This whole change is an illustration of this. It was clear from the early days of Guix that input labels and the associated machinery were suboptimal. But it took us a few years to design an implement the missing pieces: G-expressions, self-referential records, and the various idioms that allow package definitions to benefit from these. In the meantime, we built a complete system and a community and we gained experience. We cannot claim we attained the right thing, if such a thing exists, but certainly package definitions today are closer to the declarative ideal and easier to teach.

It’s here today!

This big change, along with countless other improvements and package upgrades, is just one guix pull away! After months of development, we have just merged the “core updates” branch bringing so many new things—from GNOME 41, to GCC 10 by default, to hardened Python packages and improved executable startup times. This paves the way for the upcoming release, most likely labeled “1.4”, unless a closer review of the changes that have landed leads us to think “2.0” would be more appropriate… Stay tuned!

About GNU Guix

GNU Guix is a transactional package manager and an advanced distribution of the GNU system that respects user freedom. Guix can be used on top of any system running the Hurd or the Linux kernel, or it can be used as a standalone operating system distribution for i686, x86_64, ARMv7, AArch64 and POWER9 machines.

In addition to standard package management features, Guix supports transactional upgrades and roll-backs, unprivileged package management, per-user profiles, and garbage collection. When used as a standalone GNU/Linux distribution, Guix offers a declarative, stateless approach to operating system configuration management. Guix is highly customizable and hackable through Guile programming interfaces and extensions to the Scheme language.

15 December, 2021 03:00PM by Ludovic Courtès

December 13, 2021

Andy Wingo

webassembly: the new kubernetes?

I had an "oh, duh, of course" moment a few weeks ago that I wanted to share: is WebAssembly the next Kubernetes?

katers gonna k8s

Kubernetes promises a software virtualization substrate that allows you to solve a number of problems at the same time:

  • Compared to running services on bare metal, Kubernetes ("k8s") lets you use hardware more efficiently. K8s lets you run many containers on one hardware server, and lets you just add more servers to your cluster as you need them.

  • The "cloud of containers" architecture efficiently divides up the work of building server-side applications. Your database team can ship database containers, your backend team ships java containers, and your product managers wire them all together using networking as the generic middle-layer. It cuts with the grain of Conway's law: the software looks like the org chart.

  • The container abstraction is generic enough to support lots of different kinds of services. Go, Java, C++, whatever -- it's not language-specific. Your dev teams can use what they like.

  • The operations team responsible for the k8s servers that run containers don't have to trust the containers that they run. There is some sandboxing and security built-in.

K8s itself is an evolution on a previous architecture, OpenStack. OpenStack had each container be a full virtual machine, with a whole kernel and operating system and everything. K8s instead generally uses containers, which don't generally require a kernel in the containers. The result is that they are lighter-weight -- think Docker versus VirtualBox.

In a Kubernetes deployment, you still have the kernel at a central place in your software architecture. The fundamental mechanism of containerization is the Linux kernel process, with private namespaces. These containers are then glued together by TCP and UDP sockets. However, though one or more kernel process per container does scale better than full virtual machines, it doesn't generally scale to millions of containers. And processes do have some start-up time -- you can't spin up a container for each request to a high-performance web service. These technical contraints lead to certain kinds of system architectures, with generally long-lived components that keep some kind of state.

k8s <=? w9y

Server-side WebAssembly is in a similar space as Kubernetes -- or rather, WebAssembly is similar to processes plus private namespaces. WebAssembly gives you a good abstraction barrier and (can give) high security isolation. It's even better in some ways because WebAssembly provides "allowlist" security -- it has no capabilities to start with, requiring that the "host" that runs the WebAssembly explicitly delegate some of its own capabilities to the guest WebAssembly module. Compare to processes which by default start with every capability and then have to be restricted.

Like Kubernetes, WebAssembly also gets you Conway's-law-affine systems. Instead of shipping containers, you ship WebAssembly modules -- and some metadata about what kinds of things they need from their environment (the 'imports'). And WebAssembly is generic -- it's a low level virtual machine that anything can compile to.

But, in WebAssembly you get a few more things. One is fast start. Because memory is data, you can arrange to create a WebAssembly module that starts with its state pre-initialized in memory. Such a module can start in microseconds -- fast enough to create one on every request, in some cases, just throwing away the state afterwards. You can run function-as-a-service architectures more effectively on WebAssembly than on containers. Another is that the virtualization is provided entirely in user-space. One process can multiplex between many different WebAssembly modules. This lets one server do more. And, you don't need to use networking to connect WebAssembly components; they can transfer data in memory, sometimes even without copying.

(A digression: this lightweight in-process aspect of WebAssembly makes it so that other architectures are also possible, e.g. this fun hack to sandbox a library linked into Firefox. They actually shipped that!)

I compare WebAssembly to K8s, but really it's more like processes and private namespaces. So one answer to the question as initially posed is that no, WebAssembly is not the next Kubernetes; that next thing is waiting to be built, though I know of a few organizations that have started already.

One thing does seem clear to me though: WebAssembly will be at the bottom of the new thing, and therefore that the near-term trajectory of WebAssembly is likely to follow that of Kubernetes, which means...

  • Champagne time for analysts!

  • The Gartner ✨✨Magic Quadrant✨✨™®© rides again

  • IBM spins out a new WebAssembly division

  • Accenture starts asking companies about their WebAssembly migration plan

  • The Linux Foundation tastes blood in the waters

And so on. I see turbulent waters in the near-term future. So in that sense, in which Kubernetes is not essentially a technical piece of software but rather a nexus of frothy commercial jousting, then yes, certainly: we have a fun 5 years or so ahead of us.

13 December, 2021 03:50PM by Andy Wingo

December 12, 2021

guile-sdl @ Savannah

GNU Guile-SDL 0.5.3 available

GNU Guile-SDL is Guile plus SDL.  Simple, no?

The full announcement was posted to the info-gnu mailing list:

12 December, 2021 01:26AM by Thien-Thi Nguyen

December 11, 2021

serveez @ Savannah

GNU Serveez 0.3.0 available

GNU Serveez is a server framework.  It provides routines and help for implementing IP-based servers (currently TCP, UDP and ICMP), and supports named pipes for all connection-oriented protocols.  It uses GNU Guile for (runtime) configuration and supports servers written fully in Scheme.  GNU Serveez can also be configured to install libserveez, and more.

The full announcement was posted to the info-gnu mailing list:

11 December, 2021 11:25PM by Thien-Thi Nguyen

December 10, 2021

FSF News

December 05, 2021

gnuastro @ Savannah

Gnuastro 0.16 released

The 16th release of GNU Astronomy Utilities (Gnuastro) was released in October 10th, 2021. See the full announcement (and the correction in version 0.16.1) for more.

05 December, 2021 05:54PM by Mohammad Akhlaghi

December 02, 2021

poke @ Savannah

GNU poke 1.4 released

I am happy to announce a new release of GNU poke, version 1.4.

This is what expect to be the last bug fix release in the poke 1.x maintenance series.  We are working very hard in what will become poke 2.0, expected to be released in February 2022.

See the file NEWS in the released tarball for a detailed list of
changes in this release.

The tarball poke-1.4.tar.gz is now available at
https://ftp.gnu.org/gnu/poke/poke-1.4.tar.gz.

  GNU poke (http://www.jemarch.net/poke) is an interactive,
  extensible editor for binary data.  Not limited to editing
  basic entities such as bits and bytes, it provides a full-
  fledged procedural,interactive programming language designed
  to describe data structures and to operate on them.

Thanks to the people who contributed with code and/or documentation to this release.  In certain but no significant order they are:

  Mohammad-Reza Nabipoor <m.nabipoor@yahoo.com>
  Guillermo E. Martinez <guillermo.e.martinez@oracle.com>
  Fangrui Song <i@maskray.me>

As always, thank you all!

And this is all for now.
Happy poking!

--
Jose E. Marchesi
Frankfurt am Main
3 December 2021

02 December, 2021 10:44PM by Jose E. Marchesi

November 23, 2021

parallel @ Savannah

GNU Parallel 20211122 ('Peng Shuai') released [stable]

GNU Parallel 20211122 ('Peng Shuai') [stable] has been released. It is available for download at: lbry://@GnuParallel:4

No new functionality was introduced so this is a good candidate for a stable release.

Quote of the month:

  GNU parallel 便利すぎ
    -- @butagannen@twitter 豚顔面

New in this release:

  • Bug fixes and man page updates.

News about GNU Parallel:

Get the book: GNU Parallel 2018 http://www.lulu.com/shop/ole-tange/gnu-parallel-2018/paperback/product-23558902.html

GNU Parallel - For people who live life in the parallel lane.

If you like GNU Parallel record a video testimonial: Say who you are, what you use GNU Parallel for, how it helps you, and what you like most about it. Include a command that uses GNU Parallel if you feel like it.

About GNU Parallel

GNU Parallel is a shell tool for executing jobs in parallel using one or more computers. A job can be a single command or a small script that has to be run for each of the lines in the input. The typical input is a list of files, a list of hosts, a list of users, a list of URLs, or a list of tables. A job can also be a command that reads from a pipe. GNU Parallel can then split the input and pipe it into commands in parallel.

If you use xargs and tee today you will find GNU Parallel very easy to use as GNU Parallel is written to have the same options as xargs. If you write loops in shell, you will find GNU Parallel may be able to replace most of the loops and make them run faster by running several jobs in parallel. GNU Parallel can even replace nested loops.

GNU Parallel makes sure output from the commands is the same output as you would get had you run the commands sequentially. This makes it possible to use output from GNU Parallel as input for other programs.

For example you can run this to convert all jpeg files into png and gif files and have a progress bar:

  parallel --bar convert {1} {1.}.{2} ::: *.jpg ::: png gif

Or you can generate big, medium, and small thumbnails of all jpeg files in sub dirs:

  find . -name '*.jpg' |
    parallel convert -geometry {2} {1} {1//}/thumb{2}_{1/} :::: - ::: 50 100 200

You can find more about GNU Parallel at: http://www.gnu.org/s/parallel/

You can install GNU Parallel in just 10 seconds with:

    $ (wget -O - pi.dk/3 || lynx -source pi.dk/3 || curl pi.dk/3/ || \
       fetch -o - http://pi.dk/3 ) > install.sh
    $ sha1sum install.sh | grep c82233e7da3166308632ac8c34f850c0
    12345678 c82233e7 da316630 8632ac8c 34f850c0
    $ md5sum install.sh | grep ae3d7aac5e15cf3dfc87046cfc5918d2
    ae3d7aac 5e15cf3d fc87046c fc5918d2
    $ sha512sum install.sh | grep dfc00d823137271a6d96225cea9e89f533ff6c81f
    9c5198d5 31a3b755 b7910ece 3a42d206 c804694d fc00d823 137271a6 d96225ce
    a9e89f53 3ff6c81f f52b298b ef9fb613 2d3f9ccd 0e2c7bd3 c35978b5 79acb5ca
    $ bash install.sh

Watch the intro video on http://www.youtube.com/playlist?list=PL284C9FF2488BC6D1

Walk through the tutorial (man parallel_tutorial). Your command line will love you for it.

When using programs that use GNU Parallel to process data for publication please cite:

O. Tange (2018): GNU Parallel 2018, March 2018, https://doi.org/10.5281/zenodo.1146014.

If you like GNU Parallel:

  • Give a demo at your local user group/team/colleagues
  • Post the intro videos on Reddit/Diaspora*/forums/blogs/ Identi.ca/Google+/Twitter/Facebook/Linkedin/mailing lists
  • Get the merchandise https://gnuparallel.threadless.com/designs/gnu-parallel
  • Request or write a review for your favourite blog or magazine
  • Request or build a package for your favourite distribution (if it is not already there)
  • Invite me for your next conference

If you use programs that use GNU Parallel for research:

  • Please cite GNU Parallel in you publications (use --citation)

If GNU Parallel saves you money:

About GNU SQL

GNU sql aims to give a simple, unified interface for accessing databases through all the different databases' command line clients. So far the focus has been on giving a common way to specify login information (protocol, username, password, hostname, and port number), size (database and table size), and running queries.

The database is addressed using a DBURL. If commands are left out you will get that database's interactive shell.

When using GNU SQL for a publication please cite:

O. Tange (2011): GNU SQL - A Command Line Tool for Accessing Different Databases Using DBURLs, ;login: The USENIX Magazine, April 2011:29-32.

About GNU Niceload

GNU niceload slows down a program when the computer load average (or other system activity) is above a certain limit. When the limit is reached the program will be suspended for some time. If the limit is a soft limit the program will be allowed to run for short amounts of time before being suspended again. If the limit is a hard limit the program will only be allowed to run when the system is below the limit.

23 November, 2021 12:36AM by Ole Tange

November 18, 2021

Luca Saiu

Global variable initialisation in C++

Today Volker Birk (https://fdik.org/) and I were speaking over lunch about object initialisation in C++ and about how weakly defined a program entry point is, because of objects with static storage duration. Volker wrote a short program whose output changes after reversing the order of two variable definitions, both out of a ‘main’ function whose entire body was ‘return 0;’. He discussed it in German (https://blog.fdik.org/2021-11/s1637238415), on his blog (https://blog.fdik.org). I was more annoyed by the fact that initialisation order is not guaranteed to respect functional dependency across compilation units. Here is my test case, where GCC and the GNU ... [Read more]

18 November, 2021 09:00PM by Luca Saiu (positron@gnu.org)

November 15, 2021

guile-cv @ Savannah

Guile-CV version 0.3.1

Guile-CV version 0.3.1 is released! (November 2021)

This is a maintenance release, which fixes a bug in the pre-inst-env script, which is used by Guile-CV at build time and may also be used to test and run an uninstalled Guile-CV instance.

Changes since the previous version

For a list of changes since the previous version, visit the  NEWS file. For a complete description, consult the git summary and git log.

The pre-inst-env.in script has been fixed and now adds a specific build time library location, so Guile 3.0 (>= 3.0.6) finds libguile-cv at build time.

Guile 3.0 (>= 3.0.6) does not use libltdl anymore, and although in guile (system foreign-library) module, both the comment and the definition of augment-ltdl-library-path seems to take care of finding .so files either aside .la or in a .libs/ subdir, it does not work.

15 November, 2021 11:38PM by David Pirotte

health @ Savannah

Thalamus documentation now at GNU Health portal

Dear all

We're happy to announce that the documentation of Thalamus, the GNU Health Federation message and authentication server, resides now at the GH documentation portal!

https://www.gnuhealth.org/docs

In addition to the portal, we are migrating all the documentation to reStructuredText. Having the documentation in RST format makes it simpler for collaboration. The user will also be able to access it even without Internet connectivity.

MyGNUHealth (Personal Health Record) and Thalamus have been already migrated and translated to different languages (Spanish, German, French). The GH Hospital Management System component is in the process of migration. This requires quite a bit of work, updating the documentation and images from 40+ packages.

At the end we'll have a very nice, structured GNU Health documentation portal!

Happy and healthy hacking!
Luis

15 November, 2021 08:18PM by Luis Falcon

November 08, 2021

guile-cv @ Savannah

Guile-CV version 0.3.0

Guile-CV version 0.3.0 is released! (November 2021)

This is a maintenance release, which allows Guile-CV to work with Guile 3.0 (>= 3.0.7 to be specific). In addition, im-transpose performance has been improved.

The documentation has been restructured and follows the model we adopted for GNU G-Golf. The Configuring Guile's raised exception system section has been updated. Make sure you carefully read and apply the proposed changes.

Changes since the previous version

For a list of changes since the previous version, visit the NEWS file. For a complete description, consult the git summary and git log

08 November, 2021 03:24AM by David Pirotte

November 07, 2021

poke @ Savannah

Video: the Poke compiler and the PVM

We have published a video with an online session we made as an introduction of GNU poke internals for new developers.  We mainly covered the Poke compiler and the poke virtual machine (PVM) and how to extend them to implement new language constructions.

The video can be found at:
https://www.youtube.com/watch?v=i7hehlAeOqY

Thanks to Mohammad Reza-Nabipoor for editing the video!

07 November, 2021 01:20PM by Jose E. Marchesi

November 06, 2021

remotecontrol @ Savannah

November 03, 2021

GNU Taler news

Understanding and designing technologies for everyday financial collaboration

We are happy to announce that Belén finished her PhD thesison"Understanding and designing technologies for everyday financialcollaboration" which contains many inspirational ideas for futurepayment systems like GNU Taler:

03 November, 2021 11:00PM

October 28, 2021

Mike Gran

May you live in interesting times

Hey everybody.

So last February now, I, in a fit of optimism, thought I'd take on the Guile Potluck duties for 2021: asking people to submit the fun stuff they were up to, and then I'd blog about it. That didn't happen, for which I humbly apologize. But I should know by now that every time I actually commit to something publicly visible in free software, reality intervenes. So from now on, I promise that I will never again commit to anything.

But life is getting better, my vision problems are improving. My back is all healed and I can actually sit in an office chair all day without pain.

So yeah.

Anyway, while I shy away from term commitment, I do have intention to make good on old promises.

In the meantime (and one of the reasons I'm actually talking about feelings on this backup blog right now instead of my standard repository of feelings) I do have to do something about my always-neglected primary website Lonely Cactus which apparently has gone to blog heaven.  A pity. There was some cool stuff on there.

My hope is to get Lonely Cactus up and running on a different set of technologies, as a learning exercise.  Maybe a GNU/Hurd VM. Maybe Guix.  Because if you're going to do something weird, might as well go all the way.

But in real life, if you're keeping score, I have returned to /dev/null. Single again, no kids in the house anymore, unfit, no church life to speak of. I still own this dilapidated, century-old house in Los Angeles, and have a day job, so I'm better off than billions of people. And I'm lucky in that comparatively few people I know have died during the plague year. 

Time for life v4.0, or v5.0. I'm not sure of my current revision number.


28 October, 2021 04:02PM by Mike (noreply@blogger.com)

October 27, 2021

Trisquel GNU/Linux

Release announcement: Trisquel 9.0.1 Etiona security update

Images are available at https://trisquel.info/download or directly at https://cdimage.trisquel.info/ and its mirrors.

This minor update to the 9.x "Etiona" series is intended to provide an up to date set of ISO images, both for use as an installation medium and as a live environment with newer packages. This addresses two main security concerns in the 9.0 original ISO images:

Along with those fixes, the release includes any other security update published upstream since we published Etiona, and the latest version of the Mozilla-based "Abrowser" (v93).

These updates will contribute to keep the v9.0 branch in good working order as it will continue to be actively maintained until April 2023.

In other news, the development of Trisquel 10 is ongoing at great pace, with initial ISO images being now available for testing at https://cdbuilds.trisquel.org/nabia/ Please note that these images are not yet   intended for production usage, so use them only for testing and development or (as it is true in any case) at your own risk.

 

27 October, 2021 07:36PM by quidam

October 26, 2021

GNU Guix

From ‘guix environment’ to ‘guix shell’

There are times when what looked like the right design choice some years back comes out as an odd choice as time passes. The beloved guix environment tool is having that fate. Its command-line interface has become non-intuitive and annoying for the most common use cases. Since it could not be changed without breaking compatibility in fundamental ways, we devised a new command meant to progressively replace it; guix shell—that’s the name we unimaginatively ended up with—has just landed after a three-week review period, itself a followup to discussions and hesitations on the best course of action.

This post introduces guix shell, how it differs from guix environment, the choices we made, and why we hope you will like it.

The story of guix environment

The guix environment command started its life in 2014, when Guix was a two-year old baby and the whole community could fit in a small room. It had one purpose: “to assist hackers in creating reproducible development environments”. It was meant to be similar in spirit to VirtualEnv or Bundler, but universal—not limited to a single language. You would run:

guix environment inkscape

… and obtain an interactive shell with all the packages needed to hack on Inkscape; in that shell, the relevant environment variables—PATH, CPATH, PKG_CONFIG_PATH, and so on—would automatically point to a profile created on the fly and containing the compiler, libraries, and tools Inkscape depends on, but not Inkscape itself.

Only a year later did it become clear that there are cases where one would want to create an environment containing specific packages, rather than an environment containing the dependencies of packages. To address that, David Thompson proposed the --ad-hoc option:

guix environment --ad-hoc inkscape -- inkscape

… would create an environment containing only Inkscape, and would then launch the inkscape command in that environment. Many features were added over the years, such as the invaluable --container option, but these two modes, development and “ad hoc”, are the guts of it.

Fast forward six years: today, there’s consensus that the name --ad-hoc is confusing for newcomers and above all, that the “ad hoc” mode should be the default. This is the main problem that guix shell addresses.

Doing what you’d expect

Changing the default mode from “development environment” to “ad hoc” is technically easy, but how to do that without breaking compatibility is harder. This led to lengthy discussions, including proposals of mechanisms to choose between the new and old semantics.

In the end, keeping the guix environment name while allowing it to have different semantics was deemed dangerous. For one thing, there’s lots of material out there that demoes guix environment—blog posts, magazine articles, on-line courses—and it would have been impossible to determine whether they refer to the “new” or to the “old” semantics. We reached the conclusion that it would be easier to use a new command name and to eventually deprecate guix environment.

With guix shell, the default is to create an environment that contains the packages that appear on the command line; to launch Inkscape, run:

guix shell inkscape -- inkscape

The --ad-hoc option is gone! Likewise, to spawn an ephemeral development environment containing Python and a couple of libraries, run:

guix shell python python-numpy python-scipy -- python3

Now, if you want, say, the development environment of Inkscape, add the --development or -D option right before:

guix shell -D inkscape

You can add Git and GDB on top of it like so:

guix shell -D inkscape git gdb

(Note that -D only applies to the immediately following package, inkscape in this case.) It’s more concise and more natural than with guix environment. As can be seen in the manual, all the other options supported by guix environment remain available in guix shell.

Short-hands for development environments

A convention that’s become quite common is for developers to provide a guix.scm at the top of their project source tree, so that others can start a development environment right away:

guix environment -l guix.scm

The guix.scm file would contain a package definition for the project at hand, as in this example. This option is known as -f in guix shell, for consistency with other commands, and the equivalent command is:

guix shell -D -f guix.scm

Since all Guix commands accept a “manifest” with -m, another option is to provide a manifest.scm file and to run:

guix shell -m manifest.scm

“Wouldn’t it be nice if guix shell would automatically follow these conventions when not given any argument?”, some suggested. As in the case of Bundler, direnv, or typical build tools from Meson to Make, having a default file name can save typing and contribute to a good user experience for frequently-used commands. In this spirit, guix shell automatically loads guix.scm or manifest.scm, from the current directory or an ancestor thereof, such that entering a project to hack on it is as simple as:

cd ~/my/project/src
guix shell

Worry not: guix shell loads guix.scm or manifest.scm if and only if you have first added its directory to ~/.config/guix/shell-authorized-directories. Otherwise guix shell warns you and prints a hint that you can copy/paste if you want to authorize the directory.

Caching environments

With that in place, guix shell can pretty much fill the same role as direnv and similar tools, with one difference though: speed. When all the packages are already in store, guix shell can take one to a few seconds to run, depending on the package set, on whether you’re using a solid state device (SSD) or a “spinning” hard disk, and so on. It’s acceptable but prohibitively slow for direnv-like use cases.

To address that, guix shell maintains a profile cache for the -D -f guix.scm and -m manifest.scm cases. On a hot cache, it runs in 0.1 second. All it has to do is fork a shell with the right environment variable definitions; it does not talk to guix-daemon, and it does not even read guix.scm or manifest.scm (it’s possible to forcefully update the cache with --rebuild-cache).

That makes guix shell usable even for short-lived commands like make:

guix shell -- make

Hopefully it’ll change the way we use the tool!

The shell doctor

While revamping this command-line interface, the idea of a “shell doctor” came up. In interactive use, guix shell sets environment variables and spawns a shell, but it’s not uncommon for the shell to mess up with the whole environment. Why? Because, contrary to documented practice, it’s quite common for users to define or override environment variables in the startup files of non-login shells, ~/.bashrc for Bash, ~/.zshrc for Zsh. Instead, environment variable definitions should go to the startup file of login shells—~/.bash_profile, ~/.profile, or similar. But let’s face it: it’s a subtle distinction that few of us know or care about.

As a result, users of Guix, especially on distros other than Guix System, would often be disappointed when running guix environment --pure and yet find that PATH contains non-Guix entries, that there’s a bogus LD_LIBRARY_PATH definition, and whatnot. Now, they can call the doctor, so to speak, to obtain a diagnosis of the health of their shell by adding the --check flag:

guix shell --check python python-numpy

The command creates an environment containing Python and NumPy, spawns an interactive shell, checks the environment variables as seen by the shell, and prints a warning if PATH or PYTHONPATH in this case have been overridden. It does not tell users where the problem comes from—it cannot guess—but it tells them if something’s wrong, which is a first step.

Of course, the best way to sidestep these problems is to pass --container, which gives a fresh, isolated environment that does not contain those startup files. That’s not always an option though, for instance on systems lacking support for unprivileged user namespaces, so --check comes in handy there.

Try it!

Just run guix pull to get this shiny new guix shell thingie!

If you don’t feel ready yet, that’s OK: guix environment won’t disappear overnight. We have a written commitment to keep it around until May, 1st 2023. Though overall, we hope you’ll find the guix shell interface easier to use and compelling enough that you’ll be willing to switch overnight!

About GNU Guix

GNU Guix is a transactional package manager and an advanced distribution of the GNU system that respects user freedom. Guix can be used on top of any system running the Hurd or the Linux kernel, or it can be used as a standalone operating system distribution for i686, x86_64, ARMv7, AArch64 and POWER9 machines.

In addition to standard package management features, Guix supports transactional upgrades and roll-backs, unprivileged package management, per-user profiles, and garbage collection. When used as a standalone GNU/Linux distribution, Guix offers a declarative, stateless approach to operating system configuration management. Guix is highly customizable and hackable through Guile programming interfaces and extensions to the Scheme language.

26 October, 2021 03:00PM by Ludovic Courtès

October 22, 2021

parallel @ Savannah

GNU Parallel 20211022 ('Sinclair') released

GNU Parallel 20211022 ('Sinclair') has been released. It is available for download at: lbry://@GnuParallel:4

Quote of the month:

  GNU parallel is a severely underrated tool for just spawning a
  shitload of tasks. I use it every day and fucking love it.
    -- Jane @serialexpjane@twitter

New in this release:

  • Don't postpone output until $jobslots jobs have been started.
  • Bug fixes and man page updates.

News about GNU Parallel:

Get the book: GNU Parallel 2018 http://www.lulu.com/shop/ole-tange/gnu-parallel-2018/paperback/product-23558902.html

GNU Parallel - For people who live life in the parallel lane.

If you like GNU Parallel record a video testimonial: Say who you are, what you use GNU Parallel for, how it helps you, and what you like most about it. Include a command that uses GNU Parallel if you feel like it.

About GNU Parallel

GNU Parallel is a shell tool for executing jobs in parallel using one or more computers. A job can be a single command or a small script that has to be run for each of the lines in the input. The typical input is a list of files, a list of hosts, a list of users, a list of URLs, or a list of tables. A job can also be a command that reads from a pipe. GNU Parallel can then split the input and pipe it into commands in parallel.

If you use xargs and tee today you will find GNU Parallel very easy to use as GNU Parallel is written to have the same options as xargs. If you write loops in shell, you will find GNU Parallel may be able to replace most of the loops and make them run faster by running several jobs in parallel. GNU Parallel can even replace nested loops.

GNU Parallel makes sure output from the commands is the same output as you would get had you run the commands sequentially. This makes it possible to use output from GNU Parallel as input for other programs.

For example you can run this to convert all jpeg files into png and gif files and have a progress bar:

  parallel --bar convert {1} {1.}.{2} ::: *.jpg ::: png gif

Or you can generate big, medium, and small thumbnails of all jpeg files in sub dirs:

  find . -name '*.jpg' |
    parallel convert -geometry {2} {1} {1//}/thumb{2}_{1/} :::: - ::: 50 100 200

You can find more about GNU Parallel at: http://www.gnu.org/s/parallel/

You can install GNU Parallel in just 10 seconds with:

    $ (wget -O - pi.dk/3 || lynx -source pi.dk/3 || curl pi.dk/3/ || \
       fetch -o - http://pi.dk/3 ) > install.sh
    $ sha1sum install.sh | grep c82233e7da3166308632ac8c34f850c0
    12345678 c82233e7 da316630 8632ac8c 34f850c0
    $ md5sum install.sh | grep ae3d7aac5e15cf3dfc87046cfc5918d2
    ae3d7aac 5e15cf3d fc87046c fc5918d2
    $ sha512sum install.sh | grep dfc00d823137271a6d96225cea9e89f533ff6c81f
    9c5198d5 31a3b755 b7910ece 3a42d206 c804694d fc00d823 137271a6 d96225ce
    a9e89f53 3ff6c81f f52b298b ef9fb613 2d3f9ccd 0e2c7bd3 c35978b5 79acb5ca
    $ bash install.sh

Watch the intro video on http://www.youtube.com/playlist?list=PL284C9FF2488BC6D1

Walk through the tutorial (man parallel_tutorial). Your command line will love you for it.

When using programs that use GNU Parallel to process data for publication please cite:

O. Tange (2018): GNU Parallel 2018, March 2018, https://doi.org/10.5281/zenodo.1146014.

If you like GNU Parallel:

  • Give a demo at your local user group/team/colleagues
  • Post the intro videos on Reddit/Diaspora*/forums/blogs/ Identi.ca/Google+/Twitter/Facebook/Linkedin/mailing lists
  • Get the merchandise https://gnuparallel.threadless.com/designs/gnu-parallel
  • Request or write a review for your favourite blog or magazine
  • Request or build a package for your favourite distribution (if it is not already there)
  • Invite me for your next conference

If you use programs that use GNU Parallel for research:

  • Please cite GNU Parallel in you publications (use --citation)

If GNU Parallel saves you money:

About GNU SQL

GNU sql aims to give a simple, unified interface for accessing databases through all the different databases' command line clients. So far the focus has been on giving a common way to specify login information (protocol, username, password, hostname, and port number), size (database and table size), and running queries.

The database is addressed using a DBURL. If commands are left out you will get that database's interactive shell.

When using GNU SQL for a publication please cite:

O. Tange (2011): GNU SQL - A Command Line Tool for Accessing Different Databases Using DBURLs, ;login: The USENIX Magazine, April 2011:29-32.

About GNU Niceload

GNU niceload slows down a program when the computer load average (or other system activity) is above a certain limit. When the limit is reached the program will be suspended for some time. If the limit is a soft limit the program will be allowed to run for short amounts of time before being suspended again. If the limit is a hard limit the program will only be allowed to run when the system is below the limit.

22 October, 2021 08:42PM by Ole Tange

October 19, 2021

gdbm @ Savannah

Version 1.22

Version 1.22 is available for download.  This version includes several bugfixes and improves the documentation.  The list of bugfixes follows:

  • Fix file header validation
  • Fix key verification in sequential access
  • Fix testing with DejaGNU 1.6.3
  • Fix stack overflow in print_usage
  • Fix a leak of avail entry on pushing a new avail block
  • Calls to gdbm_recover preserve crash tolerance settings

19 October, 2021 05:49AM by Sergey Poznyakoff

October 18, 2021

health @ Savannah

MyGNUHealth release 1.0.5 is out!

Dear community

We are very happy to announce MyGNUHealth 1.0.5, the libre, privacy-oriented, Personal Health Record from GNU Health.

This maintenance release contains bug fixes and three new languages for the documentation:

  • French
  • German
  • Spanish

The source English documentation has been revised.

The main package resides at GNU.org, and contains both the source and all the documentation languages.

To save download time and disk space, the packages at the Python Package Index (PyPi) contain only the source English language. You can always download your language(s) pack from GNU.org or read it online at the GNU Health documentation portal (https://www.gnuhealth.org/docs).

Thank you to all contributors, and we hope you enjoy MyGNUHealth as much as we do developing it :)

Happy and healthy hacking
Luis

 

About GNU Health

GNU Health is a Libre, community driven project from GNU Solidario (https://www.gnusolidario.org), a non-profit humanitarian organization focused on Social Medicine. Our project has been adopted by hospitals, laboratories, multilateral organizations and national public health systems around the world.

The GNU Health project provides the tools for individuals, health professionals, institutions and governments to proactively assess and improve the underlying determinants of health, from the socioeconomic agents to the molecular basis of disease. From primary health care to precision medicine.

The main components of the GNU Health digital health ecosystem are:

  • Hospital Management
  • Laboratory Management and bioinformatics
  • Personal Health Record (MyGNUHealth)
  • Thalamus (the GNU Health Federation message server)
  • Health Information System (reporting / epidemiology)

GNU Health is an official GNU project, licensed under GPL v3+

18 October, 2021 08:13PM by Luis Falcon

October 11, 2021

GNU Taler news

Cómo Emitir una Moneda Digital del Banco Central

Nos complace anunciar la publicación de nuestro artículo sobre"Cómo Emitir una Moneda Digital del Banco Central"que es un trabajo conjunto con el Banque nationale suisse.

11 October, 2021 10:00PM

October 09, 2021

remotecontrol @ Savannah

Corrections & Amplifications - WSJ - October 9th, 2021

https://www.wsj.com/articles/corrections-amplifications-11633728902

The editor of the Wall Street Journal has retracted their article about the new Google Nest Thermostat feature by issuing a public correction announcement.

09 October, 2021 11:42AM by Stephen H. Dawson DSL

October 07, 2021

Google Rolls Out Emission-Curbing Tools for Nest Thermostat

https://www.wsj.com/articles/google-rolls-out-emission-curbing-tools-for-nest-thermostat-11633503660

This offering from Google is false advertising. There is no means for an electricity customer to select the source of the electricity provided to their premises.

07 October, 2021 03:33PM by Stephen H. Dawson DSL

nano @ Savannah

GNU nano 5.9 was released

Version 5.5 brought the option --minibar, for a minimized user interface, and version 5.6 brought the spotlighting of a search match, in black on yellow by default.  Subsequent versions added a few minor things and fixed some bugs.

07 October, 2021 10:03AM by Benno Schulenberg

October 05, 2021

FSF News

October 04, 2021

automake @ Savannah

automake-1.16.5 released [stable]

This is to announce automake-1.16.5, a stable release.

Thanks to Karl for doing all the real work.
See the NEWS below for a brief summary.

There have been 18 commits by 6 people in the 10 weeks since 1.16.4.

See the NEWS below for a brief summary.

Thanks to everyone who has contributed!
The following people contributed changes to this release:

  Akim Demaille (1)
  Dimitri Papadopoulos (1)
  Jan Engelhardt (1)
  Jim Meyering (6)
  Karl Berry (8)
  Nick Bowler (1)

Jim [on behalf of the automake maintainers]
==================================================================

Here is the GNU automake home page:
    http://gnu.org/s/automake/

Here are the compressed sources:
  https://ftp.gnu.org/gnu/automake/automake-1.16.5.tar.xz (1.6MB)
  https://ftp.gnu.org/gnu/automake/automake-1.16.5.tar.gz (2.3MB)

Here are the GPG detached signatures[*]:
  https://ftp.gnu.org/gnu/automake/automake-1.16.5.tar.xz.sig
  https://ftp.gnu.org/gnu/automake/automake-1.16.5.tar.gz.sig

Use a mirror for higher download bandwidth:
  https://ftpmirror.gnu.org/automake/automake-1.16.5.tar.xz
  https://ftpmirror.gnu.org/automake/automake-1.16.5.tar.gz

Here are the SHA1 and SHA256 checksums:

8B1YzW2dd/vcqetLvV6tGYgij9tz1veiAfX41rEYtGk  automake-1.16.5.tar.xz
B70krQimS8FyUM4J7FbpIdY0OQOUPpnM9ju/BwXjRgU  automake-1.16.5.tar.gz

Each SHA256 checksum is base64 encoded, instead of the
hexadecimal encoding that most checksum tools default to.

[*] Use a .sig file to verify that the corresponding file (without the
.sig suffix) is intact.  First, be sure to download both the .sig file
and the corresponding tarball.  Then, run a command like this:

  gpg --verify automake-1.16.5.tar.xz.sig

If that command fails because you don't have the required public key,
then run this command to import it:

  gpg --keyserver keys.gnupg.net --recv-keys 7FD9FCCB000BEEEE

and rerun the 'gpg --verify' command.

Please report bugs and problems to <bug-automake@gnu.org>,
and send general comments and feedback to <automake@gnu.org>.

==================================================================
NEWS

* Bugs fixed

  - PYTHON_PREFIX and PYTHON_EXEC_PREFIX are now set according to
    Python's sys.* values only if the new configure option
    --with-python-sys-prefix is specified. Otherwise, GNU default values
    are used, as in the past. (The change in 1.16.3 was too incompatible.)

  - consistently depend on install-libLTLIBRARIES.

* Distribution

  - use const for yyerror declaration in bison/yacc tests.

04 October, 2021 04:49AM by Jim Meyering

September 29, 2021

GNU Anastasis

GNU Anastasis v0.2.0 released

GNU Anastasis is a Free Software protocol and implementation that allows users to securely deposit core secrets with an open set of escrow providers and to recover these secrets if their original copies are lost.

29 September, 2021 10:00PM

GNU Anastasis v0.2.0 released

GNU Anastasis is a Free Software protocol and implementation that allows users to securely deposit core secrets with an open set of escrow providers and to recover these secrets if their original copies are lost.

29 September, 2021 10:00PM

September 24, 2021

coreutils @ Savannah

Subject: coreutils-9.0 released [stable]

This is to announce coreutils-9.0, a stable release.

This is a new major release, with these significant changes:
  - cp has changed how it handles data
    - enables CoW by default (through FICLONE ioctl),
    - uses copy offload where available (through copy_file_range),
    - detects holes differently (though SEEK_HOLE)
    - This also applies to mv and install.

  - utilities are more tuned to the hardware available
    - wc uses avx2 instructions to count lines
    - cksum uses pclmul instructions for --algorithm=crc

  - More amalgamation of utilities
    - cksum now supports the -a option to select any digest.
    - This is the preferred interface, rather than sha*sum etc.
    - This is similar to the amalgamation of encoding utilities
      introduced in the basenc command in v8.31.
See the NEWS below for more details.

Thanks to everyone who has contributed!
There have been 257 commits by 25 people in the 81 weeks since 8.32
  Andreas Schwab (1)              KOBAYASHI Takashi (2)
  Arman Absalan (1)               Kamil Dudka (4)
  Assaf Gordon (1)                Kristoffer Brånemyr (3)
  Ben Pfaff (1)                   Nikolay Nechaev (1)
  Benno Schulenberg (1)           Nishant Nayan (1)
  Bernhard Voelker (17)           Paul Eggert (97)
  Carl Edquist (2)                Pádraig Brady (110)
  Emanuele Giacomelli (1)         Tianjia Zhang (1)
  Erik Auerswald (1)              Tim Gates (1)
  Grigorii Sokolik (2)            Tobias Stoeckmann (1)
  Jason Kim (1)                   Zorro Lang (1)
  Jim Meyering (7)                nl6720 (1)
  Justin Tracey (1)

Pádraig [on behalf of the coreutils maintainers]

==================================================================

Here is the GNU coreutils home page:
   https://gnu.org/software/coreutils/

For a summary of changes and contributors, see:
   https://git.sv.gnu.org/gitweb/?p=coreutils.git;a=shortlog;h=v9.0
or run this command from a git-cloned coreutils directory:
   git shortlog v8.32..v9.0

To summarize the 1615 gnulib-related changes, run these commands
from a git-cloned coreutils directory:
   git checkout v9.0
   git submodule summary v8.32

==================================================================


Here are the compressed sources:
  https://ftp.gnu.org/gnu/coreutils/coreutils-9.0.tar.gz   (14MB)
  https://ftp.gnu.org/gnu/coreutils/coreutils-9.0.tar.xz   (5.4MB)

Here are the GPG detached signatures[*]:
  https://ftp.gnu.org/gnu/coreutils/coreutils-9.0.tar.gz.sig
  https://ftp.gnu.org/gnu/coreutils/coreutils-9.0.tar.xz.sig

Use a mirror for higher download bandwidth:
  https://www.gnu.org/order/ftp.html

Here are the SHA1 and SHA256 checksums:

027a318930f295cb5bbc0dd06fb47a3b8552fc80  coreutils-9.0.tar.gz
b9TriKUVAEl3/HLX9HtAYgQJzEHfrwBBn90b4XZjxDQ  coreutils-9.0.tar.gz
e2623469f37259d4a89ced5f91af5eaf0ab8792d  coreutils-9.0.tar.xz
zjCs30pBvFuzDdlV6eqnX6IWtOPesIiJ7TJDPHs7l84  coreutils-9.0.tar.xz

The SHA256 checksum is base64 encoded, instead of the
hexadecimal encoding that most checksum tools default to.

[*] Use a .sig file to verify that the corresponding file (without the
.sig suffix) is intact.  First, be sure to download both the .sig file
and the corresponding tarball.  Then, run a command like this:

  gpg --verify coreutils-9.0.tar.gz.sig

If that command fails because you don't have the required public key,
then run this command to import it:

  gpg --keyserver keys.gnupg.net --recv-keys DF6FD971306037D9

and rerun the 'gpg --verify' command.

This release was bootstrapped with the following tools:
  Autoconf 2.71
  Automake 1.16.4
  Gnulib v0.1-4937-g9aca7b673
  Bison 3.7.4

==================================================================

NEWS

* Noteworthy changes in release 9.0 (2021-09-24) [stable]

** Bug fixes

  chmod -v no longer misreports modes of dangling symlinks.
  [bug introduced in coreutils-5.3.0]

  cp -a --attributes-only now never removes destination files,
  even if the destination files are hardlinked, or the source
  is a non regular file.
  [bug introduced in coreutils-8.6]

  csplit --suppress-matched now elides the last matched line
  when a specific number of pattern matches are performed.
  [bug introduced with the --suppress-matched feature in coreutils-8.22]

  df no longer outputs duplicate remote mounts in the presence of bind mounts.
  [bug introduced in coreutils-8.26]

  df no longer mishandles command-line args that it pre-mounts
  [bug introduced in coreutils-8.29]

  du no longer crashes on XFS file systems when the directory hierarchy is
  heavily changed during the run.
  [bug introduced in coreutils-8.25]

  env -S no longer crashes when given unusual whitespace characters
  [bug introduced in coreutils-8.30]

  expr no longer mishandles unmatched \(...\) in regular expressions.
  [bug introduced in coreutils-6.0]

  ls no longer crashes when printing the SELinux context for unstatable files.
  [bug introduced in coreutils-6.9.91]

  mkdir -m no longer mishandles modes more generous than the umask.
  [bug introduced in coreutils-8.22]

  nl now handles single character --section-delimiter arguments,
  by assuming a second ':' character has been specified, as specified by POSIX.
  [This bug was present in "the beginning".]

  pr again adjusts tabs in input, to maintain alignment in multi column output.
  [bug introduced in coreutils-6.9]

  rm no longer skips an extra file when the removal of an empty directory fails.
  [bug introduced by the rewrite to use fts in coreutils-8.0]

  split --number=K/N will again correctly split chunk K of N to stdout.
  Previously a chunk starting after 128KiB, output the wrong part of the file.
  [bug introduced in coreutils-8.26]

  tail -f no longer overruns a stack buffer when given too many files
  to follow and ulimit -n exceeds 1024.
  [bug introduced in coreutils-7.5]

  tr no longer crashes when using --complement with certain
  invalid combinations of case character classes.
  [bug introduced in coreutils-8.6]

  basenc --base64 --decode no longer silently discards decoded characters
  on (1024*5) buffer boundaries
  [bug introduced in coreutils-8.31]

** Changes in behavior

  cp and install now default to copy-on-write (COW) if available.

  cp, install and mv now use the copy_file_range syscall if available.
  Also, they use lseek+SEEK_HOLE rather than ioctl+FS_IOC_FIEMAP on sparse
  files, as lseek is simpler and more portable.

  On GNU/Linux systems, ls no longer issues an error message on a
  directory merely because it was removed.  This reverts a change
  that was made in release 8.32.

  ptx -T no longer attempts to substitute old-fashioned TeX escapes
  for 8-bit non-ASCII alphabetic characters.  TeX indexes should
  instead use '\usepackage[latin1]{inputenc}' or equivalent.

  stat will use decomposed (major,minor) device numbers in its default format.
  This is less ambiguous, and more consistent with ls.

  sum [-r] will output a file name, even if only a single name is passed.
  This is consistent with sum -s, cksum, and other sum(1) implementations.

** New Features

  cksum now supports the -a (--algorithm) option to select any
  of the existing sum, md5sum, b2sum, sha*sum implementations etc.
  cksum now subsumes all of these programs, and coreutils
  will introduce no future standalone checksum utility.

  cksum -a now supports the 'sm3' argument, to use the SM3 digest algorithm.

  cksum --check now supports auto detecting the digest type to use,
  when verifying tagged format checksums.

  expr and factor now support bignums on all platforms.

  ls --classify now supports the "always", "auto", or "never" flags,
  to support only outputting classifier characters if connected to a tty.

  ls now accepts the --sort=width option, to sort by file name width.
  This is useful to more compactly organize the default vertical column output.

  ls now accepts the --zero option, to terminate each output line with
  NUL instead of newline.

  nl --line-increment can now take a negative number to decrement the count.

  stat supports more formats for representing decomposed device numbers.
  %Hd,%Ld and %Hr,%Lr will output major,minor device numbers and device types
  respectively.  %d corresponds to st_dev and %r to std_rdev.

** Improvements

  cat --show-ends will now show \r\n as ^M$.  Previously the \r was taken
  literally, thus overwriting the first character in the line with '$'.

  cksum [-a crc] is now up to 4 times faster by using a slice by 8 algorithm,
  and at least 8 times faster where pclmul instructions are supported.
  A new --debug option will indicate if pclmul is being used.

  md5sum --check now supports checksum files with CRLF line endings.
  This also applies to cksum, sha*sum, and b2sum.

  df now recognizes these file systems as remote:
  acfs, coda, fhgfs, gpfs, ibrix, ocfs2, and vxfs.

  rmdir now clarifies the error if a symlink_to_dir/ has not been traversed.
  This is the case on GNU/Linux systems, where the trailing slash is ignored.

  stat and tail now know about the "devmem", "exfat", "secretmem", "vboxsf",
  and "zonefs" file system types.  stat -f -c%T now reports the file system
  type, and tail -f uses polling for "vboxsf" and inotify for the others.

  timeout now supports sub-second timeouts on macOS.

  wc is up to 5 times faster when counting only new line characters,
  where avx2 instructions are supported.
  A new --debug option will indicate if avx2 is being used.

24 September, 2021 01:55PM by Pádraig Brady

September 18, 2021

GNU MediaGoblin

MediaGoblin 0.12.0: Potions

Potions
"Potions" by Charlotte Koch (reproduced with permission)

Happy Software Freedom Day! Today we're pleased to announce the release of MediaGoblin 0.12.0. See the release notes for full details and upgrading instructions.

This release resolves two significant issues in the Celery backend media processing. The first was causing processed media to be marked as failed and the second was inhibiting useful error messages. We've also resolved installation issues caused by deprecated upstream code in the Werkzeug and jsonschema libraries.

We've added provisional gmg serve and gmg celery commands to simplify deployment. These commands may change in the future and are not yet recommended in the deployment documentation. If your deployment is already running smoothly, there's no reason to switch at this stage.

Thanks to Rodrigo Martins, Marco Pessotto and Jgart for their contributions in this release. Thanks again to Charlotte for allowing us to feature her artwork.

To join us and help improve MediaGoblin, please visit our getting involved page.

18 September, 2021 05:00AM by Ben Sturmfels