Planet GNU

Aggregation of development blogs from the GNU Project

October 29, 2020

www-zh-cn @ Savannah

Committee begins review of High Priority Projects free software list — your input is needed by January 8

Dear CTT members:

The High Priority Free Software Projects (HPP) initiative draws attention to areas of improvement to the HPP list and specific projects of great strategic importance to the goal of freedom for all computer users. Longtime committee member Benjamin Mako Hill said previously that an "updated High Priority Projects list is a description of the most important threats, and most critical opportunities, that free software faces in the modern computing landscape." As computing is more ubiquitous than ever, the HPP list must reflect ongoing changes in priorities for the free software movement. The committee is starting the new process of updating the HPP, and we need your input.

We need your input! Send your suggested changes for the list to hpp-feedback@gnu.org by January 8, 2021.

Remember, we're looking for projects of great strategic importance to the goal of freedom for all computer users. We are looking for areas where people feel they are heavily pressured or even required to use proprietary software, as well as for important missing features in existing free software, and for problems you see on the horizon as technology is developing.

If you wish, we encourage you to publish your thoughts independently (e.g., on your blog or social media) and send us a link to them. Keep in mind that not every project of great strategic importance to the goal of freedom for all computer users will be a software development project. We welcome suggestions of other forms of activism, internal or external (e.g., making free software communities safe for diverse participants, mandating use of free software in the public sector, etc.).

Suggestions for the HPP list are always welcome. The committee plans to start processing feedback for this update by January 8, 2021. Based upon the feedback we receive, the current content of the list, and our own contributions, we will publish a substantially revised list and an analysis before holding a lively discussion at LibrePlanet 2021.

Thank you.

29 October, 2020 03:52AM by Wensheng XIE

October 26, 2020

Riccardo Mottola

Arcitc Fox 27.11.0 release

 This 2020 with COVID, quarantines and lockdown was and is a strange year, but it allowed me to take care of Arctic Fox quite a bit. A lot of work is going on in my Arctic Fox fork, which Matt dutifully imports.

Thousands of commits flew in into this new release, tackling JavaScript upgrades, build fixes, further metro removal, JIT optimizations. SO much was imported from Firefox that this is really exciting!

Arctic Fox continues to run very well on MacOS-X 10.7 for example, on my MacBook Pro:



But also Linux is fully supported, of course. 



Linux/PowerPC works as before, but still no JIT of course. Roy continues his fork with WindowsXP support which differs only by a minimal set of patches.


SPARC64 support was pursued, now NetBSD/SPARC64 compiles fully, but.... the browser crashes on startup. Help seeked!

The same goes for ARM, ARM64 and MIPS: we would love to get these platforms working again: they were probably lost in PaleMoon.


Arctic Fox thus continues the pursue of PaleMoon and Firefox heritage but with enhanced compatibility on more platforms, no Rust and legacy OS/Compiler support. If you like this, please help!

26 October, 2020 10:01PM by Riccardo (noreply@blogger.com)

October 24, 2020

GNU Taler news

RFC 8905 - "The 'payto' URI Scheme for Payments" published

2020-11: RFC 8905: "The 'payto' URI Scheme for Payments" published

We are happy to announce the publication of RFC 8905 by the IETF.

RFC 8905 defines the 'payto' Uniform Resource Identifier (URI) scheme for designating targets for payments. A unified URI scheme for all payment target types allows applications to offer user interactions with URIs that represent payment targets, simplifying the introduction of new payment systems and applications.

Download links

You can download the RFC from here.

24 October, 2020 10:00PM

Parabola GNU/Linux-libre

[From Arch] libtraceevent>=5.9-1 update requires manual intervention

The libtraceevent package prior to version 5.9-1 was missing a soname link. This has been fixed in 5.9-1, so the upgrade will need to overwrite the untracked files created by ldconfig. If you get any of these errors

libtraceevent: /usr/lib/libtraceevent.so.1 exists in filesystem

when updating, use

pacman -Syu --overwrite /usr/lib/libtraceevent.so.1

to perform the upgrade.

24 October, 2020 12:15AM by David P.

October 22, 2020

parallel @ Savannah

GNU Parallel 20201022 ('Samuel Paty')

GNU Parallel 20201022 ('Samuel Paty') has been released. It is available for download at: http://ftpmirror.gnu.org/parallel/

Please help spreading GNU Parallel by making a testimonial video like Juan Sierra Pons: http://www.elsotanillo.net/wp-content/uploads/GnuParallel_JuanSierraPons.mp4 It does not have to be as detailed as Juan's. It is perfectly fine if you just say your name, and what field you are using GNU Parallel for.

Quote of the month:

  I get a weird sense of satisfaction every single time I see the lovely logo of #GNU Parallel (plus, what an underrated piece of great software!)
    -- Emre Sevinç @EmreSevinc@twitter

New in this release:

  • --termseq now works for jobs running remotely.
  • parsort: Performance optimized for 64-core machines.
  • 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 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 3374ec53bacb199b245af2dda86df6c9
    12345678 3374ec53 bacb199b 245af2dd a86df6c9
    $ md5sum install.sh | grep 029a9ac06e8b5bc6052eac57b2c3c9ca
    029a9ac0 6e8b5bc6 052eac57 b2c3c9ca
    $ sha512sum install.sh | grep f517006d9897747bed8a4694b1acba1b
    40f53af6 9e20dae5 713ba06c f517006d 9897747b ed8a4694 b1acba1b 1464beb4
    60055629 3f2356f3 3e9c4e3c 76e3f3af a9db4b32 bd33322b 975696fc e6b23cfb
    $ 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, 2020 08:26PM by Ole Tange

October 20, 2020

rcs @ Savannah

RCS 5.10.0 available

GNU RCS (Revision Control System) 5.10.0 is available.

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

20 October, 2020 02:55PM by Thien-Thi Nguyen

October 19, 2020

recutils @ Savannah

GNU recutils is back to active development

Hi good peoples!

During the last few years I somehow stopped adding new features to the GNU recutils, limiting its development to the resolution of important bugs, and releasing every one or another year.  The reason for this was that I considered the recutils to be, mostly, "finished".

However, as of recent some projects have adopted recutils as part of their infrastructure (guix, GNUnet) and it seemst hat Fred's and George's favorite tools are getting popular in the internets... and what is more, people are sending patches! o_O

So I have decided to put the GNU recutils back under active development, for the immense joy of adults and children (and turtles.)

The very first step is a simplification/modernization of the codebase, which is already work in progress (see the last couple of commits).  You see, I wrote recutils a looong time ago, and therefore I don't feel that comfortable looking at the code: I call this feeling/phenomena "shameware".

Then I will probably rewrite the multi-set internal implementation, to make it more efficient, and go straight to implement some facilities that the recutils users have been wishing for  for a long time (like sorting records in reverse order, ahem.)

So let's see, 2021 may introduce recutils 2.0!  Slowly and carefully... turtle steps..

Salud!

19 October, 2020 05:59PM by Jose E. Marchesi

October 16, 2020

Trisquel GNU/Linux

Trisquel 9.0 "Etiona" release announcement, and 10.0 plans

They say that good things come to those who wait, and for this release there has been a lot of waiting but also plenty of good things. Trisquel 9.0, codename "Etiona" is our most polished release yet, thanks to the contribution of a very committed team of volunteers. This release comes in several flavors:

  • MATE desktop, the default. Based on the popular fork of GNOME 2.x, this edition provides a classic desktop environment matching the user experience of previous Trisquel releases.
  • Trisquel Mini, a lightweight version for older machines and netbooks. Based on the LXDE desktop environment and a selection of resource-saving applications to bring new life to your hardware.
  • Triskel, running the KDE environment. Excellent for customizing the design and look in fine detail.
  • Trisquel netinstall image. To deploy with a command-line install interface, ideal for servers and advanced users.
  • Trisquel TOAST, based on the Sugar learning platform. Comes with dozens of educational activities for children.

Despite the longer than usual release time, all packages are fully up to date with long-term-support updates and security patches. The default web browser "Abrowser", our freedom and privacy respecting take on Mozilla's browser, provides the latest updates from upstream for a great browsing experience. Backports provide extended hardware support and other goodies like a newer LibreOffice and many other utilities.

Special thanks (in no particular order, and probably forgetting a few!) to adfeno, Ark74, leny2010, chaosmonk, davidpgil, dctrud, daroal, proninyaroslav, sudoman, a_slacker_here, rms, bill-auger, pabloyoyoista, kpengboy, pikurasa, mtsio, bandali, thomzane, jxself, valessio, DiivaaD, DNS, Eighth_Doctor, iank, fredd, freekurt, aklis, gnutastyc, calher, CharlieBrown, satellit, charh, fvnines, pehjota, and the whole Trisquel community, for your contributions, support, ideas and continuous encouragement.

Give Trisquel 10 a name

The development work for the next release is ready to start, and the first step start building packages is to set a codename. Join the forum/mailing-list to bring suggestions for an inspiring name from the celtic mythology (as is tradition).

New development server

Thanks to the Free Software Foundation, we now have a dedicated development server built on freedom-respecting hardware, ready to start working on Trisquel 10. A beefy 32-core, 128GB RAM machine built on the KGPE-D16 motherboard running Libreboot, hosted at the FSF's datacenter rack in Somerville.
 

MATE desktop
KDE desktop
Utilities
Games

16 October, 2020 04:30PM by quidam

vc-dwim @ Savannah

vc-dwim-1.10 released [stable]

It's been nearly a year, so here's a new release.
Thanks to Karl Berry for making nearly all of the nontrivial changes.

Here are the compressed sources and a GPG detached signature[*]:
  https://ftp.gnu.org/gnu/vc-dwim/vc-dwim-1.10.tar.xz
  https://ftp.gnu.org/gnu/vc-dwim/vc-dwim-1.10.tar.xz.sig

Use a mirror for higher download bandwidth:
  https://ftpmirror.gnu.org/vc-dwim/vc-dwim-1.10.tar.xz
  https://ftpmirror.gnu.org/vc-dwim/vc-dwim-1.10.tar.xz.sig

[*] 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 vc-dwim-1.10.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.

This release was bootstrapped with the following tools:
  Autoconf 2.69c
  Automake 1.16b
  Gnulib v0.1-3952-g8bc21357b

NEWS

* Noteworthy changes in release 1.10 (2020-10-15) [stable]

** Changes in behavior

  vc-dwim now requires a one-line summary

** New features

  --debug is much more verbose, and implies --verbose.

16 October, 2020 06:34AM by Jim Meyering

mdk @ Savannah

GNU MDK 1.2.11 released

A new bug fix release.  Happy hacking!

16 October, 2020 12:00AM by Jose Antonio Ortega Ruiz

GNU Guix

Announcing the first online Guix Day Conference

The Guix hackers are very happy to announce the first online Guix Day Conference on Sunday November, 22nd. This conference is open to everyone and will be held entirely online. Want to speak? Submit your proposal!

Important dates:

  1. November 6th: Deadline for talks proposal.
  2. November 14th: Deadline for releasing your pre-recorded talks.
  3. November 16th: Release of the schedule.
  4. November 22nd: Conference day!

Guix Days logo

The agenda of the day is:

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

There will be no presentation on the 22nd! And no registration fee.

Until November 6th: talks proposal

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

Please describe with 10 lines or more what your proposal is about. Even if it is a BoFs topic (smaller group who want to talk about specific topics).

Once you have sent your proposal, you will be notified in the coming days whether your talk be part of the Guix Day.

Good topics include your own experience with Guix and what you feel is important to share with your other fellows, for example a non-exhaustive topic list is: installer, Maven build system, Data Service, GNU Hurd and cross-compilation, Cuirass and continuous integration, authentication, secret services, website translation, translation infrastructure,… It is a single day so we won't be able to cover all. ;-)

November 9th-14th: prepare your talk

The aim of the pre-recorded talk 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 November 14th, 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 November 12th.

November 16th-22nd: watch the talks

Be sure to watch the pre-recorded talks before the conference. There will be no presentation on the 22nd.

November 22nd: 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.

16 October, 2020 12:00AM by Guix Hackers

October 15, 2020

Andy Wingo

on "binary security of webassembly"

Greets!

You may have seen an interesting paper cross your radar a couple months ago: Everything Old is New Again: Binary Security of WebAssembly, by Daniel Lehmann, Johannes Kinder and Michael Pradel. The paper makes some strong claims and I would like to share some thoughts on it.

reader-response theory

For context, I have been working on web browsers for the last 8 years or so, most recently on the JavaScript and WebAssembly engine in Firefox. My work mostly consists of implementing new features, which if you are familiar with software development translates as "writing bugs". Almost all of those bugs are security bugs, potentially causing Firefox to go from being an agent of the user to an agent of the Mossad, or of cryptocurrency thieves, or anything else.

Mitigating browser bug flow takes a siege mentality. Web browsers treat all web pages and their corresponding CSS, media, JavaScript, and WebAssembly as hostile. We try to reason about global security properties, and translate those properties into invariants ensured at compile-time and run-time, for example to ensure that a web page from site A can't access cookies from site B.

In this regard, WebAssembly has some of the strongest isolation invariants in the whole platform. A WebAssembly module has access to nothing, by default: neither functionality nor data. Even a module's memory is isolated from the rest of the browser, both by construction (that's just how WebAssembly is specified) and by run-time measures (given that pointers are 32 bits in today's WebAssembly, we generally reserve a multi-gigabyte region for a module's memory that can contain nothing else).

All of this may seem obvious, but consider that a C++ program compiled to native code on a POSIX platform can use essentially everything that the person running it has access to: your SSH secrets, your email, all of your programs, and so on. That same program compiled to WebAssembly does not -- any capability it has must have been given to it by the person running the program. For POSIX-like programs, the WebAssembly community is working on a POSIX for the web that standardizes a limited-capability access to data and functionality from the world, and in web browsers, well of course the module has access only to the capabilities that the embedding web page gives to it. Mostly, as the JS run-time accompanying the WebAssembly is usually generated by emscripten, this set of capabilties is a function of the program itself.

Of course, complex WebAssembly systems may contain multiple agents, acting on behalf of different parties. For example, a module might, through capabilities provided by the host, be able to ask flickr to delete a photo, but might also be able to crawl a URL for photos. Probably in this system, crawling a web page shouldn't be able to "trick" the WebAssembly module into deleting a photo. The C++ program compiled to WebAssembly could have a bug of course, in which case, you get to keep both pieces.

I mention all of this because we who work on WebAssembly are proud of this work! It is a pleasure to design and build a platform for high-performance code that provides robust capabilities-based security properties.

the new criticism

Therefore it was with skepticism that I started reading the Lehmann et al paper. The paper focusses on WebAssembly itself, not any particular implementation thereof; what could be wrong about WebAssembly?

I found the answer to be quite nuanced. To me, the paper shows three interesting things:

  1. Memory-safety bugs in C/C++ programs when compiled to WebAssembly can cause control-flow edges that were not present in the source program.

  2. Unexpected control-flow in a web browser can sometimes end up in a call to eval with the permissions of the web page, which is not good.

  3. It's easier in some ways to exploit bugs in a C/C++ program when compiled to WebAssembly than when compiled natively, because many common mitigations aren't used by the WebAssembly compiler toolchain.

Firstly, let's dicuss the control-flow point. Let's say that the program has a bug, and you have made an exploit to overwrite some memory location. What can you do with it? Well, consider indirect calls (call_indirect). This is what a compiler will emit for a vtable method call, or for a call to a function pointer. The possible targets for the indirect call are stored in a table, which is a side array of all possible call_indirect targets. The actual target is selected at run-time based on an index; WebAssembly function pointers are just indices into this table.

So if a function loads an index into the indirect call table from memory, and some exploit can change this index, then you can cause a call site to change its callee. Although there is a run-time type check that occurs at the call_indirect site to ensure that the callee is called with the right type, many functions in a module can have compatible types and thus be callable without an error.

OK, so that's not great. But what can you do with it? Well it turns out that emscripten will sometimes provide JavaScript's eval to the WebAssembly module. Usually it will be called only with a static string, but anything can happen. If an attacker can redirect a call site to eval instead of one of the possible targets from the source code, you can (e.g.) send the user's cookies to evil.com.

There's a similar vulnerability regarding changing the operand to eval, instead. Strings are represented in linear memory as well, and there's no write protection on them, even if they are read-only data. If your write primitive can change the string being passed to eval, that's also a win for the attacker. More details in the paper.

This observation brings us to the last point, which is that many basic mitigations in (e.g.) POSIX deployments aren't present in WebAssembly. There are no OS-level read-only protections for static data, and the compiler doesn't enforce this either. Also WebAssembly programs have to bundle their own malloc, but the implementations provided by emscripten don't implement the "hardening" techniques. There is no addres-space layout randomization, so exploits are deterministic. And so on.

on mitigations

It must be said that for most people working on WebAssembly, security "mitigations" are... unsatisfactory. They aren't necessary for memory-safe programs, and they can't prevent memory-unsafe programs from having unexpected behavior. Besides, we who work on WebAssembly are more focussed on the security properties of the WebAssembly program as embedded in its environment, but not on the program itself. Garbage in, garbage out, right?

In that regard, I think that one answer to this paper is just "don't". Don't ship memory-unsafe programs, or if you do, don't give them eval capabilities. No general mitigation will make these programs safe. Writing your program in e.g. safe Rust is a comprehensive fix to this class of bug.

But, we have to admit also that shipping programs written in C and C++ is a primary goal of WebAssembly, and that no matter how hard we try, some buggy programs will get shipped, and therefore that there is marginal value to including mitigations like read-only data or even address space randomization. We definitely need to work on getting control-flow integrity protections working well with the WebAssembly toolchain, probably via multi-table support (part of the reference types extension; my colleague Paulo Matos just landed a patch in this area). And certainly Emscripten should work towards minimizing the capabilities set exposed to WebAssembly by the generated JavaScript, notably by compiling away uses of eval by embind.

Finally, I think that many of the problems identified by this paper will be comprehensively fixed in a different way by more "managed" languages. The problem is that C/C++ pointers are capabilities into all of undifferentiated linear memory. By contrast, handles to GC-managed objects are unforgeable: given object A, you can't get to object B except if object A references B. It would be great if we could bring some of the benefits of this more capability-based approach to in-memory objects to languages like C and C++; more on that in a future note, I think.

chapeau

In the end, despite my initial orneriness, I have to admit that the paper authors point out some interesting areas to work on. It's clear that there's more work to do. I was also relieved to find that my code is not at fault in this particular instance :) Onwards and upwards, and until next time, happy hacking!

15 October, 2020 10:29AM by Andy Wingo

October 13, 2020

malloc as a service

Greetings, internet! Today I have the silliest of demos for you: malloc-as-a-service.

