GNU Planet!

Hi there, I'm Amin Bandali, often just bandali on the interwebs. I wear a few different hats around GNU as a maintainer, Web master, and Savannah hacker, and I'm very excited to be extending that to the Free Software Foundation (FSF) as an intern with the FSF tech team for spring 2020.

Growing up around parents with backgrounds in computer engineering and programming, it did not take long for me to find an interest in tinkering and playing with computers as a kid, and I first came into contact with GNU/Linux in my teenage years. My first introduction to the world of free software came a few years later, when a friend kindly pointed out to me that what I had vaguely known and referred to as "open source" software is more properly referred to as free software, and helped me see why "open source" misses the point of free software. After learning about and absorbing the ideas and ideals of free software, I have since become a free software activist. As a computer scientist who enjoys studying and hacking on various programs and sometimes writing my own, I have made a point of releasing all I can under strong copyleft licenses, particularly the GNU AGPL license.

My involvement with the GNU Project started in 2016, first as a volunteer Web master, and later as one of the maintainers of GNUzilla and IceCat late last year. Also around the same time, I led a group of volunteers in organizing and holding EmacsConf 2019 as a completely online conference, using only free software tools, much like the excellent LibrePlanet 2020. I love GNU Emacs, and use it more than any other program. GNU Emacs helps me do a wide variety of tasks such as programming, reading and composing emails, and chatting via IRC.

More closely related to my internship with the FSF tech team, I have been familiarizing myself with various pieces of the GNU Savannah infrastructure with help from veteran Savannah hacker Bob Proulx, gradually learning and picking up tasks helping with the administration and maintenance of Savannah. I am also a member of the Systems Committee of my university's computer science club, overseeing and maintaining a large fleet of GNU/Linux servers for our club members.

For my internship with the Free Software Foundation, I will be working with the FSF tech team on a number of tasks, including helping with the free software forge project, as well as various improvements for gnu.org. I look forward to learning many new things and picking up valuable skills through my internship with the FSF's exceptional tech team, who do so much for the GNU project and the wider free software community.

Dear Chinese Translators:

Are you interested in having a video conference using Jitsi?

As a valued associate member of the Free Software Foundation (FSF), we are now offering you free "as in freedom" videoconferencing, to help you push back against increased societal pressure to use nonfree software for communicating with collaborators, friends, and loved ones during the COVID-19 pandemic, and after.

Try out our FSF associate member videoconferencing

Only current FSF members can create a channel on the server, but nonmembers are then able to join you. It's a good opportunity to showcase why you are an FSF member!

We have been raising the alarm about encroachments upon user freedom by popular remote communication tools since social distancing guidelines were issued. You might have seen our recent publications warning users about widely used nonfree applications for remote communication and education, like Zoom.

As promised at LibrePlanet 2020, we have formed a working group to document and address major issues facing free software communication platforms, and this project is part of that effort. Another initiative in our free communication toolbox is a collaborative resource page created to steer users to applications that respect them. This will help you and the people you care about to stay away from conferencing tools like Zoom, which requires users to give up their software-related freedoms, and which has been a recent focal point of criticism due to problems ranging from security issues to privacy violations.

The platform we use to offer ethical videoconferencing access is Jitsi Meet. We used it previously to stream and record our annual LibrePlanet conference for an online audience after the COVID-19 pandemic forced us to cancel the in-person event. Choosing Jitsi Meet is only the first step to addressing the problems posed to freedom by services like Zoom and Facebook. Even users that start a call via a server running Jitsi could still be vulnerable if that server depends on or shares information with third parties. The FSF made changes to the code we are running, in order to enhance privacy and software freedom, and published the source code, to motivate others to host their own instances. The FSF instance does not use any third party servers for network initialization, and does not recommend or link to any potentially problematic services.
How to communicate freely with everyone you know

In order to provide a sustainable and reliable service, we are offering the ability to create conversations on the server exclusively to associate members, and it is only intended for personal, noncommercial use. You can create a channel by logging into the server using your member credentials; (your account username is wxie). Any person or group can then participate in the conversation. Nonmembers can be invited, but cannot start a channel.

To use the system, follow these steps:

    Go to https://jitsi.member.fsf.org/;

    Create a room (for privacy reasons it is better to use something random as a name);

    Click on "I am the host" in the modal window to be asked for your membership credentials.

You are now the moderator of the room. Other guests can join using the same URL, without needing to login. For extra privacy, we recommend giving the room a password by clicking on the "i" icon in the bottom right.

best regards,
wxie

The Free Software Foundation (FSF) is now offering all FSF associate members free "as in freedom" videoconferencing as an additional member benefit. Becoming a member now helps you push back against increased societal pressure to use nonfree software to communicate with coworkers, friends, and loved ones during the COVID-19 pandemic, and after.

Information about how to use the FSF videoconferencing instance for associate members

We have been raising the alarm about encroachments upon user freedom by popular remote communication tools since social distancing guidelines were issued. You might have seen our recent publications warning users about widely used nonfree applications for remote communication and education, like Zoom.

As promised at LibrePlanet 2020, we have formed a working group to document and address major issues facing free software communication platforms, and this project is part of that effort. Another initiative in our free communication toolbox is a collaborative resource page created to steer users to applications that respect them, and away from conferencing tools like Zoom, which requires users to give up their software-related freedoms, and which has been a recent focal point of criticism due to problems ranging from security issues to privacy violations.

The platform we use to offer ethical videoconferencing access is Jitsi Meet. We used it previously to stream and record our annual LibrePlanet conference for an online audience after the COVID-19 pandemic forced us to cancel the in-person event. Choosing Jitsi Meet is only the first step to addressing the problems posed to user freedom by services like Zoom and Facebook. Even users that start a call via a server running Jitsi could still be vulnerable if that server depends on or shares information with third parties. The FSF made changes to the code we are running, in order to enhance privacy and software freedom, and published the source code, to motivate others to host their own instances. The FSF instance does not use any third party servers for network initialization, and does not recommend or link to any potentially problematic services.

