Planet GNU

Aggregation of development blogs from the GNU Project

June 04, 2019

FSF Blogs

A roundup of recent updates to our licensing materials - November 2018 to June 2019

We recently added two new licenses to our list of Various Licenses and Comments about Them and we updated our comments on Creative Commons 0 (CC0). We cleaned up the Free Software Foundation (FSF) Licensing & Compliance Team page and refreshed the materials on it. What follows is a brief rundown on those changes, and how you can learn more about free software licensing.

Personal Public License Version 3a (PPL)

The PPL is a nonfree license based on the GNU General Public License version 3 (GPL). The PPL takes the language of the GPL, but redefines who is a licensee to exclude "Organizations." That means that non profits, governments, and other organizations are not able to enjoy the four freedoms in any software licensed under the PPL.

Free software does not discriminate based on who the user is, or how the user intends to use the software. The PPL falls into the same trap of those who would restrict military or "commercial" use of software. Such restrictions are antithetical to software freedom, so any license with such a term is necessarily a proprietary software license.

Anti-996 License

We added the Anti-996 License to the nonfree list. The "996" in the name refers to a common labor practice in China requiring workers to work from 9:00 am to 9:00 pm, six days a week. The license attempts to ban use of the software by organizations or users that fail to comply with local labor laws or international labor standards. Like the PPL, this restriction on who may use the software renders the license nonfree. Free software never limits the freedom to run the program.

CC0

CC0 is a public domain dedication. If for any reason such dedication is not possible, it has a fallback license meant to ensure virtually the same conditions. But CC0 explicitly does not grant a patent license, making it problematic for use on software. Our entry previously didn't cover this last aspect of the license. We've updated our comments to explain how the patent situation with CC0 works, and to warn users about the issues involved in using software available under the license.

Licensing team updates

As part of our spring cleaning, we made some updates to the overview of our available licensing materials. We welcomed some new team members over the past year, and finally have them included on the FSF Compliance Lab Team page. We made a number of other minor updates, as we're always looking to improve the resources we offer. But if we missed something, or if you would like to see more resources added, let us know by sending us an email at licensing@fsf.org. Here's what else you can do to help:

Thank you to all the FSF associate members and donors who make this important work possible.

04 June, 2019 10:27PM

gengetopt @ Savannah

2.23 released

New version (2.23) was released. Main changes were in build system, so please report any issues you notice.

04 June, 2019 08:41AM by Gray Wolf

June 03, 2019

Andy Wingo

pictie, my c++-to-webassembly workbench

Hello, interwebs! Today I'd like to share a little skunkworks project with y'all: Pictie, a workbench for WebAssembly C++ integration on the web.

loading pictie...

<noscript> JavaScript disabled, no pictie demo. See the pictie web page for more information. </noscript>>&&<&>>>&&><<>>&&<><>>

wtf just happened????!?

So! If everything went well, above you have some colors and a prompt that accepts Javascript expressions to evaluate. If the result of evaluating a JS expression is a painter, we paint it onto a canvas.

But allow me to back up a bit. These days everyone is talking about WebAssembly, and I think with good reason: just as many of the world's programs run on JavaScript today, tomorrow much of it will also be in languages compiled to WebAssembly. JavaScript isn't going anywhere, of course; it's around for the long term. It's the "also" aspect of WebAssembly that's interesting, that it appears to be a computing substrate that is compatible with JS and which can extend the range of the kinds of programs that can be written for the web.

And yet, it's early days. What are programs of the future going to look like? What elements of the web platform will be needed when we have systems composed of WebAssembly components combined with JavaScript components, combined with the browser? Is it all going to work? Are there missing pieces? What's the status of the toolchain? What's the developer experience? What's the user experience?

When you look at the current set of applications targetting WebAssembly in the browser, mostly it's games. While compelling, games don't provide a whole lot of insight into the shape of the future web platform, inasmuch as there doesn't have to be much JavaScript interaction when you have an already-working C++ game compiled to WebAssembly. (Indeed, much of the incidental interactions with JS that are currently necessary -- bouncing through JS in order to call WebGL -- people are actively working on removing all of that overhead, so that WebAssembly can call platform facilities (WebGL, etc) directly. But I digress!)

For WebAssembly to really succeed in the browser, there should also be incremental stories -- what does it look like when you start to add WebAssembly modules to a system that is currently written mostly in JavaScript?

To find out the answers to these questions and to evaluate potential platform modifications, I needed a small, standalone test case. So... I wrote one? It seemed like a good idea at the time.

pictie is a test bed

Pictie is a simple, standalone C++ graphics package implementing an algebra of painters. It was created not to be a great graphics package but rather to be a test-bed for compiling C++ libraries to WebAssembly. You can read more about it on its github page.

Structurally, pictie is a modern C++ library with a functional-style interface, smart pointers, reference types, lambdas, and all the rest. We use emscripten to compile it to WebAssembly; you can see more information on how that's done in the repository, or check the README.

Pictie is inspired by Peter Henderson's "Functional Geometry" (1982, 2002). "Functional Geometry" inspired the Picture language from the well-known Structure and Interpretation of Computer Programs computer science textbook.

prototype in action

So far it's been surprising how much stuff just works. There's still lots to do, but just getting a C++ library on the web is pretty easy! I advise you to take a look to see the details.

If you are thinking of dipping your toe into the WebAssembly water, maybe take a look also at Pictie when you're doing your back-of-the-envelope calculations. You can use it or a prototype like it to determine the effects of different compilation options on compile time, load time, throughput, and network trafic. You can check if the different binding strategies are appropriate for your C++ idioms; Pictie currently uses embind (source), but I would like to compare to WebIDL as well. You might also use it if you're considering what shape your C++ library should have to have a minimal overhead in a WebAssembly context.

I use Pictie as a test-bed when working on the web platform; the weakref proposal which adds finalization, leak detection, and working on the binding layers around Emscripten. Eventually I'll be able to use it in other contexts as well, with the WebIDL bindings proposal, typed objects, and GC.

prototype the web forward

As the browser and adjacent environments have come to dominate programming in practice, we lost a bit of the delightful variety from computing. JS is a great language, but it shouldn't be the only medium for programs. WebAssembly is part of this future world, waiting in potentia, where applications for the web can be written in any of a number of languages. But, this future world will only arrive if it "works" -- if all of the various pieces, from standards to browsers to toolchains to virtual machines, only if all of these pieces fit together in some kind of sensible way. Now is the early phase of annealing, when the platform as a whole is actively searching for its new low-entropy state. We're going to need a lot of prototypes to get from here to there. In that spirit, may your prototypes be numerous and soon replaced. Happy annealing!

03 June, 2019 10:10AM by Andy Wingo

June 01, 2019

unifont @ Savannah

GNU Unifont 12.1.02 Released

1 June 2019 Unifont 12.1.02 is now available. This version introduces a Japanese TrueType version, unifont_jp, replacing over 10,000 ideographs from the default Unifont build with kanji from the public domain Jiskan16 font. This version also contains redrawn Devanagari and Bengali glyphs. Full details are in the ChangeLog file.

Download this release at:

https://ftpmirror.gnu.org/unifont/unifont-12.1.02/

or if that fails,

https://ftp.gnu.org/gnu/unifont/unifont-12.1.02/

or, as a last resort,

ftp://ftp.gnu.org/gnu/unifont/unifont-12.1.02/

01 June, 2019 10:43PM by Paul Hardy

May 30, 2019

FSF Events

Richard Stallman - "The Free Software Movement" (Mayhew, MS)

The Free Software Movement campaigns for computer users' freedom to cooperate and control their own computing. The Free Software Movement developed the GNU operating system, typically used together with the kernel Linux, specifically to make these freedoms possible.

This speech by Richard Stallman will be nontechnical, admission is gratis, and the public is encouraged to attend.

Location: Lyceum, 8731 South Frontage Rd., Mayhew, MS 39753

Please fill out our contact form, so that we can contact you about future events in and around Mayhew.

The event this speech was going to be part of has been cancelled.

30 May, 2019 05:10PM

Richard Stallman - "Free software and your freedom" (Vienna, Austria)

Most computers now contain at least some free software. This success makes it more important than ever to know about the ideas behind free software. Users should be aware of the freedoms it gives us and how to make use of it.
As opposed to secrecy and profit orientation, free access to and sharing of knowledge and ideas have the potential to change the world. Knowledge should be treated as a common good. This revolutionary idea was the base on which GNU/Linux and the free and collaborative encyclopedia Wikipedia were built.

This speech by Richard Stallman will be nontechnical, admission is gratis, and the public is encouraged to attend.

Location: Hall: FS0.01, Fachhochschule FH Technikum Wien, Höchstädtplatz 6, KG Brigittenau, 1200 Wien, Österreich

Please fill out our contact form, so that we can contact you about future events in and around Vienna.

30 May, 2019 04:55PM

May 28, 2019

FSF Blogs

GNU Spotlight with Mike Gerwitz: 18 new GNU releases in May!

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 Wolf as co-maintainer of gengetopt.

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.

28 May, 2019 05:56PM

GNU Guile

Join the Guile and Guix Days in Strasbourg, June 21–22!

We’re organizing Guile Days at the University of Strasbourg, France, co-located with the Perl Workshop, on June 21st and 22nd.

Guile Days 2019

Update: The program is now complete, view the schedule on-line.

The schedule is not complete yet, but we can already announce a couple of events:

  • Getting Started with GNU Guix will be an introductory hands-on session to Guix, targeting an audience of people who have some experience with GNU/Linux but are new to Guix.
  • During a “code buddy” session, experienced Guile programmers will be here to get you started programming in Guile, and to answer questions and provide guidance while you hack at your pace on the project of your choice.

If you’re already a Guile or Guix user or developer, consider submitting by June 8th, on the web site, talks on topics such as:

  • The neat Guile- or Guix-related project you’ve been working on.

  • Cool Guile hacking topics—Web development, databases, system development, graphical user interfaces, shells, you name it!

  • Fancy Guile technology—concurrent programming with Fibers, crazy macrology, compiler front-ends, JIT compilation and Guile 3, development environments, etc.

  • Guixy things: on Guix subsystems, services, the Shepherd, Guile development with Guix, all things OS-level in Guile, Cuirass, reproducible builds, bootstrapping, Mes and Gash, all this!

You can also propose hands-on workshops, which could last anything from an hour to a day. We expect newcomers at this event, people who don’t know Guile and Guix and want to learn about it. Consider submitting introductory workshops on Guile and Guix!

We encourage submissions from people in communities usually underrepresented in free software, including women, people in sexual minorities, or people with disabilities.

We want to make this event a pleasant experience for everyone, and participation is subject to a code of conduct.

Many thanks to the organizers of the Perl Workshop and to the sponsors of the event: RENATER, Université de Strasbourg, X/Stra, and Worteks.

28 May, 2019 09:11AM by Ludovic Courtès (guile-devel@gnu.org)

May 24, 2019

FSF Events

Richard Stallman - "Computing, freedom, and privacy" (Brno, Czech Republic)

The way digital technology is developing, it threatens our freedom, within our computers and in the internet. What are the threats? What must we change?

This speech by Richard Stallman will be nontechnical, admission to just the speech is gratis—provided you register via the FSF link—and the public is encouraged to attend.

Location: Pavilion G1, Digital City Stage, Brno Fair Grounds (BVV), URBIS Smart City Fair, Výstaviště 405/1, 603 00

Please register, so that we can accommodate all the people who wish to attend.

Please fill out our contact form, so that we can contact you about future events in and around Brno.

24 May, 2019 01:35PM

Andy Wingo

lightening run-time code generation

The upcoming Guile 3 release will have just-in-time native code generation. Finally, amirite? There's lots that I'd like to share about that and I need to start somewhere, so this article is about one piece of it: Lightening, a library to generate machine code.

on lightning