loading walloc...

>&&<&>>>>>&&>

The above input box, if things managed to work, loads up a simple bare-bones malloc implementation, and exposes "malloc" and "free" bindings. But the neat thing is that it's built without emscripten: it's a standalone C file that compiles directly to WebAssembly, with no JavaScript run-time at all. I share it here because it might come in handy to people working on WebAssembly toolchains, and also because it was an amusing experience to build.

wat?

The name of the allocator is "walloc", in which the w is for WebAssembly.

Walloc was designed with the following priorities, in order:

  1. Standalone. No stdlib needed; no emscripten. Can be included in a project without pulling in anything else.

  2. Reasonable allocation speed and fragmentation/overhead.

  3. Small size, to minimize download time.

  4. Standard interface: a drop-in replacement for malloc.

  5. Single-threaded (currently, anyway).

Emscripten includes a couple of good malloc implementations (dlmalloc and emmalloc) which probably you should use instead. But if you are really looking for a bare-bones malloc, walloc is fine.

You can check out all the details at the walloc project page; a selection of salient bits are below.

Firstly, to build walloc, it's just a straight-up compile:

clang -DNDEBUG -Oz --target=wasm32 -nostdlib -c -o walloc.o walloc.c

The resulting walloc.o is a conforming WebAssembly file on its own, but which also contains additional symbol table and relocation sections which allow wasm-ld to combine separate compilation units into a single final WebAssembly file. walloc.c on its own doesn't import or export anything, in the WebAssembly sense; to make bindings visible to JS, you need to add a little wrapper:

typedef __SIZE_TYPE__ size_t;