In order to be able to provide a sustainable and reliable service, we are offering the ability to create conversations on the server exclusively to associate members, and it is only intended for personal, noncommercial use. Members can create a channel using their member credentials, but then any person or group can participate in the conversation. Nonmembers can be invited, but cannot start a channel.

Privacy and encryption in the FSF Jitsi Meet instance

Jitsi Meet offers end-to-end encryption for conversations between two people. For conversations between three or more people, there will always be encryption at the network level, but you still have to place some level of trust in the server operators that process your video stream. Because the FSF controls the physical machine, we can offer members the respect of privacy and freedom you have come to expect from us. The FSF servers do not store any voice, video, or messages from calls, and logging is minimal -- for the purpose of troubleshooting and abuse prevention only. Jitsi is working on developing end-to-end encryption for calls with more than two people, and we will implement these changes on our instance as soon as this becomes available.

As a nonprofit, the FSF has limited resources, which may at times affect the server capacity. We will experiment with different parameters and limitations and improve the instance as needed, and update the repo accordingly.

Support our work

Now that remote and digital connections are playing a bigger role in our daily lives than ever before, it is important to communicate about and push for free software continuously. Our success hinges on the people that support us, and in return, we want to do our part to make sure no one is forced to give up their freedom in order to live their (now remote) daily lives with technology. Please consider an FSF associate membership to help support our work, and continue your advocacy for free software.

Illustration Copyright © 2020, Free Software Foundation, Inc., by Zoë Kooyman, Licensed under Creative Commons Attribution 4.0 International license.

The FSF has been raising the alarm about encroachments upon freedom by remote communication tools since social distancing guidelines were issued. The FSF's new videoconferencing service powered by free software comes after several of its recent publications warned users about widely used nonfree applications for remote communication and education, like Zoom.

"The freedoms to associate and communicate are some of our most important. To have the means to exercise these freedoms online controlled by gatekeepers of despotic software is always dangerous and unacceptable, only more so when we can't safely gather in person," executive director John Sullivan explains. "We are a small nonprofit and can't provide hosting for the entire world, but we want to do our part. By offering feature-rich videoconferencing in freedom to our community of supporters, and sharing how others can do it, too, we demonstrate that it is possible to do this kind of communication in an ethical way."

This project came out of the working group the FSF established to document and address major issues facing free software communication platforms. Another initiative in its free communication toolbox is a collaborative resource page created to steer users to applications that respect them. The goal is to help users avoid conferencing tools like Zoom, which requires users to give up their software-related freedoms, and which has been a recent focal point for criticism due to problems ranging from security issues to privacy violations.

Zoom is not the only nonfree communication software that has received scrutiny recently while surging in popularity. Facebook's recently launched Messenger Rooms service may offer tools to keep users out, but it is not encrypted, nor does it offer protection from the ongoing data sharing issues that are inherent to the company. Google Meet, Microsoft Teams, and Webex were also reported to be collecting more data than users realized. These kinds of problems, the FSF argues, are examples of what happens when the terms of the code users are running prohibits them from inspecting or improving it for themselves and their communities.

The platform the FSF will use to offer ethical videoconferencing access is Jitsi Meet. Jitsi Meet was also used when the COVID-19 pandemic forced the FSF to bring its annual LibrePlanet conference online. Choosing Jitsi Meet is the first step to addressing the problems posed to freedom by services like Zoom and Facebook. However, even users that start a call via a server running Jitsi could still be vulnerable, if that server depends on or shares information with third parties. The FSF made changes to the code it is running to enhance privacy and software freedom, and published the source code. The FSF instance does not use any third party servers for network initialization, and does not recommend or link to any potentially problematic services.

Jitsi Meet initiates an encrypted peer-to-peer conference when there are only two participants, but achieving end-to-end encryption for more than two people is not yet possible. FSF chief technical officer Ruben Rodriguez elaborates: "For any multiparticipant conversation, there will always be encryption at the network level, but you still have to place some level of trust in the server operator that processes your video stream. We are offering what is currently possible when it comes to multiparticipant privacy, and we are doing it on machines that we physically own." The FSF servers do not store any voice, video, or messages from calls, and logging is minimal and for the purpose of troubleshooting and abuse prevention only. According to its Web site, Jitsi is working to implement end-to-end encryption for multiple callers, and the FSF has confirmed plans to implement the improvements as soon as they become available.

Sullivan provided further comment: "The FSF is offering people a chance to keep their freedom and remain in touch at the same time. With these services, you usually have to sacrifice your freedom for the ability to stay in touch with the people you care about, and place your data in the hands of an organization you don't know. Our members trust the FSF not to compromise their data, and this way, we can offer both."

Associate members of the FSF pay a $10 USD monthly fee, which is discounted to $5 USD for students. An FSF associate membership will provide users with the ability to create their own meeting rooms for personal, noncommercial use, which they can use to invite others to join regardless of their location or membership status.

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.

Associate members are critical to the FSF, since they contribute to the existence of the foundation and help propel the movement forward. Besides gratis access to the FSF Jitsi Meet instance, they receive a range of additional benefits. Donations to support the FSF's work can be made at https://my.fsf.org/donate. 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 Contact

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

Online GNUnet Hacker Meeting in June 2020

We are happy to announce that we will have a GNUnet Hacker Meeting from 17-21 of June 2020 taking place online. For more information see here.

• bison-3.6.2
• denemo-2.4.0
• emms-5.4
• freeipmi-1.6.5
• gcc-10.1.0
• gdb-9.2
• gnuastro-0.12
• gnuhealth-3.6.4
• mediagoblin-0.10.0
• nano-4.9.3
• nettle-3.6
• parallel-20200522

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.

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.

As always, please feel free to write to us at maintainers@gnu.org with any GNUish questions or suggestions for future installments.

As you may already know, every associate member is incredibly valuable to the Free Software Foundation (FSF). Since most of our funding comes from individual donations and memberships, associate members aren’t just a number. Each new membership magnifies our reach and our ability to effect social change, by demonstrating your commitment to the crucial cause of software freedom.