Lightening is a fork of GNU Lightning, adapted to suit the needs of Guile. In fact at first we chose to use GNU Lightning directly, "vendored" into the Guile source respository via the git subtree mechanism. (I see that in the meantime, git gained a kind of a subtree command; one day I will have to figure out what it's for.)

GNU Lightning has lots of things going for it. It has support for many architectures, even things like Itanium that I don't really care about but which a couple Guile users use. It abstracts the differences between e.g. x86 and ARMv7 behind a common API, so that in Guile I don't need to duplicate the JIT for each back-end. Such an abstraction can have a slight performance penalty, because maybe it missed the opportunity to generate optimal code, but this is acceptable to me: I was more concerned about the maintenance burden, and GNU Lightning seemed to solve that nicely.

GNU Lightning also has fantastic documentation. It's written in C and not C++, which is the right thing for Guile at this time, and it's also released under the LGPL, which is Guile's license. As it's a GNU project there's a good chance that GNU Guile's needs might be taken into account if any changes need be made.

I mentally associated Paolo Bonzini with the project, who I knew was a good no-nonsense hacker, as he used Lightning for a smalltalk implementation; and I knew also that Matthew Flatt used Lightning in Racket. Then I looked in the source code to see architecture support and was pleasantly surprised to see MIPS, POWER, and so on, so I went with GNU Lightning for Guile in our 2.9.1 release last October.

on lightening the lightning

When I chose GNU Lightning, I had in mind that it was a very simple library to cheaply write machine code into buffers. (Incidentally, if you have never worked with this stuff, I remember a time when I was pleasantly surprised to realize that an assembler could be a library and not just a program that processes text. A CPU interprets machine code. Machine code is just bytes, and you can just write C (or Scheme, or whatever) functions that write bytes into buffers, and pass those buffers off to the CPU. Now you know!)

Anyway indeed GNU Lightning 1.4 or so was that very simple library that I had in my head. I needed simple because I would need to debug any problems that came up, and I didn't want to add more complexity to the C side of Guile -- eventually I should be migrating this code over to Scheme anyway. And, of course, simple can mean fast, and I needed fast code generation.

However, GNU Lightning has a new release series, the 2.x series. This series is a rewrite in a way of the old version. On the plus side, this new series adds all of the weird architectures that I was pleasantly surprised to see. The old 1.4 didn't even have much x86-64 support, much less AArch64.

This new GNU Lightning 2.x series fundamentally changes the way the library works: instead of having a jit_ldr_f function that directly emits code to load a float from memory into a floating-point register, the jit_ldr_f function now creates a node in a graph. Before code is emitted, that graph is optimized, some register allocation happens around call sites and for temporary values, dead code is elided, and so on, then the graph is traversed and code emitted.

Unfortunately this wasn't really what I was looking for. The optimizations were a bit opaque to me and I just wanted something simple. Building the graph took more time than just emitting bytes into a buffer, and it takes more memory as well. When I found bugs, I couldn't tell whether they were related to my usage or in the library itself.

In the end, the node structure wasn't paying its way for me. But I couldn't just go back to the 1.4 series that I remembered -- it didn't have the architecture support that I needed. Faced with the choice between changing GNU Lightning 2.x in ways that went counter to its upstream direction, switching libraries, or refactoring GNU Lightning to be something that I needed, I chose the latter.

in which our protagonist cannot help himself

Friends, I regret to admit: I named the new thing "Lightening". True, it is a lightened Lightning, yes, but I am aware that it's horribly confusing. Pronounced like almost the same, visually almost identical -- I am a bad person. Oh well!!

I ported some of the existing GNU Lightning backends over to Lightening: ia32, x86-64, ARMv7, and AArch64. I deleted the backends for Itanium, HPPA, Alpha, and SPARC; they have no Debian ports and there is no situation in which I can afford to do QA on them. I would gladly accept contributions for PPC64, MIPS, RISC-V, and maybe S/390. At this point I reckon it takes around 20 hours to port an additional backend from GNU Lightning to Lightening.

Incidentally, if you need a code generation library, consider your choices wisely. It is likely that Lightening is not right for you. If you can afford platform-specific code and you need C, Lua's DynASM is probably the right thing for you. If you are in C++, copy the assemblers from a JavaScript engine -- C++ offers much more type safety, capabilities for optimization, and ergonomics.

But if you can only afford one emitter of JIT code for all architectures, you need simple C, you don't need register allocation, you want a simple library to just include in your source code, and you are good with the LGPL, then Lightening could be a thing for you. Check the gitlab page for info on how to test Lightening and how to include it into your project.

giving it a spin

Yesterday's Guile 2.9.2 release includes Lightening, so you can give it a spin. The switch to Lightening allowed us to lower our JIT optimization threshold by a factor of 50, letting us generate fast code sooner. If you try it out, let #guile on freenode know how it went. In any case, happy hacking!

24 May, 2019 08:44AM by Andy Wingo

May 23, 2019

GNU Guile

GNU Guile 2.9.2 (beta) released

We are delighted to announce GNU Guile 2.9.2, the second beta release in preparation for the upcoming 3.0 stable series. See the release announcement for full details and a download link.

This release extends just-in-time (JIT) native code generation support to the ia32, ARMv7, and AArch64 architectures. Under the hood, we swapped out GNU Lightning for a related fork called Lightening, which was better adapted to Guile's needs.

GNU Guile 2.9.2 is a beta release, and as such offers no API or ABI stability guarantees. Users needing a stable Guile are advised to stay on the stable 2.2 series.

Users on the architectures that just gained JIT support are especially encouraged to report experiences (good or bad) to guile-devel@gnu.org. If you know you found a bug, please do send a note to bug-guile@gnu.org. Happy hacking!

23 May, 2019 09:00PM by Andy Wingo (guile-devel@gnu.org)

Andy Wingo

bigint shipping in firefox!

I am delighted to share with folks the results of a project I have been helping out on for the last few months: implementation of "BigInt" in Firefox, which is finally shipping in Firefox 68 (beta).

what's a bigint?

BigInts are a new kind of JavaScript primitive value, like numbers or strings. A BigInt is a true integer: it can take on the value of any finite integer (subject to some arbitrarily large implementation-defined limits, such as the amount of memory in your machine). This contrasts with JavaScript number values, which have the well-known property of only being able to precisely represent integers between -253 and 253.

BigInts are written like "normal" integers, but with an n suffix:

var a = 1n;
var b = a + 42n;
b << 64n
// result: 793209995169510719488n

With the bigint proposal, the usual mathematical operations (+, -, *, /, %, <<, >>, **, and the comparison operators) are extended to operate on bigint values. As a new kind of primitive value, bigint values have their own typeof:

typeof 1n
// result: 'bigint'

Besides allowing for more kinds of math to be easily and efficiently expressed, BigInt also allows for better interoperability with systems that use 64-bit numbers, such as "inodes" in file systems, WebAssembly i64 values, high-precision timers, and so on.

You can read more about the BigInt feature over on MDN, as usual. You might also like this short article on BigInt basics that V8 engineer Mathias Bynens wrote when Chrome shipped support for BigInt last year. There is an accompanying language implementation article as well, for those of y'all that enjoy the nitties and the gritties.

can i ship it?

To try out BigInt in Firefox, simply download a copy of Firefox Beta. This version of Firefox will be fully released to the public in a few weeks, on July 9th. If you're reading this in the future, I'm talking about Firefox 68.

BigInt is also shipping already in V8 and Chrome, and my colleague Caio Lima has an project in progress to implement it in JavaScriptCore / WebKit / Safari. Depending on your target audience, BigInt might be deployable already!

thanks

I must mention that my role in the BigInt work was relatively small; my Igalia colleague Robin Templeton did the bulk of the BigInt implementation work in Firefox, so large ups to them. Hearty thanks also to Mozilla's Jan de Mooij and Jeff Walden for their patient and detailed code reviews.

Thanks as well to the V8 engineers for their open source implementation of BigInt fundamental algorithms, as we used many of them in Firefox.

Finally, I need to make one big thank-you, and I hope that you will join me in expressing it. The road to ship anything in a web browser is long; besides the "simple matter of programming" that it is to implement a feature, you need a specification with buy-in from implementors and web standards people, you need a good working relationship with a browser vendor, you need willing technical reviewers, you need to follow up on the inevitable security bugs that any browser change causes, and all of this takes time. It's all predicated on having the backing of an organization that's foresighted enough to invest in this kind of long-term, high-reward platform engineering.

In that regard I think all people that work on the web platform should send a big shout-out to Tech at Bloomberg for making BigInt possible by underwriting all of Igalia's work in this area. Thank you, Bloomberg, and happy hacking!

23 May, 2019 12:13PM by Andy Wingo

May 22, 2019

parallel @ Savannah

GNU Parallel 20190522 ('Akihito') released

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

GNU Parallel is 10 years old in a year on 2020-04-22. You are here by invited to a reception on Friday 2020-04-17.

See https://www.gnu.org/software/parallel/10-years-anniversary.html

Quote of the month:

Amazingly useful script!
-- unxusr@reddit.com

New in this release:

  • --group-by groups lines depending on value of a column. The value can be computed.
  • How to compress (bzip/gzip) a very large text quickly? https://medium.com/@gchandra/how-to-compress-bzip-gzip-a-very-large-text-quickly-27c11f4c6681
  • Simple tutorial to install & use GNU Parallel https://medium.com/@gchandra/simple-tutorial-to-install-use-gnu-parallel-79251120d618
  • 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.

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 || curl pi.dk/3/ || fetch -o - http://pi.dk/3) | bash

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 May, 2019 08:29PM by Ole Tange

FSF Events

Richard Stallman - "The Free Software Movement" (Brno, Czech Republic)

The Free Software Movement campaigns for computer users' freedom to cooperate and control their own computing. The Free Software Movement developed the GNU operating system, typically used together with the kernel Linux, specifically to make these freedoms possible.

This speech by Richard Stallman will be nontechnical, admission is gratis, and the public is encouraged to attend.

Location: University Cinema Scala, MoravskĂŠ nĂĄm. 127/3, 602 00 Brno, Czech Republic

Registration for this event is now closed. You might still be able to get a seat if you show up, but, to guarantee seating, please consider attending RMS's June 6 morning speech instead.

Please fill out our contact form, so that we can contact you about future events in and around Brno.

22 May, 2019 11:10AM

May 21, 2019

GNU Guix

Creating and using a custom Linux kernel on Guix System

Guix is, at its core, a source based distribution with substitutes, and as such building packages from their source code is an expected part of regular package installations and upgrades. Given this starting point, it makes sense that efforts are made to reduce the amount of time spent compiling packages, and recent changes and upgrades to the building and distribution of substitutes continues to be a topic of discussion within Guix.

One of the packages which I prefer to not build myself is the Linux-Libre kernel. The kernel, while not requiring an overabundance of RAM to build, does take a very long time on my build machine (which my children argue is actually their Kodi computer), and I will often delay reconfiguring my laptop while I want for a substitute to be prepared by the official build farm. The official kernel configuration, as is the case with many GNU/Linux distributions, errs on the side of inclusiveness, and this is really what causes the build to take such a long time when I build the package for myself.

The Linux kernel, however, can also just be described as a package installed on my machine, and as such can be customized just like any other package. The procedure is a little bit different, although this is primarily due to the nature of how the package definition is written.

The linux-libre kernel package definition is actually a procedure which creates a package.

(define* (make-linux-libre version hash supported-systems
                           #:key
                           ;; A function that takes an arch and a variant.
                           ;; See kernel-config for an example.
                           (extra-version #f)
                           (configuration-file #f)
                           (defconfig "defconfig")
                           (extra-options %default-extra-linux-options)
                           (patches (list %boot-logo-patch)))
  ...)

The current linux-libre package is for the 5.1.x series, and is declared like this:

(define-public linux-libre
  (make-linux-libre %linux-libre-version
                    %linux-libre-hash
                    '("x86_64-linux" "i686-linux" "armhf-linux" "aarch64-linux")
                    #:patches %linux-libre-5.1-patches
                    #:configuration-file kernel-config))

Any keys which are not assigned values inherit their default value from the make-linux-libre definition. When comparing the two snippets above, you may notice that the code comment in the first doesn't actually refer to the #:extra-version keyword; it is actually for #:configuration-file. Because of this, it is not actually easy to include a custom kernel configuration from the definition, but don't worry, there are other ways to work with what we do have.

There are two ways to create a kernel with a custom kernel configuration. The first is to provide a standard .config file during the build process by including an actual .config file as a native input to our custom kernel. The following is a snippet from the custom 'configure phase of the make-linux-libre package definition:

(let ((build  (assoc-ref %standard-phases 'build))
      (config (assoc-ref (or native-inputs inputs) "kconfig")))

  ;; Use a custom kernel configuration file or a default
  ;; configuration file.
  (if config
      (begin
        (copy-file config ".config")
        (chmod ".config" #o666))
      (invoke "make" ,defconfig))

Below is a sample kernel package for one of my computers. Linux-Libre is just like other regular packages and can be inherited and overridden like any other:

(define-public linux-libre/E2140
  (package
    (inherit linux-libre)
    (native-inputs
     `(("kconfig" ,(local-file "E2140.config"))
      ,@(alist-delete "kconfig"
                      (package-native-inputs linux-libre))))))

In the same directory as the file defining linux-libre-E2140 is a file named E2140.config, which is an actual kernel configuration file. I left the defconfig keyword of make-linux-libre blank, so the only kernel configuration in the package is the one which I included as a native-input.

The second way to create a custom kernel is to pass a new value to the extra-options keyword of the make-linux-libre procedure. The extra-options keyword works with another function defined right below it:

(define %default-extra-linux-options
  `(;; https://lists.gnu.org/archive/html/guix-devel/2014-04/msg00039.html
   ("CONFIG_DEVPTS_MULTIPLE_INSTANCES" . #t)
   ;; Modules required for initrd:
   ("CONFIG_NET_9P" . m)
   ("CONFIG_NET_9P_VIRTIO" . m)
   ("CONFIG_VIRTIO_BLK" . m)
   ("CONFIG_VIRTIO_NET" . m)
   ("CONFIG_VIRTIO_PCI" . m)
   ("CONFIG_VIRTIO_BALLOON" . m)
   ("CONFIG_VIRTIO_MMIO" . m)
   ("CONFIG_FUSE_FS" . m)
   ("CONFIG_CIFS" . m)
   ("CONFIG_9P_FS" . m)))

(define (config->string options)
  (string-join (map (match-lambda
                      ((option . 'm)
                       (string-append option "=m"))
                      ((option . #t)
                       (string-append option "=y"))
                      ((option . #f)
                       (string-append option "=n")))
                    options)
               "\n"))

And in the custom configure script from the make-linux-libre package:

;; Appending works even when the option wasn't in the
;; file.  The last one prevails if duplicated.
(let ((port (open-file ".config" "a"))
      (extra-configuration ,(config->string extra-options)))
  (display extra-configuration port)
  (close-port port))

(invoke "make" "oldconfig"))))

So by not providing a configuration-file the .config starts blank, and then we write into it the collection of flags that we want. Here's another custom kernel which I have:

(define %macbook41-full-config
  (append %macbook41-config-options
          %filesystems
          %efi-support
          %emulation
          (@@ (gnu packages linux) %default-extra-linux-options)))

(define-public linux-libre-macbook41
  ;; XXX: Access the internal 'make-linux-libre' procedure, which is
  ;; private and unexported, and is liable to change in the future.
  ((@@ (gnu packages linux) make-linux-libre) (@@ (gnu packages linux) %linux-libre-version)
                      (@@ (gnu packages linux) %linux-libre-hash)
                      '("x86_64-linux")
                      #:extra-version "macbook41"
                      #:patches (@@ (gnu packages linux) %linux-libre-5.1-patches)
                      #:extra-options %macbook41-config-options))

From the above example %filesystems is a collection of flags I compiled enabling different filesystem support, %efi-support enables EFI support and %emulation enables my x86_64-linux machine to act in 32-bit mode also. %default-extra-linux-options are the ones quoted above, which had to be added in since I replaced them in the extra-options keyword.

This all sounds like it should be doable, but how does one even know which modules are required for their system? The two places I found most helpful to try to answer this question were the Gentoo Handbook, and the documentation from the kernel itself. From the kernel documentation, it seems that make localmodconfig is the command we want.

In order to actually run make localmodconfig we first need to get and unpack the kernel source code:

tar xf $(guix build linux-libre --source)

Once inside the directory containing the source code run touch .config to create an initial, empty .config to start with. make localmodconfig works by seeing what you already have in .config and letting you know what you're missing. If the file is blank then you're missing everything. The next step is to run:

guix environment linux-libre -- make localmodconfig

and note the output. Do note that the .config file is still empty. The output generally contains two types of warnings. The first start with "WARNING" and can actually be ignored in our case. The second read:

module pcspkr did not have configs CONFIG_INPUT_PCSPKR

For each of these lines, copy the CONFIG_XXXX_XXXX portion into the .config in the directory, and append =m, so in the end it looks like this:

CONFIG_INPUT_PCSPKR=m
CONFIG_VIRTIO=m

After copying all the configuration options, run make localmodconfig again to make sure that you don't have any output starting with "module". After all of these machine specific modules there are a couple more left that are also needed. CONFIG_MODULES is necessary so that you can build and load modules separately and not have everything built into the kernel. CONFIG_BLK_DEV_SD is required for reading from hard drives. It is possible that there are other modules which you will need.

This post does not aim to be a guide to configuring your own kernel however, so if you do decide to build a custom kernel you'll have to seek out other guides to create a kernel which is just right for your needs.

The second way to setup the kernel configuration makes more use of Guix's features and allows you to share configuration segments between different kernels. For example, all machines using EFI to boot have a number of EFI configuration flags that they need. It is likely that all the kernels will share a list of filesystems to support. By using variables it is easier to see at a glance what features are enabled and to make sure you don't have features in one kernel but missing in another.

Left undiscussed however, is Guix's initrd and its customization. It is likely that you'll need to modify the initrd on a machine using a custom kernel, since certain modules which are expected to be built may not be available for inclusion into the initrd.

Suggestions and contributions toward working toward a satisfactory custom initrd and kernel are welcome!

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.

21 May, 2019 10:00AM by Efraim Flashner

FSF Events

Richard Stallman - "Copyright vs Community in the age of computer networks" (Nicosia, Cyprus)

Richard Stallman will be speaking at the Unconference (2019-05-30–06-01).

Copyright developed in the age of the printing press, and was designed to fit with the system of centralized copying imposed by the printing press. But the copyright system does not fit well with computer networks, and only draconian punishments can enforce it.
The global corporations that profit from copyright are lobbying for draconian punishments, and to increase their copyright powers, while suppressing public access to technology. But if we seriously hope to serve the only legitimate purpose of copyright–to promote progress, for the benefit of the public–then we must make changes in the other direction.

This speech will be nontechnical, admission is gratis, and the public is encouraged to attend.

Location: University of Nicosia, Cyprus

Please fill out our contact form, so that we can contact you about future events in and around Nicosia.

21 May, 2019 09:53AM

May 19, 2019

GNU Guix

GNU Guix 1.0.1 released

We are pleased to announce the release of GNU Guix version 1.0.1. This new version fixes bugs in the graphical installer for the standalone Guix System.

The release comes with ISO-9660 installation images, a virtual machine image, and with tarballs to install the package manager on top of your GNU/Linux distro, either from source or from binaries. Guix users can update by running guix pull.

It’s been just over two weeks since we announced 1.0.0—two weeks and 706 commits by 40 people already!

This is primarily a bug-fix release, specifically focusing on issues in the graphical installer for the standalone system:

  • The most embarrassing bug would lead the graphical installer to produce a configuration where %base-packages was omitted from the packages field. Consequently, the freshly installed system would not have the usual commands in $PATHls, ps, etc.—and Xfce would fail to start for that reason. See below for a “post-mortem” analysis.
  • The wpa-supplicant service would sometimes fail to start in the installation image, thereby breaking network access; this is now fixed.
  • The installer now allows you to toggle the visibility of passwords and passphrases, and it no longer restricts their length.
  • The installer can now create Btrfs file systems.
  • network-manager-applet is now part of %desktop-services, and thus readily usable not just from GNOME but also from Xfce.
  • The NEWS file has more details, but there were also minor bug fixes for guix environment, guix search, and guix refresh.

A couple of new features were reviewed in time to make it into 1.0.1:

  • guix system docker-image now produces an OS image with an “entry point”, which makes it easier to use than before.
  • guix system container has a new --network option, allowing the container to share networking access with the host.
  • 70 new packages were added and 483 packages were updated.
  • Translations were updated as usual and we are glad to announce a 20%-complete Russian translation of the manual.

Recap of bug #35541

The 1.0.1 release was primarily motivated by bug #35541, which was reported shortly after the 1.0.0 release. If you installed Guix System with the graphical installer, chances are that, because of this bug, you ended up with a system where all the usual GNU/Linux commands—ls, grep, ps, etc.—were not in $PATH. That in turn would also prevent Xfce from starting, if you chose that desktop environment for your system.

We quickly published a note in the system installation instructions explaining how to work around the issue:

  • First, install packages that provide those commands, along with the text editor of your choice (for example, emacs or vim):

    guix install coreutils findutils grep procps sed emacs vim
  • At this point, the essential commands you would expect are available. Open your configuration file with your editor of choice, for example emacs, running as root:

    sudo emacs /etc/config.scm
  • Change the packages field to add the “base packages” to the list of globally-installed packages, such that your configuration looks like this:

    (operating-system
      ;; … snip …
      (packages (append (list (specification->package "nss-certs"))
                        %base-packages))
      ;; … snip …
      )
  • Reconfigure the system so that your new configuration is in effect:

    guix pull && sudo guix system reconfigure /etc/config.scm

If you already installed 1.0.0, you can perform the steps above to get all these core commands back.

Guix is purely declarative: if you give it an operating system definition where the “base packages” are not available system-wide, then it goes ahead and installs precisely that. That’s exactly what happened with this bug: the installer generated such a configuration and passed it to guix system init as part of the installation process.

Lessons learned

Technically, this is a “trivial” bug: it’s fixed by adding one line to your operating system configuration and reconfiguring, and the fix for the installer itself is also a one-liner. Nevertheless, it’s obviously a serious bug for the impression it gives—this is not the user experience we want to offer. So how did such a serious bug go through unnoticed?

For several years now, Guix has had a number of automated system tests running in virtual machines (VMs). These tests primarily ensure that system services work as expected, but some of them specifically test system installation: installing to a RAID or encrypted device, with a separate /home, using Btrfs, etc. These tests even run on our continuous integration service (search for the “tests.*” jobs there).

Unfortunately, those installation tests target the so-called “manual” installation process, which is scriptable. They do not test the installer’s graphical user interface. Consequently, testing the user interface (UI) itself was a manual process. Our attention was, presumably, focusing more on UI aspects since—so we thought—the actual installation tests were already taken care of by the system tests. That the generated system configuration could be syntactically correct but definitely wrong from a usability viewpoint perhaps didn’t occur to us. The end result is that the issue went unnoticed.

The lesson here is that: manual testing should also look for issues in “unexpected places”, and more importantly, we need automated tests for the graphical UI. The Debian and Guix installer UIs are similar—both using the Newt toolkit. Debian tests its installer using “pre-seeds” (code), which are essentially answers to all the questions and choices the UI would present. We could adopt a similar approach, or we could test the UI itself at a lower level—reading the screen, and simulating key strokes. UI testing is notoriously tricky so we’ll have to figure out how to get there.

Conclusion

Our 1.0 party was a bit spoiled by this bug, and we are sorry that installation was disappointing to those of you who tried 1.0. We hope 1.0.1 will allow you to try and see what declarative and programmable system configuration management is like, because that’s where the real value of Guix System is—the graphical installer is icing on the cake.

Join us on #guix and on the mailing lists!

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.

19 May, 2019 09:30PM by Ludovic Courtès

bison @ Savannah

Bison 3.4 released [stable]

We are happy to announce the release of Bison 3.4.

A particular focus was put on improving the diagnostics, which are now
colored by default, and accurate with multibyte input. Their format was
also changed, and is now similar to GCC 9's diagnostics.

Users of the default backend (yacc.c) can use the new %define variable
api.header.include to avoid duplicating the content of the generated header
in the generated parser. There are two new examples installed, including a
reentrant calculator which supports recursive calls to the parser and
Flex-generated scanner.

See below for more details.

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

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.

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

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

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

Here are the GPG detached signatures[*]:
https://ftp.gnu.org/gnu/bison/bison-3.4.tar.gz.sig
https://ftp.gnu.org/gnu/bison/bison-3.4.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.4.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.1
Flex 2.6.4
Gettext 0.19.8.1
Gnulib v0.1-2563-gd654989d8

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

NEWS

19 May, 2019 10:01AM by Akim Demaille

May 16, 2019

FSF News

Six more devices from ThinkPenguin, Inc. now FSF-certified to Respect Your Freedom

This is ThinkPenguin's second batch of devices to receive RYF certification this spring. The FSF announced certification of seven other devices from ThinkPenguin on March 21st. This latest collection of devices makes ThinkPenguin the retailer with the largest catalog of RYF-certified devices.

"It's unfortunate that so many of even the simplest devices out there have surprise proprietary software requirements. RYF is an antidote for that. It connects ethical shoppers concerned about their freedom with companies offering options respecting that freedom," said the FSF's executive director, John Sullivan.

Today's certifications expands the availability of RYF-certified peripheral devices. The Penguin USB 2.0 External USB Stereo Sound Adapter and the 5.1 Channels 24-bit 96KHz PCI Express Audio Sound Card help users get the most of their computers in terms of sound quality. For wireless connectivity, ThinkPenguin offers the Wireless N PCI Express Dual-Band Mini Half-Height Card and Penguin Wireless N Mini PCIe Card. For users with an older printer, the USB to Parallel Printer Cable can let them continue to use it with their more current hardware. Finally, the PCIe eSATA / SATA 6Gbps Controller Card help users to connect to external eSATA devices as well as internal SATA.

"I've spent the last 14 years working on projects aimed at making free software adoption easy for everyone, but the single greatest obstacle over the past 20 years has not been software. It's been hardware. The RYF program helps solve this problem by linking users to trustworthy sources where they can get hardware guaranteed to work on GNU/Linux, and be properly supported using free software," said Christopher Waid, founder and CEO of ThinkPenguin.

While ThinkPenguin has consistently sought certification since the inception of the RYF program -- gaining their first certification in 2013, and adding several more over the years since -- the pace at which they are gaining certifications now eclipses all past efforts.

"ThinkPenguin continues to impress with the rapid expansion of their catalog of RYF-certified devices. Adding 14 new devices in a little over a month shows their dedication to the RYF certification program and the protection of users it represents," said the FSF's licensing and compliance manager, Donald Robertson, III.

To learn more about the Respects Your Freedom certification program, including details on the certification of these ThinkPenguin devices, please visit https://fsf.org/ryf.

Retailers interested in applying for certification can consult https://www.fsf.org/resources/hw/endorsement/criteria.

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.

About ThinkPenguin, Inc.

Started by Christopher Waid, founder and CEO, ThinkPenguin, Inc., is a consumer-driven company with a mission to bring free software to the masses. At the core of the company is a catalog of computers and accessories with broad support for GNU/Linux. The company provides technical support for end-users and works with the community, distributions, and upstream projects to make GNU/Linux all that it can be.

Media Contacts

Donald Robertson, III
Licensing and Compliance Manager
Free Software Foundation
+1 (617) 542 5942
licensing@fsf.org

ThinkPenguin, Inc.
+1 (888) 39 THINK (84465) x703
media@thinkpenguin.com

16 May, 2019 05:44PM

May 13, 2019

FSF Blogs

LibrePlanet 2019 videos now live!

At the LibrePlanet 2019 conference, the Free Software Foundation (FSF) recorded 40 speaker sessions -- over 24 hours of video, and they are now online on our GNU MediaGoblin instance.

The FSF team put their heads together and selected a few of our favorites from the entire 2019 Libreplanet program for you to start with -- brought to you in a Digital Restrictions Management (DRM)-free, downloadable, free format.

  • In their talk, entitled "Sharing global opportunities for new developers in the Wikipedia community," Srishti Sethi gave us some valuable insights into how you can get involved in the Wikipedia community.

  • Amanda Sopkin's talk, "The secret battle of encryption algorithms," delved into the history of encryption, with lots of fun factoids about how encryption methods were invented, used and foiled.

  • Martha Esperilla and StefanĂ­a Acevedo joined us from Hackerspace Rancho ElectrĂłnico, sharing their work in building community around their work, including CoAA TV, an online audiovisual archive.

  • In "GPL enforcement and customer benefits: Evidence from OpenWRT," Do Yoon Kim explained to us how his research shows that free software wireless routers are valued higher and sell better.

  • Mary Kate Fain asked us "What free software can learn from successful social movements," and answered this question by sharing experiences as a grassroots organizer and as a free software activist.

  • Free Software Award winners OpenStreetMap and Deb Nicholson both shared their work talking about "OpenStreetMap" mapping developments, and the free software community challenges we face in "Free software/utopia," respectively.

These are just a few of the interesting and varied subjects discussed at the LibrePlanet 2019 conference. Please have a look at the entire collection of 2019 videos and photos for hours of viewing pleasure. And if you really can't get enough, you can scroll down to the archives, where you can revisit the 2018 videos and photos, and much more.

All the LibrePlanet 2019 videos were created using free software, with high resolution USB Web cameras and USB audio mixing desks, whose drivers are supported by Trisquel. We want to thank everyone who participated in LibrePlanet 2019, plus our sponsor, Red Hat, and you too, for your continued support of free software, the FSF, and LibrePlanet.

We look forward to welcoming you again in 2020!

13 May, 2019 08:35PM

May 12, 2019

GNUnet News

2019-05-12: GNUnet 0.11.4 released

2019-05-12: GNUnet 0.11.4 released

We are pleased to announce the release of GNUnet 0.11.4.

This is a bugfix release for 0.11.3, mostly fixing minor bugs, improving documentation and fixing various build issues. In terms of usability, users should be aware that there are still a large number of known open issues in particular with respect to ease of use, but also some critical privacy issues especially for mobile users. Also, the nascent network is tiny (about 200 peers) and thus unlikely to provide good anonymity or extensive amounts of interesting information. As a result, the 0.11.4 release is still only suitable for early adopters with some reasonable pain tolerance.

Download links

(gnunet-gtk and gnunet-fuse were not released again, as there were no changes and the 0.11.0 versions are expected to continue to work fine with gnunet-0.11.4.)

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/

Note that GNUnet is now started using gnunet-arm -s. GNUnet should be stopped using gnunet-arm -e.

Noteworthy changes in 0.11.4

  • gnunet-arm -s no longer logs into the console by default and instead into a logfile (in $GNUNET_HOME).
  • The reclaim subsystem is no longer experimental. Further, the internal encryption scheme moved from ABE to GNS-style encryption.
  • GNUnet now depends on a more recent version of libmicrohttpd.
  • The REST API now includes read-only access to the configuration.
  • All manpages are now in mdoc format.
  • gnunet-download-manager.scm removed.

Known Issues

  • There are known major design issues in the TRANSPORT, ATS and CORE subsystems which will need to be addressed in the future to achieve acceptable usability, performance and security.
  • There are known moderate implementation limitations in CADET that negatively impact performance. Also CADET may unexpectedly deliver messages out-of-order.
  • There are known moderate design issues in FS that also impact usability and performance.
  • There are minor implementation limitations in SET that create unnecessary attack surface for availability.
  • The RPS subsystem remains experimental.
  • Some high-level tests in the test-suite fail non-deterministically due to the low-level TRANSPORT issues.

In addition to this list, you may also want to consult our bug tracker at bugs.gnunet.org which lists about 190 more specific issues.

Thanks

This release was the work of many people. The following people contributed code and were thus easily identified: ng0, Christian Grothoff, Hartmut Goebel, Martin Schanzenbach, Devan Carpenter, Naomi Phillips and Julius Bünger.

12 May, 2019 03:53PM

May 11, 2019

unifont @ Savannah

Unifont 12.1.01 Released

11 May 2019 Unifont 12.1.01 is now available. Significant changes in this version include the Reiwa Japanese era glyph (U+32FF), which was the only addition made in the Unicode 12.1.0 release of 7 May 2019; Rebecca Bettencourt has contributed many Under ConScript Uniocde Registry (UCSUR) scripts; and David Corbett and Johnnie Weaver modified glyphs in two Plane 1 scripts. Full details are in the ChangeLog file.

Download this release at:

https://ftpmirror.gnu.org/unifont/unifont-12.1.01/

or if that fails,

https://ftp.gnu.org/gnu/unifont/unifont-12.1.01/

or, as a last resort,

ftp://ftp.gnu.org/gnu/unifont/unifont-12.1.01/

11 May, 2019 08:59PM by Paul Hardy

remotecontrol @ Savannah

May 10, 2019

FSF Blogs

GNU Guix 1.0.0 released

guix logo

On May 2, the GNU Guix project announced the release of version 1.0 of the Guix software manager. Since the project’s beginnings a little more than seven years ago, nearly 300 volunteers from all over the world have contributed more than 50,000 improvements. Guix now provides a huge collection of bit-reproducible free software packages consisting of close to 10,000 applications and libraries from a wide range of categories, including gaming, music production, video editing, programming, and specialized scientific software.

What distinguishes Guix from other free software distributions is that it is designed with reproducibility in mind. It builds packages in controlled environments to ensure that the results are bit for bit the same no matter when or where packages are built. This means that users can easily deploy the very same software environment or even the very same operating system, at different points in time or on different machines. Reproducibility provides strong assurances that are of fundamental value for security, for the use of software in computational science, and for user freedom.

guix scope

While Guix offers package management features such as transactional upgrades, safe roll-backs, and per-user profiles, package management is just one special case of its general facilities for reproducible, declarative software environment management. Guix bends the notion of a traditional package manager by extending these features to building systems: lightweight containers, Docker images, virtual machine images or bare-metal operating systems -- Guix specifies a flexible, programmable configuration framework for reproducible software deployment at every level. With Guix’s simple, well-documented extension to the general purpose language Scheme, users and developers alike can easily declare custom packages and package variants, compose and inspect arbitrarily complex software environments, and generate full operating systems with minimal effort -- Guix is designed to be hackable!

Whether you’re a software developer, a user, or a free software enthusiast, we hope GNU Guix will provide you with the tools to deploy and manage software with confidence and ease, qualities that are not usually associated with software deployment. The Guix community would love to hear from you!

The FSF supports the work of GNU Guix through its Working Together for Free Software fund. Make a contribution here!

10 May, 2019 02:40PM

May 09, 2019

gettext @ Savannah

GNU gettext 0.20 released

Download from https://ftp.gnu.org/pub/gnu/gettext/gettext-0.20.tar.gz

New in this release:

  • Support for reproducible builds:

- msgfmt now eliminates the POT-Creation-Date header field from .mo files.

  • Improvements for translators:

- update-po target in Makefile.in.in now uses msgmerge --previous.

  • Improvements for maintainers:

- msgmerge now has an option --for-msgfmt, that produces a PO file meant for use by msgfmt only. This option saves processing time, in particular by omitting fuzzy matching that is not useful in this situation.
- The .pot file in a 'po' directory is now erased by "make maintainer-clean".
- It is now possible to override xgettext options from the po/Makefile.in.in through options in XGETTEXT_OPTIONS (declared in po/Makevars).
- The --intl option of the gettextize program (deprecated since 2010) is no longer available. Instead of including the intl sources in your package, we suggest making the libintl library an optional prerequisite of your package. This will simplify the build system of your package.
- Accordingly, the Autoconf macro AM_GNU_GETTEXT_INTL_SUBDIR is gone as well.

  • Programming languages support:

- C, C++:
xgettext now supports strings in u8"..." syntax, as specified in C11 and C++11.
- C, C++:
xgettext now supports 'p'/'P' exponent markers in number tokens, as specified in C99 and C++17.
- C++:
xgettext now supports underscores in number tokens.
- C++:
xgettext now supports single-quotes in number tokens, as specified in C++14.
- Shell:
o The programs 'gettext', 'ngettext' now support a --context argument.
o gettext.sh contains new function eval_pgettext and eval_npgettext for producing translations of messages with context.
- Java:
o xgettext now supports UTF-8 encoded .properties files (a new feature of Java 9).
o The build system and tools now support Java 9, 10, and 11. On the other hand, support for old versions of Java (Java 5 and older, GCJ 4.2.x and older) has been dropped.
- Perl:
o Native support for context functions (pgettext, dpgettext, dcpgettext, npgettext, dnpgettext, dcnpgettext).
o better detection of question mark and slash as operators (as opposed to regular expression delimiters).
- Scheme:
xgettext now parses the syntax for specialized byte vectors (#u8(...), #vu8(...), etc.) correctly.
- Pascal:
xgettext can now extract strings from .rsj files, produced by the Free Pascal compiler version 3.0.0 or newer.
- Vala:
xgettext now parses escape sequences in strings more accurately.
- JavaScript:
xgettext now parses template literals correctly.

  • Runtime behaviour:

- The interpretation of the language preferences on macOS has been fixed.
- Per-thread locales are now also supported on Solaris 11.4.
- The replacements for the printf()/fprintf()/... functions that are provided through <libintl.h> on native Windows and NetBSD are now POSIX compliant. There is no conflict any more between these replacements and other possible replacements provided by gnulib or mingw.

  • Libtextstyle:

- This package installs a new library 'libtextstyle', together with a new header file <textstyle.h>. It is a library for styling text output sent to a console or terminal emulator. Packagers: please see the suggested packaging hints in the file PACKAGING.

09 May, 2019 02:15AM by Bruno Haible

May 07, 2019

cssc @ Savannah

CSSC-1.4.1 released

07 May, 2019 08:27PM by James Youngman

May 02, 2019

GNU Guix

GNU Guix 1.0.0 released

We are excited to announce the release of GNU Guix version 1.0.0!

The release comes with ISO-9660 installation images, a virtual machine image, and with tarballs to install the package manager on top of your GNU/Linux distro, either from source or from binaries. Guix users can update by running guix pull.

Guix 1.0!

One-point-oh always means a lot for free software releases. For Guix, 1.0 is the result of seven years of development, with code, packaging, and documentation contributions made by 260 people, translation work carried out by a dozen of people, and artwork and web site development by a couple of individuals, to name some of the activities that have been happening. During those years we published no less than 19 “0.x” releases.

The journey to 1.0

We took our time to get there, which is quite unusual in an era where free software moves so fast. Why did we take this much time? First, it takes time to build a community around a GNU/Linux distribution, and a distribution wouldn’t really exist without it. Second, we feel like we’re contributing an important piece to the GNU operating system, and that is surely intimidating and humbling.

Last, we’ve been building something new. Of course we stand on the shoulders of giants, and in particular Nix, which brought the functional software deployment paradigm that Guix implements. But developing Guix has been—and still is!—a challenge in many ways: it’s a programming language design challenge, an operating system design challenge, a challenge for security, reproducibility, bootstrapping, usability, and more. In other words, it’s been a long but insightful journey! :-)

What GNU Guix can do for you

Presumably some of the readers are discovering Guix today, so let’s recap what Guix can do for you as a user. Guix is a complete toolbox for software deployment in general, which makes it different from most of the tools you may be familiar with.

Guix manages packages, environments, containers, and systems.

This may sound a little abstract so let’s look at concrete use cases:

  • As a user, Guix allows you to install applications and to keep them up-to-date: search for software with guix search, install it with guix install, and maintain it up-to-date by regularly running guix pull and guix upgrade. Guix follows a so-called “rolling release” model, so you can run guix pull at any time to get the latest and greatest bits of free software.

    This certainly sounds familiar, but a distinguishing property here is dependability: Guix is transactional, meaning that you can at any time roll back to a previous “generation” of your package set with guix package --roll-back, inspect differences with guix package -l, and so on.

    Another useful property is reproducibility: Guix allows you to deploy the exact same software environment on different machines or at different points in time thanks to guix describe and guix pull.

    This, coupled with the fact that package management operations do not require root access, is invaluable notably in the context of high-performance computing (HPC) and reproducible science, which the Guix-HPC effort has been focusing on.

  • As a developer, we hope you’ll enjoy guix environment, which allows you to spawn one-off software environments. Suppose you’re a GIMP developer: running guix environment gimp spawns a shell with everything you need to hack on GIMP—much quicker than manually installing its many dependencies.

    Developers often struggle to push their work to users so they get quick feedback. The guix pack provides an easy way to create container images for use by Docker & co., or even standalone relocatable tarballs that anyone can run, regardless of the GNU/Linux distribution they use.

    Oh, and you may also like package transformation options, which allow you define package variants from the command line.

  • As a system administrator—and actually, we’re all system administrators of sorts on our laptops!—, Guix’s declarative and unified approach to configuration management should be handy. It surely is a departure from what most people are used to, but it is so reassuring: one configuration file is enough to specify all the aspects of the system config—services, file systems, locale, accounts—all in the same language.

    That makes it surprisingly easy to deploy otherwise complex services such as applications that depend on Web services. For instance, setting up CGit or Zabbix is a one-liner, even though behind the scenes that involves setting up nginx, fcgiwrap, etc. We’d love to see to what extent this helps people self-host services—sort of similar to what FreedomBox and YunoHost have been focusing on.

    With guix system you can instantiate a configuration on your machine, or in a virtual machine (VM) where you can test it, or in a container. You can also provision ISO images, VM images, or container images with a complete OS, from the same config, all with guix system.

The quick reference card shows the important commands. As you start diving deeper into Guix, you’ll discover that many aspects of the system are exposed using consistent Guile programming interfaces: package definitions, system services, the “init” system, and a whole bunch of system-level libraries. We believe that makes the system very hackable, and we hope you’ll find it as much fun to play with as we do.

So much for the overview!

What’s new since 0.16.0

For those who’ve been following along, a great many things have changed over the last 5 months since the 0.16.0 release—99 people contributed over 5,700 commits during that time! Here are the highlights:

  • The ISO installation image now runs a cute text-mode graphical installer—big thanks to Mathieu Othacehe for writing it and to everyone who tested it and improved it! It is similar in spirit to the Debian installer. Whether you’re a die-hard GNU/Linux hacker or a novice user, you’ll certainly find that this makes system installation much less tedious than it was! The installer is fully translated to French, German, and Spanish.
  • The new VM image better matches user expectations: whether you want to tinker with Guix System and see what it’s like, or whether you want to use it as a development environment, this VM image should be more directly useful.
  • The user interface was improved: aliases for common operations such as guix search and guix install are now available, diagnostics are now colorized, more operations show a progress bar, there’s a new --verbosity option recognized by all commands, and most commands are now “quiet” by default.
  • There’s a new --with-git-url package transformation option, that goes with --with-branch and --with-commit.
  • Guix now has a first-class, uniform mechanism to configure keyboard layout—a long overdue addition. Related to that, Xorg configuration has been streamlined with the new xorg-configuration record.
  • We introduced guix pack -R a while back: it creates tarballs containing relocatable application bundles that rely on user namespaces. Starting from 1.0, guix pack -RR (like “reliably relocatable”?) generates relocatable binaries that fall back to PRoot on systems where user namespaces are not supported.
  • More than 1,100 packages were added, leading to close to 10,000 packages, 2,104 packages were updated, and several system services were contributed.
  • The manual has been fully translated to French, the German and Spanish translations are nearing completion, and work has begun on a Simplified Chinese translation. You can help translate the manual into your language by joining the Translation Project.

That’s a long list already, but you can find more details in the NEWS file.

What’s next?

One-point-oh is a major milestone, especially for those of us who’ve been on board for several years. But with the wealth of ideas we’ve been collecting, it’s definitely not the end of the road!

If you’re interested in “devops” and distributed deployment, you will certainly be happy to help in that area, those interested in OS development might want to make the Shepherd more flexible and snappy, furthering integration with Software Heritage will probably be #1 on the to-do list of scientists concerned with long-term reproducibility, programming language tinkerers may want to push G-expressions further, etc. Guix 1.0 is a tool that’s both serviceable for one’s day-to-day computer usage and a great playground for the tinkerers among us.

Whether you want to help on design, coding, maintenance, system administration, translation, testing, artwork, web services, funding, organizing a Guix install party… your contributions are welcome!

We’re humans—don’t hesitate to get in touch with us, and enjoy Guix 1.0!

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.

02 May, 2019 02:00PM by Ludovic Courtès

April 26, 2019

FSF Blogs

GNU Spotlight with Mike Gerwitz: 15 new GNU releases in April!

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 Tom Tromey as comaintainer of src-hilight and Abhilash Raj as comaintainer of mailman.

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.

26 April, 2019 04:53PM

April 24, 2019

dico @ Savannah

Version 2.9

Version 2.9 of GNU dico is available from download from the GNU archive and from its main archive site.

This version fixes compilation on 32-bit systems.

24 April, 2019 06:57AM by Sergey Poznyakoff

rush @ Savannah

Version 1.9

Version 1.9 is available for download from GNU and Puszcza archives. It should soon become available in the mirrors too.

New in this version:

Backreference expansion

Arguments to tranformations, chroot and chdir statements can contain references to parenthesized groups in the recent regular expression match. Such references are replaced with the strings that matched the corresponding groups. Syntactically, a backreference expansion is a percent sign followed by one-digit number of the subexpression (1-based, %0 refers to entire matched line). For example

User-defined variables

The configuration file can define new variables or redefine the built-in ones using the setvar statement:

Here, VAR is the variable name, and PATTERN is its new value. The PATTERN is subject to variable and backreference expansion.

User-defined variables can be unset using the "unsetvar" statement:

Unsetting a built-in variable, previously redefined using the setvar statement causes the user-supplied definition to be forgotten and the built-in one restored.

Shell-like variable expansion

The following shell-like notations are supported:

New script rush-po for extracting translatable strings from the configuration

The script rush-po.awk that was used in prior versions has been withdrawn.

24 April, 2019 06:02AM by Sergey Poznyakoff

April 23, 2019

remotecontrol @ Savannah

How hacking threats spurred secret U.S. blacklist

U.S. energy regulators are pursuing a risky plan to share with electric utilities a secret "don't buy" list of foreign technology suppliers, according to multiple sources.

https://www.eenews.net/stories/1060176111

23 April, 2019 09:38PM by Stephen H. Dawson DSL

gnustep @ Savannah

April 21, 2019

parallel @ Savannah

GNU Parallel 20190422 ('Invitation') released [stable]

GNU Parallel 20190422 ('Invitation') [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.

Invitation to 10 year reception

GNU Parallel is 10 years old in a year on 2020-04-22. You are here by invited to a reception on Friday 2020-04-17.

The primary reception will be held in Copenhagen, DK. Please reserve the date and email happybirthdaygnuparallel@tange.dk if you want to join.

If you cannot make it, you are encouraged to host a parallel party.

So far we hope to have parallel parties at:

If you want to host a party held in parallel (either in this or in a parallel universe), please let me know, so it can be announced.

If you have parallel ideas for how to celebrate GNU Parallel, please post on the email list parallel@gnu.org. So far we have the following ideas:

  • Use GNU Parallel logo (the café wall illusion) as decoration everywhere - preferably in a moving version where the bars slide. Maybe we can borrow this https://www.youtube.com/watch?v=_XFDnFLqRFE or make an animation in javascript based on https://bl.ocks.org/Fil/13177d3c911fb8943cb0013086469b87? Other illusions might be fun, too.
  • Only serve beverages in parallel (2 or more), which may or may not be the same kind of beverage, and may or may not be served to the same person, and may or may not be served by multiple waiters in parallel
  • Let people drink in parallel with straws (2 or more straws)
  • Serve popcorn as snack (funny because cores and kernels are the same word in Danish, and GNU Parallel keeps cores hot)
  • Serve saltstænger and similar parallel snacks.
  • Serve (snack friendly) cereal ("serial") in parallel bowls.
  • Live parallel streaming from parallel parties
  • Play songs in parallel that use the same 4 chords: https://www.youtube.com/watch?v=5pidokakU4I
  • Play songs named parallel, serial, mutex, race condition and similar
  • Have RC racing cars to demonstrate race condition
  • Put a counting semaphore on the toilets
  • Only let people leave one at a time to simulate serialized output - UNLESS they swap some clothing (to simulate half line mixing)

If you have interesting stories about or uses of GNU Parallel, please post them, so can be part of the anniversary update.

Quote of the month:

Y'all need some GNU parallel in your lives
-- ChaKu @ChaiLovesChai@twitter

New in this release:

  • Invitation to the 10 years anniversary next year.
  • 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.

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 || curl pi.dk/3/ || fetch -o - http://pi.dk/3) | bash

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.

21 April, 2019 06:20PM by Ole Tange

April 17, 2019

gnuastro @ Savannah

Gnuastro 0.9 released

The 9th release of GNU Astronomy Utilities (Gnuastro) is now available for download. Please see the announcement for details.

17 April, 2019 05:54PM by Mohammad Akhlaghi

April 14, 2019

GNU Hackers Meeting

Malfunction in ghm-planning (at) gnu.org

Due to a problem in the alias configuration, mails sent to ghm-planning before Sun Apr 14 8:00 CEST have been silently dropped.

If you sent a registration email and/or a talk proposal for the GHM 2019, please resend it.

Sorry for the inconvenience!

14 April, 2019 07:56AM by Jose E. Marchesi

April 12, 2019

GNU Hackers' Meeting 2019 in Madrid

Twelve years after it's first edition in Orense, the GHM is back to Spain! This time, we will be gathering in the nice city of Madrid for hacking, learning and meeting each other.

The event will have place from Wednesday 4 September to Friday 6
September, 2019.

Please visit http://www.gnu.org/ghm/2019 for more information on the venue and instructions on how to register and propose talks.

The website will be updated as we complete the schedule and the organizational details, so stay tuned!

12 April, 2019 08:03PM by Jose E. Marchesi

April 04, 2019

GNUnet News

2019-04-04: GNUnet 0.11.2 released

2019-04-04: GNUnet 0.11.2 released

We are pleased to announce the release of GNUnet 0.11.2.

This is a bugfix release for 0.11.0, mostly fixing minor bugs, improving documentation and fixing various build issues. In terms of usability, users should be aware that there are still a large number of known open issues in particular with respect to ease of use, but also some critical privacy issues especially for mobile users. Also, the nascent network is tiny (about 200 peers) and thus unlikely to provide good anonymity or extensive amounts of interesting information. As a result, the 0.11.2 release is still only suitable for early adopters with some reasonable pain tolerance.

Download links

(gnunet-gtk and gnunet-fuse were not released again, as there were no changes and the 0.11.0 versions are expected to continue to work fine with gnunet-0.11.2.)

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/

Note that GNUnet is now started using gnunet-arm -s. GNUnet should be stopped using gnunet-arm -e.

Noteworthy changes in 0.11.2

  • gnunet-qr was rewritten in C, removing our last dependency on Python 2.x
  • REST and GNS proxy configuration options for address binding were added
  • gnunet-publish by default no longer includes creation time
  • Unreliable message ordering logic in CADET was fixed
  • Various improvements to build system and documentation

The above is just the short list, our bugtracker lists 14 individual issues that were resolved since 0.11.0.

Known Issues

  • There are known major design issues in the TRANSPORT, ATS and CORE subsystems which will need to be addressed in the future to achieve acceptable usability, performance and security.
  • There are known moderate implementation limitations in CADET that negatively impact performance. Also CADET may unexpectedly deliver messages out-of-order.
  • There are known moderate design issues in FS that also impact usability and performance.
  • There are minor implementation limitations in SET that create unnecessary attack surface for availability.
  • The RPS subsystem remains experimental.
  • Some high-level tests in the test-suite fail non-deterministically due to the low-level TRANSPORT issues.

In addition to this list, you may also want to consult our bug tracker at bugs.gnunet.org which lists about 190 more specific issues.

Thanks

This release was the work of many people. The following people contributed code and were thus easily identified: ng0, Christian Grothoff, Hartmut Goebel, Martin Schanzenbach, Devan Carpenter, Naomi Phillips and Julius Bünger.

04 April, 2019 01:00PM

April 03, 2019

2019-04-03: GNUnet 0.11.1 released

2019-04-03: GNUnet 0.11.1 released

We are pleased to announce the release of GNUnet 0.11.1.

This is a bugfix release for 0.11.0, mostly fixing minor bugs, improving documentation and fixing various build issues. In terms of usability, users should be aware that there are still a large number of known open issues in particular with respect to ease of use, but also some critical privacy issues especially for mobile users. Also, the nascent network is tiny (about 200 peers) and thus unlikely to provide good anonymity or extensive amounts of interesting information. As a result, the 0.11.1 release is still only suitable for early adopters with some reasonable pain tolerance.

Download links

(gnunet-gtk and gnunet-fuse were not released again, as there were no changes and the 0.11.0 versions are expected to continue to work fine with gnunet-0.11.1.)

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/

Note that GNUnet is now started using gnunet-arm -s. GNUnet should be stopped using gnunet-arm -e.

Noteworthy changes in 0.11.1

  • gnunet-qr was rewritten in C, removing our last dependency on Python 2.x
  • REST and GNS proxy configuration options for address binding were added
  • gnunet-publish by default no longer includes creation time
  • Unreliable message ordering logic in CADET was fixed
  • Various improvements to build system and documentation

The above is just the short list, our bugtracker lists 14 individual issues that were resolved since 0.11.0.

Known Issues

  • There are known major design issues in the TRANSPORT, ATS and CORE subsystems which will need to be addressed in the future to achieve acceptable usability, performance and security.
  • There are known moderate implementation limitations in CADET that negatively impact performance. Also CADET may unexpectedly deliver messages out-of-order.
  • There are known moderate design issues in FS that also impact usability and performance.
  • There are minor implementation limitations in SET that create unnecessary attack surface for availability.
  • The RPS subsystem remains experimental.
  • Some high-level tests in the test-suite fail non-deterministically due to the low-level TRANSPORT issues.

In addition to this list, you may also want to consult our bug tracker at bugs.gnunet.org which lists about 190 more specific issues.

Thanks

This release was the work of many people. The following people contributed code and were thus easily identified: ng0, Christian Grothoff, Hartmut Goebel, Martin Schanzenbach, Devan Carpenter, Naomi Phillips and Julius Bünger.

03 April, 2019 04:00PM

March 29, 2019

GNU Guix

Connecting reproducible deployment to a long-term source code archive

GNU Guix can be used as a “package manager” to install and upgrade software packages as is familiar to GNU/Linux users, or as an environment manager, but it can also provision containers or virtual machines, and manage the operating system running on your machine.

One foundation that sets it apart from other tools in these areas is reproducibility. From a high-level view, Guix allows users to declare complete software environments and instantiate them. They can share those environments with others, who can replicate them or adapt them to their needs. This aspect is key to reproducible computational experiments: scientists need to reproduce software environments before they can reproduce experimental results, and this is one of the things we are focusing on in the context of the Guix-HPC effort. At a lower level, the project, along with others in the Reproducible Builds community, is working to ensure that software build outputs are reproducible, bit for bit.

Work on reproducibility at all levels has been making great progress. Guix, for instance, allows you to travel back in time. That Guix can travel back in time and build software reproducibly is a great step forward. But there’s still an important piece that’s missing to make this viable: a stable source code archive. This is where Software Heritage (SWH for short) comes in.

When source code vanishes

Guix contains thousands of package definitions. Each package definition specifies the package’s source code URL and hash, the package’s dependencies, and its build procedure. Most of the time, the package’s source code is an archive (a “tarball”) fetched from a web site, but more and more frequently the source code is a specific revision checked out directly from a version control system.

The obvious question, then, is: what happens if the source code URL becomes unreachable? The whole reproducibility endeavor collapses when source code disappears. And source code does disappear, or, even worse, it can be modified in place. At GNU we’re doing a good job of having stable hosting that keeps releases around “forever”, unchanged (modulo rare exceptions). But a lot of free software out there is hosted on personal web pages with a short lifetime and on commercial hosting services that come and go.

By default Guix would look up source code by hash in the caches of our build farms. This comes for free: the “substitute” mechanism extends to all “build artifacts”, including downloads. However, with limited capacity, our build farms do not keep all the source code of all the packages for a long time. Thus, one could very well find oneself unable to rebuild a package months or years later, simply because its source code disappeared or moved to a different location.

Connecting to the archive

It quickly became clear that reproducible builds had “reproducible source code downloads”, so to speak, as a prerequisite. The Software Heritage archive is the missing piece that would finally allow us to reproduce software environments years later in spite of the volatility of code hosting sites. Software Heritage’s mission is to archive essentially “all” the source code ever published, including version control history. Its archive already periodically ingests release tarballs from the GNU servers, repositories from GitHub, packages from PyPI, and much more.

Software Heritage logo

We quickly settled on a scheme where Guix would fall back to the Software Heritage archive whenever it fails to download source code from its original location. That way, package definitions don’t need to be modified: they still refer to the original source code URL, but the downloading machinery transparently goes to Software Heritage when needed.

There are two types of source code downloads in Guix: tarball downloads, and version control checkouts. In the former case, resorting to Software Heritage is easy: Guix knows the SHA256 hash of the tarball so it can look it up by hash using the /content endpoint of the archive’s interface.

Fetching version control checkouts is more involved. In this case, the downloader would first resolve the commit identifier to obtain a Software Heritage revision. The actual code for that revision is then fetched through the vault.

The vault conveniently allows users to fetch the tarball corresponding to a revision. However, not all revisions are readily available as tarballs (understandably), so the vault has an interface that allows you to request the “cooking” of a specific revision. Cooking is asynchronous and can take some time. Currently, if a revision hasn’t been cooked yet, the Guix download machinery will request it and wait until it is available. The process can take some time but will eventually succeed.

Success! At this point, we have essentially bridged the gap between the stable archive that Software Heritage provides and the reproducible software deployment pipeline of Guix. This code was integrated in November 2018, making it the first free software distribution backed by a stable archive.

The challenges ahead

This milestone was encouraging: we had seemingly achieved our goal, but we also knew of several shortcomings. First, even though the software we package is still primarily distributed as tarballs, Software Heritage keeps relatively few of these tarballs. Software Heritage does ingest tarballs, notably those found on the GNU servers, but the primary focus is on preserving complete version control repositories rather than release tarballs.

It is not yet clear to us what to do with plain old tarballs. On one hand, they are here and cannot be ignored. Furthermore, some provide artifacts that are not in version control, such as configure scripts, and often enough they are accompanied by a cryptographic signature from the developers that allows recipients to authenticate the code—an important piece of information that’s often missing from version control history. On the other hand, version control tags are increasingly becoming the mechanism of choice to distribute software releases. It may be that tags will become the primary mechanism for software release distribution soon enough.

Version control tags turn out not to be ideal either, because they’re mutable and per-repository. Conversely, Git commit identifiers are unambiguous and repository-independent because they’re essentially content-addressed, but our package definitions often refer to tags, not commits, because that makes it clearer that we’re providing an actual release and not an arbitrary revision (this is another illustration of Zooko’s triangle).

This leads to another limitation that stems from the mismatch between the way Guix and Software Heritage compute hashes over version control checkouts: both compute a hash over a serialized representation of the directory, but they serialize the directory in a different way (SWH serializes directories as Git trees, while Guix uses “normalized archives” or Nars, the format the build daemon manipulates, which is inherited from Nix.) That prevents Guix from looking up revisions by content hash. The solution will probably involve changing Guix to support the same method as Software Heritage, and/or adding Guix’s method to Software Heritage.

Having to wait for “cooking” completion can also be problematic. The Software Heritage team is investigating the possibility to automatically cook all version control tags. That way, relevant revisions would almost always be readily available through the vault.

Similarly, we have no guarantee that software provided by Guix is available in the archive. Our plan is to extend Software Heritage such that it would periodically archive the source code of software packaged by Guix.

Going further

In the process of adding support for Software Heritage, Guix gained Guile bindings to the Software Heritage HTTP interface. Here’s a couple of things we can do:

(use-modules (guix swh))

;; Check whether SWH has ever crawled our repository.
(define o (lookup-origin "https://git.savannah.gnu.org/git/guix.git"))
⇒ #<<origin> id: 86312956 …>

;; It did! When was its last visit?
(define last-visit
  (first (origin-visits o)))

(date->string (visit-date last-visit))
⇒ "Fri Mar 29 10:07:45Z 2019"

;; Does it have our “v0.15.0” Git tag?
(lookup-origin-revision "https://git.savannah.gnu.org/git/guix.git" "v0.15.0")
⇒ #<<revision> id: "359fdda40f754bbf1b5dc261e7427b75463b59be" …>

Guix itself is a Guile library so when we combine the two, there are interesting things we can do:

(use-modules (guix) (guix swh)
             (gnu packages base)
             (gnu packages golang))

;; This is our GNU Coreutils package.
coreutils
⇒ #<package coreutils@8.30 gnu/packages/base.scm:342 1c67b40>

;; Does SWH have its tarball?
(lookup-content (origin-sha256 (package-source coreutils))
                "sha256")
⇒ #<<content> checksums: (("sha1" …)) data-url: …>

;; Our package for HashiCorp’s Configuration Language (HCL) is
;; built from a Git commit.
(define commit
  (git-reference-commit
    (origin-uri (package-source go-github-com-hashicorp-hcl))))

;; Is this particular commit available in the archive?
(lookup-revision commit)
⇒ #<<revision> id: "23c074d0eceb2b8a5bfdbb271ab780cde70f05a8" …>

We’re currently using a subset of this interface, but there’s certainly more we could do. For example, we can compute archive coverage of the Guix packages; we can also request the archival of each package’s source code via the “save code” interface—though all this is subject to rate limiting.

Wrap-up

Software Heritage support in Guix creates a bridge from the stable source code archive to reproducible software deployment with complete provenance tracking. For the first time it gives us a software package distribution that can be rebuilt months or years later. This is particularly beneficial in the context of reproducible science: finally we can describe reproducible software environments, a prerequisite for reproducible computational experiments.

Going further, we can provide a complete software supply tool chain with provenance tracking that links revisions in the archive to bit-reproducible build artifacts produced by Guix. Oh and Guix itself is archived, so we have this meta-level where we could link Guix revisions to the revisions of packages it provides… There are still technical challenges to overcome, but that vision is shaping up.

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.

29 March, 2019 02:50PM by Ludovic Courtès

March 28, 2019

osip @ Savannah

osip2 [5.1.0] & exosip2 [5.1.0]

I have released today newer versions for both osip2 & exosip2.

osip is very mature. There was only one tiny feature change to allow more flexible NAPTR request (such as ENUM). A very few bugs were discovered and fixed.

eXosip is also mature. However a few bugs around PRACK and retransmissions were reported and fixed. openssl support has also been updated to support more features, be more flexible and support all openssl versions. ENUM support has been introduced this year. See the ChangeLog for more!

In all case, upgrading is strongly recommanded. API changes are documented in the ChangeLog: there is not much!

28 March, 2019 07:50PM by Aymeric MOIZARD

March 27, 2019

nano @ Savannah

GNU nano 4.0 was released

This version breaks with the close compatibility with Pico: nano no longer hard-wraps the current line by default when it becomes overlong, and uses smooth scrolling by default, plus two other minor changes. Further, in 3.0 indenting and unindenting became undoable, and now, with 4.0, also justifications have become undoable (to any depth), making that all of the user's actions are now undoable and redoable (with the M-U and M-E keystrokes).

27 March, 2019 06:36PM by Benno Schulenberg

March 25, 2019

FSF News

FSF job opportunity: campaigns manager

The Free Software Foundation (FSF), a Massachusetts 501(c)(3) charity with a worldwide mission to protect computer user freedom, seeks a motivated and talented Boston-based individual to be our full-time campaigns manager.

Reporting to the executive director, the campaigns manager works on our campaigns team to lead, plan, carry out, evaluate, and improve the FSF's advocacy and education campaigns. The team also works closely with other FSF departments, including licensing, operations, and tech. The position will start by taking responsibility for existing campaigns in support of the GNU Project, free software adoption, free media formats, and freedom on the network; and against Digital Restrictions Management (DRM), software patents, and proprietary software.

Examples of job responsibilities include, but are not limited to:

  • Planning and participating in online and physical actions to achieve our campaign goals;
  • Setting specific goals for each action and then measuring our success in achieving them;
  • Doing the writing and messaging work needed to effectively explain our campaigns and motivate people to support them;
  • Overseeing or doing the graphic design work to make our campaigns and their Web sites attractive;
  • Supporting and attending special events, including community-building activities and our annual LibrePlanet conference;
  • Assisting with annual online and mail fundraising efforts;
  • Working with our tech team on the technology choices and deployments -- especially of Web publication systems like Drupal and Plone -- for our campaign sites; and
  • Being an approachable, humble, and friendly representative of the FSF to our worldwide community of existing supporters and the broader public, both in person and online.

Ideal candidates have at least three to five years of work experience in online issue advocacy and free software; proficiency and comfort with professional writing and publications preferred. Because the FSF works globally and seeks to have our materials distributed in as many languages as possible, multilingual candidates will have an advantage. With our small staff of fourteen, each person makes a clear contribution. We work hard, but offer a humane and fun work environment at an office located in the heart of downtown Boston. The FSF is a mature but growing organization that provides great potential for advancement; existing staff get the first chance at any new job openings.

Benefits and salary

This job is a union position that must be worked on-site at the FSF's downtown Boston office. The salary is fixed at $63,253/year and is non-negotiable. Other benefits include:

  • Full individual or family health coverage through Blue Cross/Blue Shield's HMO Blue program;
  • Subsidized dental plan;
  • Four weeks of paid vacation annually;
  • Seventeen paid holidays annually;
  • Weekly remote work allowance;
  • Public transit commuting cost reimbursement;
  • 403(b) program through TIAA with employer match;
  • Yearly cost-of-living pay increases (based on government guidelines);
  • Healthcare expense reimbursement budget;
  • Ergonomic budget;
  • Relocation (to Boston area) expense reimbursement;
  • Conference travel and professional development opportunities; and
  • Potential for an annual performance bonus.

Application instructions

Applications must be submitted via email to hiring@fsf.org. The email must contain the subject line "Campaigns manager". A complete application should include:

  • Cover letter, including a brief example of a time you motivated and organized others to take action on an issue important to you;
  • Resume;
  • Two recent writing samples;
  • Links to any talks you have given (optional); and
  • Graphic design samples (optional).

All materials must be in a free format (such as plain text, PDF, or OpenDocument). Email submissions that do not follow these instructions will probably be overlooked. No phone calls, please.

Applications will be reviewed on a rolling basis until the position is filled. To guarantee consideration, submit your application by Sunday, April 28th.

The FSF is an equal opportunity employer and will not discriminate against any employee or application for employment on the basis of race, color, marital status, religion, age, sex, sexual orientation, national origin, handicap, or any other legally protected status recognized by federal, state or local law. We value diversity in our workplace.

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 fsf.org and 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. We are based in Boston, MA, USA.

25 March, 2019 08:15PM

March 23, 2019

OpenStreetMap and Deborah Nicholson win 2018 FSF Awards

BOSTON, Massachusetts, USA -- Saturday, March 23, 2019 -- The Free Software Foundation (FSF) recognizes OpenStreetMap with the 2018 Free Software Award for Projects of Social Benefit and Deborah Nicholson with the Award for the Advancement of Free Software. FSF president Richard M. Stallman presented the awards today in a yearly ceremony during the LibrePlanet 2019 conference at the Massachusetts Institute of Technology (MIT).

The Award for Projects of Social Benefit is presented to a project or team responsible for applying free software, or the ideas of the free software movement, to intentionally and significantly benefit society. This award stresses the use of free software in service to humanity.

Richard Stallman with Free Software Awards winners Deborah Nicholson and Kate Chapman

This year the FSF awarded OpenStreetMap and the award was accepted by Kate Chapman, chairperson of the OpenStreetMap Foundation and co-founder of the Humanitarian OpenStreetMap Team (HOT).

OpenStreetMap is a collaborative project to create a free editable map of the world. Founded by Steve Coast in the UK in 2004, OpenStreetMap is built by a community of over one million community members and has found its application on thousands of Web sites, mobile apps, and hardware devices. OpenStreetMap is the only truly global service without restrictions on use or availability of map information.

Stallman emphasized the importance of OpenStreetMap in a time where geotech and geo-thinking are highly prevalent. "It has been clear for decades that map data are important. Therefore we need a free collection of map data. The name OpenStreetMap doesn't say so explicitly, but its map data is free. It is the free replacement that the Free World needs."

Kate thanked the Free Software Foundation and the large community of contributors of OpenStreetMap. "In 2004, much of the geospatial data was either extraordinarily expensive or unavailable. Our strong community of people committed to free and open map information has changed that. Without the leadership before us from groups such as the Free Software Foundation, we would not have been able to grow and develop to the resource we are today."

The Award for the Advancement of Free Software goes to an individual who has made a great contribution to the progress and development of free software through activities that accord with the spirit of free software.

Richard Stallman presenting Free Software Award to Deborah Nicholson

This year it was presented to Deborah Nicholson, who, motivated by the intersection of technology and social justice, advocates access to political information, unfettered freedom of speech and assembly, and civil liberties in our increasingly digital world. She joined the free software movement in 2006 after years of local organizing for free speech, marriage equality, government transparency and access to the political process. The Free Software Foundation recognizes her as an exceptional opinion leader, activist and community advocate.

Deborah is the director of community operations at the Software Freedom Conservancy, where she supports the work of its member organizations and facilitates collaboration with the wider free software community. She has served as the membership coordinator for the Free Software Foundation, where she created the Women's Caucus to increase recruitment and retention of women in the free software community. She has been widely recognized for her volunteer work with GNU MediaGoblin, a federated media-publishing platform, and OpenHatch, free software's welcoming committee. She continues her work as a founding organizer of the Seattle GNU/Linux Conference, an annual event dedicated to surfacing new voices and welcoming new people to the free software community.

Stallman praised her body of work and her unremitting and widespread contributions to the free software community. "Deborah continuously reaches out to, and engages, new audiences with her message on the need for free software in any version of the future."

Deborah continued: "Free software is critically important for autonomy, privacy and a healthy democracy -- but it can't achieve that if it is only accessible for some, or if it is alienating for large swathes of people. That's why it's so important that we continue surfacing new voices, making room for non-coders and welcoming new contributors into the free software community. I also find that in addition to helping us build a better, bigger movement, the work of welcoming is extremely rewarding."

Nominations for both awards are submitted by members of the public, then evaluated by an award committee composed of previous winners and FSF founder and president Richard Stallman.

More information about both awards, including the full list of previous winners, can be found at https://www.fsf.org/awards.

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://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 Contacts

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

Photo credits: Copyright Š 2019 Madi Muhlberg, photos licensed under CC-BY 4.0.

23 March, 2019 11:30PM

OpenStreetMap and Deborah Nicholson win 2019 FSF Awards

BOSTON, Massachusetts, USA -- Saturday, March 23, 2019-- The Free Software Foundation (FSF) recognizes OpenStreetMap with the 2018 Free Software Award for Projects of Social Benefit and Deborah Nicholson with the Award for the Advancement of Free Software. FSF president Richard M. Stallman presented the awards today in a yearly ceremony during the LibrePlanet 2019 conference at the Massachusetts Institute of Technology (MIT).

The Award for Projects of Social Benefit is presented to a project or team responsible for applying free software, or the ideas of the free software movement, to intentionally and significantly benefit society. This award stresses the use of free software in service to humanity.

Richard Stallman with Free Software Awards winners Deborah Nicholson and Kate Chapman

This year the FSF awarded OpenStreetMap and the award was accepted by Kate Chapman, chairperson of the OpenStreetMap Foundation and co-founder of the Humanitarian OpenStreetMap Team (HOT).

OpenStreetMap is a collaborative project to create a free editable map of the world. Founded by Steve Coast in the UK in 2004, OpenStreetMap is built by a community of over one million community members and has found its application on thousands of Web sites, mobile apps, and hardware devices. OpenStreetMap is the only truly global service without restrictions on use or availability of map information.

Stallman emphasized the importance of OpenStreetMap in a time where geotech and geo-thinking are highly prevalent. "It has been clear for decades that map data are important. Therefore we need a free collection of map data. The name OpenStreetMap doesn't say so explicitly, but its map data is free. It is the free replacement that the Free World needs."

Kate thanked the Free Software Foundation and the large community of contributors of OpenStreetMap. "In 2004, much of the geospatial data was either extraordinarily expensive or unavailable. Our strong community of people committed to free and open map information has changed that. Without the leadership before us from groups such as the Free Software Foundation, we would not have been able to grow and develop to the resource we are today."

The Award for the Advancement of Free Software goes to an individual who has made a great contribution to the progress and development of free software through activities that accord with the spirit of free software.

Richard Stallman presenting Free Software Award to Deborah Nicholson

This year it was presented to Deborah Nicholson, who, motivated by the intersection of technology and social justice, advocates access to political information, unfettered freedom of speech and assembly, and civil liberties in our increasingly digital world. She joined the free software movement in 2006 after years of local organizing of free speech, marriage equality, government transparency and access to the political process. The Free Software Foundation recognizes her as an exceptional opinion leader, activist and community advocate.

Deborah is the director of community operations at the Software Freedom Conservancy, where she supports the work of its member organizations and facilitates collaboration with the wider free software community. She has served as the membership coordinator for the Free Software Foundation, where she created the Women's Caucus to increase recruitment and retention of women in the free software community. She has been widely recognized for her volunteer work with GNU MediaGoblin, a federated media-publishing platform, and OpenHatch, free software's welcoming committee. She continues her work as a founding organizer of the Seattle GNU/Linux Conference, an annual event dedicated to surfacing new voices and welcoming new people to the free software community.

Stallman praised her body of work and her unremitting and widespread contributions to the free software community. "Deborah continuously reaches out to, and engages, new audiences with her message on the need for free software in any version of the future."

Deborah continued: "Free software is critically important for autonomy, privacy and a healthy democracy -- but it can't achieve that if it is only accessible for some, or if it is alienating for large swathes of people. That's why it's so important that we continue surfacing new voices, making room for non-coders and welcoming new contributors into the free software community. I also find that in addition to helping us build a better, bigger movement, the work of welcoming is extremely rewarding."

Nominations for both awards are submitted by members of the public, then evaluated by an award committee composed of previous winners and FSF founder and president Richard Stallman.

More information about both awards, including the full list of previous winners, can be found at https://www.fsf.org/awards.

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://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 Contacts

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

Photo credits: Copyright Š 2019 Madi Muhlberg, photos licensed under CC-BY 4.0.

23 March, 2019 10:59PM

March 21, 2019

parallel @ Savannah

GNU Parallel 20190322 ('FridayforFuture') released

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

The change in signalling makes this release experimental for users that send SIGTERM to GNU Parallel.

Quote of the month:

There are so many things to love about GNU parallel. You could honestly teach a whole parallel computing course with it and never have to leave it for a real language.
-- Aubrey Bailey @DNAvinci@twitter

New in this release:

  • SIGTERM is changed to SIGHUP, so sending SIGHUP will make GNU Parallel start no more jobs, but wait for running jobs to finish.
  • SIGTERM SIGTERM is changed to SIGTERM, so sending SIGTERM will make GNU Parallel kill all running jobs.
  • GNU Parallel now includes a cheat sheet: parallel_cheat.pdf
  • 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.

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 || curl pi.dk/3/ || fetch -o - http://pi.dk/3) | bash

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.

21 March, 2019 10:15PM by Ole Tange

FSF News

Seven new devices from ThinkPenguin, Inc. now FSF-certified to Respect Your Freedom

BOSTON, Massachusetts, USA -- Thursday, March 21st, 2019 -- The Free Software Foundation (FSF) today awarded Respects Your Freedom (RYF) certification to seven devices from ThinkPenguin, Inc.: The Penguin Wireless G USB Adapter (TPE-G54USB2), the Penguin USB Desktop Microphone for GNU / Linux (TPE-USBMIC), the Penguin Wireless N Dual-Band PCIe Card (TPE-N300PCIED2), the PCIe Gigabit Ethernet Card Dual Port (TPE-1000MPCIE), the PCI Gigabit Ethernet Card (TPE-1000MPCI), the Penguin 10/100 USB Ethernet Network Adapter v1 (TPE-100NET1), and the Penguin 10/100 USB Ethernet Network Adapter v2 (TPE-100NET2). The RYF certification mark means that these products meet the FSF's standards in regard to users' freedom, control over the product, and privacy.

TPE-N300PCIED2_2

These are not the first devices from ThinkPenguin to receive RYF certification. This fresh batch joins four previously certified devices in the ThinkPenguin lineup. With these additions, ThinkPenguin becomes one of the largest retailers of RYF-certified devices.

"I'm excited about this announcement, because this collection of devices includes some for which there previously was no certified option. These certifications get us closer to our goal of making sure there is a certified device in each product category, to meet all users' needs," said the FSF's executive director, John Sullivan.

Today's certification broadly expands the availability of RYF-certified peripheral devices. The Penguin Wireless G USB Adapter and Penguin Wireless N Dual-Band PCIe Card enable wireless network connectivity. The PCIe Gigabit Ethernet Card Dual Port, PCI Gigabit Ethernet Card, Penguin 10/100 USB Ethernet Network Adapter v1, and Penguin 10/100 USB Ethernet Network Adapter v2 provide a direct Ethernet connection. Finally, the Penguin USB Desktop Microphone for GNU / Linux helps users to connect to one another by providing a freedom-respecting microphone.

"I've always believed that the biggest difficulty for users in the free software world has been in obtaining compatible hardware, and so I'm glad to be participating in the expansion of the RYF program" said Christopher Waid, founder and CEO of ThinkPenguin.

ThinkPenguin, Inc. was one of the first companies to receive RYF certification, gaining their first and second certifications in 2013, and adding several more over the years since.

"ThinkPenguin has excelled for years in providing users with the tools they need to control their own computing. We are excited by these new additions today, and look forward to what they have in store for the future," said the FSF's licensing and compliance manager, Donald Robertson, III.

To learn more about the Respects Your Freedom certification program, including details on the certification of these ThinkPenguin devices, please visit https://fsf.org/ryf.

Hardware sellers interested in applying for certification can consult https://www.fsf.org/resources/hw/endorsement/criteria.

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.

About ThinkPenguin, Inc.

Started by Christopher Waid, founder and CEO, ThinkPenguin, Inc., is a consumer-driven company with a mission to bring free software to the masses. At the core of company is a catalog of computers and accessories with broad support for GNU/Linux. The company provides technical support for end-users and works with the community, distributions, and upstream projects to make GNU/Linux all that it can be.

Media Contacts

Donald Robertson, III
Licensing and Compliance Manager
Free Software Foundation
+1 (617) 542 5942
licensing@fsf.org

ThinkPenguin, Inc.
+1 (888) 39 THINK (84465) x703
media@thinkpenguin.com

Image Copyright 2016 ThinkPenguin, Inc., licensed under Creative Commons Attribution-ShareAlike 4.0.

21 March, 2019 08:45PM

March 18, 2019

health @ Savannah

GNU Health installer 3.4.1

Dear community

The GNU Health installer (gnuhealth-setup) has been updated to 3.4.1.

It basically fixes an issue due to the removal of the the pybarcode library from pypi (https://savannah.gnu.org/bugs/?55942)

We have also updated the documentation to always download the latest installer as the first step (https://en.wikibooks.org/wiki/GNU_Health/Installation#Downloading_and_Installing_GNU_Health)

This applies for new installations / migrations.

Best
Luis

18 March, 2019 01:59PM by Luis Falcon

March 15, 2019

GNU Guix

Documentation video creation

Over the last few months, I have been working as an Outreachy intern with the GNU Guix crowd to develop videos presenting and documenting the project. My goal in this round as an Outreachy intern for the December 2018 to March 2019 period consists of creating introductory documentation videos about different topics for people who would like to use GNU Guix, admins and/or those who would like to join Guix community and don’t know where to start. Even interested or having a clear documentation, they might feel overwhelmed by it. I experienced this issue in the past with people in another context.

My main tasks consist of creating a workflow for automating as much as possible the process of creating the videos, as well as, of course, creating the videos themselves. Creating the videos is not that easy as it might seem, I have to design them (I cannot automate that part), let the audio match the video, and matching the exact timing is quite difficult. Something very important that I should mention is that the workflow currently allows translations to other languages.

It is a work in progress for too many reasons, specially because it keeps being improved all the time.

Also, I had to study tools deeply both for the creation of the workflow and the videos because I did not know them beforehand or I knew just the basics.

After trying several approaches for the workflow, the current one consists of creating “pieces of videos” and gluing them together in the end.

These “pieces of videos” may consist of:

  • Slide videos: they contain only a sequence of one or more slides.
  • Command line session videos: they contain only Guix or shell commands and their output, without showing any slide at all.
Workflow for creating each slide video.

slide

The inputs are SVG files and audio files. First, SVGs are converted to PNGs (“the slides”). Then, a text file having the order in which each slide will appear and the duration of the audio that matches it is created. An audio text file containing all the audio files sorted to have a complete audio file is created too. Lastly, with the slides' text file that has the reference to the slide files and the glued audio file the final slide video is made.

Workflow for creating each command line session video.

cli

The input is a session text file that has commands or meta-commands that are used to simulate, for example, the typing of a command, or the printing of it’s output. This file is passed to a Guile script that is in charge of executing the commands defined in the input text file and take text snapshots at a fixed time interval. Then, all these files are converted to postscript format. After that, they are transformed to SVG format. Finally, the process is repeated and the audio and the slides are glued to have final command line session video.

Workflow for creating the final video.

gluing

Slide videos and command line videos are a “bunch of videos” that need to be glued into the final one. They are sorted, and using the same tool for video creation our final introductory video is created.

The code for this video creation workflow is available on Savannah. Enjoy!

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.

15 March, 2019 11:00AM by Laura Lazzati

March 11, 2019

coreutils @ Savannah

coreutils-8.31 released [stable]

11 March, 2019 12:48AM by Pádraig Brady

March 10, 2019

health @ Savannah

Thalamus 0.9.8 is out. HIS Migration from MongoDB to PosrgreSQL

Dear all

I am proud to announce the availability of Thalamus 0.9.8, which has been migrated from MongoDB to now interact with PostgreSQL .
(see related news https://savannah.gnu.org/forum/forum.php?forum_id=9366 )

Please make sure you update the package

$ pip3 install --user --upgrade thalamus

The interaction for the enduser and from GNU Health HMIS node will be transparent.

The Health Information System installation has been updated in Wikipedia. You can refer to https://en.wikibooks.org/wiki/GNU_Health/Federation_Technical_Guide#Installing_Thalamus

Please don't forget to report any issues you find to health@gnu.org

Bests
Luis

10 March, 2019 03:50AM by Luis Falcon

GNU Health HMIS 3.4.1 released

Dear community

GNU Health HMIS 3.4.1 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 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.4.1.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 and Tryton 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

Patch 3.4.1 fixes issues related to the generation of the Federation Account, and it adapts the ID field on the federation objects.

The gnuhealth-control program and the documentation / man page have also been updated.

It is important to know that since 3.4.1 and Thalamus 0.9.8, the Health Information System has been migrated from MongoDB to PostgreSQL.

Refer to the List of issues related to this patchset for a comprehensive list of fixed bugs.

Installation Notes

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

You must apply previous patchsets before installing this patchset.
You can find the patchsets at GNU Health main download site at GNU.org (https://ftp.gnu.org/gnu/health/)

Follow the general instructions at

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

  • Restart the GNU Health Tryton server

List of issues and tasks related to this patchset

  • bug #55595: Remove unimplemented functionality fields from Federation Country
  • bug #55594: Traceback when creating a person without a system institution

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

10 March, 2019 03:37AM by Luis Falcon

March 06, 2019

unifont @ Savannah

GNU Unifont 12.0.01 Released

5 March 2019

GNU Unifont 12.0.01 is now available. This is a major release incorporating glyphs added in Unicode 12.0.0, which also was just released today.

Significant changes in this version include contributions from David Corbett and Johnnie Weaver. Notably, the Unifont Upper font has now reached 11,000 Unicode Plane 1 glyphs. New Unicode script ranges introduced in Unicode Standard version 12.0.0 that are included in this release are (in order of appearance in Unifont Upper): Elymaic, Tamil Supplement, Nandinagari, Egyptian Hieroglyph Format Controls, Small Kana Extension, Nyiakeng Puachue Hmong, Wancho, Ottoman Siyaq Numbers, Chess Symbols, and Symbols and Pictographs Extended-A. Full details are in the ChangeLog file.

This release also includes two new programs: unibmpbump and unihexrotate. unibmpbump, by Paul Hardy, adjusts images created by unihex2png but saved as Bitmap (".bmp") format files, for processing with unibmp2hex. unihexrotate, by David Corbett, rotates a set of glyphs in Unifont ".hex" format clockwise or counterclockwise by a specified number of quarter turns.

Download this release at:

https://ftpmirror.gnu.org/unifont/unifont-12.0.01/

or if that fails,

https://ftp.gnu.org/gnu/unifont/unifont-12.0.01/

or, as a last resort,

ftp://ftp.gnu.org/gnu/unifont/unifont-12.0.01/

Enjoy!

Paul Hardy
GNU Unifont Maintainer

06 March, 2019 05:49AM by Paul Hardy

March 02, 2019

health @ Savannah

GNU Health control center 3.4.1 is out !

Dear all

We just released GNU health control center 3.4.1 !

It mainly fixes an issue with the file format of the translation files from pootle on our GNU Health translation portal, when executing the getlang command.

You can update automatically the gnuhealth control center using the command

$ gnuhealth-control update

You can also find the program at our GNU FTP site (https://ftp.gnu.org/gnu/health/)

Best
Luis

02 March, 2019 07:26PM by Luis Falcon

February 28, 2019

GNUnet News

2019-02: GNUnet 0.11.0 released

2019-02: GNUnet 0.11.0 released

We are pleased to announce the release of GNUnet 0.11.0.

This is a major release after about five years of development. In terms of usability, users should be aware that there are still a large number of known open issues in particular with respect to ease of use, but also some critical privacy issues especially for mobile users. Also, the nascent network is tiny (about 200 peers) and thus unlikely to provide good anonymity or extensive amounts of interesting information. As a result, the 0.11.0 release is still only suitable for early adopters with some reasonable pain tolerance.

Download links

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/

Note that GNUnet is now started using gnunet-arm -s. GNUnet should be stopped using gnunet-arm -e.

Noteworthy changes in 0.11.0

  • The Web site and manuals have undergone significant rework. You can find an archive of the old Web site at old.gnunet.org.
  • The code now builds again on macOS. GNUnet on macOS is experimental. While it builds and seems to run fine, some tests are known to fail.
  • Build process now works properly with libidn2
  • Except for gnunet-qr, all Python code was migrated to Python 3.7.
  • Fixed security issues in secret sharing cryptography logic
  • Services running out of file descriptors on accept() no longer busy wait
  • Fixed crash in gnunet-gns2dns proxy
  • GNS responses are now padded to minimize information disclosure from the size
  • Fixed API issues and (rare) crash bugs in CADET
  • The experimental SecuShare code is not included in the release, you can now find it in the gnunet-secushare Git repository.
  • The Ascension tool (separate download) now allows importing DNS zones into GNS via AXFR.
  • GNUnet now includes a decentralised identity attribute sharing service: reclaimID. A ready-to-use client can be found in an external repo.
  • The code now builds again on NetBSD. GNUnet on NetBSD is experimental. While it builds and seems to run fine, full support requires more changes in the core of GNUnet It will soon be available via pkgsrc.
  • Many things changed on the build system side. If you package GNUnet for an operating system or otherwise package manager, make sure that you read the README.

The above is just the short list, our bugtracker lists over 100 individual issues that were resolved since 0.11.0pre66.

Known Issues

  • There are known major design issues in the TRANSPORT, ATS and CORE subsystems which will need to be addressed in the future to achieve acceptable usability, performance and security.
  • There are known moderate implementation limitations in CADET that negatively impact performance. Also CADET may unexpectedly deliver messages out-of-order.
  • There are known moderate design issues in FS that also impact usability and performance.
  • There are minor implementation limitations in SET that create unnecessary attack surface for availability.
  • The RPS subsystem remains experimental.
  • Some high-level tests in the test-suite fail non-deterministically due to the low-level TRANSPORT issues.

In addition to this list, you may also want to consult our bug tracker at bugs.gnunet.org which lists about 150 more specific issues.

28 February, 2019 12:00AM

February 26, 2019

dico @ Savannah

February 24, 2019

Sylvain Beucler

Android Free dev repository

Android Rebuilds, which provides freely-licensed Android development tools, starts a public repository with F-Droid :)

https://mirror.f-droid.org/android-free/repository/

We're now trying to make it usable for sdkmanager, which should vastly ease the installation process (download what you need, rather than huge mono-version bundles).
Help is welcome to format the repository and possibly adding a way to override sdkmanager's default repositories, join the conversation!

https://forum.f-droid.org/t/call-for-help-making-free-software-builds-of-the-android-sdk/4685

24 February, 2019 08:26PM

February 23, 2019

tar @ Savannah

Version 1.32

GNU tar version 1.32 is available for download.

New in this release:

  • Fix the use of --checkpoint without explicit --checkpoint-action
  • Fix extraction with the -U option

See http://lists.gnu.org/archive/html/bug-tar/2019-01/msg00015.html,
for details

  • Fix iconv usage on BSD-based systems
  • Improve the testsuite

23 February, 2019 01:15PM by Sergey Poznyakoff

cflow @ Savannah

Version 1.6

Version 1.6 is available for download. New in this version:

New option --all (-A)

Produce graphs for all global functions in the program. Use this
option if your program contains functions which are not directly
reachable from main().

The output consist of separate flow graphs for each global function
defined in the program. These graphs will be placed after the graph
for main() (if it exists), and will be ordered lexicographically by
the function name.

New option --no-main

This option has the same effect as '--all', except that the graph for
main() function (if it exists) is treated same way as all the other
graphs, i.e. it will not be placed at the top of output, but in its
place as per the lexicographic ordering of function names.

23 February, 2019 12:54PM by Sergey Poznyakoff

mailutils @ Savannah

Version 3.6

Version 3.6 is available for download.

For the list of changes in this version, please see the NEWS file entry.

23 February, 2019 12:20PM by Sergey Poznyakoff

February 22, 2019

parallel @ Savannah

GNU Parallel 20190222 ('Baghuz') released

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

Quote of the month:

With GNU Parallel you sure can!
I like getting things done

--Kyle Lady @kylelady@twitter

New in this release:

  • --shard makes it possible to send input to the same jobslot based on the value in one column of the input. It is similar to sharding in databases.
  • --shellquote --shellquote will shell quote the input twice.
  • Parallelizing Freesurfer blog.cogneurostats.com/?p=148
  • 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.

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 || curl pi.dk/3/ || fetch -o - http://pi.dk/3) | bash

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 February, 2019 09:34PM by Ole Tange