#define WASM_EXPORT(name) \
  __attribute__((export_name(#name))) \
  name

// Declare these as coming from walloc.c.
void *malloc(size_t size);
void free(void *p);
                          
void* WASM_EXPORT(walloc)(size_t size) {
  return malloc(size);
}

void WASM_EXPORT(wfree)(void* ptr) {
  free(ptr);
}

If you compile that to exports.o and link via wasm-ld --no-entry --import-memory -o walloc.wasm exports.o walloc.o, you end up with the walloc.wasm used in the demo above. See your inspector for the URL.

The resulting wasm file is about 2 kB (uncompressed).

Walloc isn't the smallest allocator out there. A simple bump-pointer allocator that never frees is the fastest thing you can have. There is also an alternate allocator for Rust, wee_alloc, which is said to be smaller than walloc, though I think it is less space-efficient for small objects. But still, walloc is pretty small.

implementation notes

When a C program is compiled to WebAssembly, the resulting wasm module (usually) has associated linear memory. It can be linked in a way that the memory is created by the module when it's instantiated, or such that the module is given a memory by its host. The above example passed --import-memory to the linker, allowing the host to bound memory usage for the module instance.

The linear memory has the usual data, stack, and heap segments. The data and stack are placed first. The heap starts at the &__heap_base symbol. (This symbol is computed and defined by the linker.) All bytes above &__heap_base can be used by the wasm program as it likes. So &__heap_base is the lower bound of memory managed by walloc.

                                              memory growth ->
+----------------+-----------+-------------+-------------+----
| data and stack | alignment | walloc page | walloc page | ...
+----------------+-----------+-------------+-------------+----
^ 0              ^ &__heap_base            ^ 64 kB aligned

Interestingly, there are a few different orderings of data and stack used by different toolchains. It used to even be the case that the stack grew up. This diagram from the recent "Everything Old is New Again: Binary Security of WebAssembly" paper by Lehmann et al is a good summary:

The sensible thing to prevent accidental overflow (underflow, really) is to have the stack grow down to 0, with data at higher addresses. But this can cause WebAssembly code that references data to take up more bytes, because addresses are written using variable-length "LEB" encodings that favor short offsets, so it isn't the default, right now at least.

Anyway! The upper bound of memory managed by walloc is the total size of the memory, which is aligned on 64-kilobyte boundaries. (WebAssembly ensures this alignment.) Walloc manages memory in 64-kb pages as well. It starts with whatever memory is initially given to the module, and will expand the memory if it runs out. The host can specify a maximum memory size, in pages; if no more pages are available, walloc's malloc will simply return NULL; handling out-of-memory is up to the caller.

Walloc has two allocation strategies: small and large objects.

big bois

A large object is more than 256 bytes.

There is a global freelist of available large objects, each of which has a header indicating its size. When allocating, walloc does a best-fit search through that list.

struct large_object {
  struct large_object *next;
  size_t size;
  char payload[0];
};
struct large_object* large_object_free_list;

Large object allocations are rounded up to 256-byte boundaries, including the header.

If there is no object on the freelist that can satisfy an allocation, walloc will expand the heap by the size of the allocation, or by half of the current walloc heap size, whichever is larger. The resulting page or pages form a large object that can satisfy the allocation.

If the best object on the freelist has more than a chunk of space on the end, it is split, and the tail put back on the freelist. A chunk is 256 bytes.

+-------------+---------+---------+-----+-----------+
| page header | chunk 1 | chunk 2 | ... | chunk 255 |
+-------------+---------+---------+-----+-----------+
^ +0          ^ +256    ^ +512                      ^ +64 kB

As each page is 65536 bytes, and each chunk is 256 bytes, there are therefore 256 chunks in a page. The first chunk in a page that begins an allocated object, large or small, contains a header chunk. The page header has a byte for each of the 256 chunks in the page. The byte is 255 if the corresponding chunk starts a large object; otherwise the byte indicates the size class for packed small-object allocations (see below).

+-------------+---------+---------+----------+-----------+
| page header | large object 1    | large object 2 ...   |
+-------------+---------+---------+----------+-----------+
^ +0          ^ +256    ^ +512                           ^ +64 kB

When splitting large objects, we avoid starting a new large object on a page header chunk. A large object can only span where a page header chunk would be if it includes the entire page.

Freeing a large object pushes it on the global freelist. We know a pointer is a large object by looking at the page header. We know the size of the allocation, because the large object header precedes the allocation. When the next large object allocation happens after a free, the freelist will be compacted by merging adjacent large objects.

small fry

Small objects are allocated from segregated freelists. The granule size is 8 bytes. Small object allocations are packed in a chunk of uniform allocation size. There are size classes for allocations of each size from 1 to 6 granules, then 8, 10, 16, and 32 granules; 10 sizes in all. For example, an allocation of e.g. 12 granules will be satisfied from a 16-granule chunk. Each size class has its own free list.

struct small_object_freelist {
  struct small_object_freelist *next;
};
struct small_object_freelist small_object_freelists[10];

When allocating, if there is nothing on the corresponding freelist, walloc will allocate a new large object, then change its chunk kind in the page header to the size class. It then goes through the fresh chunk, threading the objects through each other onto a free list.

+-------------+---------+---------+------------+---------------------+
| page header | large object 1    | granules=4 | large object 2' ... |
+-------------+---------+---------+------------+---------------------+
^ +0          ^ +256    ^ +512    ^ +768       + +1024               ^ +64 kB

In this example, we imagine that the 4-granules freelist was empty, and that the large object freelist contained only large object 2, running all the way to the end of the page. We allocated a new 4-granules chunk, splitting the first chunk off the large object, and pushing the newly trimmed large object back onto the large object freelist, updating the page header appropriately. We then thread the 4-granules (32-byte) allocations in the fresh chunk together (the chunk has room for 8 of them), treating them as if they were instances of struct freelist, pushing them onto the global freelist for 4-granules allocations.

           in fresh chunk, next link for object N points to object N+1
                                 /--------\                     
                                 |        |
            +------------------+-^--------v-----+----------+
granules=4: | (padding, maybe) | object 0 | ... | object 7 |
            +------------------+----------+-----+----------+
                               ^ 4-granule freelist now points here 

The size classes were chosen so that any wasted space (padding) is less than the size class.

Freeing a small object pushes it back on its size class's free list. Given a pointer, we know its size class by looking in the chunk kind in the page header.

and that's it

Hey have fun with the thing! Let me know if you find it useful. Happy hacking and until next time!

13 October, 2020 01:34PM by Andy Wingo

October 08, 2020

GNU Guix

Childhurds and GNU/Hurd substitutes

A lot has happened since our Hello Hurd post beginning of April. No, not nearly as much as we joked on April 1st , but more than enough to share and be proud of.

Building a Hurd virtual machine

As some of you noticed, the previous hacks to build a Hurd virtual machine (VM) were removed and no longer work; using Guix you can now build a GNU/Hurd VM just like you would build a GNU/Linux VM:

guix system disk-image -t hurd-raw bare-hurd.tmpl

This cross-compiles all the relevant packages for GNU/Hurd—specifically the i586-pc-gnu triplet—and produces a VM image:

/gnu/store/n7jkfajw0fzp975hv0b9v18r9bbr961q-disk-image

You can build it and start it from your GNU/Linux machine with this command:

qemu-system-i386 -enable-kvm -m 512 -snapshot -hda \
  $(guix system disk-image -t hurd-raw bare-hurd.tmpl)

We are using this ready-made, minimal GNU/Hurd operating system description gnu/system/examples/bare-hurd.tmpl that looks suprisingly familiar:

(use-modules (gnu) (gnu system hurd) (guix utils))
(use-service-modules ssh)
(use-package-modules ssh)

(define %hurd-os
  (operating-system
    (inherit %hurd-default-operating-system)
    (bootloader (bootloader-configuration
                 (bootloader grub-minimal-bootloader)
                 (target "/dev/sdX")))
    (file-systems (cons (file-system
                          (device (file-system-label "my-root"))
                          (mount-point "/")
                          (type "ext2"))
                        %base-file-systems))
    (host-name "guixygnu")
    (timezone "Europe/Amsterdam")
    (packages (cons openssh-sans-x %base-packages/hurd))
    (services (cons (service openssh-service-type
                             (openssh-configuration
                              (openssh openssh-sans-x)
                              (use-pam? #f)
                              (port-number 2222)
                              (permit-root-login #t)
                              (allow-empty-passwords? #t)
                              (password-authentication? #t)))
               %base-services/hurd))))

%hurd-os

and it can be customized just like a GNU/Linux operating system description. The end result is a full-blown Guix System with the Shepherd managing system services and all that—finally we can run herd on the Hurd.

A lot of things had to be in place to support this, we worked on

counting some ~200 patches by ten people over six months; including generic cross-compilation fixes and support, and Hurd fixes and support.

Also, we finished the passive translator settings over extended attributes (xattrs) for the Hurd and for Linux.

You may notice that we are using the new disk-image command rather than the old vm-image. One of the big hurdles in producing a VM image was the way Guix produces VM images: it would run a target QEMU, e.g. qemu-arm. That does not work for the Hurd, as there is no qemu-hurd. Without going into the hairy details, when Ludo and Janneke were—three patch sets, 50 messages and 13 days later—almost ready to give up, Mathieu came to the rescue with his brand-new implementation of the disk-image command. At the time, Hurd work was done on the wip-hurd branch and the disk-image work on wip-disk-image. Soon after, Mathieu proposed an explosive mix of the two branches; we managed to create the first Hurd system that really felt like Guix System.

The new implementation of the disk-image command was followed by the introduction of an --image-type or -t option. This option allows to produce disk images targeting different supports. The hurd-raw and hurd-qcow2 image types, producing respectively a raw Hurd disk-image and a Hurd QCOW2 disk-image were introduced. They can be used this way:

guix system disk-image -t hurd-raw bare-hurd.tmpl
guix system disk-image -t hurd-qcow2 bare-hurd.tmpl

This mechanism providing much more flexibility in the Guix System image generation will be described in a future blog post.

We also offer downloads of continuously built (actually cross-built) Guix System on GNU/Hurd (~350 MiB).

Substitutes

While amazing to be able to just run the Hurd in a VM, development without substitutes is a real pain; a Guix system needs substitutes. How to go about that? We have a build farm but currently Hurd only runs on ancient hardware: not an option. We need a machine running Guix/Hurd to offload Hurd build jobs to.

The proposed solution was to automate the building and running of a Guix VM into a new Guix service: the so-called hurd-vm or childhurd service. We would add something like:

(service hurd-vm-service-type)

to a couple of our build nodes to add a hird of virtual Hurd machines to our build farm.

The Childhurd service

The Hurd—being based on a microkernel—has some beautiful built-in "virtualization" possibilites that have their own naming: neighborhurds, subhurds. Similarly, we are adding childhurds to this mix: a childhurd is a GNU/Hurd VM running on GNU/Linux and managed by Guix.

When you are running Guix System, building a Hurd VM manually is no longer necessary. Just add the hurd-vm service to your operating system description:

(service hurd-vm-service-type
         (hurd-vm-configuration
          (disk-size (* 12 (expt 2 30))) ;12GiB
          (memory-size 1024)))           ; 1GiB

and this will build a childhurd for you when you reconfigure your system. This childhurd can be stopped and started just like any other service:

herd stop hurd-vm
herd start childhurd

(childhurd is an alias for hurd-vm).

WARNING

This Hurd is fully operational

It is highly addictive.

Having shaved this yak, let’s not lose sight that our initial goal was to offload builds to those GNU/Hurd VMs. The childhurd service does all the heavy lifting. To offload from GNU/Linux to my childhurd, I added this to my /etc/guix/machines.scm:

 (build-machine
  (name "localhost")
  (systems (list "i586-gnu"))
  (host-key "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIHZsrZ63zs+AhWbVJgYq6j1h2rgQGrWKCokpR2/Q/Jzy root@guixygnu")
  (port 10022)  ;the Hurd VM has SSH listening on that port
  (user "root")
  (private-key "/home/janneke/.ssh/id_rsa_childhurd"))

That can be used to transparently offload builds from GNU/Linux to the childhurd:

$ uname -o
GNU/Linux
$ guix build hello -s i586-gnu
The following derivation will be built:
   /gnu/store/jqdvjhcxxnbq370y8i2c973c9zfiqrgl-hello-2.10.drv
[…]
guix offload: sending 1 store item (12 MiB) to 'localhost'...
offloading '/gnu/store/jqdvjhcxxnbq370y8i2c973c9zfiqrgl-hello-2.10.drv' to 'localhost'...
[…]
/gnu/store/803q5wapfnmr91ag8d9dzwabkbdxz3ay-hello-2.10
$ file -L $(guix build hello -s i586-gnu)/bin/hello
/gnu/store/803q5wapfnmr91ag8d9dzwabkbdxz3ay-hello-2.10/bin/hello: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /gnu/store/9vs3gkp6svam82zw7vjlml7iiarcs11c-glibc-2.31/lib/ld.so.1, for GNU/Hurd 0.0.0, not stripped

Hurrah!

Hurd substitutes

Last Friday we produced the very first GNU Hello substitute for the Hurd:

StorePath: /gnu/store/803q5wapfnmr91ag8d9dzwabkbdxz3ay-hello-2.10
URL: nar/gzip/803q5wapfnmr91ag8d9dzwabkbdxz3ay-hello-2.10
Compression: gzip
FileSize: 61822
URL: nar/lzip/803q5wapfnmr91ag8d9dzwabkbdxz3ay-hello-2.10
Compression: lzip
FileSize: 52887
NarHash: sha256:0g4k1kppjs5148ynm4zw4x1kpaby67npc3ws6s7y7hf0il1cgryk
NarSize: 204328
References: 803q5wapfnmr91ag8d9dzwabkbdxz3ay-hello-2.10 9vs3gkp6svam82zw7vjlml7iiarcs11c-glibc-2.31 bwvd5338kfm0vsc4i9xvh48vdxr5ywrz-gcc-7.5.0-lib
System: i586-gnu
Deriver: jqdvjhcxxnbq370y8i2c973c9zfiqrgl-hello-2.10.drv
Signature: 1;berlin.guix.gnu.org;KHNpZ25hdHVyZSAKIChkYXRhIAogIChmbGFncyByZmM2OTc5KQogIChoYXNoIHNoYTI1NiAjMDVGOEY5NjMxRUU5QzcxM0REQUNBRTYwNUNCNjJBNzlDNUY4NEVFQTIwMjc5OERBNTQ3NURCOUU2Q0FBRDMwMSMpCiAgKQogKHNpZy12YWwgCiAgKGVjZHNhIAogICAociAjMDVBMzkzMTgwOUY1RkQyMTdGMDM4MUVDMTJEODYyNzIyOEYyNjJGRDA4MTcxQjREMzZBNEM0RjBBNjZEQkY4NSMpCiAgIChzICMwQTc2RjZGNENCOTMzQTczNzA4QkNGMzRGREExMzkyOTRGQTQxREQzQTUwQkEwOUE0ODRCQUQyOTA4MjQ5ODIxIykKICAgKQogICkKIChwdWJsaWMta2V5IAogIChlY2MgCiAgIChjdXJ2ZSBFZDI1NTE5KQogICAocSAjOEQxNTZGMjk1RDI0QjBEOUE4NkZBNTc0MUE4NDBGRjJEMjRGNjBGN0I2QzQxMzQ4MTRBRDU1NjI1OTcxQjM5NCMpCiAgICkKICApCiApCg==

For development, porting and fixing of packages, you can use a Childhurd configuration like this:

(use-modules (srfi srfi-1) (guix packages) (guix records))
(use-package-modules base compression file gawk gdb hurd less m4 package-management)

(define guix-packages
  (filter-map input->package
              (fold alist-delete (package-direct-inputs guix)
                    '("glibc-utf8-locales" "graphviz" "po4a"))))

(operating-system
  (inherit %hurd-vm-operating-system)
  (users ...)
  (packages
    (cons* diffutils file findutils gawk gdb-minimal git-minimal
           gnu-make grep gzip less m4 openssh-sans-x tar xz
           (append
            guix-packages
            (delete guile-3.0 %base-packages/hurd)))))

… which allows working from a Git clone:

15:51:05 janneke@dundal:~/src/guix/master [env]
$ ssh -A janneke@childhurd
Last login: Sat Oct  3 15:31:55 2020 from 10.0.2.2


  This is the GNU Hurd.  Welcome.

janneke@childhurd ~$ git config --global url."git+ssh://git.sv.gnu.org/srv/git/".insteadOf gnu:
janneke@childhurd ~$ git clone gnu:guix
Cloning into 'guix'...
remote: Counting objects: 394436, done.
remote: Compressing objects: 100% (85728/85728), done.
remote: Total 394436 (delta 309572), reused 392294 (delta 307893)
Receiving objects: 100% (394436/394436), 137.05 MiB | 1.18 MiB/s, done.
Resolving deltas: 100% (309572/309572), done.
Updating files: 100% (2199/2199), done.

but before we continue let's first check the weather:

janneke@childhurd ~$ guix weather
computing 11079 package derivations for i586-gnu...
looking for 11521 store items on https://ci.guix.gnu.org...
updating substitutes from 'https://ci.guix.gnu.org'... 100.0%
https://ci.guix.gnu.org
  1.5% substitutes available (169 out of 11521)
  at least 443.3 MiB of nars (compressed)
  966.7 MiB on disk (uncompressed)
  0.012 seconds per request (142.2 seconds in total)
  81.0 requests per second
[..]

this gives an idea of how young this project is. Any day now, more Hurd substitutes will follow. Now let's configure and build Guix:

janneke@childhurd ~$ cd guix
janneke@childhurd ~/guix$ guix environment --bootstrap \
  --ad-hoc gcc-toolchain@7 libgcrypt zlib
substitute: updating substitutes from 'https://ci.guix.gnu.org'... 100.0%
The following derivations will be built:
   /gnu/store/gxq5flc8kwpn999dw9xxvldy9xfd0q2x-profile.drv
   /gnu/store/vfkjnwgl4ckyklrl2z4q8x2vnlrwwyfr-gcc-toolchain-7.5.0.drv
   /gnu/store/zh6snj49ayrpw24jn7whpzygj1fpy9cm-module-import-compiled.drv

66.3 MB will be downloaded
[..]
building profile with 3 packages...
janneke@childhurd ~/guix [env]$ ./bootstrap
[..]
janneke@childhurd ~/guix [env]$ ./configure --with-courage\
  --localstatedir=/var --sysconfdir=/etc
[..]
janneke@childhurd ~/guix [env]$ make
[..]
janneke@childhurd ~/guix [env]$ ./pre-inst-env guix build hello
substitute: updating substitutes from 'https://ci.guix.gnu.org'... 100.0%
0.1 MB will be downloaded:
   /gnu/store/803q5wapfnmr91ag8d9dzwabkbdxz3ay-hello-2.10
substituting /gnu/store/803q5wapfnmr91ag8d9dzwabkbdxz3ay-hello-2.10...
downloading from https://ci.guix.gnu.org/nar/lzip/803q5wapfnmr91ag8d9dzwabkbdxz3ay-hello-2.10 ...
 hello-2.10  52KiB                    258KiB/s 00:00 [##################] 100.0%

/gnu/store/803q5wapfnmr91ag8d9dzwabkbdxz3ay-hello-2.10

just like we are used to do…almost. We are using --bootstrap and a targeted --ad-hoc to avoid dependencies like libx11, python-minimal, and other packages that do not build yet.

Isolated build environments

To help achieve reproducible builds, Guix builds packages in isolated build environments: build environments contain nothing but the inputs explicitly declared in the package definition—not even /bin/sh. Build environments also lack network access. On GNU/Linux this is achieved by running builds in separate namespaces. Besides, the environment contains device nodes and “special” file systems that are usually expected to be available: /dev/null, /dev/pts, /dev/shm, /proc, the loopback networking device, and so on. (The exact contents are documented.)

On GNU/Linux, these special files and file systems are implemented by the kernel. Guix only cares about user-land software, meaning that these devices “leak” from the host kernel instead of being an explicit “input” of derivations, but that’s OK, that’s the deal: the kernel and hardware are considered outside of Guix’s control.

What about GNU/Hurd, though? In GNU/Hurd, /dev/null, a Linux-compatible /proc, the TCP/IP stack necessary to implement the loopback device, and even support for pipes are all implemented in user-land: writing to /dev/null amounts to talking to the /hurd/null service (or translator), operations on AF_INET sockets translate to remote procedure calls (RPCs) to /servers/socket/2, which the /hurd/pfinet program listens to, and so on.

That raises an interesting question: what should the build environment contain on GNU/Hurd? So far our GNU/Hurd builds were made in non-isolated environments; we have just started implementing support for isolated builds but we’ll have to answer that question first. If we stick to our approach—every piece of user-land software must be an explicit input of the build process—then code that implements TCP/IP, /dev/null, or even pipe should be an explicit input of any build process that needs those facilities.

This principled approach can push the notion of controlled, reproducible build environments to a whole new level. For example, we’ve had cases where the choice of the root file system—e.g., ext4 vs. Btrfs—has an observable effect on software behavior, leading to concrete issues such as test failures in one case and not in the other. On GNU/Hurd, build processes could run their own root file system, doing away with this kind of discrepancy.

On the other hand, there are practical issues that cannot be ignored: virtually all build processes need these facilities so they’ll need to be set up one way or another. Also, one could argue that things like /dev/null have a well-defined interface that’s set in stone and that, consequently, how they’re implemented does not matter at all. Can we say the same of the TCP/IP stack though? Maybe not. A line needs to be drawn somewhere.

We have yet to decide where to draw the line and to precisely define what the build environment contains on GNU/Hurd. These questions are closely related to bootstrapping issues we notably discussed at the 2019 Reproducible Builds Summit. Tricky, but exciting.

What's next?

In an earlier post we tried to answer the question “Why bother with the Hurd anyway?” An obvious question because it is all too easy to get discouraged, to downplay or underestimate the potential social impact of GNU and the Hurd.

We tried to make Hurd development as easy and as pleasant as we could. As you have seen, things start to work pretty nicely and there is still plenty of work to do in Guix. But in a way this is “merely packaging” the amazing work of others. Some of the real work that needs to be done and which is being discussed and is in progress right now includes:

All these tasks look daunting, and indeed that’s a lot of work ahead. But the development environment is certainly an advantage. Take an example: surely anyone who’s hacked on device drivers or file systems before would have loved to be able to GDB into the code, restart it, add breakpoints and so on—that’s exactly the experience that the Hurd offers. As for Guix, it will make it easy to test changes to the micro-kernel and to the Hurd servers, and that too has the potential to speed up development and make it a very nice experience.

Join #guix and #hurd on irc.freenode.net or the mailing lists and get involved!

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.

About the GNU Hurd

The GNU Hurd is the GNU project's replacement for the Unix kernel. It is a collection of servers that run on the Mach microkernel to implement file systems, network protocols, file access control, and other features that are implemented by the Unix kernel or similar kernels (such as Linux). More info.

The mission of the GNU Hurd project is to create a general-purpose kernel suitable for the GNU operating system, which is viable for everyday use, and gives users and programs as much control over their computing environment as possible.

08 October, 2020 02:15PM by Jan (janneke) Nieuwenhuizen, Ludovic Courtès, Mathieu Othacehe

October 07, 2020

www-zh-cn @ Savannah

Join the FSF for an online birthday celebration on Friday, October 9th

This Friday, October 9th, from 12:00 EDT (16:00 UTC) until 17:00 (21:00 UTC), we will host a fun and informative live event with guests from all over the world, to discuss the future of free software and learn from their experiences in different fields driving free software forward. You can find the full program on the FSF Web site, but here are some of the highlights we are looking forward to:

    We invited illustrator and artist David Revoy, who also designed our beautiful coral anniversary artwork, to join us and talk about his artwork, the challenges of design in free software, and his work with Pepper & Carrot. You can join us in the IRC #fsf channel on Freenode to ask him questions as well!

    We count on federated social media to keep developing our ethical social experience online, so we asked Pouhiou, co-director of Framasoft, to have a conversation with us about what a program like video sharing platform Peertube can mean for the future, and the importance and challenges of moderating a server.

    We will also be joined by Eda Nano, board member at April in France, who can elaborate on developments of free software in France, and talk about collaboration between organizations.

    A segment focusing on the challenges and successes of local free software activism worldwide will welcome organizers from free software groups large and small, including long-time LibrePlanet speaker Italo Vignoli from The Document Foundation, located in Italy, and Bonnie Mehring, Free Software Foundation Europe's junior project manager.

    Also, be sure to join us for short talks from FSF president Geoffrey Knauth, executive director John Sullivan, and FSF founder Richard Stallman on the last thirty-five years of software freedom, and what the future holds for the FSF.

It is promising to be a fun, educational, and entertaining event. You can join us via fsf.org, and join the conversation with our speakers live through IRC on Freenode in the #fsf channel; we'll make sure we put the link up prominently on our homepage as well. You can also join the online experience by sending in your own video commemorating the occasion, following the instructions on the LibrePlanet wiki.

This birthday celebration is gratis, and all of our speakers are volunteering their time to create a joyous event where we can share our experiences and knowledge together. The LibrePlanet safe space policy will be followed throughout the event, so please make sure you read it. If this online experience is anything like LibrePlanet 2020, we will have a wonderful event, and we can't wait to see everyone online.

07 October, 2020 09:28AM by Wensheng XIE

October 06, 2020

FSF News

FSF celebrates thirty-fifth anniversary with week of surprises and online event

BOSTON, Massachusetts, USA -- Tuesday, October 6, 2020 -- On October 4th, the Free Software Foundation (FSF) turned thirty-five years old, and is taking this week to celebrate. Activities will include the launch of a new FSF video, anniversary-themed artwork, and a livestreamed event with special guests from around the world.

On October 4, 1985, Harold Abelson, Robert J. Chassell, Richard M. Stallman, Gerald Jay Sussman, and Leonard H. Tower, Jr. incorporated the Free Software Foundation, Inc. In their application they wrote: "Our hope is to encourage members of the public to cooperate with each other by sharing software and other useful information. [...] In addition, the virtues of self-reliance and independent initiative will be furthered because users of our software will have the plans with which to repair or change it."

Free software gives every person the rights to run, change, share, and contribute to the software, and the FSF believes that these rights also help to support other fundamental rights like freedom of speech, freedom of the press, and the right to privacy. Since its incorporation, the encroachments on computer users that FSF founder Richard Stallman wrote about in his GNU Manifesto, published that same year, have not subsided.

The New Yorker published an article celebrating the Manifesto, and the Foundation's thirtieth birthday in 2015. They emphasized the visionary nature of the FSF's founding principles, and the ever-increasing encroachment of proprietary software:

"[...] if commercial entities were going to own the methods and technologies that controlled computers, then computer users would inevitably become beholden to those entities. This has come to pass, and in spades. Most computer users have become dependent on proprietary code provided by companies like Apple, Facebook, and Google, the use of which comes with conditions we may not condone or even know about, and can’t control; we have forfeited the freedom to adapt such code according to our needs, preferences, and personal ethics."

The FSF points to evidence that in the five years since, the problems have continued to get worse -- as the recent US antitrust hearings have shown, governments are still struggling to address the technological threats to fundamental freedoms.

Commenting on the birthday, and his time at the FSF, executive director John Sullivan said: "I've been fortunate to be a member of the FSF staff for almost half of these thirty-five years. Standing up to the biggest, most powerful companies and governments on the planet is exhausting work. In addition to the multiple generations of FSF staff and board members, I want to thank all of the community supporters -- activists, hackers, donors, volunteers -- who have stuck with us through the ups and downs, knowing the vital long-term importance of the FSF as a staunch protector of computer user freedom. We'll take a second to celebrate how far we've come, and then take that energy to keep moving forward."

FSF president Geoffrey Knauth also stressed the importance of individuals involved in defending computer user rights for all these years, and called for continued activism:

"It is you who are important, it is you who joined the effort to help the world see the virtues of free software, the dedication of its thousands of contributors and volunteers, the high quality of free software used every day around the world, and its sheer endurance and ability to find itself in widespread use even by those who were once fierce opponents to free software. Take that to heart, let's keep it going. Tell it to your children, and let's make sure your children have the freedoms you have achieved, and more."

To celebrate the thirty-fifth birthday, the FSF has announced a week full of surprises, including a video about the fundamental importance of software freedom; the release of anniversary-themed artwork, available on a T-shirt and poster, designed by illustrator and artist David Revoy; and, on Friday, October 9th, 2020, they will host an online event with guests from around the world. The online program goes from 12:00 EDT (16:00 UTC) until 17:00 EDT (21:00 UTC), and features, among other things, a session about federated social media and its moderation, and an interactive discussion with a range of international free software group organizers.

"There is no better way to celebrate this occasion than to call attention to the community members around the world who are at the center of the movement's past and future successes," says FSF program manager and event organizer Zoë Kooyman.

The FSF has sent out a call for free software supporters to send a celebratory two-minute video to the organization during this week, to be featured during the event. It also encourages people to take specific actions to protect their and others' freedoms.

About the Free Software Foundation

The Free Software Foundation, founded in 1985, is dedicated to promoting computer users' right to run, edit, share, contribute to, and redistribute computer programs. The FSF promotes the development and use of free (as in freedom) software -- particularly the GNU operating system and its GNU/Linux variants -- and free documentation for free software. The FSF also helps to spread awareness of the ethical and political issues of freedom in the use of software, and its Web sites, located at https://fsf.org and https://gnu.org, are an important source of information about GNU/Linux. Donations to support the FSF's work can be made at https://donate.fsf.org. Its headquarters are in Boston, MA, USA.

More information about the FSF, as well as important information for journalists and publishers, is at https://www.fsf.org/press.

Media Contacts

Zoë Kooyman
Program Manager
Free Software Foundation
+1 (617) 542 5942
campaigns@fsf.org

06 October, 2020 09:11PM

FSF Blogs

Join the FSF for an online birthday celebration on Friday, October 9th

FSF birthday ilustration

Thirty-five years after the founding of the Free Software Foundation (FSF), its mission is more important than ever, and the organization has grown to fill that need, with multiple departments attending to crucial education, advocacy, and enforcement. Our Campaigns Team sounds the alarm about freedom-restricting developments and creates educational materials to bring more free software advocates to the movement. Our Licensing and Compliance Lab defends the GNU General Public License (GPL) and the thousands of programs distributed under its terms, and is actively building a future in which we can direct people to ethical hardware of any kind through the Respects Your Freedom (RYF) program.

Free software is first and foremost about ethical principles. But we also want everyone to be able to actually live in freedom, and to demonstrate the way free software can be technically excellent. This work is supported by our talented Tech Team, who provide dedicated "bare metal" and virtual machines for the daily operations of the GNU Project and other free software communities, including Web hosting, mailing lists, software repositories, and compiling and testing software packages. The FSF Tech Team is also building a free collaboration site, which will assist free software projects and developers with being able to share their code, as always, in full freedom.

We are so grateful for our community, who have stood with the FSF to demand change for the past thirty-five years. And as we celebrate the FSF's birthday week, we reflect upon the changes that we are all fighting for. Change is necessary, because people view and experience the world through technology, and that view is obstructed by the lens that proprietary software corporations try to force us to look through.

We couldn't let thirty-five years of free software accomplishments pass without a celebration with, and for, the community that has made this happen. Traditionally, we would celebrate such a milestone in person, but for this exceptional coral anniversary of the FSF, we had to get creative.

Birthday event program for Friday, October 9th

This Friday, October 9th, from 12:00 EDT (16:00 UTC) until 17:00 (21:00 UTC), we will host a fun and informative live event with guests from all over the world, to discuss the future of free software and learn from their experiences in different fields driving free software forward. You can find the full program on the FSF Web site, but here are some of the highlights we are looking forward to:

  • We invited illustrator and artist David Revoy, who also designed our beautiful coral anniversary artwork, to join us and talk about his artwork, the challenges of design in free software, and his work with Pepper & Carrot. You can join us in the IRC #fsf channel on Freenode to ask him questions as well!

  • We count on federated social media to keep developing our ethical social experience online, so we asked Pouhiou, co-director of Framasoft, to have a conversation with us about what a program like video sharing platform Peertube can mean for the future, and the importance and challenges of moderating a server.

  • We will also be joined by Eda Nano, board member at April in France, who can elaborate on developments of free software in France, and talk about collaboration between organizations.

  • A segment focusing on the challenges and successes of local free software activism worldwide will welcome organizers from free software groups large and small, including long-time LibrePlanet speaker Italo Vignoli from The Document Foundation, located in Italy, and Bonnie Mehring, Free Software Foundation Europe's junior project manager.

  • Also, be sure to join us for short talks from FSF president Geoffrey Knauth, executive director John Sullivan, and FSF founder Richard Stallman on the last thirty-five years of software freedom, and what the future holds for the FSF.

It is promising to be a fun, educational, and entertaining event. You can join us via fsf.org, and join the conversation with our speakers live through IRC on Freenode in the #fsf channel; we'll make sure we put the link up prominently on our homepage as well. You can also join the online experience by sending in your own video commemorating the occasion, following the instructions on the LibrePlanet wiki.

This birthday celebration is gratis, and all of our speakers are volunteering their time to create a joyous event where we can share our experiences and knowledge together. The LibrePlanet safe space policy will be followed throughout the event, so please make sure you read it. If this online experience is anything like LibrePlanet 2020, we will have a wonderful event, and we can't wait to see everyone online.

Support the FSF and get an anniversary pin

If you can, please support our work for this celebration. With your help, we can effect major change! You can show your support for the future of free software by donating $35 or more to the FSF during this birthday week to get a free anniversary pin (while stocks last). You can also support free software by purchasing David's magnificent design on a T-shirt or poster through the GNU Press Shop.

We hope to see you this Friday, October 9th, to help us celebrate!

Illustration Copyright © 2020 Free Software Foundation, Inc., by David Revoy, licensed under Creative Commons Attribution 4.0 International license.

06 October, 2020 08:23PM

www @ Savannah

Should Rockets Have Only Free Software?

New article by Richard Stallman: Should Rockets Have Only Free Software?

Could there be a rocket that is totally free software? Should we demand that SpaceX liberate the software in its satellite launching rockets? I don't think the person who asked me this was serious, but answering that question may illuminate similar issues about the sorts of products people really buy today.

06 October, 2020 02:40PM by Dora Scilipoti

GNU Guix

Running Guix System on a Linode Server

Christopher Lemmer Webber recently discovered how to run Guix System on a Linode server. The below guide details how to set up your Linode server to run Guix System. We invite you to run your website using Guix system!

To run Guix on a server hosted by Linode, start with a recommended Debian server. We recommend using the default distro as a way to bootstrap Guix. Create your SSH keys.

ssh-keygen

Be sure to add your SSH key for easy login to the remote server. This is trivially done via Linode's graphical interface for adding SSH keys. Go to your profile and click add SSH Key. Copy into it the output of:

cat ~/.ssh/<username>_rsa.pub

Power the Linode down. In the Linode's Disks/Configurations tab, resize the Debian disk to be smaller. 30 GB is recommended.

In the Linode settings, choose Add a disk with the following:

  • Label: Guix
  • Filesystem: ext4
  • Set it to the remaining size

On the configuration field that comes with the default image, press ... and select Edit, then on that menu add to /dev/sdc the Guix label.

Now select Add a Configuration, with the following:

  • Label: Guix
  • Kernel: GRUB 2 (it's at the bottom! This step is important!
  • Block device assignment:

    • /dev/sda: Guix
    • /dev/sdb: swap
  • Root device: /dev/sda
  • Turn off all the filesystem/boot helpers.

Now power it back up, picking the Debian configuration. Once it's booted up, ssh in your server via ssh root@<your-server-IP-here>. (You can find your server IP address in your Linode Summary section.) Now you can run the binary installation as explained in the manual:

sudo apt-get install gpg
wget https://sv.gnu.org/people/viewgpg.php?user_id=15145 -qO - | gpg --import -
wget https://git.savannah.gnu.org/cgit/guix.git/plain/etc/guix-install.sh
chmod +x guix-install.sh
./guix-install.sh
guix pull

Now it's time to write out a config for the server. The key information is below. Save the resulting file as guix-config.scm.

(use-modules (gnu)
             (guix modules))
(use-service-modules networking
                     ssh)
(use-package-modules admin
                     certs
                     package-management
                     ssh
                     tls)

(operating-system
  (host-name "my-server")
  (timezone "America/New_York")
  (locale "en_US.UTF-8")
  ;; This goofy code will generate the grub.cfg
  ;; without installing the grub bootloader on disk.
  (bootloader (bootloader-configuration
               (bootloader
                (bootloader
                 (inherit grub-bootloader)
                 (installer #~(const #t))))))
  (file-systems (cons (file-system
                        (device "/dev/sda")
                        (mount-point "/")
                        (type "ext4"))
                      %base-file-systems))
  (swap-devices (list "/dev/sdb"))

  (initrd-modules (cons "virtio_scsi"    ;needed to find the disk
                        %base-initrd-modules))

  (users (cons (user-account
                (name "janedoe")
                (group "users")
                ;; Adding the account to the "wheel" group
                ;; makes it a sudoer.
                (supplementary-groups '("wheel"))
                (home-directory "/home/janedoe"))
               %base-user-accounts))

  (packages (cons* nss-certs            ;for HTTPS access
                   openssh-sans-x
                   %base-packages))

  (services (cons*
             (service dhcp-client-service-type)
             (service openssh-service-type
                      (openssh-configuration
                       (openssh openssh-sans-x)
                       (password-authentication? #f)
                       (authorized-keys
                        `(("janedoe" ,(local-file "janedoe_rsa.pub"))
                          ("root" ,(local-file "janedoe_rsa.pub"))))))
             %base-services)))

Replace the following fields in the above configuration:

(host-name "my-server")       ; replace with your server name
; if you chose a linode server outside the U.S., then
; use tzselect to find a correct timezone string
(timezone "America/New_York") ; if needed replace timezone
(name "janedoe")              ; replace with your username
("janedoe" ,(local-file "janedoe_rsa.pub")) ; replace with your ssh key
("root" ,(local-file "janedoe_rsa.pub")) ; replace with your ssh key

The last line in the above example lets you log into the server as root and set the initial root password. After you have done this, you may delete that line from your configuration and reconfigure to prevent root login.

Save your ssh public key (eg: ~/.ssh/id_rsa.pub) as <your-username-here>_rsa.pub and your guix-config.scm in the same directory. In a new terminal run these commands.

sftp root@@<remote server ip address>
put /home/<username>/ssh/id_rsa.pub .
put /path/to/linode/guix-config.scm .

In your first terminal, mount the guix drive:

mkdir /mnt/guix
mount /dev/sdc /mnt/guix

Due to the way we set things up above, we do not install GRUB completely. Instead we install only our grub configuration file. So we need to copy over some of the other GRUB stuff that is already there:

mkdir -p /mnt/guix/boot/grub
cp -r /boot/grub/* /mnt/guix/boot/grub/

Now initialize the Guix installation:

guix system init guix-config.scm /mnt/guix

Ok, power it down! Now from the Linode console, select boot and select Guix.

Once it boots, you should be able to log in via SSH! (The server config will have changed though.) You may encounter an error like:

$ ssh root@<server ip address>
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@    WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED!     @
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!
Someone could be eavesdropping on you right now (man-in-the-middle attack)!
It is also possible that a host key has just been changed.
The fingerprint for the ECDSA key sent by the remote host is
SHA256:0B+wp33w57AnKQuHCvQP0+ZdKaqYrI/kyU7CfVbS7R4.
Please contact your system administrator.
Add correct host key in /home/joshua/.ssh/known_hosts to get rid of this message.
Offending ECDSA key in /home/joshua/.ssh/known_hosts:3
ECDSA host key for 198.58.98.76 has changed and you have requested strict checking.
Host key verification failed.

Either delete ~/.ssh/known_hosts file, or delete the offending line starting with your server IP address.

Be sure to set your password and root's password.

ssh root@<remote ip address>
passwd  ; for the root password
passwd <username> ; for the user password

You may not be able to run the above commands at this point. If you have issues remotely logging into your linode box via SSH, then you may still need to set your root and user password initially by clicking on the Launch Console option in your linode. Choose the Glish instead of Weblish. Now you should be able to ssh into the machine.

Hooray! At this point you can shut down the server, delete the Debian disk, and resize the Guix to the rest of the size. Congratulations!

By the way, if you save it as a disk image right at this point, you'll have an easy time spinning up new Guix images! You may need to down-size the Guix image to 6144 MB, to save it as an image. Then you can resize it again to the max size.

That's all for today! We hope you have fun playing with your brand new Guix System Server!

A variant of this guide is available in the Guix Cookbook.

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 kernel Linux, 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.

06 October, 2020 02:30PM by Joshua Branson, Christopher Lemmer Webber

October 05, 2020

FSF Blogs

FSF 35 years: Limited edition T-shirt and poster for sale

For the Free Software Foundation's (FSF) thirty-fifth birthday, we collaborated with free culture illustrator David Revoy to create a marvelous design, and we think you'll like the results.

Behold the FSF thirty-fifth anniversary graphic:

It's wonderful, but what is it? The undersea architecture of the future, of course! We looked up traditional thirty-fifth anniversary gifts, and learned that the thirty-fifth is our "coral anniversary."

This is auspicious: the more we considered coral -- particularly Scleractinia, the reef-forming "stony corals" -- the more similarities to the free software ethos became apparent. In a coral reef, countless individuals of diverse species band together and share resources to collectively create the framework for an ecosystem of dazzling diversity. The free software movement is similar, being a large group of individuals collaborating to advance human freedom and an array of related ethical goals.

A reef is home to thousands upon thousands of different species of fish, cnidarians, molluscs, crustaceans, and more, all built on the bedrock infrastructure of the coral. Sound familiar? Colonies of coral share resources by circulating food and water between individuals; they can split apart collectively or individually to go separate ways, or multiple colonies can join together in cooperation. Humans stand to learn much from coral -- lessons already embodied in the free software movement.

As we consider what we can learn from coral, it's apparent that we are responsible to give something back. Coral reef ecosystems, much like free software, are under severe threat all around the world.

Get the design on a T-shirt or poster through the shop

By becoming an FSF associate member, you will be a vital part of the free software ecosystem, one which helps continue to create a world where all software respects our freedom and dignity. Of course, as one of the benefits, you receive a 20% discount at the GNU Press Shop, which will come in handy when you are so impressed with this design, you decide that you would love it on a T-shirt or a 18 x 24" poster.

The items are available now at the GNU Press Shop. We have limited quantities, so get yours before they sell out!

Happy thirty-five years of FSF!

Illustration Copyright © 2020 Free Software Foundation, Inc., by David Revoy, licensed under Creative Commons Attribution 4.0 International license.

05 October, 2020 08:25PM

October 04, 2020

FSF Events

The FSF's 35th anniversary event

Join us in celebrating the FSF's thirty-fifth year of fighting for software freedom.

Online and via IRC in #fsf (on Freenode)
Celebration image
Source files for the anniversary artwork by illustrator and artist David Revoy.
Our work will not be finished until every computer user is able to do all of their digital tasks in complete freedom -- whether that's on a desktop, laptop, or the computer in your pocket. The fight for free software continues, and we wouldn't be here without you.

To celebrate, we have a full week of announcements and surprises planned.

We will end in an online anniversary event featuring both live and prerecorded segments this Friday, October 9th, from 12:00 EDT (16:00 UTC) until 17:00 EDT (21:00 UTC).


Submit a celebration video

We'd love for you to join in celebration of this amazing community by submitting a short (two-minute) video sharing your favorite memory about free software or the FSF, or a wish for the future of software freedom. We'll be collecting the videos all week and airing a selection during the birthday event on October 9th. Please follow these instructions on how to successfully (and freely!) submit the video via FTP.

If you submit your video before Thursday October 8th 16:00 EDT (20:00 UTC), you may be featured in the live event on October 9th. However, submissions after this time will still be accepted.


Program (Times are in EDT)

  • 12:00 - 12:10: Welcome and introductory remarks
    by Greg Farough (FSF campaigns manager)
    and Zoë kooyman (FSF program manager)

  • 12:10 - 12:25: Celebrating 35 years of FSF
    by FSF president Geoffrey Knauth

  • 12:30 - 13:15 Free software design and Q&A
    with illustrator and artist David Revoy

  • 13:15 - 13:30: Community videos

  • 13:30 - 14:15: Free software in France, federated social media and moderation
    with Pouhiou, co-founder of Framasoft and Eda Nano, board member of April, France

  • 14:15 - 14:30: A prerecorded message from RMS
    by FSF founder Richard Stallman

  • 14:30 - 15:00: FSF History Quiz
    by Craig Topham (FSF copyright and licensing associate & quizmaster)

  • 15:00 - 16:30: How to organize local free software groups
    with Bonnie Mehring (FSFE, DE), Italo Vignoli (TDF)
    and local groups organizers from around the world.

  • 16:30 - 16:45: Celebrating 35 years of FSF
    by FSF executive director John Sullivan

  • 16:45 - 16:55: Community videos

  • 16:55 - 17:00: Closing remarks

This live event will follow the LibrePlanet safe space policy will be followed throughout the event, so please make sure you read it.


How to join the anniversary event

The event will be livestreamed through the fsf.org Web site, and the link will be posted here as soon as the livepage is available. Join the conversation, and ask questions to the speakers through IRC on Freenode at #fsf.


Support the FSF and receive an anniversary pin

Image of anniversary pin

If you are also able to, please consider making a donation of $35 or more to help keep the fight for user freedom going another 35 years, we'll send you a commemorative pin as pictured at the top of this email.


Share

Invite people to join the community's celebration of thirty-five years of software freedom sharing the hashtag #FSF35.

Feel free to adapt the text and use it with the #fsf35 hashtag and the included image.

Join me in celebrating #fsf35 with the free software community and the @FSF this Friday, October 9th by tuning into fsf.org for the live anniversary event.


Illustration Copyright © 2020 Free Software Foundation, Inc., by David Revoy, licensed under Creative Commons Attribution 4.0 International license.

04 October, 2020 08:55PM

FSF Blogs

FSF at 35 -- join us in celebrating the incredible community

Celebration image

Today, on October 4th, the Free Software Foundation (FSF) celebrates its thirty-fifth year of fighting for software freedom. Our work will not be finished until every computer user is able to do all of their digital tasks in complete freedom -- whether that's on a desktop, laptop, or the computer in your pocket. The fight for free software continues, and we wouldn't be here without you.

To celebrate, we have a full week of announcements and surprises planned starting today, and we will end in an online anniversary event featuring both live and prerecorded segments this Friday, October 9th, from 12:00 EDT (16:00 UTC) until 17:00 EDT (21:00 UTC). We'd love for you to join in celebration of this amazing community by submitting a short (two-minute) video sharing your favorite memory about free software or the FSF, and a wish for the future of software freedom. We'll be collecting the videos all week and airing a selection during the birthday event on October 9th. Please follow the instructions linked below on how to successfully (and freely!) submit the video via FTP.

If you are able to, please make a donation of $35 or more to help keep the fight for user freedom going another 35 years, we'll send you a commemorative pin as pictured in this blog post.

Uploading a video

We'd love to have you submit a video for us to show during this week's festivities. Please follow the instructions we've posted to the LibrePlanet wiki to upload your video, and write to us at campaigns@fsf.org when you're finished. Please keep your comments on the topic of free software and the FSF, and your video length under two minutes.

There's no better way to commemorate the FSF's 35th anniversary than to spread the free software message. We've come up with a few more ways you can do so, and ideally encourage your friends to do the same. The best gifts we can ask for are the individual contributions that keep this movement going.

Ways to celebrate

  • Try a fully free distribution of GNU/Linux, which can be run "live" without making any permanent changes to your computer's hard drive.

  • Take an hour to follow our Email Self-Defense Guide guide, and learn how to opt out of bulk surveillance.

  • Download and experiment with one of the oldest parts of the GNU operating system, the GNU Emacs text editor. Try the tutorial by launching the editor and typing Ctrl-h + t (C-h t), or see if you can make it through some of the games included with Emacs, such as Alt-x (M-x) dunnet or M-x tetris.

  • Make the commitment to replace one nonfree program that you use with one that respects your freedom, such as using LibreOffice instead of Microsoft Office.

  • Petition the administrators of your favorite Web site to free the proprietary JavaScript lurking on their page that many users run and download without ever realizing it.

  • Contribute to the Free Software Directory by writing or updating the entry for a freely licensed program you enjoy, or join us on the Freenode IRC channel #fsf Fridays from 16:00-19:00 UTC for our weekly meetings on how to improve the Directory.

Image of anniversary pin

  • Help support the FSF's important work by buying manuals, apparel, and other GNU gear at the GNU Press shop! You could upgrade your skills with a GNU/Linux command line manual, or just get an adorable stuffed baby GNU as a companion for late-night hacking. Also, keep your eyes peeled for special items related to our 35th anniversary. The pin you see here is just one of them!

  • Watch and share the videos from our animated series, as well as the keynotes, presentations, and panels given at LibrePlanet, the annual conference dedicated to defending computer user freedom.

  • Have an Android phone? Install F-Droid, a repository with hundreds of fun and useful free software apps.

  • Share a message on social media about the FSF's thirty-fifth anniversary! Feel free to adapt the text and use it with the #fsf35 hashtag and the included image.

Join me in celebrating #fsf35 with the free software community and the @FSF this Friday, October 9th by tuning into fsf.org for the live anniversary event.

We're another year older, but that doesn't mean we're slowing down our efforts to bring software freedom to users around the globe. Stay tuned for more information on how we plan to ring in the FSF's next year, and the vital role each one of us plays in ensuring free software's success for the future. We hope that you'll be able to take part in our festivities this week!

04 October, 2020 07:50PM

Sylvain Beucler

git filter-branch and --state-branch - how?

I'm mirroring and reworking a large Git repository with git filter-branch (conversion ETA: 20h), and I was wondering how to use --state-branch which is supposed to speed-up later updates, or split a large conversion in several updates.

The documentation is pretty terse, the option can produce weird results (like an identity mapping that breaks all later updates, or calling the expensive tree-filter but discarding the results), wrappers are convoluted, but I got something to work so I'll share :)

The main point is: run the initial script and the later updates in the same configuration, which means the target branch needs to be reset to the upstream branch each time, before it's rewritten again by filter-branch. In other words, don't re-run it on the rewritten branch, nor attempt some complex merge/cherry-pick.

git fetch
git branch --no-track -f myrewrite origin/master
git filter-branch \
  --xxx-filter ... \
  --xxx-filter ... \
  --state-branch refs/heads/filter-branch/myrewrite \
  -d /dev/shm/filter-branch/$$ -f \
  myrewrite

Updates restart from scratch but only take a few seconds to skim through all the already-rewritten commits, and maintain a stable history.

Note that if the process is interrupted, the state-branch isn't modified, so it's not a stop/resume feature. If you want to split a lenghty conversion, you could simulate multiple upstream updates by checking out successive points in history (e.g. per year using $(git rev-list -1 --before='2020-01-01 00:00:00Z')).

--state-branch isn't meant to rewrite in reverse chronological order either, because all commit ids would constantly change. Still, you can rewrite only the recent history for a quick discardable test.

Be cautious when using/deleting rewritten branches, especially during early tests, because Git tends to save them to multiple places which may desync (e.g. .git/refs/heads/, .git/logs/refs/, .git/packed-refs). Also remember to delete the state-branch between different tests. Last, note the unique temporary directory -d to avoid ruining concurrent tests ^_^'

04 October, 2020 10:18AM

October 01, 2020

Parabola GNU/Linux-libre

[From Arch] ghostpcl>=9.53.2-2 and ghostxps>=9.53.2-2 updates require manual intervention

The ghostpcl and ghostxps packages prior to version 9.53.2-2 were missing a soname link each. This has been fixed in 9.53.2-2, so the upgrade will need to overwrite the untracked files created by ldconfig. If you get any of these errors

ghostpcl: /usr/lib/libgpcl6.so.9 exists in filesystem
ghostxps: /usr/lib/libgxps.so.9 exists in filesystem

when updating, use

pacman -Syu --overwrite /usr/lib/libgpcl6.so.9,/usr/lib/libgxps.so.9

to perform the upgrade.

01 October, 2020 09:20PM by David P.

FSF Blogs

September GNU spotlight with Mike Gerwitz: Twelve new releases!

For announcements of most new GNU releases, subscribe to the info-gnu mailing list: https://lists.gnu.org/mailman/listinfo/info-gnu.

To download: nearly all GNU software is available from https://ftp.gnu.org/gnu/, or preferably one of its mirrors from https://www.gnu.org/prep/ftp.html. You can use the url https://ftpmirror.gnu.org/ to be automatically redirected to a (hopefully) nearby and up-to-date mirror.

This month, we welcome Amin Bandali as comaintainer of Jami and John Darrington as comaintainer of PSPP.

A number of GNU packages, as well as the GNU operating system as a whole, are looking for maintainers and other assistance: please see https://www.gnu.org/server/takeaction.html#unmaint if you'd like to help. The general page on how to help GNU is at https://www.gnu.org/help/help.html.

If you have a working or partly working program that you'd like to offer to the GNU project as a GNU package, see https://www.gnu.org/help/evaluation.html.

01 October, 2020 06:18PM

September 30, 2020

GNU Taler news

Talk about GNU Taler in Valencia

2020-10: GNU Taler presentation by Javier Sepúlveda in Valencia

Javier Sepúlveda will give a talk in Spanish about GNU Taler at Valencia at an event organized by the GNU/Linux group from Valencia, which is a public organization supported by the Valencia City Hall to promote urban innovation and entrepreneurship.

30 September, 2020 10:00PM

Christopher Allan Webber

Spritely website launches, plus APConf video(s)!

Note: This originally appeared as a post on my Patreon account... thanks to all who have donated to support my work!

Hello, hello! Spritely's website has finally launched! Whew... it's been a lot of work to get it to this state! Plus check out our new logo:

Spritely logo

Not bad, eh? Also with plenty of cute characters on the Spritely site (thank you to David Revoy for taking my loose character sketches and making them into such beautiful paintings!)

But those cute characters are there for a reason! Spritely is quite ambitious and has quite a few subprojects. Here's a video that explains how they all fit together. Hopefully that makes things more clear!

Actually that video is from ActivityPub Conference 2020, the talks of which have now all have their videos live! I also moderated the intro keynote panel about ActivityPub authors/editors. Plus there's an easter egg, the ActivityPub Conference Opening Song! :)

But I can't take credit for APConf 2020... organization and support are thanks to Morgan Lemmer-Webber, Sebastian Lasse, and FOSSHost for hosting the website and BigBlueButton instance and conf.tube for generously hosting all the videos. There's a panel about the organization of APConf you can watch if you're interested in more of that! (And of course, all the other great videos too!)

So... what about that week I was going to work on Terminal Phase? Well... I'm still planning on doing it but admittedly it hasn't happened yet. All of the above took more time than expected. However, today I am working on my talk about Spritely Goblins for RacketCon, and as it turns out, extending Terminal Phase is a big part of that talk. But I'll announce more soon when the Terminal Phase stuff happens.

Onwards and upwards!

30 September, 2020 07:20PM by Christopher Lemmer Webber

September 28, 2020

grep @ Savannah

grep-3.5 released [stable]

This is to announce grep-3.5, a stable release.

Thanks especially to Paul Eggert, Norihiro Tanaka and Bruno Haible
for changes both in grep proper and in gnulib.

There have been 56 commits by 3 people in the 38 weeks since 3.4.

See the NEWS below for a summary.

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

  Jim Meyering (22)
  Norihiro Tanaka (1)
  Paul Eggert (33)

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

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

For a summary of changes and contributors, see:
  http://git.sv.gnu.org/gitweb/?p=grep.git;a=shortlog;h=v3.5
or run this command from a git-cloned grep directory:
  git shortlog v3.4-almost..v3.5

To summarize the 806 gnulib-related changes, run these commands
from a git-cloned grep directory:
  git checkout v3.5
  git submodule summary v3.4-almost

==================================================================
Here are the compressed sources:
  https://ftp.gnu.org/gnu/grep/grep-3.5.tar.gz   (2.6MB)
  https://ftp.gnu.org/gnu/grep/grep-3.5.tar.xz   (1.6MB)

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

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

[*] 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 grep-3.5.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 7FD9FCCB000BEEEE

and rerun the 'gpg --verify' command.

This release was bootstrapped with the following tools:
  Autoconf 2.69c
  Automake 1.16b
  Gnulib v0.1-3927-g02b29b878

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

* Noteworthy changes in release 3.5 (2020-09-27) [stable]

** Changes in behavior

  The message that a binary file matches is now sent to standard error
  and the message has been reworded from "Binary file FOO matches" to
  "grep: FOO: binary file matches", to avoid confusion with ordinary
  output or when file names contain spaces and the like, and to be
  more consistent with other diagnostics.  For example, commands
  like 'grep PATTERN FILE | wc' no longer add 1 to the count of
  matching text lines due to the presence of the message.  Like other
  stderr messages, the message is now omitted if the --no-messages
  (-s) option is given.

  Two other stderr messages now use the typical form too.  They are
  now "grep: FOO: warning: recursive directory loop" and "grep: FOO:
  input file is also the output".

  The --files-without-match (-L) option has reverted to its behavior
  in grep 3.1 and earlier.  That is, grep -L again succeeds when a
  line is selected, not when a file is listed.  The behavior in grep
  3.2 through 3.4 was causing compatibility problems.

** Bug fixes

  grep -I no longer issues a spurious "Binary file FOO matches" line.
  [Bug#33552 introduced in grep 2.23]

  In UTF-8 locales, grep -w no longer ignores a multibyte word
  constituent just before what would otherwise be a word match.
  [Bug#43225 introduced in grep 2.28]

  grep -i no longer mishandles ASCII characters that match multibyte
  characters.  For example, 'LC_ALL=tr_TR.utf8 grep -i i' no longer
  dumps core merely because 'i' matches 'İ' (U+0130 LATIN CAPITAL
  LETTER I WITH DOT ABOVE) in Turkish when ignoring case.
  [Bug#43577 introduced partly in grep 2.28 and partly in grep 3.4]

  A performance regression with -E and many patterns has been mostly fixed.
  "Mostly" as there is a performance tradeoff between Bug#22357 and Bug#40634.
  [Bug#40634 introduced in grep 2.28]

  A performance regression with many duplicate patterns has been fixed.
  [Bug#43040 introduced in grep 3.4]

  An N^2 RSS performance regression with many patterns has been fixed
  in common cases (no backref, and no use of -o or --color).
  With only 80,000 lines of /usr/share/dict/linux.words, the following
  would use 100GB of RSS and take 3 minutes. With the fix, it used less
  than 400MB and took less than one second:
    head -80000 /usr/share/dict/linux.words > w; grep -vf w w
  [Bug#43527 introduced in grep 3.4]

** Build-related

  "make dist" builds .tar.gz files again, as they are still used in
  some barebones builds.

28 September, 2020 03:30AM by Jim Meyering

September 26, 2020

hyperbole @ Savannah

GNU Hyperbole 7.1.3, the Antiviral Release, is now available on GNU ELPA

What's new in this release is described here:

   http://www.gnu.org/s/hyperbole/HY-NEWS.html

   Everything back until release 7.0.3 is new since the last major
   release announcement (about a year ago), so updates are extensive.

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

  • Introduction

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

Hyperbole is like Markdown for hypertext.  Hyperbole automatically
recognizes dozens of common patterns in any buffer regardless of mode
and can instantly activate them as hyperbuttons with a single key:
email addresses, URLs, grep -n outputs, programming backtraces,
sequences of Emacs keys, programming identifiers, Texinfo and Info
cross-references, Org links, Markdown links and on and on.  All you do
is load Hyperbole and then your text comes to life with no extra
effort or complex formatting.

Hyperbole interlinks all your working information within Emacs for
fast access and editing, not just within special modes.  Every button
is automatically assigned a type and new types can be developed for
your own buttons with simple function definitions.  You can create
your own buttons by simply dragging between two buffers.

But Hyperbole is also a hub controller for your information supplying
built-in capabilities of contact management/hierarchical record
lookup, legal-numbered outlines with hyperlinkable views and a unique
window and frame manager.  It is even Org-compatible so you can use
all of Org's capabilities together with Hyperbole.

Hyperbole is unique, powerful, extensively documented, and free.  Like
Emacs, Org, Counsel and Helm, Hyperbole has many different uses all
based around the theme of reducing cognitive load and improving your
everyday information management.  Then as you grow with it across
time, it helps you build new capabilities that continue to speed your
work.

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

  • Using Hyperbole

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

To install:

   {M-x package-install RET hyperbole RET} to install it.

   It installs in about a minute and can be uninstalled even faster if
   ever need be.  Give it a try.

Then to invoke its menu:

   {C-h h} or {M-x hyperbole RET}

The best way to get a feel for many of its capabilities is to
invoke the interactive DEMO and explore sections of interest:

   {C-h h d d}

The Hyperbole home page with screen shots is here:

   http://www.gnu.org/s/hyperbole

For use cases, see:

   http://www.gnu.org/s/hyperbole/HY-WHY.html

For what users think about Hyperbole, see:

   http://www.gnu.org/s/hyperbole/hyperbole.html#user-quotes

Enjoy,

The Hyperbole Team

26 September, 2020 01:59AM by Robert Weiner

September 24, 2020

autoconf @ Savannah

Autoconf 2.69c [beta]

Autoconf 2.69c has been released, see the release announcement:
<https://lists.gnu.org/archive/html/autoconf/2020-09/msg00006.html>

24 September, 2020 05:31PM by Zack Weinberg

FSF Blogs

From the FSF Bulletin: Trial by proprietary software

This article was originally published in the Spring 2020 issue of the Free Software Foundation Bulletin, our biannual newsletter, which is mailed to over 10,000 free software supporters around the world. See the rest of the special expanded online issue of the Bulletin at https://static.fsf.org/nosvn/magazine/2020-spring/.

"At a remote eviction hearing...in Collin County, Texas, the court granted landlords the right to evict five people who didn't or couldn't dial into the [Zoom] hearing."

John Sullivan, Executive Director of the FSF, does a presentation at the FSF Continuing Legal Education Seminar in Raleigh, North Carolina, in October 2019.

John Sullivan, Executive Director of the FSF, does a presentation at the FSF Continuing Legal Education Seminar in Raleigh, North Carolina, in October 2019.

There has been so much to worry about during the COVID-19 pandemic, even just within the category of technology policy. At the FSF, our role is to worry specifically about the impact of software on human freedom. Software can be a tremendous tool for solving social and scientific problems, but only when the terms of its distribution and use allow everyone to inspect how it works, share copies of it, modify it for their own purposes, and share those improvements or tweaks with others.

Unfortunately, with the shutdown of in-person institutions around the world, people have turned to the proprietary software companies that had the sales and marketing resources to quickly insert themselves as "solutions." Among these institutions are courts of law, many of which have been conducting some proceedings over Zoom. While Zoom is a "service," it also requires those using it to run nonfree software on their local devices -- either the official client application, or downloaded nonfree JavaScript when connecting via a Web browser.

While Zoom's software itself doesn't cost an individual any money to use, it raises two clear categories of concern: requiring people to agree to Zoom's arbitrary demands as a condition for access to justice, and the state's public endorsement of Zoom.

First, for a person to use Zoom, they ostensibly have to agree to Zoom's terms of service. Having to agree to a contract with a private company in order to access public services is immediately objectionable. It puts that company in the position of being an actual gatekeeper for our rights under the law. The fact that they can change their terms at any time makes the situation even worse. Right now, they make users promise not to aid any effort to reverse engineer Zoom software -- something which is ethical and legal when done cleanly. Similarly to a celebrity's rider, they also require assent to an assortment of ridiculous provisions. Don't you dare put a Zoom trademark in a picture frame! It's not allowed, if you want to use Zoom. A company attempting to make you mind their trademarks in such specific ways before you can explain why you shouldn't lose your home is horrifying.

Second, for the state to require use of Zoom is for it to promote and subsidize that company. This promotion influences public perception of videoconferencing tools, a business area that depends heavily on network effect (people will use the tools that most other people they know are already using). If the state is going to promote a platform, it should be one that all citizens -- and their businesses -- can use and build on. The money spent every month on Zoom contracts could instead be spent improving free software, on the foundation of some very capable free platforms that already exist for this purpose, like Jitsi Meet and Big Blue Button. The state's choice of Zoom sends the wrong social message and misappropriates public resources. Further, the state has an obligation to preserve its own autonomy, which it by definition cannot do when it cannot see the source code or choose from multiple providers to fix or improve the software.

Whether videoconferencing is acceptable for court proceedings at all is a separate and important topic. Even free software wouldn't address the fact that videoconferencing requires a sufficiently capable Internet connection and a sufficiently powerful computer with a camera, neither of which everyone has access to. Other issues, like how personal data is handled by the service, also need to be considered, separately from what software is used. But no matter what, if there is videoconferencing, people should never be required to run nonfree programs to participate. We should not accept opaque, proprietary software as infrastructure for our democracy.

It is asking a lot to say that people should refuse to use Zoom for a court date, since they could face serious repercussions. If anyone is able to take such a stand, the FSF will amplify their story and help make it count. When localities anywhere in the world do the right thing, we can highlight their work and help share how they did it. As an individual, even without a court date, you should write letters to your local officials, and then share those letters on libreplanet.org so others can reuse them and add to them. The FSF will be working hard with you on these challenges through the pandemic and beyond. We know that if we don't do this together, user freedom won't get the public hearing it needs.

And if you do have to attend a Zoom court date, please consider putting a framed copy of the Zoom logo on the wall behind you.

Photo Copyright ©2019 Free Software Foundation, Inc. This image is licensed under a Creative Commons Attribution ShareAlike 4.0 International license.

24 September, 2020 03:51PM

September 23, 2020

parallel @ Savannah

GNU Parallel 20200922 ('Ginsburg') released

GNU Parallel 20200922 ('Ginsburg') has been released. It is available for download at: http://ftpmirror.gnu.org/parallel/

Quote of the month:

  Great tool, gets jobs done fast.
  Great tool, gets jobs done fast.
  Great tool, gets jobs done fast.
    -- Paul F. De La Cruz @pdelacruzcc@twitter

 

New in this release:

  • New CPU detection for GNU/Linux.
  • 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.

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 3374ec53bacb199b245af2dda86df6c9
    12345678 3374ec53 bacb199b 245af2dd a86df6c9
    $ md5sum install.sh | grep 029a9ac06e8b5bc6052eac57b2c3c9ca
    029a9ac0 6e8b5bc6 052eac57 b2c3c9ca
    $ sha512sum install.sh | grep f517006d9897747bed8a4694b1acba1b
    40f53af6 9e20dae5 713ba06c f517006d 9897747b ed8a4694 b1acba1b 1464beb4
    60055629 3f2356f3 3e9c4e3c 76e3f3af a9db4b32 bd33322b 975696fc e6b23cfb
    $ 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 September, 2020 03:49PM by Ole Tange

September 15, 2020

GNU Taler news

GNU Taler launched at BFH

2020-09: GNU Taler operational at Bern University of Applied Sciences

The GNU Taler payment system was launched at the BFH in the presence of a representative of the Swiss National Bank. Students, staff, faculty and visitors can visit the cafeteria at Höheweg 80 to withdraw the electronic equivalent of Swiss Franks (CHF) onto Taler Wallet App running on their mobile phones and pay at a Taler-enabled snack machine. The system is expected to expand to allow payments at other places in the future. Various faculty members and students are involved various aspects of the project. Students interested in working on projects or theses related to the subject should contact Prof. Grothoff.

15 September, 2020 10:00PM

September 13, 2020

Christopher Allan Webber

Spritely Goblins v0.7 released!

I'm delighted to say that Spritely Goblins v0.7 has been released! This is the first release featuring CapTP support (ie, "capability-secure distributed/networked programming support"), which is a huge milestone for the project!

Okay, caveat... there are still some things missing from the CapTP stuff so far; you can only set up a bidirectional connection between two machines, and can't "introduce" capabilities to other machines on the network. Also setting up connections is an extremely manual process. Both of those should be improved in the next release.

But still! Goblins can now be used to easily write distributed programs! And Goblins' CapTP code even includes such wild features as distributed garbage collection!

As an example (also mentioned in a recent blogpost), I recently wrote a short chat program demo. Both the client and server "protocol" code were less than 250 lines of code, despite having such features as authenticating users during subscription to the chatroom and verifying that messages claimed by the chatroom came from the users it said it did. (The GUI code, by contrast, was a little less than 300 lines.) I wrote this up without writing any network code at all and then tested hooking together two clients over Tor Onion Services using Goblins' CapTP support, and it Just Worked (TM):

Goblins chat GUI demo

What's interesting here is that not a single line of code was added to the backend or GUI to accomodate networking; the host and guest modules merely imported the backend and GUI files completely unchanged and did the network wiring there. Yes, that's what it sounds like: in Goblins you can write distributed asynchronous programs

This is the really significant part of Goblins that's starting to become apparent, and it's all thanks to the brilliant design of CapTP. Goblins continues to stand on the shoulders of giants; thank you to everyone in the ocap community, but especially in this case Michael FIG, Mark S. Miller, Kevin Reid, and Baldur Jóhannsson, all of whom answered an enormous amount of questions (some of them very silly) about CapTP.

There are more people to thank too (too many to list here), and you can see some of them in this monster thread on the captp mailing list which started on May 18th (!!!) as I went through my journey of trying to understand and eventually implement CapTP. I actually started preparing a few weeks before which really means that this journey took me about four and a half months to understand and implement. As it turns out, CapTP is a surprisingly simple protocol protocol in its coneptualization once you understand what it's doing (though implementing it is a bit more complex). I do hope to try to build a guide for others to understand and implement on their own systems... but that will probably wait until Goblins is ported to another language (due to the realative simplicity of the task due to the language similarities, the current plan is to port to Guile next).

Anyway. This is a big deal, a truly exciting moment for goblinkind. If you're excited yourself, maybe join the #spritely channel on irc.freenode.net.

OH! And also, I can't believe I nearly forgot to say this, but if you want to hear more about Spritely in general (not just Goblins), we just released a Spritely-centric episode of FOSS and Crafts. Maybe take a listen!

13 September, 2020 10:20PM by Christopher Lemmer Webber

September 11, 2020

remotecontrol @ Savannah

September 08, 2020

FSF Events

LibrePlanet 2021 CFS office hours

The LibrePlanet call for sessions is open now and will be open until November 20 and we want to hear from you!

Speaking at a conference, and even submitting a proposal, can be intimidating or hard. Luckily, some great, experienced speakers are volunteering their time to help out during the CFS office hours.

Whether you want to propose a talk and want feedback on your idea, proposal wording, talk title, or just advice on how to deal with nerves, there is one more office hour slot scheduled over the next few weeks.

Join #libreplanet on Freenode IRC on any of the following dates:

  • Tuesday, September 15 from 13:00 - 14:00 (EDT)
  • Tuesday, September 22 from 13:00 - 14:00 (EDT)
  • Tuesday, September 29 from 13:00 - 14:00 (EDT)
  • Tuesday, October 06 from 13:00 - 14:00 (EDT)
  • Tuesday, October 13 from 13:00 - 14:00 (EDT)
  • Tuesday, October 20 from 13:00 - 14:00 (EDT)
  • Tuesday, October 27 from 13:00 - 14:00 (EDT)

If you do not have an IRC client, you can log onto Freenode IRC here, and connect to the channel #libreplanet.

If you can't make an office hours meeting, feel free to email campaigns@fsf.org with questions.

08 September, 2020 10:50PM

September 07, 2020

gnuastro @ Savannah

Gnuastro 0.13 released

The 13th release of Gnuastro is now available. See the the full announcement for more.

07 September, 2020 03:21AM by Mohammad Akhlaghi

September 05, 2020

GNUnet News

GNUnet 0.13.3

GNUnet 0.13.3 released

Continuing to "release early / release often", we present GNUnet 0.13.3. This is a bugfix release for gnunet 0.13.2.
It fixes some build issues and contains major changes to the re:claimID API.

Download links

The GPG key used to sign is: 3D11063C10F98D14BD24D1470B0998EF86F59B6A

Note that due to mirror synchronization, not all links might be functional early after the release. For direct access try http://ftp.gnu.org/gnu/gnunet/

Noteworthy changes in 0.13.3 (since 0.13.2)

  • REST:
    • re:claimID attestation API change reflected in endpoint naming.
    • Fix regression in NAMESTORE REST API endpoint processing.
  • RECLAIM: "Attestations" renamed to "Credentials". Credentials are now converted to "Presentations" when a ticket is issued in preparation for DID-style VCs and Privacy-ABCs.
  • UTIL: Fix gnunet-qr device parameter.
  • SET: Separated into set intersection (SETI) and set union subsystems (SETU).
  • BUILD:
    • Fix build on OpenBSD.
    • Correctly check for required libsodium version. #6506

Thanks

This release was the work of many people. The following people contributed code and were thus easily identified: Christian Grothoff, Jonathan Buchanan, Johannes Späth and Martin Schanzenbach.

05 September, 2020 10:00PM

September 04, 2020

freeipmi @ Savannah

FreeIPMI 1.6.6 Released

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

o In libfreeipmi, fix segfault in SPMI parsing leading to immediate failures on some hardware across all tools.

04 September, 2020 05:18PM by Albert Chu

dico @ Savannah

Version 2.10

Version 2.10 is available for download.  This is a bugfix release, that fixes compilation with gcc 10 and restores the po files, which were absent in the two previous releases due to the packaging error.

04 September, 2020 05:45AM by Sergey Poznyakoff

September 02, 2020

remotecontrol @ Savannah

Ventilation and Coronavirus (COVID-19) | Coronavirus (COVID-19) | US EPA

02 September, 2020 11:18AM by Stephen H. Dawson DSL

August 31, 2020

Parabola GNU/Linux-libre

manual intervention required for some non-systemd users

a change was made this week to 'nonsystemd/base', in order to reduce dependency conflicts, when installing a nonsystemd system, and when migrating to or from nonsystemd<->systemd - this has exposed several dependency conflicts which were not obvious before, and made them explicit


manual intervention will be required, if pacman has a conflict such as:

your-initfreedom and systemd-_ANYTHING_ are in conflict

if you get that error, see this redmine issue for the solution:

https://labs.parabola.nu/issues/2884


there is a separate, but related issue, where we are collecting examples of conflicts which were exposed by this change to 'nonsystemd/base' - these are evident by the following pacman error message:

systemd and openrc are in conflict (systemd-tools)

if you get that error, please add your specific details to this redmine issue:

https://labs.parabola.nu/issues/2886

31 August, 2020 06:43AM by bill auger

August 29, 2020

Christopher Allan Webber

If you can't tell people anything, can you show them?

The other day I made a sadpost on the fediverse that said: "simultaneously regularly feel like people don't take the directions I'm trying to push seriously enough and that I'm not worth taking seriously". (Similarly, I've also joked that "imposter syndrome and a Cassandra complex are a hell of a combo" before.) I got a number of replies from people, both publicly and privately, and the general summary of most of them are, "We do care! The stuff you're working on seems really cool and valuable! I'll admit that I don't really know what it is you're talking about but it sounds important!" (Okay, and I just re-read, and it was only a portion of it that even said the latter part, but of course, what do I emphasize in my brain?) That was nice to hear that people care and are enthusiastic, and I did feel much better, but it did also kind of feel like confirmation that I'm not getting through to people completely either.

But then jfred made an interesting reply:

Yeah, that feels familiar. Impostor syndrome hits hard. You're definitely worth taking seriously though, and the projects you're working on are the most exciting ones I've been following.

As for people not taking the directions you're pushing seriously... I've felt the same at work, and I think part of it is that there's only so much one person can do. But also part of it is: http://habitatchronicles.com/2004/04/you-cant-tell-people-anything/

...it's hard to get ideas across to someone until they can interact with it themselves

So first of all, what a nice post! Second of all, it's kind of funny that jfred replied with this because out of everyone, jfred is one of the people who's picked up and understood what's happening in Spritely Goblins in particular the most, often running or creating demos of things on top of it using things I haven't even documented yet (so definitely not a person I would say isn't taking me seriously or getting what the work is doing).

But third, that link to Habitat Chronicles is right on point for a few reasons: first of all, Spritely is hugely influenced by the various generations of Habitat, from the original first-ever-graphical-virtual-worlds Habitat (premiering on the Commodore 64 in the mid 1980s, of all things!) to Electric Communities Habitat, especially because that's where the E programming language came from, which I think it's safe to say has had a bigger influence on Spritely Goblins than anything (except maybe this paper by Jonathan Rees, which is the first time I realized that "oh, object capability security is just normal programming flow"). But also, that blogpost in particular was so perfect about this subject: You can't tell people anything...!

In summary, the blogpost isn't saying that people aren't foolishly incapable of understanding things, but that people in general don't understand well by "being explained to". What helps people understand is experiences:

Eventually people can be educated, but what you have to do is find a way give them the experience, to put them in the situation. Sometimes this can only happen by making real the thing you are describing, but sometimes by dint of clever artifice you can simulate it.

This really congealed for me and helped me feel justified in an approach I've been taking in the Spritely project. In general, up until now I've spent most of my time between two states: coding the backend super-engineering stuff, and coding demos on top of it. You might in the meanwhile see me post technobabble onto my fediverse or birdsite accounts, but I'm not in general trying too hard to write about the structurally interesting things going on until it comes time to write documentation (whether it be for Goblins, or the immutable storage and mutable storage writeups). But in general, the way that I'm convinced people will get it is not by talk but by first, demonstration, and second, use.

Aside from the few people that have picked up and played with Goblins yet, I don't think I've hit a sufficient amount of "use" yet in Spritely. That's ok, I'm not at that stage yet, and when I am, it'll be fairly clear. (ETA: one year from now.) So let's talk about demonstration.

The first demo I wrote was the Golem demo, that showed roughly that distributed but encrypted storage could be applied to the fediverse. Cute and cool, and that turned the heads of a few fediverse implementers.

But let's face it, the best demo I've done yet was the Terminal Phase time travel demo. And it didn't hurt that it had a cool looking animated GIF to go with it:

Time travel in Spritely Goblins shown through Terminal Phase

Prior to this demo, people would ask me, "What's this Goblins thing?" And I'd try to say a number of things to them... "oh, its a distributed, transactional, quasi-functional distributed programming system safe to run in mutually suspicious networks that follows object capability security and the classic actor model in the style of the E programming language but written in Scheme!" And I'd watch as their eyes glaze over because why wouldn't their eyes glaze over after a statement like that, and then I'd try to explain the individual pieces but I could tell that the person would be losing interest by then and why wouldn't they lose interest but even realizing that I'd kind of feel despair settling in...

But when you show them a pew pew space lasers game and oh wow why is there time travel, how did you add time travel, is it using functional reactive programming or something? (Usually FRP systems are the only other ones where people have seen these kinds of time travel demos.) And I'd say nope! It doesn't require that. Mostly it looks like writing just straightahead code but you get this kind of thing for free. And the person would say, wow! Sounds really cool! How much work does it take to add the time travel into the game? And I just say: no extra work at all. I wrote the whole game without testing anything about time travel or even thinking about it, then later I just threw a few extra lines to write the UI to expose the time travel part and it just worked. And that's when I see peoples' heads explode with wonder and the connections start to be made about what Goblins might be able to do.

But of course, that's only a partial connection for two reasons. One is that the time travel demo above only shows off a small, minute part of the features of Goblins. And actually, the least interesting of them! It doesn't show off the distributed programming or asynchronous programming parts, it doesn't show off the cool object capability security that's safe to run in mutually suspicious networks. But still: it gave a taste that something cool is happening here. Maybe Chris hasn't just been blowing a bunch of time since finishing the ActivityPub standardization process about two and a half years ago. (Yikes, two and a half years ago!?!)

To complete the rest of that demonstration of the other things in the system requires a different kind of demo. Terminal Phase was a demo to show off the synchronous half of Goblins, but where Goblins really shines is in the asynchronous, distributed programming stuff. That's not ready to show off yet, but I'll give you the first taste of what's in progress:

Goblins chat GUI demo

(Actually a bit more has progressed since I've recorded that GIF, multiple chatrooms and etc, but not really worth bothering to show off quite yet.)

Hmm, that's not really all that thrilling. A chatroom that looks about the same level of featureful, maybe less, than IRC? Well, it could be more exciting if you hear that the full chat protocol implementation is only about 250 lines of code, including authenticating users and posts by users. That's smaller even than its corresponding GUI code, which is less than 300 lines of code. So the exciting thing there is how much heavy lifting Goblins takes care of for you.

But that's hardly razzle-dazzle exciting. In order for me to hint at the rest of what's happening here, we need to put out an asynchronous programming demo that's as or more interesting than the time travel demo. And I expect to do that. I hope soon enough to show off stuff that will make people go, "Oh, what's going on here?"

But even that doesn't complete the connection for people, because showing is one thing but to complete the loop, we need people to use things. We need to get this stuff in the hands of users to play with and experiment themselves. I have plans to do that... and not only that, make this stuff not intimidating for newcomers. When Spritely guides everyday people towards extending Spritely from inside of Spritely as it runs, that's when it'll really click.

And once it clicks sufficiently, it'll no longer become exciting, because people will just come to expect it. A good example of that comes from the aforementioned You can't tell people anything article:

Years ago, before Lucasfilm, I worked for Project Xanadu (the original hypertext project, way before this newfangled World Wide Web thing). One of the things I did was travel around the country trying to evangelize the idea of hypertext. People loved it, but nobody got it. Nobody. We provided lots of explanation. We had pictures. We had scenarios, little stories that told what it would be like. People would ask astonishing questions, like “who’s going to pay to make all those links?” or “why would anyone want to put documents online?” Alas, many things really must be experienced to be understood. We didn’t have much of an experience to deliver to them though — after all, the whole point of all this evangelizing was to get people to give us money to pay for developing the software in the first place! But someone who’s spent even 10 minutes using the Web would never think to ask some of the questions we got asked.

Eventually, if we succeed, the ideas in Spritely will no longer seem exciting... because people will have internalized and come to expect them. Just like hyperlinks on the web today.

But to get there, in the meanwhile, we have to get people interested. To become so successful as to be mundane, we have to first be razzle-dazzle exciting. And to that end, that's why I take the demo approach to Spritely. Because it's hard to tell someone something... but showing them, that's another matter.

PS: It's also not true that people don't get what I'm doing, and that's even been reflected materially. I've been lucky to be supported over the last few years from a combination of a grant from Samsung's Stack Zero and one from NLNet, not to mention quite a few donors on Patreon. I do recognize and appreciate that people are supporting me. In some ways receiving this support makes me feel more seriously about the need to demonstrate and prove that what I'm doing is real. I hope I am doing and will continue to do a sufficient job, and hope that the upcoming demos contribute to that more materially!

PPS: If, in the meanwhile, you're already excited, check out the Goblins documentation. The most exciting stuff is coming in the next major release (which will be out soon), which is when the distributed programming tools will be made available to users of the system for the first time. But if you want to get a head start, the code you'll be writing will mostly work the same between the distributed and non-distributed (as in, distributed across computers/processes) asynchronous stuff, so if you start reading the docs today, most of your code will already just work on the new stuff once released. And if you do start playing around, maybe drop by the #spritely channel on freenode and say hello!

29 August, 2020 05:05PM by Christopher Lemmer Webber

August 25, 2020

nano @ Savannah

GNU nano 5.2 was released

Version 5.0 brought: direct access to the "Execute Command" prompt, the ability to place and jump to anchors, the --indicator option for showing a kind of scrollbar, nine new color names plus the "italic" attribute, and several major internal changes.  Versions 5.1 and 5.2 then fixed the bugs that these changes had caused along the way.

25 August, 2020 06:50AM by Benno Schulenberg

August 22, 2020

parallel @ Savannah

GNU Parallel 20200822 ('Beirut')

GNU Parallel 20200822 ('Beirut') has been released. It is available for download at: http://ftpmirror.gnu.org/parallel/

Quote of the month:

  Gnu parallel is also awesome, fwiw.
    -- Rogan Dawes @RoganDawes@twitter

New in this release:

  • Max command line length is changed for MacOS - making this version

  beta quality for MacOS.

  • Bug fixes and man page updates.

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.

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 3374ec53bacb199b245af2dda86df6c9
    12345678 3374ec53 bacb199b 245af2dd a86df6c9
    $ md5sum install.sh | grep 029a9ac06e8b5bc6052eac57b2c3c9ca
    029a9ac0 6e8b5bc6 052eac57 b2c3c9ca
    $ sha512sum install.sh | grep f517006d9897747bed8a4694b1acba1b
    40f53af6 9e20dae5 713ba06c f517006d 9897747b ed8a4694 b1acba1b 1464beb4
    60055629 3f2356f3 3e9c4e3c 76e3f3af a9db4b32 bd33322b 975696fc e6b23cfb
    $ 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 August, 2020 11:29PM by Ole Tange

www-zh-cn @ Savannah

Submit your session for LibrePlanet 2021 before Oct. 28

Dear Translators:

From FSF

The thirteenth edition of the Free Software Foundation's (FSF) conference on technology and social justice will be held in spring 2021. The Call for Sessions is now open, and will close on October 28th. Potential talks should examine free software through the lens of this year's theme: Empowering Users.
Call for Sessions LP image

Submissions to the Call for Sessions are being accepted through Wednesday, October 28 at 12:00 Eastern Daylight Time (16:00 UTC). General registration, award nominations, exhibitor registration and sponsoring packages will open soon.

We invite activists, hackers, law professionals, artists, students, developers, young people, policymakers, tinkerers, newcomers to free software, and anyone looking for technology that aligns with their ideals, to submit a proposal for a session at LibrePlanet 2021. To access the submission form, use your my.fsf.org username wxie. Session proposals can focus on software development, copyleft, community, or other related issues to this year's theme.

22 August, 2020 03:45AM by Wensheng XIE

August 21, 2020

health @ Savannah

GNU Health HMIS patchset 3.6.5 released

Dear community

GNU Health 3.6.5 patchset has been released !

Priority: High

Table of Contents

  • About GNU Health Patchsets
  • Updating your system with the GNU Health control Center
  • Summary of this patchset
  • Installation notes
  • List of other issues related to this patchset

About GNU Health Patchsets

We provide "patchsets" to stable releases. Patchsets allow applying bug
fixes and updates on production systems. Always try to keep your
production system up-to-date with the latest patches.

Patches and Patchsets maximize uptime for production systems, and keep
your system updated, without the need to do a whole installation.

NOTE: Patchsets are applied on previously installed systems only. For
new, fresh installations, download and install the whole tarball (ie,
gnuhealth-3.6.5.tar.gz)

Updating your system with the GNU Health control Center

Starting GNU Health 3.x series, you can do automatic updates on the GNU
Health HMIS kernel and modules using the GNU Health control center
program.

Please refer to the administration manual section (
https://en.wikibooks.org/wiki/GNU_Health/Control_Center )

The GNU Health control center works on standard installations (those
done following the installation manual on wikibooks). Don't use it if
you use an alternative method or if your distribution does not follow
the GNU Health packaging guidelines.

Summary of this patchset

GNU Health 3.6.5 includes:

  • ICD-10 package:

  The World Health Organization International Classification of Diseases, 10th revision, h  has been extensively revised and updated to the 2020 edition.
  The translation templates have been also updated, specially the German and Chinese.
  Special thanks to Dr. Edgar Hagenbichler for his excellent work on this package!

Installation Notes

You must apply previous patchsets before installing this patchset. If
your patchset level is 3.6.5, then just follow the general
instructions. You can find the patchsets at GNU Health main download
site at GNU.org (https://ftp.gnu.org/gnu/health/)

In most cases, GNU Health Control center (gnuhealth-control) takes care
of applying the patches for you. 

Pre-requisites for upgrade to 3.6.5: None

Now follow the general instructions at

 

After applying the patches, make a full update of your GNU Health
database as explained in the documentation.

When running "gnuhealth-control" for the first time, you will see the following message: "Please restart now the update with the new control center" Please do so. Restart the process and the update will continue.

  • Restart the GNU Health server

List of other issues and tasks related to this patchset

For detailed information about each issue, you can visit
 https://savannah.gnu.org/bugs/?group=health For detailed information about each task, you can visit
 https://savannah.gnu.org/task/?group=health

 For detailed information you can read about Patches and Patchsets

Happy and healthy hacking !

Dr. Luis Falcon, MD, MSc
President, GNU Solidario
GNU Health: Freedom and Equity in Healthcare
http://www.gnuhealth.org
GPG Fingerprint :ACBF C80F C891 631C 68AA  8DC8 C015 E1AE 0098 9199

21 August, 2020 02:28PM by Luis Falcon

August 15, 2020

pspp @ Savannah

PSPP 1.4.0 has been released

I'm very pleased to announce the release of a new version of GNU PSPP.  PSPP is a program for statistical analysis of sampled data.  It is a free replacement for the proprietary program SPSS.

Changes from 1.2.0 to 1.4.0:

  • The file pspp-mode.el (the pspp-mode for Emacs) is no longer distributed with PSPP.  Instead, it can be installed directly in emacs and is available from https://elpa.gnu.org/packages/pspp-mode.html
  • The Find dialog box, when searching for numeric values, will match only to the precision of the variable's print format.  This avoids behaviour which is suprising to some users.
  • PSPP now supports the SPSS viewer (.spv) format that SPSS 16 and later use to save the contents of its output editor:
    • PSPP and PSPPIRE can write output to .spv files.
    • The new utility pspp-output can convert .spv files to other formats.
    • The pspp-convert utility can now decrypt encrypted .spv files.  The encrypted viewer file format is unacceptably insecure, so to discourage its use PSPP and PSPPIRE do not directly read or write this format.
  • A bug where the Data|Select Cases|Random Sample menu would generate invalid syntax has been fixed.
  • FREQUENCIES will emit a warning if one or more weight values are missing.
  • Plain text output is no longer divided into pages, since it is now rarely printed on paper.
  • pspp-convert improvements:
    • New "-a", "-l", "--password-list" options to search for an encrypted file's password.
    • New "--keep" and "--drop" options to output only selected variables.
    • New "--recode", "--no-var-name", "--labels", "--print-formats", "--decimal", "--delimiter", and "--qualifier" options to control CSV output.
  • Improvements to SAVE DATA COLLECTION support for MDD files.
  • Bug fix for CVE-2018-20230.
  • The /RENAME subcommand in SAVE TRANSLATE et al. has been extended to support the syntax also accepted by other software.
  • The EXAMINE command will now perform the Shapiro-Wilk test when one or more plots are requested.
  • The REGRESSION command now supports the /STATISTICS=TOL option which outputs tolerance and variance inflation factor metrics for the data.
  • The QUICK CLUSTER command now supports the /SAVE option which can be used to save the cases' cluster membership and/or their distance from the cluster centre to the active file.
  • The MEANS command has been re-implemented.
  • The GUI now has a sub-dialog for post-hoc tests of the oneway anova test.
  • Gtk+3.22.0 or later must now be used when building.
  • GRAPH: Categorical barcharts displaying percentages now show the sub-category as a percentage of the primary category instead of the total.
  • The Syntax Window now has a Find function to perform simple text searching.
  • AUTORECODE:
    • The PRINT subcommand is now implemented.
    • Many bug fixes.

15 August, 2020 11:30PM by Ben Pfaff

Sylvain Beucler

Planet upgrade

planet.gnu.org logo

The system running planet.gnu.org was upgraded/reinstalled to Debian 10 "buster" :)
Documentation was updated.

Let me know if you notice any issue - planet@gnu.org.

For the next upgrade, we'll have to decide whether to takeover Planet Venus and upgrade it to Python 3, or migrate to another Planet software.
Suggestions/help welcome :)

15 August, 2020 06:55AM

August 14, 2020

mailutils @ Savannah

Version 3.10

Version 3.10 of GNU mailutils is available for download.

See the NEWS file for a list of noteworthy changes in this release.

14 August, 2020 07:19PM by Sergey Poznyakoff

August 13, 2020

GNUnet News

GNUnet 0.13.2

GNUnet 0.13.2 released

This is a bugfix release for gnunet 0.13.1.
It fixes some build issues and contains changes to the REST API implmementation (no change in the API itself) as well as OpenID Connect related fixes to re:claimID.

Download links

The GPG key used to sign is: 3D11063C10F98D14BD24D1470B0998EF86F59B6A

Note that due to mirror synchronization, not all links might be functional early after the release. For direct access try http://ftp.gnu.org/gnu/gnunet/

Noteworthy changes in 0.13.2 (since 0.13.1)

  • REST:
    • Plugins may now handle any namespace. #6462
    • Fixed incomplete/missing cleanup and teardown of REST plugins.
  • RECLAIM:
    • Support for /.well-known/openid-configuration. #6463
    • Support for standard scope values (profile, address, email, phone) and corresponding mapping to standard claim values
    • Correct processing of claims parameter for individual claim requests.
    • Support for POST token request.
    • Support for public clients (Token request without client secrets).
    • Fixed urlencoding of parameters on redirect
  • UTIL: New string API for percent-encode/decode.
  • MYSQL: Fix version detection and build against mysql-8 and later. #6465
  • POSTGRESQL: Ensure postgresql fails hard if there is an error in the SQL. #6437
  • Extensions:
    • Load GNSRECORD plugins within GNUnet's context.
    • Add convenience function to return GNUnet's default configuration.

Thanks

This release was the work of many people. The following people contributed code and were thus easily identified: Christian Grothoff, Florian Dold, Alessio Vanni, t3sserakt, Martin Schanzenbach.

13 August, 2020 10:00PM

August 12, 2020

Christopher Allan Webber

Terminal Phase in Linux Magazine (Polish edition)

Terminal Phase featured in Polish version of Linux Magazine

Hey look at that! My terminal-space-shooter-game Terminal Phase made an appearance in the Polish version of Linux Magazine. I had no idea, but Michal Majchrzak both tipped me off to it and took the pictures. (Thank you!)

I don't know Polish but I can see some references to Konami and SHMUP (shoot-em-up game). The screenshot they have isn't the one I published, so I guess the author got it running too... I hope they had fun!

Apparently it appeared in the June 2020 edition:

June 2020 edition of Polish Magazine

I guess because print media coverage is smaller, it feels cooler to get covered these days in it in some way?

I wonder if I can find a copy somewhere!

12 August, 2020 05:54PM by Christopher Lemmer Webber

August 07, 2020

libredwg @ Savannah

libredwg-0.11 released

New features:
  * new programs dwgfilter, dxfwrite.
    dwgfilter allows custom jq queries.
    dxfwrite allows version conversions, which dwgwrite does not yet support.
  * Can now read all 2004+ section types: added AppInfo, FileDepList,
    Template, ObjFreeSpace;
    and as blob: RevHistory, Security, AppInfoHistory.
    AcDsPrototype_1b datastore not fully yet, so we cannot reliably yet read
    new ACIS r2013+ SAB blobs stored there, but we extract them from the AcDs
    blob by brute-force.
  * Added new string types: T and T16, TU16, T32 (for those sections)
  * Convert ACIS BinaryFile v2 SAB to old encrypted ACIS SAT v1 data, needed
    to convert pre-r2013 ACIS v2 entities to DXF.
  * Added support for many object/entity types:

    Now stable: ACSH_BOOLEAN_CLASS ACSH_BOX_CLASS ACSH_CYLINDER_CLASS
    ACSH_FILLET_CLASS ACSH_SPHERE_CLASS ACSH_WEDGE_CLASS LIGHT MESH
    CELLSTYLEMAP DETAILVIEWSTYLE DYNAMICBLOCKPURGEPREVENTER INDEX
    GEODATA LAYERFILTER MULTILEADER PLOTSETTINGS SECTION_MANAGER
    SECTIONOBJECT SECTIONVIEWSTYLE VBA_PROJECT VISUALSTYLE.
    and some Dynblocks: BLOCKGRIPLOCATIONCOMPONENT BLOCKBASEPOINTPARAMETER
    BLOCKFLIPACTION BLOCKFLIPPARAMETER BLOCKFLIPGRIP BLOCKLINEARGRIP
    BLOCKMOVEACTION BLOCKROTATEACTION BLOCKSCALEACTION
    BLOCKVISIBILITYGRIP

    New unstable: ACSH_BREP_CLASS ACSH_CHAMFER_CLASS ACSH_CONE_CLASS
    ACSH_PYRAMID_CLASS ACSH_TORUS_CLASS ARC_DIMENSION ASSOCACTION
    ASSOCBLENDSURFACEACTIONBODY ASSOCEXTENDSURFACEACTIONBODY
    ASSOCEXTRUDEDSURFACEACTIONBODY ASSOCFILLETSURFACEACTIONBODY
    ASSOCGEOMDEPENDENCY ASSOCLOFTEDSURFACEACTIONBODY ASSOCNETWORK
    ASSOCNETWORKSURFACEACTIONBODY ASSOCOFFSETSURFACEACTIONBODY
    ASSOCPATCHSURFACEACTIONBODY ASSOCREVOLVEDSURFACEACTIONBODY
    ASSOCTRIMSURFACEACTIONBODY ASSOCVALUEDEPENDENCY BACKGROUND
    BLOCKLINEARPARAMETER BLOCKLOOKUPGRIP BLOCKROTATIONPARAMETER
    BLOCKXYPARAMETER BLOCKVISIBILITYPARAMETER HELIX
    LARGE_RADIAL_DIMENSION LIGHTLIST MATERIAL MENTALRAYRENDERSETTINGS
    RAPIDRTRENDERSETTINGS RENDERSETTINGS SECTION_SETTINGS
    SPATIAL_INDEX SUN TABLESTYLE.

    Fixed PROXY_OBJECT, PROXY_ENTITY.
    Demoted to Unstable: SPATIAL_INDEX
    Demoted to Debugging: PERSSUBENTMANAGER DIMASSOC

    Note: Unstable objects are not preserved via DXF conversion, just
    the external import is supported.

    Add most Constraint (ASSOC*) and DYNBLOCK objects (BLOCK*).
    Debugging classes added (needs --with-debug option):

    ACMECOMMANDHISTORY ACMESCOPE ACMESTATEMGR ACSH_EXTRUSION_CLASS
    ACSH_HISTORY_CLASS ACSH_LOFT_CLASS ACSH_REVOLVE_CLASS
    ACSH_SWEEP_CLASS ALDIMOBJECTCONTEXTDATA ALIGNMENTPARAMETERENTITY
    ANGDIMOBJECTCONTEXTDATA ANNOTSCALEOBJECTCONTEXTDATA
    ASSOC3POINTANGULARDIMACTIONBODY ASSOCACTIONPARAM
    ASSOCARRAYACTIONBODY ASSOCARRAYMODIFYACTIONBODY
    ASSOCARRAYMODIFYPARAMETERS ASSOCARRAYPATHPARAMETERS
    ASSOCARRAYPOLARPARAMETERS ASSOCARRAYRECTANGULARPARAMETERS
    ASSOCASMBODYACTIONPARAM ASSOCCOMPOUNDACTIONPARAM
    ASSOCDIMDEPENDENCYBODY ASSOCEDGEACTIONPARAM
    ASSOCEDGECHAMFERACTIONBODY ASSOCEDGEFILLETACTIONBODY
    ASSOCFACEACTIONPARAM ASSOCMLEADERACTIONBODY ASSOCOBJECTACTIONPARAM
    ASSOCORDINATEDIMACTIONBODY ASSOCOSNAPPOINTREFACTIONPARAM
    ASSOCPATHACTIONPARAM ASSOCPOINTREFACTIONPARAM
    ASSOCRESTOREENTITYSTATEACTIONBODY ASSOCROTATEDDIMACTIONBODY
    ASSOCSWEPTSURFACEACTIONBODY ASSOCVARIABLE ASSOCVERTEXACTIONPARAM
    ATEXT BASEPOINTPARAMETERENTITY BLKREFOBJECTCONTEXTDATA
    BLOCKALIGNEDCONSTRAINTPARAMETER BLOCKALIGNMENTGRIP
    BLOCKALIGNMENTPARAMETER BLOCKANGULARCONSTRAINTPARAMETER
    BLOCKARRAYACTION BLOCKDIAMETRICCONSTRAINTPARAMETER
    BLOCKHORIZONTALCONSTRAINTPARAMETER BLOCKLINEARCONSTRAINTPARAMETER
    BLOCKLOOKUPACTION BLOCKLOOKUPPARAMETER BLOCKPARAMDEPENDENCYBODY
    BLOCKPOINTPARAMETER BLOCKPOLARGRIP BLOCKPOLARPARAMETER
    BLOCKPOLARSTRETCHACTION BLOCKPROPERTIESTABLE
    BLOCKPROPERTIESTABLEGRIP BLOCKRADIALCONSTRAINTPARAMETER
    BLOCKREPRESENTATION BLOCKROTATIONGRIP BLOCKSTRETCHACTION
    BLOCKUSERPARAMETER BLOCKVERTICALCONSTRAINTPARAMETER BLOCKXYGRIP
    CONTEXTDATAMANAGER CSACDOCUMENTOPTIONS CURVEPATH DATALINK
    DATATABLE DMDIMOBJECTCONTEXTDATA DYNAMICBLOCKPROXYNODE
    EXTRUDEDSURFACE FCFOBJECTCONTEXTDATA FLIPPARAMETERENTITY
    GEOPOSITIONMARKER LAYOUTPRINTCONFIG LEADEROBJECTCONTEXTDATA
    LINEARPARAMETERENTITY LOFTEDSURFACE MLEADEROBJECTCONTEXTDATA
    MOTIONPATH MPOLYGON MTEXTATTRIBUTEOBJECTCONTEXTDATA
    MTEXTOBJECTCONTEXTDATA NAVISWORKSMODEL NURBSURFACE
    ORDDIMOBJECTCONTEXTDATA PERSUBENTMGR PLANESURFACE
    POINTPARAMETERENTITY POINTPATH RADIMLGOBJECTCONTEXTDATA
    RADIMOBJECTCONTEXTDATA RENDERENTRY RENDERENVIRONMENT RENDERGLOBAL
    REVOLVEDSURFACE ROTATIONPARAMETERENTITY RTEXT SUNSTUDY
    SWEPTSURFACE TABLE TABLECONTENT TEXTOBJECTCONTEXTDATA
    TVDEVICEPROPERTIES VISIBILITYGRIPENTITY VISIBILITYPARAMETERENTITY
    XYPARAMETERENTITY

  * Started support to write r2004+ format DWG's (which includes also r2010,
    r2013, r2018, but not r2007), but this does not work fully yet.
  * Added all remaining Dwg_Version types: R_1_3 for AC1.3, R_2_4 for AC1001, and
    AC1013 for R_13c3.
  * The header can now be compiled wth C++ compilers, needed for some bindings.
    Re-arranged nested structs, names, malloc casts, reserved keywords like this,
    template.
    Started with the gambas bindings, a Visual Basic clone for unix.
  * DXF and JSON importers now create PLACEHOLDER objects for unsupported
    objects.
  * 3DSOLID got now material properties and revisionguid fields.
  * Many parts of the API are now auto-generated/updated: dwg.i, dwg_api.c, dwg_api.h,
    unions and setup in dwg.h
  * Added geojsonhint or gjv linter support. Fixed all violations (esp. point arrays,
    and POLYLINE_2D). Add a Feature id (the handle)
  * Added support for GeoJSON RFC7946, write closed polygons, re-order by the
    right-hand rule..
  * new API functions:
    dwg_ctrl_table, dwg_handle_name, dwg_find_dicthandle_objname, dwg_variable_dict,
    dwg_next_entity, get_next_owned_block_entity, dwg_section_name,
    dwg_version_type, dwg_version_as, dwg_errstrings,  dwg_rgb_palette,
    dwg_find_color_index.
  * new dynapi functions: dwg_dynapi_subclass_value, dwg_dynapi_subclass_field,
    dwg_dynapi_fields_size.
    (BTW. the dynapi proved to be a godsend for the json importer)

API breaking changes:
  * Renamed dwg_section_type to dwg_section_wtype, added a new dwg_section_type
    for ASCII names.
  * Removed all extra null_handle fields, and add the missing handle fields.
  * Renamed all dwg_add_OBJECT functions to dwg_setup_OBJECT. They didn't add them, just setup
    the internal structures.
  * Renamed VPORT_ENTITY_HEADER to VX_TABLE_RECORD and VPORT_ENTITY_CONTROL to VX_CONTROL.
    Also section enum SECTION_VPORT_ENTITY to SECTION_VX and dwg->vport_entity_control likewise.
  * Hundreds of field renames due to harmonization efforts with the more generic
    JSON importer. Note that some deprecated dwg_api accessor functions were also
    renamed accordingly, but not all.

    For the stable objects:
    TEXT,ATTRIB,ATTDEF,SHAPE,STYLE: oblique_ang => oblique_angle,
    TEXT,ATTRIB,ATTDEF,SHAPE,MTEXT,UNDERLAY,TABLE,...: insertion_pt => ins_pt,
    DIMENSION_* _13_pt => xline1_pt, _14_pt => xline2_pt,
      ext_line_rotation => oblique_angle
    DIMENSION_ANG2LN _16_pt => xline1start_pt, _14_pt => xline2start_pt,
      _13_pt => xline1end_pt, first_arc_pt => xline2end_pt
    VIEW,VIEWPORT: view_direction => VIEWDIR (as it overrides this header),
      view_twist => twist_angle,
      view_height => VIEWSIZE,
      snap_angle => SNAPANG,
      view_center => VIEWCTR,
      snap_base => SNAPBASE,
      snap_spacing => SNAPUNIT,
      grid_spacing => GRIDUNIT,
      ucs_per_viewport => UCSVP,
      ucs_origin => ucsorg,
      ucs_x_axis => ucsxdir,
      ucs_y_axis => ucsydir,
      ucs_ortho_view_type => UCSORTHOVIEW
    OLEFRAME.data_length => data_size,
    LEADER.offset_to_block_ins_pt => inspt_offset
    TOLERANCE.text_string => text_value
    STYLE.vertical => is_vertical, shape_file => is_shape, fixed_height => text_size,
      extref => xref
    DICTIONARYVAR.intval => schema, str => strvalue

    COMMON_TABLE_FIELDS: xrefref => is_xref_ref, xrefindex_plus1 => is_xref_resolved,
      xrefdep => is_xref_dep. new common xref HANDLE field (was null_handle in many objects)

    LAYER got a new visualstyle handle.
    LTYPE.dashes got a new style handle and text field.
    LTYPE has no styles H* anymore, moved to dashes.
    LTYPE.text_area_is_present => has_strings_area, extref_handle => xref.
    VIEW, VIEWPORT:
      height => VIEWSIZE, width => view_width, center => VIEWCTR, target => view_target,
      direction => VIEWDIR, front_clip => front_clip_z, back_clip => back_clip_z,
      pspace_flag => is_pspace,
      origin => ucsorg, x_direction => ucsxdir, y_direction => ucsydir,
      elevation => ucs_elevation, orthographic_view_type => UCSORTHOVIEW,
      camera_plottable => is_camera_plottable

    UCS got a new orthopts array, and the renames as above.
    DIMSTYLE got a new flag0. flag is computed from that.
    VPORT_ENTITY_HEADER flag1 => is_on, vport_entity => viewport, xref_handle => xref,
      new prev_entity handle.
    MLINESTYLE index/ltype union changed to seperate lt_index, lt_ltype fields.
      They were overwriting each other on version conversions.
    MLINESTYLE.desc => description, data_length => data_size.
    HATCH booleans got a is_ prefix.
    MTEXT.annotative => is_annotative.
    MTEXT.drawing_dir => flow_dir.
    XRECORD.num_databytes => xdata_size
    MLEADERSTYLE text_frame => is_text_frame, is_new_format removed.
      changed => is_changed.
    DICTIONARYYWDFLT got a new format_flags and data_handle
    SCALE.has_unit_scale => is_unit_scale
    SORTENTSTABLE.dictionary => block_owner

    Type changes in stable objects:
    SPLINE.fit_pts are now ordinary BITCODE_3DPOINT*
    SPLINE.color is BL, scale is now 3BD
  * Changed truecolor attributes in GeoJSON with a # prefix.

Major bugfixes:
  * Fixed converting ASCII from and to Unicode strings, when converting across
    versions. Embed Unicode as \U+XXXX into ASCII, and decode it back to Unicode.
    Honor dat,dwg->from_version and use the new FIELD_T as seperate type. (#185)
  * Invalid numbers (read failures) are converted to 0.0 in the released version.
  * Fixed wrong CMC color reads and writes, check the method, lookup the index,
    support a CMTC truecolor-only type.
  * Fixed EED writes, by writing to seperate streams and merging them at the end,
    with proper size calculation.
  * All remaining assertions are now protected. (GH #187)

Minor bugfixes:
  * Fixed uncompressed sections overflows, some fuzzed (GH #183), some
    with the new sections.
  * Normalize extrusion vectors.
  * Fix bit_write_BT, the thickness vector pre-R2000.
  * Added many overflow checks, due to extensive fuzzing campains.
  * Fixed wrong julian date conversions with TIMEBLL types.
  * Fxed keyword conflicts with the bindings: No next, from, self fieldnames.
  * Many more, see the ChangeLog.

Other newsworthy changes:
  * Harmonized 2004 section search with the better 2007 variant. Added a new
    section and info fixedtype field.
  * Added unit-tests for all supported objects.
  * Added src/classes.c defining the class stability (stable, unstable, debugging, unhandled).
  * Need now -lm, the system math library, in all cases.
  * Got a complete collection of old DWGs to cross-check against. Many new object types
    could be stabilized because of this. Many thanks to Michal Josef Špaček.
  * CMC color got 2 new fields: raw (EMC only), method (the first rgb byte).
  * Many DXF re-ordering fixes.

Notes: The new constraint and dynblock objects just miss a major refactor into seperate
impl subclasses, and subent and curve support.

Here are the compressed sources:
  http://ftp.gnu.org/gnu/libredwg/libredwg-0.11.tar.gz  (16.0MB)
  http://ftp.gnu.org/gnu/libredwg/libredwg-0.11.tar.xz   (7.9MB)

Here are the GPG detached signatures[*]:
  http://ftp.gnu.org/gnu/libredwg/libredwg-0.11.tar.gz.sig
  http://ftp.gnu.org/gnu/libredwg/libredwg-0.11.tar.xz.sig

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

Here are more binaries:
  https://github.com/LibreDWG/libredwg/releases/tag/0.11

Here are the SHA256 checksums:
6b48304c50320b1ee7fbfea63c3b1437bbc3d4cd1b0ecb7fecd5f00ed4f4bdc8  libredwg-0.11.tar.gz
c25bbab29e7814663a203c38df8cbcce850d0b003a7132cf3f849429468ca7ed  libredwg-0.11.tar.xz

[*] 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 libredwg-0.11.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 B4F63339E65D6414

and rerun the 'gpg --verify' command.

07 August, 2020 10:49AM by Reini Urban

August 05, 2020

FSF News

Geoffrey Knauth elected Free Software Foundation president; Odile Bénassy joins the board

BOSTON, Massachusetts, USA -- Wednesday, August 5th, 2020 -- The Free Software Foundation (FSF) today announced the addition of a new director to its board, and the election of a new president.

Long-time free software activist and developer Odile Bénassy, known especially for her work promoting free software in France, was elected to the FSF's board of directors. Geoffrey Knauth, who has served on the FSF's board for over twenty years, was elected president.

On her election, Bénassy said, "I'm happy and proud to accept FSF's invitation to be part of the board. I want to help keep steady the principles of free software, and the philosophical values around it. Free software counts among what the world badly needs nowadays."

Knauth welcomed Bénassy, saying, "I am delighted that Odile Bénassy has agreed to become a director of the FSF, FSF's first director from Europe. Odile is a mathematics educator, researcher, software engineer, and leader of the GNU Edu project. She has been advocating for and developing free software for more than twenty years."

FSF's executive director, John Sullivan, added, "Being on the FSF's board of directors means first and foremost standing as a guardian for free software and the associated user freedoms. With such a long track record, Odile has shown herself to be someone FSF members and supporters can count on. I'm really looking forward to working with her, and I'm excited to see all the ways she'll help the FSF be better and stronger."

Describing his approach to his new position as president, Knauth posted a statement which begins, "The FSF board chose me at this moment as a servant leader to help the community focus on our shared dedication to protect and grow software that respects our freedoms. It is also important to protect and grow the diverse membership of the community. It is through our diversity of backgrounds and opinions that we have creativity, perspective, intellectual strength and rigor."

Geoff Knauth Odile Benassy

The full list of FSF board members and officers can be found at https://www.fsf.org/about/staff-and-board.

About the Free Software Foundation

The Free Software Foundation, founded in 1985, is dedicated to promoting computer users' right to use, study, copy, modify, and redistribute computer programs. The FSF promotes the development and use of free (as in freedom) software -- particularly the GNU operating system and its GNU/Linux variants -- and free documentation for free software. The FSF also helps to spread awareness of the ethical and political issues of freedom in the use of software, and its Web sites, located at https://fsf.org and https://gnu.org, are an important source of information about GNU/Linux. Donations to support the FSF's work can be made at https://donate.fsf.org. Its headquarters are in Boston, MA, USA.

More information about the FSF, as well as important information for journalists and publishers, is at https://www.fsf.org/press.

Media Contacts

John Sullivan
Executive Director
Free Software Foundation
+1 (617) 542 5942
campaigns@fsf.org

Geoffrey Knauth Photo Copyright ©2020 Geoffrey Knauth and used with permission. Odile Bénassy Photo Copyright ©2020 Odile Bénassy and used with permission.

Updated 2020-08-07: Knauth has served on the FSF board for over twenty years, not thirty.

05 August, 2020 08:20PM

July 25, 2020

remotecontrol @ Savannah

July 24, 2020

bison @ Savannah

Bison 3.7 released

I am very happy to announce the release of Bison 3.7, whose main novelty,
contributed by Vincent Imbimbo, is the generation of counterexamples for
conflicts.  For instance on a grammar featuring the infamous "dangling else"
problem, "bison -Wcounterexamples" now gives:

    $ bison -Wcounterexamples else.y
    else.y: warning: 1 shift/reduce conflict [-Wconflicts-sr]
    else.y: warning: shift/reduce conflict on token "else" [-Wcounterexamples]
      Example: "if" exp "then" "if" exp "then" exp • "else" exp
      Shift derivation
        exp
        ↳ "if" exp "then" exp
                          ↳ "if" exp "then" exp • "else" exp
      Reduce derivation
        exp
        ↳ "if" exp "then" exp                     "else" exp
                          ↳ "if" exp "then" exp •

which actually proves that the grammar is ambiguous by exhibiting a text
sample with two derivations (corresponding to two parse trees).  When Bison
is installed with text styling enabled, the example is actually shown twice,
with colors demonstrating the ambiguity (see
https://www.gnu.org/software/bison/manual/html_node/Counterexamples.html).

Joshua Watt contributed the option "--file-prefix-map OLD=NEW", to make
reproducible builds.

There are many other changes (hyperlinks in the diagnostics, reproducible
handling of string aliases with escapes, improvements in the push parsers,
etc.), please see the NEWS below for more details.

Cheers!

       Akim

PS/ The experimental back-end for the D programming language is still
looking for active support from the D community.

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

Here are the compressed sources:
  https://ftp.gnu.org/gnu/bison/bison-3.7.tar.gz   (5.1MB)
  https://ftp.gnu.org/gnu/bison/bison-3.7.tar.lz   (3.1MB)
  https://ftp.gnu.org/gnu/bison/bison-3.7.tar.xz   (3.1MB)

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

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

[*] 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 bison-3.7.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 0DDCAA3278D5264E

and rerun the 'gpg --verify' command.

This release was bootstrapped with the following tools:
  Autoconf 2.69
  Automake 1.16.2
  Flex 2.6.4
  Gettext 0.19.8.1
  Gnulib v0.1-3644-gac34618e8

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

GNU Bison is a general-purpose parser generator that converts an annotated
context-free grammar into a deterministic LR or generalized LR (GLR) parser
employing LALR(1) parser tables.  Bison can also generate IELR(1) or
canonical LR(1) parser tables.  Once you are proficient with Bison, you can
use it to develop a wide range of language parsers, from those used in
simple desk calculators to complex programming languages.

Bison is upward compatible with Yacc: all properly-written Yacc grammars
work with Bison with no change.  Anyone familiar with Yacc should be able to
use Bison with little trouble.  You need to be fluent in C, C++ or Java
programming in order to use Bison.

Bison and the parsers it generates are portable, they do not require any
specific compilers.

GNU Bison's home page is https://gnu.org/software/bison/.

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

* Noteworthy changes in release 3.7 (2020-07-23) [stable]

** Deprecated features

  The YYPRINT macro, which works only with yacc.c and only for tokens, was
  obsoleted long ago by %printer, introduced in Bison 1.50 (November 2002).
  It is deprecated and its support will be removed eventually.

  In conformance with the recommendations of the Graphviz team, in the next
  version Bison the option `--graph` will generate a *.gv file by default,
  instead of *.dot.  A transition started in Bison 3.4.

** New features

*** Counterexample Generation

  Contributed by Vincent Imbimbo.

  When given `-Wcounterexamples`/`-Wcex`, bison will now output
  counterexamples for conflicts.

**** Unifying Counterexamples

  Unifying counterexamples are strings which can be parsed in two ways due
  to the conflict.  For example on a grammar that contains the usual
  "dangling else" ambiguity:

    $ bison else.y
    else.y: warning: 1 shift/reduce conflict [-Wconflicts-sr]
    else.y: note: rerun with option '-Wcounterexamples' to generate conflict counterexamples

    $ bison else.y -Wcex
    else.y: warning: 1 shift/reduce conflict [-Wconflicts-sr]
    else.y: warning: shift/reduce conflict on token "else" [-Wcounterexamples]
      Example: "if" exp "then" "if" exp "then" exp • "else" exp
      Shift derivation
        exp
        ↳ "if" exp "then" exp
                          ↳ "if" exp "then" exp • "else" exp
      Example: "if" exp "then" "if" exp "then" exp • "else" exp
      Reduce derivation
        exp
        ↳ "if" exp "then" exp                     "else" exp
                          ↳ "if" exp "then" exp •

  When text styling is enabled, colors are used in the examples and the
  derivations to highlight the structure of both analyses.  In this case,

    "if" exp "then" [ "if" exp "then" exp • ] "else" exp

  vs.

    "if" exp "then" [ "if" exp "then" exp • "else" exp ]


  The counterexamples are "focused", in two different ways.  First, they do
  not clutter the output with all the derivations from the start symbol,
  rather they start on the "conflicted nonterminal". They go straight to the
  point.  Second, they don't "expand" nonterminal symbols uselessly.

**** Nonunifying Counterexamples

  In the case of the dangling else, Bison found an example that can be
  parsed in two ways (therefore proving that the grammar is ambiguous).
  When it cannot find such an example, it instead generates two examples
  that are the same up until the dot:

    $ bison foo.y
    foo.y: warning: 1 shift/reduce conflict [-Wconflicts-sr]
    foo.y: note: rerun with option '-Wcounterexamples' to generate conflict counterexamples
    foo.y:4.4-7: warning: rule useless in parser due to conflicts [-Wother]
        4 | a: expr
          |    ^~~~

    $ bison -Wcex foo.y
    foo.y: warning: 1 shift/reduce conflict [-Wconflicts-sr]
    foo.y: warning: shift/reduce conflict on token ID [-Wcounterexamples]
      First example: expr • ID ',' ID $end
      Shift derivation
        $accept
        ↳ s                      $end
          ↳ a                 ID
            ↳ expr
              ↳ expr • ID ','
      Second example: expr • ID $end
      Reduce derivation
        $accept
        ↳ s             $end
          ↳ a        ID
            ↳ expr •
    foo.y:4.4-7: warning: rule useless in parser due to conflicts [-Wother]
        4 | a: expr
          |    ^~~~

  In these cases, the parser usually doesn't have enough lookahead to
  differentiate the two given examples.

**** Reports

  Counterexamples are also included in the report when given
  `--report=counterexamples`/`-rcex` (or `--report=all`), with more
  technical details:

    State 7

      1 exp: "if" exp "then" exp •  [$end, "then", "else"]
      2    | "if" exp "then" exp • "else" exp

      "else"  shift, and go to state 8

      "else"    [reduce using rule 1 (exp)]
      $default  reduce using rule 1 (exp)

      shift/reduce conflict on token "else":
          1 exp: "if" exp "then" exp •
          2 exp: "if" exp "then" exp • "else" exp
        Example: "if" exp "then" "if" exp "then" exp • "else" exp
        Shift derivation
          exp
          ↳ "if" exp "then" exp
                            ↳ "if" exp "then" exp • "else" exp
        Example: "if" exp "then" "if" exp "then" exp • "else" exp
        Reduce derivation
          exp
          ↳ "if" exp "then" exp                     "else" exp
                            ↳ "if" exp "then" exp •

*** File prefix mapping

  Contributed by Joshua Watt.

  Bison learned a new argument, `--file-prefix-map OLD=NEW`.  Any file path
  in the output (specifically `#line` directives and `#ifdef` header guards)
  that begins with the prefix OLD will have it replaced with the prefix NEW,
  similar to the `-ffile-prefix-map` in GCC.  This option can be used to
  make bison output reproducible.

** Changes

*** Diagnostics

  When text styling is enabled and the terminal supports it, the warnings
  now include hyperlinks to the documentation.

*** Relocatable installation

  When installed to be relocatable (via `configure --enable-relocatable`),
  bison will now also look for a relocated m4.

*** C++ file names

  The `filename_type` %define variable was renamed `api.filename.type`.
  Instead of

    %define filename_type "symbol"

  write

    %define api.filename.type {symbol}

  (Or let `bison --update` do it for you).

  It now defaults to `const std::string` instead of `std::string`.

*** Deprecated %define variable names

  The following variables have been renamed for consistency.  Backward
  compatibility is ensured, but upgrading is recommended.

    filename_type       -> api.filename.type
    package             -> api.package

*** Push parsers no longer clear their state when parsing is finished

  Previously push-parsers cleared their state when parsing was finished (on
  success and on failure).  This made it impossible to check if there were
  parse errors, since `yynerrs` was also reset.  This can be especially
  troublesome when used in autocompletion, since a parser with error
  recovery would suggest (irrelevant) expected tokens even if there were
  failure.

  Now the parser state can be examined when parsing is finished.  The parser
  state is reset when starting a new parse.

** Documentation

*** Examples

  The bistromathic demonstrates %param and how to quote sources in the error
  messages:

    > 123 456
    1.5-7: syntax error: expected end of file or + or - or * or / or ^ before number
        1 | 123 456
          |     ^~~

** Bug fixes

*** Include the generated header (yacc.c)

  Historically, when --defines was used, bison generated a header and pasted
  an exact copy of it into the generated parser implementation file.  Since
  Bison 3.4 it is possible to specify that the header should be `#include`d,
  and how.  For instance

    %define api.header.include {"parse.h"}

  or

    %define api.header.include {<parser/parse.h>}

  Now api.header.include defaults to `"header-basename"`, as was intended in
  Bison 3.4, where `header-basename` is the basename of the generated
  header.  This is disabled when the generated header is `y.tab.h`, to
  comply with Automake's ylwrap.

*** String aliases are faithfully propagated

  Bison used to interpret user strings (i.e., decoding backslash escapes)
  when reading them, and to escape them (i.e., issue non-printable
  characters as backslash escapes, taking the locale into account) when
  outputting them.  As a consequence non-ASCII strings (say in UTF-8) ended
  up "ciphered" as sequences of backslash escapes.  This happened not only
  in the generated sources (where the compiler will reinterpret them), but
  also in all the generated reports (text, xml, html, dot, etc.).  Reports
  were therefore not readable when string aliases were not pure ASCII.
  Worse yet: the output depended on the user's locale.

  Now Bison faithfully treats the string aliases exactly the way the user
  spelled them.  This fixes all the aforementioned problems.  However, now,
  string aliases semantically equivalent but syntactically different (e.g.,
  "A", "\x41", "\101") are considered to be different.

*** Crash when generating IELR

  An old, well hidden, bug in the generation of IELR parsers was fixed.

24 July, 2020 04:40AM by Akim Demaille

July 23, 2020

GNU Guix

Improve Internationalization Support for the Guix Data Service

The first half of my Outreachy internship is already over and I am really excited to share my experience. Over the past weeks I’ve had the opportunity to work on the Guix Data Service, watch myself change, and accomplish way more than I thought I would.

The Guix Data Service processes, stores and provides data about Guix over time. It provides a complementary interface to Guix itself by having a web interface and API to browse and access the data.

The work I have done so far revolves around storing translated lint checker descriptions as well as package synopsis and descriptions in the Guix Data Service PostgreSQL database and making them available through the Guix Data Service web interface.

Initially the Guix Data Service database had translated versions of lint warning messages available, but they were not accessible through the web interface, so I made that possible during the contribution period.

Working on making lint warning messages available on the web interface made it easier for me to understand how translations for lint checker descriptions and package synopsis and descriptions would be stored in the database and later on be made available through the Guix Data Service web interface. At this point, the Guix Data Service supports package synopsis and descriptions as well as lint checker descriptions in various locales.

Guix Data Service page for the audacity package, in the Spanishlocale

Hopefully these changes will provide the Guix Data Service users with a more feasible way to interact with Guix data.

I have to note that this is my first internship and I was initially reluctant to believe that I would be able to tackle or successfully accomplish the tasks I was assigned, but with my mentor’s help and guidance I managed to. So far it has been a rewarding experience because it has helped me make progress in so many aspects, whilst contributing to a project that will potentially increase inclusion.

While working on this project, I’ve significantly improved my Guile, SQL, and Git skills and I am now more aware of how software localization is achieved. In addition to getting more technically skilled, this internship has taught me how to manage time and emotions when dealing with more than one activity at a time.

Now that a good share of what was initially planned to be done is accomplished, my mentor suggested working on something using the Guix Data Service data and I will be engaged in that during the remaining half.

These first 7 weeks of my internship have gone by really fast, but I have enjoyed everything and I am so eager to experience what's to come.

23 July, 2020 12:00PM by Danjela Lura

July 22, 2020

parallel @ Savannah

GNU Parallel 20200722 ('Privacy Shield') released [stable]

GNU Parallel 20200722 ('Privacy Shield') [stable] has been released. It is available for download at: http://ftpmirror.gnu.org/parallel/

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

Quote of the month:

  With multicore systems everywhere GNU Parallel is a must have tool.
    -- Neil H. Watson @neil_h_watson@twitter

 

New in this release:

  • No new functionality
  • 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.

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 3374ec53bacb199b245af2dda86df6c9
    12345678 3374ec53 bacb199b 245af2dd a86df6c9
    $ md5sum install.sh | grep 029a9ac06e8b5bc6052eac57b2c3c9ca
    029a9ac0 6e8b5bc6 052eac57 b2c3c9ca
    $ sha512sum install.sh | grep f517006d9897747bed8a4694b1acba1b
    40f53af6 9e20dae5 713ba06c f517006d 9897747b ed8a4694 b1acba1b 1464beb4
    60055629 3f2356f3 3e9c4e3c 76e3f3af a9db4b32 bd33322b 975696fc e6b23cfb
    $ 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 July, 2020 09:17PM by Ole Tange

July 20, 2020

Applied Pokology

Integral structs in GNU poke

This weekend I finally implemented support for the so-called "integral structs" in poke. This expands the expressivity power of Poke structs to cover cases where data is stored in composited integral containers, i.e. when data is structured within stored integers.

20 July, 2020 12:00AM