Right now, FSF associate members have the opportunity to reap some fantastic rewards by participating in our virtual LibrePlanet membership drive. We still have the raffle prizes generously donated by Technoethical, Vikings, JMP.chat, and ThinkPenguin for this year’s LibrePlanet conference, which we held entirely online this year due to the COVID-19 pandemic. Now, we’re giving them away to those who go the extra mile to help us grow by referring new annual associate members to sign up!

Associate members receive a range of benefits for their contribution, like an FSF email alias, access to the member forum, 20% discount in the FSF shop, and gratis entrance to the annual LibrePlanet conference. In fact, we've been working hard to add an exciting new member benefit this month as well -- stay tuned!

Winning the prizes is easy: just find a friend, acquaintance, colleague, or family member who uses free software, knows about free software, or is just worried about how corporate abuses of computer users by proprietary software are ramping up right now, and tell them why they need to support the FSF today.

In order for you to qualify to win a prize, new members have to sign up using your referral link. You will find your personal referrer link on the dashboard after logging in at https://my.fsf.org/.

To see the prize list, and find out how many referrers you need for each prize, check out our original announcement of the raffle at https://www.fsf.org/blogs/community/virtual-libreplanet-raffle-encourage-others-to-join-fsf-and-win-prizes.

It shouldn’t be difficult to understand or explain why our work is so crucial today, and why the fight to free our software deserves everyone’s support. We hope you’ll agree with John Hamelink, who told us he became an associate member this month because "We've never needed the Free Software Foundation more than right now."

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

Quote of the month:

  GNU Parallel: dead simple process-level parallelization of ad hoc tasks.
  Write for a chunk, let gnu manage the splitting, permutations and pool concurrency.
    -- Nick Ursa @nickursa@twitter

New in this release:

• While running a job $PARALLEL_JOBSLOT is the jobslot of the job. It is equal to {%} unless the job is being retried. See {%} for details.
• While running a job $PARALLEL_SSHLOGIN is the sshlogin line with number of cores removed. E.g. '4//usr/bin/specialssh user@host' becomes: '/usr/bin/specialssh user@host'
• While running a job $PARALLEL_SSHHOST is the host part of an sshlogin line. E.g. '4//usr/bin/specialssh user@host' becomes: 'host'
• --plus activates the replacement strings {slot} = $PARALLEL_JOBSLOT, {sshlogin} = $PARALLEL_SSHLOGIN, {host} = $PARALLEL_SSHHOST
• Bug fixes and man page updates.

News about GNU Parallel:

• Portable Batch System (PBS) & GNU Parallel - Running a Program Multiple Times in Parallel https://www.youtube.com/watch?v=6ccbWu6Befo
• GNU Parallel przykład https://www.youtube.com/watch?v=gs_wG4Kt2G4
• demo of LINUX APP - GNU PARALLEL - running multiple Gstreamer webcam .sh scripts with only 1 command https://www.youtube.com/watch?v=trQuA_wmWjg

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:

• (Have your company) donate to FSF https://my.fsf.org/donate/

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.

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

- Add FRU parsing workaround for Fujitsu Primergy RX1330, in which a CEh is used to indicate that no FRU data is available.
- Misc minor fixes.

Often, a proprietary software company's silence can speak as loudly as their latest campaign against a computer user's right to freedom. This is the case with Microsoft's developer-centric "Build" event. While Microsoft announced a few more welcome additions to its free software output, it missed the opportunity to demonstrate a real commitment to user freedom by upcycling its recently abandoned Windows 7 operating system under a free software license.

The predictable failure here here fits together well with the corporation's complex history of mixed messaging on freedom, which once compared copyleft to "a virus that gobbles up intellectual property like a Pac-Man," and yet now would have you believe that it "loves [free software]." Our Upcycle Windows 7 petition has given Microsoft the perfect opportunity to take the next step in its promotion of free software, to show that its "love" was real. We are disappointed, but not surprised, that they have ignored this call from us and thousands of potential users.

Although the petition signatures and "special gift" were signed, sealed, and delivered safely to their Redmond, WA headquarters, the FSF has not received any response from a Microsoft representative. Of course, the COVID-19 pandemic has impacted the operations of even the largest companies, but as of yet, we haven't heard anything from Microsoft suggesting this was the reason for the lack of response. They certainly seem to have had the resources to put on a 48-hour video marathon about proprietary software.

We can only take this to mean that it's "business as usual" as far as the corporation is concerned, but things don't have to remain that way. And while Microsoft has failed to live up to its own words, we (and all of our petition signers) aren't just shouting into the void. 13,635 free software supporters from around the globe signed the petition, and the initiative saw more than 6,000 newcomers subscribe to the monthly Free Software Supporter newsletter.

Of course, this small setback is just another bump in the road in our fight for a world in which people can use their computers to work, hack, and play in complete freedom. In this vein, we encourage everyone Microsoft has left in the lurch to give a fully free operating system a try. Your friends, colleagues, and loved ones might be surprised by how free software's elegance and ease-of-use continues to improve each day, and you might get your first glimpse of living in participating in a collaborative digital community: one in which your contributions, whether they're in the form of code, translations, graphic design, or bug reports, can benefit the experience of users everywhere. And unlike a certain operating system from Redmond, we can assure you that GNU/Linux isn't going anywhere anytime soon. After all, it powers the Internet!

There's still time for Microsoft to step up and show its respect for user freedom, and if they do, we're ready to give them all the assistance that they need. We'll continue to welcome the contributions Microsoft has been making to various free software programs. It's not that we don't appreciate those. Rather, it's that they still exist in a context where the company appears to be trying to get the best of both worlds -- proprietary and free -- and they just passed up a huge opportunity to show their commitment by ending the waffling. But if they still choose not to, we and every other free software activist can take consolation in the fact that to deny users freedom is to be on the wrong side of history.

The 12th release of GNU Astronomy Utilities (Gnuastro) is now available. Please see the announcement for more.

New Features
        Omission Criteria
            A lightweight alternative to Score Layouts
            A single flag turns on/off features of the score
        Swing Playback
            Playback with altered note durations
            Use for Jazz swing and note inègales
        Page Turner/Annotater
            Annotate while playing from digital score
            Page turn digital score from pedals
        New from Current
            Create a new score using the current one as template
            Use for books of songs, sonatas etc to keep style uniform
Bug Fixes
        Easier object edit interface
        After Grace command now fully automatic
        Crash on Windows during delete measure all staffs
        Template save bugs fixed
        Assign Instrument command in score with voices fixed.

One of the things which sets Guix apart from other GNU/Linux distributions is that it uses GNU Shepherd instead of the now ubiquitous systemd. A side effect of this is that user systemd units do not work on Guix System. Love, hate or extremely ambivalent toward systemd, this means that users cannot rely on already written systemd unit files for their regular user-level services.

There are a couple of benefits to using GNU Shepherd, and not all of them are due to it already being installed on Guix. Becoming comfortable with using Shepherd and understanding how to write and edit Shepherd service configurations makes the transition from other GNU/Linux distributions to Guix System easier. More complex services with their own logic tree, using the full power of GNU Guile, are also possible. This means you can have one service that behaves differently if it's running on a different system or architecture without needing to call out to shell scripts or using minimally different service definitions.

The GNU Shepherd manual suggests putting all the services inside a monolithic init.scm file, located by default at $XDG_CONFIG_DIR/shepherd/init.scm. While this does make it easy to keep everything in one place, it does create one glaring issue: any changes to the file mean that all the services need to be stopped and restarted in order for any changes to take place.

Luckily there's a nice function called scandir hiding in ice-9 ftw which returns a list of all files in a specified directory (with options for narrowing down the list or sorting it). This means that our init.scm can contain a minimum of code and all actual services can be loaded from individual files.

First the minimal init.scm:

(use-modules (shepherd service) ((ice-9 ftw) #:select (scandir))) ;; Load all the files in the directory 'init.d' with a suffix '.scm'. (for-each (lambda (file) (load (string-append "init.d/" file))) (scandir (string-append (dirname (current-filename)) "/init.d") (lambda (file) (string-suffix? ".scm" file)))) ;; Send shepherd into the background (action 'shepherd 'daemonize)

Let's take a sample service for running syncthing, as defined in $XDG_CONFIG_DIR/shepherd/init.d/syncthing.scm:

(define syncthing (make <service> #:provides '(syncthing) #:docstring "Run `syncthing' without calling the browser" #:start (make-forkexec-constructor '("syncthing" "-no-browser") #:log-file (string-append (getenv "HOME") "/log/syncthing.log")) #:stop (make-kill-destructor) #:respawn? #t)) (register-services syncthing) (start syncthing)

As with any other shepherd service it is defined and registered, and in this case it will start automatically. When the file is loaded by shepherd after being discovered by scandir everything works exactly as though the service definition were located directly inside the init.scm.

Now lets make a change. Since syncthing already has a -logfile flag and it has built-in log rotation that sounds better than using shepherd's #:log-file option. First we'll make our changes to the service:

(define syncthing (make <service> #:provides '(syncthing) #:docstring "Run `syncthing' without calling the browser" #:start (make-forkexec-constructor '("syncthing" "-no-browser" "-logflags=3" ; prefix with date & time "-logfile=/home/user/log/syncthing.log")) #:stop (make-kill-destructor) #:respawn? #t)) (register-services syncthing) (start syncthing)

Now we stop syncthing:

$ herd stop syncthing

And we load the new service:

$ herd load root ~/.config/shepherd/init.d/syncthing.scm

This allows for quickly iterating on services without needing to stop all the services! Let's take a look at another service:

(define fccache (make <service> #:provides '(fccache) #:docstring "Run 'fc-cache -frv'" #:start (make-forkexec-constructor '("guix" "environment" "--ad-hoc" "fontconfig" "--" "fc-cache" "-frv") #:log-file (string-append (getenv "HOME") "/log/fccache.log")) #:one-shot? #t)) (register-services fccache)

In this example I want to refresh my font cache but I don't want to actually install fontconfig either system-wide or in my profile.

$ which fc-cache which: no fc-cache in (/home/user/.config/guix/current/bin:/home/user/.guix-profile/bin:/home/user/.guix-profile/sbin:/run/setuid-programs:/run/current-system/profile/bin:/run/current-system/profile/sbin) $ herd start fccache Service fccache has been started.

Of course we can import other modules and leverage the code already written there. In this case, instead of using the string "guix environment --ad-hoc fontutils -- fc-cache -frv" let's use the guix environment function already available in guix scripts environment:

(use-modules (guix scripts environment)) (define fccache (make <service> #:provides '(fccache) #:docstring "Run 'fc-cache -frv'" #:start (lambda () ; Don't run immediately when registered! (guix-environment "--ad-hoc" "fontconfig" "--" "fc-cache" "-frv")) #:one-shot? #t)) (register-services fccache)$ herd load root ~/.config/shepherd/init.d/fccache.scm Loading /home/user/.config/shepherd/init.d/fccache.scm. $ herd start fccache /gnu/store/hbqlzgd8hcf6ndcmx7q7miqrsxb4dmkk-gs-fonts-8.11/share/fonts: caching, new cache contents: 0 fonts, 1 dirs /gnu/store/hbqlzgd8hcf6ndcmx7q7miqrsxb4dmkk-gs-fonts-8.11/share/fonts/type1: caching, new cache contents: 0 fonts, 1 dirs /gnu/store/hbqlzgd8hcf6ndcmx7q7miqrsxb4dmkk-gs-fonts-8.11/share/fonts/type1/ghostscript: caching, new cache contents: 35 fonts, 0 dirs /home/user/.guix-profile/share/fonts: caching, new cache contents: 0 fonts, 7 dirs /home/user/.guix-profile/share/fonts/opentype: caching, new cache contents: 8 fonts, 0 dirs /home/user/.guix-profile/share/fonts/otf: caching, new cache contents: 12 fonts, 0 dirs /home/user/.guix-profile/share/fonts/terminus: caching, new cache contents: 18 fonts, 0 dirs /home/user/.guix-profile/share/fonts/truetype: caching, new cache contents: 58 fonts, 0 dirs /home/user/.guix-profile/share/fonts/ttf: caching, new cache contents: 12 fonts, 0 dirs /home/user/.guix-profile/share/fonts/type1: caching, new cache contents: 0 fonts, 1 dirs /home/user/.guix-profile/share/fonts/type1/ghostscript: caching, new cache contents: 35 fonts, 0 dirs /home/user/.guix-profile/share/fonts/woff: caching, new cache contents: 1 fonts, 0 dirs /run/current-system/profile/share/fonts: skipping, no such directory /home/user/.local/share/fonts: skipping, no such directory /home/user/.fonts: skipping, no such directory /gnu/store/hbqlzgd8hcf6ndcmx7q7miqrsxb4dmkk-gs-fonts-8.11/share/fonts/type1: skipping, looped directory detected /home/user/.guix-profile/share/fonts/opentype: skipping, looped directory detected /home/user/.guix-profile/share/fonts/otf: skipping, looped directory detected /home/user/.guix-profile/share/fonts/terminus: skipping, looped directory detected /home/user/.guix-profile/share/fonts/truetype: skipping, looped directory detected /home/user/.guix-profile/share/fonts/ttf: skipping, looped directory detected /home/user/.guix-profile/share/fonts/type1: skipping, looped directory detected /home/user/.guix-profile/share/fonts/woff: skipping, looped directory detected /gnu/store/hbqlzgd8hcf6ndcmx7q7miqrsxb4dmkk-gs-fonts-8.11/share/fonts/type1/ghostscript: skipping, looped directory detected /home/user/.guix-profile/share/fonts/type1/ghostscript: skipping, looped directory detected /var/cache/fontconfig: not cleaning unwritable cache directory /home/user/.cache/fontconfig: cleaning cache directory /home/user/.fontconfig: not cleaning non-existent cache directory fc-cache: succeeded herd: exception caught while executing 'start' on service 'fccache': Throw to key `quit' with args `(0)'.

The problem with this approach is that guix-environment returns the exit code of the programs it calls and #:start expects a constructor to return #t or #f so there's some work to be done here.

This was just a quick peek into what's possible with GNU Shepherd when run as a user. Next time we'll take a look at integrating mcron to replicate some of systemd's timer functionality.

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.

Dear community

GNU Health 3.6.4 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.4.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.4 includes:
The most relevant features on this version are:

• health_contact_tracing package: Allows to trace people that have been in contact with a person suspected of being positive of a infectious disease. Name, demographics, place and date of contact, sanitary region (operational sector), type of contact, exposure risk and follow-up status are some of the information that is recorded per contact.

• Epidemiological Surveillance: A new report that provides epidemiological information on an specific health condition. Data on prevalence of the disease as well as the incidence over a period of time. It produces epi curves for new confirmed cases, deaths related to the disease (both immediate cause as well as underlying conditions) from death certificates. It also shows very relevant charts on the population affected from a demographic and socioeconomic point of view (age, gender, ethnicity, socioeconomic status).

• Lab and lab crypto packages: When a disease is confirmed from a positive lab test result, GNU Health LIMS automatically includes the health condition in the patient medical history upon the validation of the lab manager.

• GH Control center and gnuhealth-setup have been updated.

Installation Notes

You must apply previous patchsets before installing this patchset. If your patchset level is 3.6.3, 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.4: Matplotlib (You can skip this step if you are doing a fresh installation.)
If you are upgrading from 3.6.3, you need to install the matplotlib package:

$pip3 install --upgrade --user matplotlib

Now follow the general instructions at

• https://en.wikibooks.org/wiki/GNU_Health/Control_Center

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

• bug #58104: view_attributes() method should extend list of attributes
• bug #58358: Need current SES in main patient info
• task #15563: Assign health condition from a confirmed lab
• task #15562: ((updated)) Include coronavirus COVID-19 in ICD10 codes

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

• https://en.wikibooks.org/wiki/GNU_Health/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
Fingerprint: ACBF C80F C891 631C 68AA 8DC8 C015 E1AE 0098 9199

As countries around the world are beginning their long and slow recovery from the coronavirus, schools and universities may have to continue their struggle to give their students a quality education while using remote communication services until the end of the year. With the need to continue classes and exams, school administrators have ended up relying on proprietary conference tools like Zoom to stay connected, and are unfortunately turning to contracting proctoring businesses with names like ProctorU, Proctorio, and Examity to monitor testing and exams.

The increased use of proprietary test-administering software is a dangerous development, both because of the software's proprietary nature, and because of its inherent purpose of exposing a student's, or in some cases a family's, data to the proctor. In schemes like these, the user ends up sacrificing both personal information and biometric data. Because the software is proprietary, there's no possibility of understanding how it works -- besides leaking personal data, it could also create security concerns or deliver bad quality tests (and results). Requiring students to cede control over their entire computer to a test proctoring company is fundamentally unjust. Worse, we cannot be sure that any of these nonfree software dependencies and their accompanying surveillance techniques will be rolled back after social distancing guidelines are no longer enforced.

It is important that decisions made in the education sector are first and foremost ethically motivated. Here at the Free Software Foundation (FSF), we have started a free communications working group. Initiatives include a remote communication email list, as well as a collaborative resource page for documenting and sharing free communication tools to help spread awareness of the ethical choices that can be made. We have also been assisting educational professionals in offering their classes online using only free software. And we have been reading many stories about activism in education from the larger community, and want to share those with you. They have inspired and motivated us. We need more people like this around the world to be vocal and critical about infringements on user freedom in the area of remote learning.

Students revolt against online proctoring

As educational institutions are scrambling to offer remote learning, online proctoring companies will be used well into the fall. These businesses require students to identify themselves with valid ID, and then give consent to access their browser history. Of course, the "consent" is hardly meaningful, since the student is not given the option to take their test without monitoring, so this means that they either submit to monitoring or flunk their exam.

The students are made to give a tour of their bedroom, desk, and anything the proctor demands, in order to establish a "cheat-safe" environment. They are then asked to waive their rights so the company can record their webcams and microphones, the student's keystrokes, screen, mouse movements, and even facial expressions.

Students are also forced to consent to the organization's right to retain much of what they gather from students’ computers and bedrooms. The Daily Mail reports that "Examity's fine print notes that students handed over their data 'at their own risk' because 'no data protection procedures are entirely infallible.'" Reports have centered around added stress for the students and inequality issues, as well as (naturally) privacy concerns. Cory Doctorow highlighted the issue that the software, by design, allows the organization to hijack the student's hardware, leaving it outside their control, even after the exam is finished, or when the user wants it to stop.

But students in Australia took matters into their own hands, forcing institutions and global media to recognize the issue at hand. Thirteen groups from the Australian National University (ANU) wrote an open letter calling for the university to find an alternative approach that is acceptable for all students. And once the ANU open letter gained some traction in media, other Australian student groups followed their lead. The Washington Post reports that a faculty group in California also recognized that the privacy and digital rights of their students could not be sacrificed for the purpose of the "expediency of a take-home final exam." In the Netherlands, students of the University of Tilburg started a petition against the use of proctoring software, which is currently signed almost 5,000 times.

Free conferencing video implementations for classes

We have seen many reports on the dangers of using proprietary conferencing tools like Zoom recently. Zoom has gotten enough negative attention that New York City banned Zoom usage by schools, sadly in favor of the equally dangerous nonfree Microsoft Teams. Now, the recently launched Facebook Messenger Rooms service is also receiving its fair share of criticism. But there is hope yet, as some governments and institutions are expressing concerns and are actively looking to preserve people's freedom.

In Italy, WeSchool, an organization dedicated to the digitization of Italian schools, decided to opt for Jitsi over proprietary tools like Zoom to help teachers bring their classes online. We don't know the full extent of their commitment to freedom, but their effort to provide a platform for teachers aiming to respect the student's freedom, now that videoconferencing is such an significant part of education, is laudable. Nearly two million students connect, collaborate, and learn via video with the help of this organization.

And in France, a temporary platform has been built by the French government offering teachers and employees of the French Ministry of National Education access to free software applications like Etherpad, Nextcloud, and Discourse, tools that were also on our recommendation list for free software tools to help us get through social distancing.

In San Antonio de Benageber, near Valencia, Spain, one free software advocate made a major difference in his community. Javier Sepulveda was informed by his children's school that they intended to continue teaching weekly lessons, using proprietary videoconferencing software. Realizing this was not an isolated decision affecting only his children, Javier turned the school's choice towards free software instead.

After convincing the teachers, he set up a Jitsi Meet instance on a virtual private server (VPS) with enough resources to be able to offer this server to the school as well. He also continues to work with the local English school, single-handedly mitigating a spread of proprietary software in his community. Together with the local GNU/Linux group, he then proceeded to set up another server, so they could offer it publicly.

Advocacy matters

It's logical to seek remote connections during this time, but let's not forget that businesses are filling their pockets because of decisions made in urgency. It is wrong to open up students' personal information to proprietary software companies, and to require students to use a specific company's proprietary products in order to get credit. As Javier puts it: "We need to make decisions based on the welfare of the children." It is young people's futures that are at stake, and the above examples show that advocacy matters. Small successes are what we need to make a difference, and to give others the confidence to take a stand.

Now is not the time to accept just any decision because of the unique positions we have been placed in. We should stand up, and continue to fight for our rights and lay bare the issues and solutions for organizations struggling to make the right decisions. You can support such efforts by sharing your knowledge, giving feedback to institutions that are making decisions (right or wrong), donating to the FSF and other organizations fighting for freedom, and speaking out publicly about your successes. If you have a success story to share, you can share it on the remote communication email list, and we would be happy to help your story be heard.

Illustration Copyright © 2020, Free Software Foundation, Inc., by Zoë Kooyman, Licensed under Creative Commons Attribution 4.0 International license.

Over the last year and a half I've had a good time presenting on Libre Lounge with my co-host Serge Wroclawski. I'm very proud of the topics we've decided to cover, of which there are quite a few good ones in the archive, and the audience the show has had is just the best.

However, I've decided to depart the show... Serge and I continue to be friends (and are still working on a number of projects together, such as Datashards and the recently announced grant), but in terms of the podcast I think we'd like to take things in different creative directions.

This is probably not the end of me doing podcasting, but if I start something up again it'll be a bit different in its structure... and you can be sure you'll hear about it here and on my fediverse account and over at the birdsite.

In the meanwhile, I look forward to continuing to tuning into Libre Lounge, but as a listener.

Thanks for all the support, Libre Loungers!

I've been putting off making this blogpost for a while because I kept thinking, "I should wait to do it until I finish making some sort of website for Spritely and make a blogpost there!" Which, in a sense is a completely reasonable thought because right now Spritely's only "website" is a loose collection of repositories, but I'd like something that provides a greater narrative for what Spritely is trying to accomplish. But that also kind of feels like a distraction (or maybe I should just make a very minimal website) when there's something important to announce... so I'm just doing it here (where I've been making all the other Spritely posts so far anyway).

Spritely is an NLnet grant recipient! Specifically, we have received a grant for "Interface Discovery for Distributed Systems"! I'll be implementing the work alongside Serge Wroclawski.

There are two interesting sub-phrases there: "Interface Discovery" and "Distributed Systems". Regarding "distributed systems", we should really say "mutually suspicious open-world distributed systems". Those extra words change some of the requirements; we have to assume we'll be told about things we don't understand, and we have to assume that many objects we interact with may be opaque to us... they might lie about what kind of thing they are.

Choosing how to name interfaces then directly ties into something I wrote about here more recently, namely content addressed vocabulary.

I wrote more ideas and details about the interfaces ideas email to cap-talk so you can read more there if you like... but I think more details about the interfaces thoughts than that can wait until we publish a report about it (and publishing a report is baked into the grant).

The other interesting bit though is the "distributed" aspect; in order to handle distributed computation and object interaction, we need to correctly design our protocols. Thankfully there is a lot of good prior art to work from, usually some variant of "CapTP" (Capability Transport Protocol), as implemented in its original form by E, taking on a bit of a different form in the Waterken project, adapted in Cap'N Proto, as well as with the new work happening over at Agoric. Each of these variants of the core CapTP ideas have tried to tackle some different use cases, and Goblins has its own needs to be covered. Is there a possibility of convergence? Possibly... I am trying to understand the work of and communicate with the folks over at Agoric but I think it's a bit too early to be conclusive about anything. Regardless, it'll be a major milestone once Spritely Goblins is able to actually live up to its promise of distributed computation, and work on this is basically the next step to proceed on.

When I first announced Spritely about a year and a half ago I included a section that said "Who's going to pay for all this?" to which I then said, "I don't really have a funding plan, so I guess this is kind of a non-answer. However, I do have a Patreon account you could donate to." To be honest, I was fairly nervous about it... so I want to express my sincere and direct appreciation to NLnet, Samsung Stack Zero, and all the folks donating on Patreon and Liberapay. With all the above, and especially the new grant from NLnet, I should have enough funding to continue working on Spritely through a large portion of 2021. I am determined to make good on the support I've received, and am looking forward to put out more interesting demonstrations of this technology over the next few months.

We are thrilled to announce that three people will join Guix as interns over the next few months! As part of Google’s Summer of Code (GSoC), under the umbrella of the GNU Project, one person is joining us:

• Brice Waegeneire (liberdiko) will work on network booting Guix System. This will involve both making Guix System network bootable, and making it easy to set up a network boot server on Guix System.

Through Outreachy, the internship program for groups underrepresented in free software and tech, two people will join:

• Danjela will work on improving internationalization support for the Guix Data Service,
• Raghav Gururajan will work on integrating desktop environments into Guix System.

Christopher Baines and Danny Milosavljevic will be their primary mentors, and the whole Guix crowd will undoubtedly help and provide guidance as it has always done.

We welcome all three interns, exciting things are sure to come!

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.

New Features
        Omission Criteria
            A lightweight alternative to Score Layouts
            A single flag turns on/off features of the score
        Swing Playback
            Playback with altered note durations
            Use for Jazz swing and note inègales
        Page Turner/Annotater
            Annotate while playing from digital score
            Page turn digital score from pedals
        New from Current
            Create a new score using the current one as template
            Use for books of songs, sonatas etc to keep style uniform
Bug Fixes
        Easier object edit interface
        After Grace command now fully automatic
        Crash on Windows during delete measure all staffs
        Template save bugs fixed
        Assign Instrument command in score with voices fixed.

We are extremely happy to announce the release of Bison 3.6:

- the developer can forge syntax error messages the way she wants.

- token string aliases can be internationalized, and UTF-8 sequences
  are properly preserved.

- push parsers can ask at any moment for the list of "expected tokens",
  which can be used to provide syntax-driven autocompletion.

- yylex may now tell the parser to enter error-recovery without issuing an
  error message (when the error was already reported by the scanner).

- several new examples were added, in particular "bistromathic" demonstrates
  almost all the existing bells and whistles, including interactive
  autocompletion on top of GNU readline.

Please see the much more detailed release notes below.

Many thanks to testers, bug reporters, contributors and feature requesters:
Adrian Vogelsgesang, Ahcheong Lee, Alexandre Duret-Lutz, Andy Fiddaman,
Angelo Borsotti, Arthur Schwarz, Christian Schoenebeck, Dagobert Michelsen,
Denis Excoffier, Dennis Clarke, Don Macpherson, Evan Lavelle, Frank
Heckenbach, Horst von Brand, Jannick, Nikki Valen, Paolo Bonzini, Paul
Eggert, Pramod Kumbhar and Victor Morales Cayuela.  The author also thanks
an anonymous reviewer for his precious comments.

Special thanks to Bruno Haible for his investment into making Bison
portable.

Happy parsing!

       Akim

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

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

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

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

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

Here are the GPG detached signatures[*]:
  https://ftp.gnu.org/gnu/bison/bison-3.6.tar.gz.sig
  https://ftp.gnu.org/gnu/bison/bison-3.6.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.6.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-3382-g2ac33b29f

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

* Noteworthy changes in release 3.6 (2020-05-08) [stable]

** Backward incompatible changes

  TL;DR: replace "#define YYERROR_VERBOSE 1" by "%define parse.error verbose".

  The YYERROR_VERBOSE macro is no longer supported; the parsers that still
  depend on it will now produce Yacc-like error messages (just "syntax
  error").  It was superseded by the "%error-verbose" directive in Bison
  1.875 (2003-01-01).  Bison 2.6 (2012-07-19) clearly announced that support
  for YYERROR_VERBOSE would be removed.  Note that since Bison 3.0
  (2013-07-25), "%error-verbose" is deprecated in favor of "%define
  parse.error verbose".

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

** New features

*** Improved syntax error messages

  Two new values for the %define parse.error variable offer more control to
  the user.  Available in all the skeletons (C, C++, Java).

**** %define parse.error detailed

  The behavior of "%define parse.error detailed" is closely resembling that
  of "%define parse.error verbose" with a few exceptions.  First, it is safe
  to use non-ASCII characters in token aliases (with 'verbose', the result
  depends on the locale with which bison was run).  Second, a yysymbol_name
  function is exposed to the user, instead of the yytnamerr function and the
  yytname table.  Third, token internationalization is supported (see
  below).

**** %define parse.error custom

  With this directive, the user forges and emits the syntax error message
  herself by defining the yyreport_syntax_error function.  A new type,
  yypcontext_t, captures the circumstances of the error, and provides the
  user with functions to get details, such as yypcontext_expected_tokens to
  get the list of expected token kinds.

  A possible implementation of yyreport_syntax_error is:

    int
    yyreport_syntax_error (const yypcontext_t *ctx)
    {
      int res = 0;
      YY_LOCATION_PRINT (stderr, *yypcontext_location (ctx));
      fprintf (stderr, ": syntax error");
      // Report the tokens expected at this point.
      {
        enum { TOKENMAX = 10 };
        yysymbol_kind_t expected[TOKENMAX];
        int n = yypcontext_expected_tokens (ctx, expected, TOKENMAX);
        if (n < 0)
          // Forward errors to yyparse.
          res = n;
        else
          for (int i = 0; i < n; ++i)
            fprintf (stderr, "%s %s",
                     i == 0 ? ": expected" : " or", yysymbol_name (expected[i]));
      }
      // Report the unexpected token.
      {
        yysymbol_kind_t lookahead = yypcontext_token (ctx);
        if (lookahead != YYSYMBOL_YYEMPTY)
          fprintf (stderr, " before %s", yysymbol_name (lookahead));
      }
      fprintf (stderr, "\n");
      return res;
    }

**** Token aliases internationalization

  When the %define variable parse.error is set to `custom` or `detailed`,
  one may specify which token aliases are to be translated using _().  For
  instance

    %token
        PLUS   "+"
        MINUS  "-"
      <double>
        NUM _("number")
      <symrec*>
        FUN _("function")
        VAR _("variable")

  In that case the user must define _() and N_(), and yysymbol_name returns
  the translated symbol (i.e., it returns '_("variable")' rather that
  '"variable"').  In Java, the user must provide an i18n() function.

*** List of expected tokens (yacc.c)

  Push parsers may invoke yypstate_expected_tokens at any point during
  parsing (including even before submitting the first token) to get the list
  of possible tokens.  This feature can be used to propose autocompletion
  (see below the "bistromathic" example).

  It makes little sense to use this feature without enabling LAC (lookahead
  correction).

*** Returning the error token

  When the scanner returns an invalid token or the undefined token
  (YYUNDEF), the parser generates an error message and enters error
  recovery.  Because of that error message, most scanners that find lexical
  errors generate an error message, and then ignore the invalid input
  without entering the error-recovery.

  The scanners may now return YYerror, the error token, to enter the
  error-recovery mode without triggering an additional error message.  See
  the bistromathic for an example.

*** Deep overhaul of the symbol and token kinds

  To avoid the confusion with types in programming languages, we now refer
  to token and symbol "kinds" instead of token and symbol "types".  The
  documentation and error messages have been revised.

  All the skeletons have been updated to use dedicated enum types rather
  than integral types.  Special symbols are now regular citizens, instead of
  being declared in ad hoc ways.

**** Token kinds

  The "token kind" is what is returned by the scanner, e.g., PLUS, NUMBER,
  LPAREN, etc.  While backward compatibility is of course ensured, users are
  nonetheless invited to replace their uses of "enum yytokentype" by
  "yytoken_kind_t".

  This type now also includes tokens that were previously hidden: YYEOF (end
  of input), YYUNDEF (undefined token), and YYerror (error token).  They
  now have string aliases, internationalized when internationalization is
  enabled.  Therefore, by default, error messages now refer to "end of file"
  (internationalized) rather than the cryptic "$end", or to "invalid token"
  rather than "$undefined".

  Therefore in most cases it is now useless to define the end-of-line token
  as follows:

    %token T_EOF 0 "end of file"

  Rather simply use "YYEOF" in your scanner.

**** Symbol kinds

  The "symbol kinds" is what the parser actually uses.  (Unless the
  api.token.raw %define variable is used, the symbol kind of a terminal
  differs from the corresponding token kind.)

  They are now exposed as a enum, "yysymbol_kind_t".

  This allows users to tailor the error messages the way they want, or to
  process some symbols in a specific way in autocompletion (see the
  bistromathic example below).

*** Modernize display of explanatory statements in diagnostics

  Since Bison 2.7, output was indented four spaces for explanatory
  statements.  For example:

    input.y:2.7-13: error: %type redeclaration for exp
    input.y:1.7-11:     previous declaration

  Since the introduction of caret-diagnostics, it became less clear.  This
  indentation has been removed and submessages are displayed similarly as in
  GCC:

    input.y:2.7-13: error: %type redeclaration for exp
        2 | %type <float> exp
          |       ^~~~~~~
    input.y:1.7-11: note: previous declaration
        1 | %type <int> exp
          |       ^~~~~

  Contributed by Victor Morales Cayuela.

*** C++

  The token and symbol kinds are yy::parser::token_kind_type and
  yy::parser::symbol_kind_type.

  The symbol_type::kind() member function allows to get the kind of a
  symbol.  This can be used to write unit tests for scanners, e.g.,

    yy::parser::symbol_type t = make_NUMBER ("123");
    assert (t.kind () == yy::parser::symbol_kind::S_NUMBER);
    assert (t.value.as<int> () == 123);

** Documentation

*** User Manual

  In order to avoid ambiguities with "type" as in "typing", we now refer to
  the "token kind" (e.g., `PLUS`, `NUMBER`, etc.) rather than the "token
  type".  We now also refer to the "symbol type" (e.g., `PLUS`, `expr`,
  etc.).

*** Examples

  There are now examples/java: a very simple calculator, and a more complete
  one (push-parser, location tracking, and debug traces).

  The lexcalc example (a simple example in C based on Flex and Bison) now
  also demonstrates location tracking.


  A new C example, bistromathic, is a fully featured interactive calculator
  using many Bison features: pure interface, push parser, autocompletion
  based on the current parser state (using yypstate_expected_tokens),
  location tracking, internationalized custom error messages, lookahead
  correction, rich debug traces, etc.

  It shows how to depend on the symbol kinds to tailor autocompletion.  For
  instance it recognizes the symbol kind "VARIABLE" to propose
  autocompletion on the existing variables, rather than of the word
  "variable".