Planet GNU

Aggregation of development blogs from the GNU Project

July 30, 2015

FSF News

The FSF's statement on Windows 10

Microsoft uses draconian laws to prevent anyone from popping the hood on Windows and studying the source code that underlies it. Because of this, the world's most widespread computer system is completely outside the control of its users. This puts Microsoft in a dominant position over its customers, which it takes advantage of to treat them as a product. In fact, Microsoft announced that, with Windows 10, it will begin forcing lower-paying users to test less-secure new updates before giving higher-paying users the option of whether or not to adopt them.

Increased public scrutiny has forced Microsoft to adjust its advertising to focus on how secure it is and how well it protects privacy. But who does it secure and protect? Certainly not the user. Since Windows 10 is nonfree software, users and independent security experts can't access the source code, so they are forced to take Microsoft's word for it that their computers are safe and their data is being used responsibly. And it hardly seems warranted to trust a company that is reported to give the NSA special security tip-offs that it could use to crack into Windows computers.

Advertising companies are surely licking their chops over Windows 10's new privacy policy, which asserts the privilege to sell almost any information it wants about users, even creating a unique advertising ID for each user to increase sweeten the deal.

By contrast, free software like the GNU/Linux operating system is developed by professional and volunteer communities working transparently, freely sharing their work with each other and the world. Users have meaningful influence over the software development process and complete choice over what code they run. This means the software usually treats them with respect. Even if a free software developer took a page from Microsoft's book and began abusing its users, it would have no way to keep them locked in -- when this happens, independent experts copy the source code, remove the offending bits and help people switch to the user-respecting version.

Because it is fundamentally insecure and scoffs at privacy, Windows is an open window onto you. Because it locks users and independent experts out of the development process, it is also a locked door to your computer, and only Microsoft has the key. If you are considering replacing your operating system with Windows 10, we hope you switch to GNU/Linux instead. Join thousands of others and pledge to try GNU/Linux today.

The FSF maintains a list of endorsed GNU/Linux distributions, and there are myriad resources online for getting started. If you want to try free software but you can't be persuaded to leave Windows quite yet, try these free programs that work on Windows. If you are thinking about buying a new computer, check out the laptops we certify through our Respects Your Freedom program. If you're the type that builds their own computer, use h-node, the community-maintained database of computer components that work well with free software.

We can't hope to match Microsoft's huge advertising budget, but if you're on social media (see our recommendations for user-respecting social media systems) you can help raise awareness of Windows' abuses and encourage people to switch, in your own words. Help us jam Microsoft's ridiculous #UpgradeYourWorld hashtag by including it in your posts encouraging people to steer clear of Windows.

Media Contacts

Zak Rogoff
Campaigns Manager
Free Software Foundation
+1 (617) 542 5942
campaigns@fsf.org

July 30, 2015 09:35 PM

July 28, 2015

Andy Wingo

loop optimizations in guile

Sup peeps. So, after the slog to update Guile's intermediate language, I wanted to land some new optimizations before moving on to the next thing. For years I've been meaning to do some loop optimizations, and I was finally able to land a few of them.

loop peeling

For a long time I have wanted to do "loop peeling". Loop peeling means peeling off the first iteration of a loop. If you have a source program that looks like this:

while foo:
  bar()
  baz()

Loop peeling turns it into this:

if foo:
  bar()
  baz()
  while foo:
    bar()
    baz()

You wouldn't think that this is actually an optimization, would you? Well on its own, it's not. But if you combine it with common subexpression elimination, then it means that the loop body is now dominated by all effects and all loop-invariant expressions that must be evaluated for the expression to loop.

In dynamic languages, this is most useful when one source expression expands to a number of low-level steps. So for example if your language runtime implements top-level variable references in three parts, one where it gets a reference to a mutable box, then it checks if the box has a value, and and the third where it unboxes it, then we would have:

if foo:
  bar_location = lookup("bar")
  bar_value = dereference(bar_location)
  if bar_value is null: throw NotFound("bar")
  call(bar_value)

  baz_location = lookup("baz")
  baz_value = dereference(baz_location)
  if baz_value is null: throw NotFound("baz")
  call(baz_value)

  while foo:
    bar_value = dereference(bar_location)
    call(bar_value)

    baz_value = dereference(baz_location)
    call(baz_value)

The result is that we have hoisted the lookups and null checks out of the loop (if a box can never transition from full back to empty). It's a really powerful transformation that can even hoist things that traditional loop-invariant code motion can't, but more on that later.

Now, the problem with loop peeling is that usually values will escape your loop. For example:

while foo:
  x = qux()
  if x then return x
...

In this little example, there is a value x, and the return x statement is actually not in the loop. It's syntactically in the loop, but the underlying representation that the compiler uses looks more like this:

function qux(k):
  label loop_header():
    fetch(foo) -gt; loop_test
  label loop_test(foo_value):
    if foo_value then -> exit else -> body
  label body():
    fetch(x) -gt; have_x
  label have_x(x_value):
    if x_value then -> return_x else -> loop_header
  label return_x():
    values(x) -> k
  label exit():
    ...

This is the "CPS soup" I described in my last post. Only the bold parts are in the loop; notably, the return is outside the loop. Point being, if we peel off the first iteration, then there are two possible values for x that we would return:

if foo:
  x1 = qux()
  if x1 then return x1
  while foo:
    x2 = qux()
    if x2 then return x2
  ...

I have them marked as x1 and x2. But I've also duplicated the return x terms, which is not what we want. We want to peel off the first iteration, which will cause code growth equal to the size of the loop body, but we don't want to have to duplicate everything that's after the loop. What we have to do is re-introduce a join point that defines x:

if foo:
  x1 = qux()
  if x1 then join(x1)
  while foo:
    x2 = qux()
    if x2 then join(x2)
  ...
label join(x)
  return x

Here I'm playing fast and loose with notation because the real terms are too gnarly. What I'm trying to get across is that for each value that flows out of a loop, you need a join point. That's fine, it's a bit more involved, but what if your loop exits to two different points, but one value is live in both of them? A value can only be defined in one place, in CPS or SSA. You could re-place a whole tree of phi variables, in SSA parlance, with join blocks and such, but it's just too hard.

However we can still get the benefits of peeling in most cases if we restrict ourselves to loops that exit to only one continuation. In that case the live variable set is the intersection of all variables defined in the loop that are live at the exit points. Easy enough, and that's what we have in Guile now. Peeling causes some code growth but the loops are smaller so it should still be a win. Check out the source, if that's your thing.

loop-invariant code motion

Usually when people are interested in moving code out of loops they talk about loop-invariant code motion, or LICM. Contrary to what you might think, LICM is complementary to peeling: some things that peeling+CSE can hoist are not hoistable by LICM, and vice versa.

Unlike peeling, LICM does not cause code growth. Instead, for each expression in a loop, LICM tries to hoist it out of the loop if it can. An expression can be hoisted if all of these conditions are true:

  1. It doesn't cause the creation of an observably new object. In Scheme, the definition of "observable" is quite subtle, so in practice in Guile we don't hoist expressions that can cause any allocation. We could use alias analysis to improve this.

  2. The expression cannot throw an exception, or the expression is always evaluated for every loop iteration.

  3. The expression makes no writes to memory, or if it writes to memory, other expressions in the loop cannot possibly read from that memory. We use effects analysis for this.

  4. The expression makes no reads from memory, or if it reads from memory, no other expression in the loop can clobber those reads. Again, effects analysis.

  5. The expression uses only loop-invariant variables.

This definition is inductive, so once an expression is hoisted, the values it defines are then considered loop-invariant, so you might be able to hoist a whole chain of values.

Compared to loop peeling, this has the gnarly aspect of having to explicitly reason about loop invariance and manually move code, which is a pain. (Really LICM would be better named "artisanal code motion".) However it causes no code growth, which is a plus, though like peeling it can increase register pressure. But the big difference is that LICM can hoist effect-free expressions that aren't always executed. Consider:

while foo:
  x = qux() ? "hi" : "ho"

Here for some reason it could be faster to cache "hi" or "ho" in registers, which is what LICM allows:

hi, ho = "hi", "ho"
while foo:
  x = qux() ? hi : ho

On the other hand, LICM alone can't hoist the if baz is null checks in this example from above:

while foo:
  bar()
  baz()

The issue is that the call to bar() might not return, so the error that might be thrown if baz is null shouldn't be observed until bar is called. In general we can't hoist anything that might throw an exception past some non-hoisted code that might throw an exception. This specific situation happens in Guile but there are similar ones in any language, I think.

More formally, LICM will hoist effectful but loop-invariant expressions that postdominate the loop header, whereas peeling hoists those expressions that dominate all back-edges. I think? We'll go with that. Again, the source.

loop inversion

Loop inversion is a little hack to improve code generation, and again it's a little counterintuitive. If you have this loop:

while n < x:
  n++

Loop inversion turns it into:

if n < x:
  do
    n++
  while n < x

The goal is that instead of generating code that looks like this:

header:
  test n, x;
  branch-if-greater-than-or-equal done;
  x = x + 1
  goto header
done:

You make something that looks like this:

  test n, x;
  branch-if-greater-than-or-equal done;
header:
  x = x + 1
  test n, x;
  branch-if-less-than header;
done:

The upshot is that the loop body now contains one branch instead of two. It's mostly helpful for tight loops.

It turns out that you can express this transformation on CPS (or SSA, or whatever), but that like loop peeling the extra branch introduces an extra join point in your program. If your loop exits to more than one label, then we have the same problems as loop peeling. For this reason Guile restricts loop inversion (which it calls "loop rotation" at the moment; I should probably fix that) to loops with only one exit continuation.

Loop inversion has some other caveats, but probably the biggest one is that in Guile it doesn't actually guarantee that each back-edge is a conditional branch. The reason is that usually a loop has some associated loop variables, and it could be that you need to reshuffle those variables when you jump back to the top. Mostly Guile's compiler manages to avoid shuffling, allowing inversion to have the right effect, but it's not guaranteed. Fixing this is not straightforward, since the shuffling of values is associated with the predecessor of the loop header and not the loop header itself. If instead we reshuffled before the header, that might work, but each back-edge might have a different shuffling to make... anyway. In practice inversion seems to work out fine; I haven't yet seen a case where it doesn't work. Source code here.

loop identification

One final note: what is a loop anyway? Turns out this is a somewhat hard problem, especially once you start trying to identify nested loops. Guile currently does the simple thing and just computes strongly-connected components in a function's flow-graph, and says that a loop is a non-trivial SCC with a single predecessor. That won't tease apart loop nests but oh wells! I spent a lot of time last year or maybe two years ago with that "Loop identification via D-J graphs" paper but in the end simple is best, at least for making incremental steps.

Okeysmokes, until next time, loop on!

by Andy Wingo at July 28, 2015 08:10 AM

July 27, 2015

Andy Wingo

cps soup

Hello internets! This blog goes out to my long-time readers who have followed my saga hacking on Guile's compiler. For the rest of you, a little history, then the new thing.

In the olden days, Guile had no compiler, just an interpreter written in C. Around 8 years ago now, we ported Guile to compile to bytecode. That bytecode is what is currently deployed as Guile 2.0. For many reasons we wanted to upgrade our compiler and virtual machine for Guile 2.2, and the result of that was a new continuation-passing-style compiler for Guile. Check that link for all the backstory.

So, I was going to finish documenting this intermediate language about 5 months ago, in preparation for making the first Guile 2.2 prereleases. But something about it made me really unhappy. You can catch some foreshadowing of this in my article from last August on common subexpression elimination; I'll just quote a paragraph here:

In essence, the scope tree doesn't necessarily reflect the dominator tree, so not all transformations you might like to make are syntactically valid. In Guile 2.2's CSE pass, we work around the issue by concurrently rewriting the scope tree to reflect the dominator tree. It's something I am seeing more and more and it gives me some pause as to the suitability of CPS as an intermediate language.

This is exactly the same concern that Matthew Fluet and Stephen Weeks had back in 2003:

Thinking of it another way, both CPS and SSA require that variable definitions dominate uses. The difference is that using CPS as an IL requires that all transformations provide a proof of dominance in the form of the nesting, while SSA doesn't. Now, if a CPS transformation doesn't do too much rewriting, then the partial dominance information that it had from the input tree is sufficient for the output tree. Hence tree splicing works fine. However, sometimes it is not sufficient.

As a concrete example, consider common-subexpression elimination. Suppose we have a common subexpression x = e that dominates an expression y = e in a function. In CPS, if y = e happens to be within the scope of x = e, then we are fine and can rewrite it to y = x. If however, y = e is not within the scope of x, then either we have to do massive tree rewriting (essentially making the syntax tree closer to the dominator tree) or skip the optimization. Another way out is to simply use the syntax tree as an approximation to the dominator tree for common-subexpression elimination, but then you miss some optimization opportunities. On the other hand, with SSA, you simply compute the dominator tree, and can always replace y = e with y = x, without having to worry about providing a proof in the output that x dominates y (i.e. without putting y in the scope of x)

[MLton-devel] CPS vs SSA

To be honest I think all this talk about dominators is distracting. Dominators are but a lightweight flow analysis, and I usually find myself using full-on flow analysis to compute the set of optimizations that I can do on a piece of code. In fact the only use I had for dominators in the nested CPS language was to rewrite scope trees! The salient part of Weeks' observation is that nested scope trees are the problem, not that dominators are the solution.

So, after literally years of hemming and hawing about this, I finally decided to remove nested scope trees from Guile's CPS intermediate language. Instead, a function is now a collection of labelled continuations, with one distinguished entry continuation. There is no more $letk term to nest continuations in each other. A program is now represented as a "soup" -- basically a map from labels to continuation bodies, again with a distinguished entry. As an example, consider this expression:

function(x):
  return add(x, 1)

If we rewrote it in continuation-passing style, we'd give the function a name for its "tail continuation", ktail, and annotate each expression with its continuation:

function(ktail, x):
  add(x, 1) -> ktail

Here the -> ktail means that the add expression passes its values to the continuation ktail.

With nested CPS, it could look like:

function(ktail, x):
  letk have_one(one): add(x, one) -> ktail
    load_constant(1) -> have_one

Here the label have_one is in a scope, as is the value one. With "CPS soup", though, it looks more like this:

function(ktail, x):
  label have_one(one): add(x, one) -> ktail
  label main(x): load_constant(1) -> have_one

It's a subtle change, but it took a few months to make so it's worth pointing out what's going on. The difference is that there is no scope tree for labels or variables any more. A variable can be used at a label if it flows to the label, in a flow analysis sense. Indeed, determining the set of variables that can be used at a label requires flow analysis; that's what Weeks was getting at in his 2003 mail about the advantages of SSA, which are really the advantages of an intermediate language without nested scope trees.

The question arises, though, now that we've decided on CPS soup, how should we represent a program as a value? We've gone from a nested term to a graph term, and we need to find a way to represent it somehow that facilitates looking up labels by name, and facilitates tree rewrites.

In Guile's IR, labels and variables are both integers, so happily enough, we have such a data structure: Clojure-style maps specialized for integer keys.

Friends, if there has been one realization or revolution for me in the last year, it has been Clojure-style data structures. Here's why. In compilers, I often have to build up some kind of analysis, then use that analysis to transform data. Often I need to keep the old term around while I build a new one, but it would be nice to share state between old and new terms. With a nested tree, if a leaf changed you'd have to rebuild all surrounding terms, which is gnarly. But with Clojure-style data structures, more and more I find myself computing in terms of values: build up this value, transform this map to that set, fold over this map -- and yes, you can fold over Guile's intmaps -- and so on. By providing an expressive data structure for which I can control performance characteristics by using transients if needed, these data structures make my programs more about data and less about gnarly machinery.

As a concrete example, the old contification pass in Guile, I didn't have the mental capacity to understand all the moving parts in such a way that I could compute an optimal contification from the beginning; instead I had to iterate to a fixed point, as Kennedy did in his "Compiling with Continuations, Continued" paper. With the new CPS soup language and with Clojure-style data structures, I could actually fit more of the algorithm into my head, with the result that Guile now contifies optimally while avoiding the fixed-point transformation. Also, the old pass used hash tables to represent the analysis, which I found incredibly confusing to reason about -- I totally buy Rich Hickey's argument that place-oriented programming is the source of many evils in programs, and hash tables are nothing if not a place party. Using functional maps let me solve harder problems because they are easier for me to reason about.

Contification isn't an isolated case, either. For example, we are able to do the complete set of optimizations from the "Optimizing closures in O(0) time" paper, including closure sharing, which I think makes Guile unique besides Chez Scheme. I wasn't capable of doing it on the old representation because it was just too hard for me to think about, because my data structures weren't right.

This new "CPS soup" language is still a first-order CPS language in that each term specifies its continuation, and that variable names appear in the continuation of a definition, not the definition itself. This effectively makes every variable a phi variable, in the sense of SSA, and you have to do some work to get to a variable's definition. It could be that still this isn't the right number of names; consider this function:

function foo(k, x):
  label have_y(y) bar(y) -> k
  label y_is_two() load_constant(2) -> have_y
  label y_is_one() load_constant(1) -> have_y
  label main(x) if x -> y_is_one else -> y_is_two

Here there is no distinguished name for the value load_constant(1) versus load_constant(2): both are possible values for y. If we ended up giving them names, we'd have to reintroduce actual phi variables for the joins, which would basically complete the transformation to SSA. Until now though I haven't wanted those names, so perhaps I can put this off. On the other hand, every term has a label, which simplifies many things compared to having to contain terms in basic blocks, as is usually done in SSA. Yet another chapter in CPS is SSA is CPS is SSA, it seems.

Welp, that's all the nerdery for right now. Talk at yall later!

by Andy Wingo at July 27, 2015 02:43 PM

July 24, 2015

FSF News

FSF invites the free software community to its 30th birthday party on October 3rd, 2015

FSF30 logo

The event homepage is https://fsf.org/fsf30/celebration and the RSVP form is open. The FSF encourages use of the hashtag #FSF30 on social media (read the foundation's position on different social media platforms).

The FSF is also planning a mini-conference, also on October 3, during the day, where the free software community will share lessons from its first thirty years and plan for the future. The foundation may also hold a fundraising dinner on Friday, October 2nd.

Volunteer or Sponsor

The FSF is seeking volunteers to help set up the venue and greet guests. Individuals with skills in free software livestreaming are also needed. All volunteers will receive a special reverse birthday gift from the FSF.

The foundation is also seeking general event, beer, or food sponsors. To sponsor or recommend a sponsor, or to volunteer, contact campaigns@fsf.org.

Satellite events

Supporters around the world have already expressed interest in holding their own local events for the FSF's birthday. The foundation would be delighted to cover these events on its blog or come up with a creative way of connecting them to the event in Boston. Please contact campaigns@fsf.org if you are interested in organizing a satellite event.

Streaming

The FSF intends to livestream the event and post videos online afterwards. Volunteers with free software video skills are needed as well.

Read the New Yorker article, The GNU Manifesto Turns Thirty by Maria Bustillos.

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

Georgia Young
Program Manager
Free Software Foundation
+1 (617) 542 5942
campaigns@fsf.org

July 24, 2015 03:40 PM

FSF Blogs

You're invited: 30th birthday party and mini-conference

FSF30 logo

Join the Free Software Foundation and friends in Boston, MA, USA on the evening of Saturday, October 3rd for our 30th Birthday Party. We'll share hors d'oeuvres, drinks, and an address by FSF founder and president Richard Stallman, as well as plenty of social time for catching up with old friends and making new ones.

RSVP now! If you want to brag about it on social media, use the hashtag #FSF30.

If the free software movement is coming together for a party, we might as well get some work done, too. We're planning a mini-conference for the day of October 3rd, before the party, where we'll share what we've learned from the first thirty years of the free software movement and swap ideas about the future. Stay tuned for more details about this, as well as a possible dinner on Friday night.

Bookmark the event homepage for lodging suggestions and more information about the mini-conference and other festivities that weekend, coming soon.

Not coming to Boston?

We've been flattered by supporters around the world asking to hold their own local events for the FSF's birthday. Of course! We'd even love to write about it, or come up with a creative way of connecting it to the event in Boston. Contact us at campaigns@fsf.org if you're interested.

We also intend to stream the event and post videos online afterwards.

Support our work for computer user freedom

Our supporters have made our thirty wonderful years possible. By becoming an associate member you'll help us achieve even more in the next thirty. Members also get special benefits, including gratis admission to our LibrePlanet conference each spring.

If you'd rather not become a member, you can also help by making a donation when you RSVP, or on our donation page.

Volunteer or sponsor

If you are interested in helping out at the mini-conference or the party, we welcome you! In addition to setting up the venue and greeting guests, we need people with skills in free software livestreaming. All volunteers will receive a special reverse birthday gift from us to you.

The FSF is also seeking general event, beer, or food sponsors. To sponsor or recommend a sponsor, or to volunteer, reply to this email.

Also, we'd like to introduce Georgia Young, our newest FSF staffer, in the role of program manager. Georgia is planning the thirtieth birthday events, so expect to hear more from her soon.

See you in October!

Read the New Yorker Article, The GNU Manifesto Turns Thirty by Maria Bustillos.

July 24, 2015 03:20 PM

FSF Events

EmacsConf (San Francisco, CA)

EmacsConf is a conference about the joy of Emacs, Emacs Lisp, and memorizing key sequences.

If you'd like to attend, please send an e-mail to register@emacsconf2015.org expressing your interest in going so that the organizers can save you a space.

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

July 24, 2015 02:03 PM

July 22, 2015

FSF Blogs

Now at a new time, Friday Free Software Directory IRC meeting: July 24

Join the FSF and friends this Friday, July 24 — at a new time — from 12pm to 3pm EDT (16:00 to 19:00 UTC) to help improve the Free Software Directory by adding new entries and updating existing ones. We will be on IRC in the #fsf channel on freenode. There are also weekly FSD Meetings pages that everyone is welcome to contribute to before, during, and after each meeting.

Tens of thousands of people visit directory.fsf.org each month to discover free software. Each entry in the Directory contains a wealth of useful information, from basic category and descriptions to providing detailed info about version control, IRC channels, documentation, and licensing info that has been carefully checked by FSF staff and trained volunteers.

While the Free Software Directory has been and continues to be a great resource to the world over the past decade, it has the potential to be a resource of even greater value. But it needs your help!

If you are eager to help and you can't wait or are simply unable to join on IRC on Friday, our participation guide will provide you with all the information you need to get started helping the Directory today!

Still can't figure out what time the meeting starts? Open up a terminal and enter the following to get the start time in your time zone:

date --date='TZ="America/New_York" 12:00 this Fri'

July 22, 2015 07:28 PM

guix @ Savannah

GNU Guix 0.8.3 released

We are pleased to announce the next alpha release of GNU Guix, version 0.8.3.

The release comes with USB installation images to install the standalone Guix System Distribution (GuixSD), and with tarballs to install the package manager on top of a running GNU/Linux system, either from source or from binaries.

The highlights for this release include:

See http://lists.gnu.org/archive/html/guix-devel/2015-07/msg00585.html for details.

About GNU Guix

GNU Guix is a functional package manager for the GNU system. The Guix System Distribution or GuixSD is an advanced distribution of the GNU system that relies on GNU Guix and respects the user's freedom.

In addition to standard package management features, Guix supports transactional upgrades and roll-backs, unprivileged package management, per-user profiles, and garbage collection. Guix uses low-level mechanisms from the Nix package manager, except that packages are defined as native Guile modules, using extensions to the Scheme language. GuixSD offers a declarative approach to operating system configuration management, and is highly customizable and hackable.

GuixSD can be used on an i686 or x86_64 machine. It is also possible to use Guix on top of an already installed GNU/Linux system, including on mips64el and armv7.

by Ludovic Courtès at July 22, 2015 09:25 AM

parallel @ Savannah

GNU Parallel 20150722 ('Pluto') released

GNU Parallel 20150722 ('Pluto') has been released. It is available for download at: http://ftp.gnu.org/gnu/parallel/

Haiku of the month:

Multi cores I see.
Doing nothing. I say no!
Use GNU Parallel.
-- Ole Tange

New in this release:

  • If a record fits in a block, --block only reads upto the size of --block. If not: --block reads a full --block more.
  • Due to widely spread distributions still using --tollef even after a year of being retired following a year of being obsolete, --tollef now gives an error unless used with --gnu.
  • --nice now uses a perl wrapper instead of the nice command.
  • Cookie 2013-08-18 was won by Mark Maimone, 1 year and 11 months after release.
  • GNU Parallel was cited in: Dynamical formation & scattering of hierarchical triples: Cross sections, Kozai-Lidov oscillations, and collisions http://arxiv.org/pdf/1507.03593.pdf
  • Bug fixes and man page updates.

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 is 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/) | bash

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

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

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

O. Tange (2011): GNU Parallel - The Command-Line Power Tool, ;login: The USENIX Magazine, February 2011:42-47.

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://www.gnu.org/s/parallel/merchandise.html
  • 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 GNU Parallel for research:

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

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.

by Ole Tange at July 22, 2015 07:31 AM

July 21, 2015

FSF Blogs

SeaGL: A free software conference that's not just for the birds

The Seattle GNU/Linux Conference -- we like to call it SeaGL -- is the Emerald City’s best grassroots technical conference for free and libre software. The 3rd annual conference happens Friday, October 23 and Saturday, October 24 at Seattle Central College, and it’s already shaping up to be better than last year!

First, we’re thrilled to announce the keynote addresses will be delivered by the FSF’s own Richard M. Stallman, and Shauna Gordon-McKeon, the main organizer of OpenHatch’s campus events. This year we’re honoring the origins of free software while recognizing the importance of growing the movement through recruiting new activists, users, and enthusiasts.

We are also accepting nominations for the first annual Cascadia Community Builder award recognizing a person who has significantly contributed to the free software movement in Washington, Oregon, British Columbia, or Idaho. Please take a minute to nominate someone who is doing great community work in the area!

We’re also looking for speakers. Our Call for Participation is open until July 26. SeaGL welcomes a diverse range of topics. It doesn’t matter if this is your first conference presentation or your fifteenth; If you’re excited about a topic related to GNU/Linux or free software, then we want to hear about it. We’ll be helping folks edit and flesh out their proposals in our IRC channel, #seagl, a few times over the next couple of weeks.

Finally, for groups or businesses interested in sponsoring the event, the Exhibitor & Sponsor Prospectus is now posted. We will have a small hall with tables available for sponsors and exhibitors, with free tables available for local nonprofit or educational organizations.

Here are the details:

http://seagl.org

Friday, October 23 to Saturday, October 24, 2015

Seattle Central College

Cost: Free (as in beer). No registration necessary.

July 21, 2015 02:50 PM

denemo @ Savannah

Release 1.2.4 is out

New features in this version:

Command Search Improved
Search for commands containing key words
Fuzzy search
Search command help text and label

New Commands
Choose format of rehearsal marks
Plain, boxed or circled
Alphabetic or Numeric
Controls for page numbering

Music Snippets
Saved with the score
Use extended to all objects
Command for insertion from keyboard
Re-labelling of snippets

Staff Groups (Braces)
Graphically displayed
Click to edit the start or end

Updated Manual
New sections on Command Center, Tablature, Fret Diagrams …

Autosave
Auto-saved versions detected on start up
Save rate in granularity of seconds

Bug Fixes
Fix over long menus
Menu of searchable objects avoid spurious items
Improved Check Score routine
more errors detected
error position indicated in all cases

Known issues for this release:
option -a is ignored unless -n is given.

Here are the compressed sources (from a mirror) :

http://ftpmirror.gnu.org/denemo/denemo-1.2.4.tar.gz

If automatic redirection fails, the list of mirrors is at:
http://www.gnu.org/order/ftp.html

Or if need be you can use the main GNU ftp server:

ftp://ftp.gnu.org/gnu/denemo/denemo-1.2.4.tar.gz

by Richard Shann at July 21, 2015 11:19 AM

July 20, 2015

GNUnet News

IETF getting cold feet about P2P Names?

With broad support from the P2P community, we have been trying for a while to follow RFC 6761 to register special use domain names for ".bit", ".exit", ".gnu", ".i2p", ".onion" and ".zkey" to reduce the likelihood of ICANN accidentally creating a conflicting gTLD assignment.

by Christian Grothoff at July 20, 2015 04:26 PM

July 19, 2015

guix @ Savannah

GSoC update

This year Guix was lucky to have 3 GSoC projects, and they have made rather good progress so far:

  • Manolis successfully completed the recipes to get a cross-compilation toolchain to GNU/Hurd, with part of the work already in the main branch. This allowed him to produce statically-linked bootstrap binaries (stumbling upon nasty ld.so issues on the way.) Manolis is now running Guix and building packages natively on GNU/Hurd, which will constitute a large part of the remainder of his project.
  • Rémi has written Guile bindings to crucial parts of the GNUnet API, including the file sharing API. This will allow him to move to the next step: Writing tools to publish and retrieve Guix substitutes (pre-built binaries.)
  • Rohan laid the foundations of the DHCP client. The current code can send packets on all the configured network interfaces. Rohan hopes to have working code to establish leases in the following weeks.

Happy hacking!

About GNU Guix

GNU Guix is a functional package manager for the GNU system. The Guix System Distribution or GuixSD is an advanced distribution of the GNU system that relies on GNU Guix and respects the user's freedom.

In addition to standard package management features, Guix supports transactional upgrades and roll-backs, unprivileged package management, per-user profiles, and garbage collection. Guix uses low-level mechanisms from the Nix package manager, except that packages are defined as native Guile modules, using extensions to the Scheme language. GuixSD offers a declarative approach to operating system configuration management, and is highly customizable and hackable.

GuixSD can be used on an i686 or x86_64 machine. It is also possible to use Guix on top of an already installed GNU/Linux system, including on mips64el and armv7.

by Ludovic Courtès at July 19, 2015 08:57 AM

July 17, 2015

FSF Blogs

Fall internships with the Free Software Foundation: Apply by July 31st

Do you want to help people learn why free software matters, and how to use it? Do you want to dig deep into software freedom issues like copyleft, Digital Restrictions Management, or surveillance and encryption?

The Free Software Foundation is looking for fall interns to work in one of three areas: spend the semester contributing to our campaigns, licensing, or technical team.

These positions are unpaid, but the FSF will provide any appropriate documentation you might need to receive funding and school credit from outside sources. We place an emphasis on providing hands-on educational opportunities for interns in which they work closely with staff mentors on semester-long projects that match their skills and interest.

Our current campaigns intern is focusing on computer user privacy and encryption, expanding our Email Self-Defense project. Past licensing interns have worked to improve the Free Software Directory and analyzed the compatibility of other licenses with the GPL. And a past sysadmin intern did extensive work to set up our StatusNet instance.

Fall internships begin on or about August 31st and run through December 4th. We prefer candidates who are able to work in our Boston office, but may consider remote interns. The deadline to apply for a fall internship at the Free Software Foundation is July 31st.

To apply, send a letter of interest and a resume with two references to hiring@fsf.org. Please send all application materials in free software-friendly formats like .pdf, .odt, and .txt. Use "Fall internship application" as the subject line of your email. Please include links to your writing, design, or coding work if it applies -- personal, professional, or class work is acceptable. URLs are preferred, though email attachments in free formats are acceptable, too. Learn more about our internships, and direct any questions to info@fsf.org.

July 17, 2015 07:17 PM

July 15, 2015

FSF News

Statement on Canonical's updated licensing terms for Ubuntu GNU/Linux

This update now makes Canonical's policy unequivocally comply with the terms of the GNU General Public License (GPL) and other free software licenses. It does this by adding a "trump clause" that prevails in all situations possibly covered by the policy:

Ubuntu is an aggregate work of many works, each covered by their own license(s). For the purposes of determining what you can do with specific works in Ubuntu, this policy should be read together with the license(s) of the relevant packages. For the avoidance of doubt, where any other license grants rights, this policy does not modify or reduce those rights under those licenses.

In July 2013, the FSF, after receiving numerous complaints from the free software community, brought serious problems with the policy to Canonical's attention. Since then, on behalf of the FSF, the GNU Project, and a coalition of other concerned free software activists, we have engaged in many conversations with Canonical's management and legal team proposing and analyzing significant revisions of the overall text. We have worked closely throughout this process with the Software Freedom Conservancy, who provides their expert analysis in a statement published today.

While the FSF acknowledges that the first update emerging from that process solves the most pressing issue with the policy -- its interference with users' rights under the GNU GPL and potentially other copyleft licenses covering individual works within Ubuntu -- the policy remains problematic in ways that prevent us from endorsing it as a model for others. The FSF will continue to provide feedback to Canonical in the days ahead, and urge them to make additional changes.

Today's "trump clause" makes clear that, for example, Canonical's requirement that users recompile Ubuntu packages from source code before redistributing them is not intended to and does not override the GPL's explicit permission for users to redistribute covered packages in binary form (with no recompilation requirement) as long as they also provide the corresponding source.

While this change handles the situation for works covered by the GPL, it does not help works covered by lax permissive licenses (such as the X11 license) that do allow such additional restrictions. With that in mind, the FSF has urged Canonical to not only respect the GPL but to also change its terms to remove restrictions on any of the free works it distributes, no matter which license covers that software. In the meantime, this is a useful reminder that developers are nearly always better off choosing copyleft licenses like the GPL in order to prevent others from imposing arbitrary restrictions on users.

Further, the patent language in the current policy should be replaced with a real pledge to only make defensive use of patents and to not initiate litigation against other free software developers. The trademark policy should be revised to provide better guidance to downstream distributors so that they can be confident they know exactly where and when trademarks need to be removed in order to comply with the policy.

Canonical, in our conversations, repeatedly expressed that it is their full intention to liberally allow use of their trademarks and patents by community projects, and not to interfere with the exercise of rights under any copyleft license covering works within Ubuntu. While we appreciate today's development and do see it as a big step in that direction, we hope they will further revise the policy so that users, to the greatest extent possible, know their rights in advance rather than having to inquire about them or negotiate them. To this end, it will be important to choose language and terms that emphasize freedom over power and avoid terms like intellectual property, which spread bias and confusion.

It would be helpful for the FSF, as we evaluate the importance of the remaining work like this to be done with Canonical in relation to the other activities of the FSF's Licensing and Compliance Lab (such as doing GPL enforcement, and developing public educational materials about free software licensing), to know how significantly you, as a free software user, see this policy affecting your rights. Please contact us at licensing@fsf.org, and Canonical via their contact form.

Donations to support the work of the FSF's Licensing and Compliance Lab in safeguarding your freedoms can be made at https://donate.fsf.org. Over 80% of the FSF's annual funding comes from individuals like you.

Lastly, we wish to thank FSF general counsel Eben Moglen and everyone at the Software Freedom Law Center for their pro bono legal counsel and extensive participation in the conversations of the last two years.

July 15, 2015 02:20 PM

July 14, 2015

FSF Events

Richard Stallman to speak at NYC Camp (New York, NY)

Richard Stallman will be giving the NYC Camp keynote address. His speech will be nontechnical and the public is encouraged to attend.

Please see event page for registration/admission requirements. Attendees will have to present a valid ID to gain access to the building.

Speech topic and start time to be determined. Speech tentatively scheduled to run from 13:30 to 14:15, but might start a little later or a little earlier.

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

July 14, 2015 01:48 PM

gnuzilla @ Savannah

IceCat 31.8.0 release

GNUzilla is the GNU version of the Mozilla suite, and GNU IceCat is the GNU version of the Firefox browser. Its main advantage is an ethical one: it is entirely free software. While the Firefox source code from the Mozilla project is free software, they distribute and recommend non-free software as plug-ins and addons. Also their trademark license restricts distribution in several ways incompatible with freedom 0.
https://www.gnu.org/software/gnuzilla/

The user manual pages are at http://libreplanet.org/wiki/Group:IceCat/
You can contribute by joining the wiki and editing the manuals.

The user manual pages are at http://libreplanet.org/wiki/Group:IceCat/
You can contribute by joining the wiki and editing the manuals.

Source tarballs, binaries for generic GNU/Linux systems and translations
are available at http://ftp.gnu.org/gnu/gnuzilla/31.8.0/
GPG key ID:D7E04784 GNU IceCat releases
Fingerprint: A573 69A8 BABC 2542 B5A0 368C 3C76 EED7 D7E0 4784
https://savannah.gnu.org/project/memberlist-gpgkeys.php?group=gnuzilla

Changes since v31.7.0

  • Applied fix for LogJam attack https://weakdh.org/
  • HTML5 Video Everywhere updated to 0.2.38.1
  • LibreJS updated to 6.0.9
  • HTTPS-Everywhere updated to 5.0.5
  • Spyblock updated to 2.6.9.0 from upstream changes
  • Disabled hardware acceleration and WebGL

Also applied the the upstream fixes listed upstream at:
https://www.mozilla.org/en-US/security/known-vulnerabilities/firefox-esr/

by Ruben Rodriguez at July 14, 2015 04:11 AM

July 13, 2015

FSF Events

Meetup - with FSF campaigns manager Zak Rogoff (Phoenix, AZ)

Mingle with the local free software community and FSF campaigns manager Zak Rogoff. There will be appetizers with vegan and vegetarian options courtesy of the FSF, and more food and drink available to buy (full menu). All ages welcome.

This is an informal gathering for anyone interested in spending time with the free software community or learning more about the FSF; you don't have to be a current member to attend. So come hang out and talk software freedom over a beer or soft drink.

RSVP: We'd love it if you'd let us know you're coming, so we can better estimate attendance. Please contact us at campaigns@fsf.org if you can make it, or if you have any questions.

July 13, 2015 10:16 PM

July 12, 2015

GNUtls

GnuTLS 3.4.3

Released GnuTLS 3.3.16 and GnuTLS 3.4.3 which are bug fix releases in the current and next stable branches.

by Nikos Mavrogiannopoulos (nmav@gnutls.org) at July 12, 2015 12:00 AM

July 10, 2015

gettext @ Savannah

July 08, 2015

FSF Blogs

GNU Spotlight with Brandon Invergo: 26 new GNU releases!

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

To download: nearly all GNU software is available from http://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 Thien-Thi Nguyen as the new maintainer of GNU Superopt.

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.

July 08, 2015 10:17 PM

FSF News

FSF endorses embedded GNU/Linux distro ProteanOS as fully free

The FSF's list consists of ready-to-use full GNU/Linux systems whose developers have made a commitment to follow the Guidelines for Free System Distributions. This means each distro includes and steers users toward exclusively free software. All distros on this list reject nonfree software, including firmware "blobs" and nonfree documentation.

ProteanOS is a new, small, and fast distribution that primarily targets embedded devices, but is also being designed to be part of the boot system of laptops and other devices. The lead maintainer of ProteanOS is P. J. McDermott, who is working closely with the Libreboot project and hopes to have ProteanOS be part of the boot system of Libreboot-compatible devices.

"ProteanOS combines the ease of installation of a binary distribution with the flexibility of a source distribution or build system: its platform configuration feature allows binary packages to be configured at build-time and run-time for different hardware and use cases," said McDermott.

The distro is being independently developed and is not based on other distributions. Users and potential contributors will find a complete toolchain with which the distro can build all of its own packages. Those interested in contributing to ProteanOS can start by joining the project mailing list and looking over the developer documentation.

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

About the GNU Operating System and Linux

Richard Stallman announced in September 1983 the plan to develop a free software Unix-like operating system called GNU. GNU is the only operating system developed specifically for the sake of users' freedom. See https://www.gnu.org/gnu/the-gnu-project.html.

In 1992, the essential components of GNU were complete, except for one, the kernel. When in 1992 the kernel Linux was re-released under the GNU GPL, making it free software, the combination of GNU and Linux formed a complete free operating system, which made it possible for the first time to run a PC without non-free software. This combination is the GNU/Linux system. For more explanation, see https://www.gnu.org/gnu/gnu-linux-faq.html.

Media Contacts

Joshua Gay
Licensing & Compliance Manager
Free Software Foundation
+1 (617) 542 5942
licensing@fsf.org

July 08, 2015 07:25 PM

FSF Blogs

The Licensing and Compliance Lab interviews Joël Krähemann, maintainer of Advanced GTK+ Sequencer

In this edition, we conducted an IRC-based interview with Joël Krähemann, Maintainer of Advanced GTK+ Sequencer. Joël is an IT professional in Switzerland and works on music for fun. Advanced GTK+ Sequencer (AGS) is a an audio processing and composition tool.

What inspired you to create AGS?

I'm a long time GNU/Linux user and enthusiast. I had dislikes about Rosegarden but it was you're only choice in 2002 to do composition on a free operating system. So, I decided to write new software. I chose to write it in C, because it is my favorite programming language, and further, GObject does a great job to do basic tasks for implementing a library.

What features do you think really set AGS apart from similar software?

For users, the modular GUI and multi-channel editing. For example, you may edit each audio channel on its own or as a group. Also, in the latest version there is also a new pattern editor. For developers, its atomic design, its multi-threaded capabilities, and that it is object orientated are what make it stand apart.

Why did you choose the GNU GPLv3 as the license for AGS?

It's evident software must be free in order the give you freedoms to share, learn or improve. I read the GNU GPL and decided it fit my needs.

How can people help contribute to AGS?

Contributing good code, good documentation, or reporting bugs is probably the best way someone can help to contribute. But, there are many other ways to contribute, like spreading the word.

Right now, users need to download source code or binary distro packages provided on the project's website. So getting distributions to provide those packages in their repositories would also be a good way to contribute.

What's the next big thing for AGS?

AGS 0.4.3 brings extended MIDI support and LV2 host implementation. Down the road, LibAGS 1.0 will be released, and it will give users users remote and scripting capabilities, as well desktop integration for GNU/Linux.

Enjoy this interview? Check out our previous entry in this series, featuring François Marier, of Libravatar

July 08, 2015 04:33 PM

July 05, 2015

GNU Remotecontrol

Newsletter – July 2015

THIS MONTH…..

  • TRENDS
  • EYE CATCHING
  • ANNUAL PLAN
  • DISCUSSIONS
  • EXISTING CODE
  • SECURITY
  • LASTLY
TRENDSThe stuff going on in the big picture now

United States Electricity Price per KWH
Present and Past

April May Trend % Change
$0.137 $0.137 Same 0.00%
Year May Trend % Change % Since Difference
2005 $0.097 Same 0.00% 0.00% 0.00%
2006 $0.110 Increase 13.40% 13.40% 13.40%
2007 $0.115 Increase 4.55% 18.56% 5.15%
2008 $0.120 Increase 4.35% 23.71% 5.15%
2009 $0.126 Increase 5.00% 29.90% 6.19%
2010 $0.127 Increase 0.79% 30.93% 1.03%
2011 $0.129 Increase 1.57% 32.99% 2.06%
2012 $0.129 Same 0.00% 32.99% 0.00%
2013 $0.131 Increase 1.55% 35.05% 2.06%
2014 $0.136 Increase 3.82% 40.21% 5.15%
2015 $0.137 Increase 0.74% 41.24% 1.03%

 

United Kingdom Utility Prices
Present and Past

London_Night

London by night

EYE CATCHINGThe stuff that has caught our eye

Demand Response
The clear message in play now, from many sources, is Demand Response has a money problem. The problem seems to be driven by not having a sound financial plan to replace thousands of miles of supply and distribution lines with new technologies called the Smart Grid. This problem is no surprise, as any sound strategy involves both supply and execution planning. A recent decision has approved substantial modifications to a capacity market framework, known as the Reliability Pricing Model (RPM). Many industry observers believe this decision will lead to substantial increases in capacity prices, spurring the development of Demand Response resources. Another article affirms Demand Response spending has officially stalled. “Leadership of the utility sector has really embraced energy efficiency as a core part of their business…” They now have to find the willingness to spend money. A consistent article holds the position Demand Response is key to utilities’ survival. This is a strong statement, but a well-supported argument justifies this position. GNU remotecontrol maintains our long held position, as stated in our 2014 FSF interview, the success of the Smart Grid, in the context of the network connected HVAC thermostat, requires a team of the financial officer, mechanical engineer, and information technology to find how to make the Smart Grid a sustainable reality.

Smart Grid – Consumer
An article reports the national electrical grid is getting smarter, but the average consumer customer is not realizing the benefits. This condition is due to the presence of electric meters speaking with the Smart Grid, though not too many appliances and devices in the customer residence. This condition is caused by a lack of clear interoperable standards enabling mass production and commoditization of appliances and devices. A short-term gain can be realized by helping customers see in their electric bill how lesser spending impacts their purchasing value. This gain is realized by improved customer relation management on the part of the electricity provider. This gain also positions the electricity provider to better respond when appliances and devices begin to become part of the Smart Grid. A related article finds Google Nest is providing more devices for sale, but not providing energy management applications, let alone application capabilities including security, convenience and connectivity. A relevant article finds the Apple Siri Smart Home has stumbled from their launch, from design failures causing tenuous reliability. This is a clear pattern money and size, alone or combined, do not necessarily deliver a viable network connected HVAC thermostat management strategy, let alone a software application.

Smart Grid – Producer
A recent study found consumers are not unjustified to waive weatherization subsidies, to achieve energy efficiency. This finding is determined as the return on the investment is not enough to justify the investment expense. Again, strong evidence the consumer is mindful of the cost to achieve efficiency and is pursuing more viable options. A related article found little to no economic value gained by in-home displays for implementing time-of-use electricity pricing plans. People are not willing to stand and wait for a message to purchase electricity at a lower rate. Another delivery mechanism must be found to offer the lower purchase rate. A recent report provides recommendations of how to effectively achieve time-of-use electricity pricing plans. Again, the source of the problem to find energy efficiency is a financial problem, due to not offering what people want to purchase in the manner they want to purchase. This is more than a marketing or technology problem.

ANNUAL PLAN

Status of our 2015 Plan

ModelViewController

  • We are in development stage.
  • We are approximately 80% finished with development.
  • We have simplified index.php to have lesser fields for displaying thermostat profiles, through the usage of supporting web forms.
  • These additional web forms accommodate handling more information and separating information changing on a less frequent basis from the view of index.php page.
  • We have separated sensor calibration from the index.php page, to avoid any risk of inadvertently altering calibration settings.
  • We have achieved selecting thermostats by group functionality.
  • The outcome is only viewing what is necessary for changing HVAC control settings.
  • We are prepared to immediately enter structured system testing, upon completion of development.
  • We maintain our position to release a subsequent version, 2.1, within six months of releasing v2.0, as we do not want to delay MVC from being available to the general public.

Translation Subsystem

  • More work on the items addressed in the April 2015 newsletter.

ANSI C

  • More work on the items addressed in the April 2015 newsletter.

Talk to us with your comments and suggestions on our plan for the next year.

DISCUSSIONS

VISUALIZATION
Our efforts to read from and write to the network connected HVAC thermostat, in combination with gathering data from weather stations, has resulted in identifying usage patterns we did not expect. Visualization has helped us identity these patterns. Specifically, the ability to know with a considerable amount of accuracy how much energy it will take to either heat or cool a facility, based upon historical run time of the equipment. A pertinent article addressed the benefits of visualization. We have rendered the data we have collected in various graphs and charts. An excellent example of successfully combining data and visualization is the Chesapeake Bay Interpretive Buoy System. We see no reason not to include visualization in GNU remotecontrol. We have decided to include this visualization functionality in a future release. We estimate this functionality will be developed and released in either version 2.2 or 3.0, depending upon user feedback.

Please contact us, if you would like to participate in the completion of version 2.0.

OTHER TYPES OF THERMOSTATS?
Many people have asked us about adding other types of thermostats to GNU remotecontrol. There are three questions that need to be answered before we can offer GNU remotecontrol support for any IP thermostat. These questions are:

  • How to CONNECT to it (NETWORK).
  • How to READ from it (CODE).
  • How to WRITE to it (CODE).

It is our hope to have dozens and dozens of thermostat types that work with GNU remotecontrol. Let us know if you designed or manufactured a device and you would like to test it with GNU remotecontrol.

EXISTING CODEThe stuff you may want to consider

BUGS
We have 0 new bugs and 0 fixed bugs since our last Blog posting. Please review these changes and apply to your GNU remotecontrol installation, as appropriate.

TASKS
We have 0 new tasks and 0 completed tasks since our last Blog posting. Please review these changes and apply to your GNU remotecontrol installation, as appropriate.

SECURITYThe stuff you REALLY want to consider

ASSET MANAGEMENT
A common security threat is one computer posing as another computer. This is also true at the device level. We identify the need to mature the firmware running on all known network connected HVAC thermostats, to have improved security capabilities. We are discussing this need now, both internally and externally, to determine how we can better assist with providing security measures to prevent against any form of thermostat hijacking. We first discussed this concept in our February 2013 edition. The risk of convenience through remote access is too great of risk to bear, given the impact of nefarious activity with your HVAC system.

REMEMBER
GNU remotecontrol relies on OS file access restrictions, Apache authentication, MySQL authentication, and SSL encryption to secure your data. Talk to us you want to find out how you can further strengthen the security of your system, or you have suggestions for improving the security of our current system architecture.

LASTLY

Whatever you do…..don’t get beat up over your Energy Management strategy. GNU remotecontrol is here to help simplify your life, not make it more complicated. Talk to us if you are stuck or cannot figure out the best option for your GNU remotecontrol framework. The chances are the answer you need is something we have already worked through. We would be happy to help you by discussing your situation with you.

…..UNTIL NEXT MONTH!

Why the Affero GPL?

GNU Affero General Public License LOGO

GNU remotecontrol LOGO


by gnuremotecontrol at July 05, 2015 09:56 PM

July 04, 2015

Andreas Enge

Kernel recompilation on Novena

For Guix to work, the Novena board needs a kernel option that is disabled by default. So before installing Guix, one needs to rebuild a kernel, which is amazingly easy using a check-out of the official Novena Linux kernel sources and a script also provided by the project.

On the Novena machine, clone the Novena Linux kernel repository:

git clone https://github.com/xobs/novena-linux.git

and change into the newly created directory:

cd novena-linux

The default branch is the older v3.17-rc5-novena; check out the newest one:

git checkout origin/v3.19-novena

Copy the configuration of the currently running kernel:

zcat /proc/config.gz > .config

Open .config in an editor, look for the line

# CONFIG_DEVPTS_MULTIPLE_INSTANCES is not set

and replace it by

CONFIG_DEVPTS_MULTIPLE_INSTANCES=y

The Novena Wiki contains a script to build a Debian package of the kernel; I slightly modified it as follows and stored it under the name build.sh in the novena-linux directory:

#!/bin/sh
threads=4
version=1.4
make -j${threads} \\
        LD=gold \\
        KBUILD_DEBARCH=armhf \\
        KBUILD_IMAGE=zImage \\
        KBUILD_DTB=imx6q-novena.dtb \\
        KBUILD_DESTDIR=usr/share/linux-novena-custom \\
        KDEB_PKGVERSION=${version} \\
        EMAIL="andreas@enge.fr" \\
        NAME="Andreas Enge" \\
        dtbs || exit 1
make -j${threads} \\
        LD=gold \\
        KBUILD_DEBARCH=armhf \\
        KBUILD_IMAGE=zImage \\
        KBUILD_DTB=imx6q-novena.dtb \\
        KBUILD_DESTDIR=usr/share/linux-novena-custom \\
        KDEB_PKGVERSION=${version} \\
        EMAIL="andreas@enge.fr" \\
        NAME="Andreas Enge" \\
        deb-pkg

I switched to four threads instead of the suggested two, since after all we have four cores, and changed the name and e-mail addresses (which modifies the maintainer field of the final package). I also modified KBUILD_DESTDIR, where the resulting kernel image will be installed, from usr/share/linux-novena to a custom location; this turned out to be an unnecessary precaution, as the file names contain sufficient information on the kernel versions to avoid conflicts. The version number in the script is that of the Debian package and of minor importance; it can be increased if one compiles a newer kernel later on.

Make the script executable:

chmod u+x build.sh

execute it:

./build.sh

and wait for a few hours while the kernel compiles.

The output is (in my case one directory up, do a cd .., or maybe cd $HOME) given by five files:

linux-firmware-image-3.19.0-00273-ge3b61d5_1.4_armhf.deb
linux-headers-3.19.0-00273-ge3b61d5_1.4_armhf.deb
linux-image-3.19.0-00273-ge3b61d5_1.4_armhf.deb
linux-image-3.19.0-00273-ge3b61d5-dbg_1.4_armhf.deb
linux-libc-dev_1.4_armhf.deb

Only the third one is really needed. Install it with

dpkg -i linux-image-3.19.0-00273-ge3b61d5_1.4_armhf.deb

This installs the kernel modules into /lib/modules/3.19.0-00273-ge3b61d5/ and a number of files in /usr/share/linux-novena-custom/ (the KBUILD_DESTDIR of the script above):

config-3.19.0-00273-ge3b61d5
initrd.img-3.19.0-00273-ge3b61d5
System.map-3.19.0-00273-ge3b61d5
vmlinuz-3.19.0-00273-ge3b61d5
vmlinuz-3.19.0-00273-ge3b61d5.dtb

The first one is a copy of the .config created in the beginning. By the post-install scripts of the Debian package, the last two files are copied to /boot, under the names of zImage and novena.dtb, respectively.

Reboot, and the new kernel is active.

Thanks to Ludovic Courtès and Mark Weaver for their advice on obtaining the correct configuration.

by andreas at July 04, 2015 07:16 PM

July 03, 2015

coreutils @ Savannah

coreutils-8.24 released [stable]

by Pádraig Brady at July 03, 2015 10:13 PM

July 02, 2015

FSF Blogs

Friday Free Software Directory IRC meetup: July 3

Join the FSF and friends Friday, July 3, from 2pm to 5pm EDT (18:00 to 21:00 UTC) to help improve the Free Software Directory by adding new entries and updating existing ones. We will be on IRC in the #fsf channel on freenode.

Tens of thousands of people visit directory.fsf.org each month to discover free software. Each entry in the Directory contains a wealth of useful information, from basic category and descriptions, to providing detailed info about version control, IRC channels, documentation, and licensing info that has been carefully checked by FSF staff and trained volunteers.

While the Free Software Directory has been and continues to be a great resource to the world over the past decade, it has the potential of being a resource of even greater value. But it needs your help!

If you are eager to help and you can't wait or are simply unable to make it onto IRC on Friday, our participation guide will provide you with all the information you need to get started on helping the Directory today!

July 02, 2015 08:52 PM

Teaching Email Self-Defense: Campaigns intern leads a workshop at PorcFest

The Web of trust

My workshop on Email Self-Defense took place at the 12th annual Porcupine Freedom Festival in Lancaster, New Hampshire. Around eight people attended, which was a few more than I expected. Christopher Waid and Bob Call of ThinkPenguin joined me in helping everyone who brought a laptop to set up GnuPG properly. Those who didn't bring a laptop participated by observing the process on the system most similar to their own and asking questions about particular steps, so as to enable them to achieve the same configuration when they returned home.

The workshop was part of the Alternatives Exposition, which brings together people with a broad range of interests with the intention of helping strengthen community and build alternative infrastructure. Free software supporter François-René Rideau also participated in the AltExpo, delivering an excellent talk titled Who Controls Your Computer? which swayed many attendees to investigate the benefits of free software. Thank you, François!

Although I attended PorcFest as an individual (as opposed to a representative of the FSF), I encouraged everyone I talked with to switch to free software. Without freedom, security and privacy are unrealistic goals.

I'm back at the Free Software Foundation now, and I'm processing my experiences. The workshop went well, and provided me with insights on how to better organize similar workshops in the future. Right now, I'm formalizing those insights into a Facilitating Email Self-Defense Workshops guide, to be published within the next two months.

In the meantime, I'd like to ask all of you: what unusual and extraordinary people do you know about who use GnuPG? I'm going to include a list of inspiring people who use GnuPG in my guide, and I'd love hear your suggestions! Send them to campaigns@fsf.org or, for encrypted messages, adaml@fsf.org with the GnuPG key fingerprint 9D7E D11A F670 9719 F854 A307 198C 9A1E 9309 EF0C.

I'm a campaigns intern at the FSF -- learn more about our internships.

July 02, 2015 08:17 PM

July 01, 2015

guix @ Savannah

Reproducible and User-Controlled Software Environments in HPC with Guix

Our paper entitled Reproducible and User-Controlled Software Environments in HPC with Guix was accepted for RepPar, a workshop on reproducibility in parallel computing:

Support teams of high-performance computing (HPC) systems often find themselves between a rock and a hard place: on one hand, they understandably administrate these large systems in a conservative way, but on the other hand, they try to satisfy their users by deploying up-to-date tool chains as well as libraries and scientific software. HPC system users often have no guarantee that they will be able to reproduce results at a later point in time, even on the same system—software may have been upgraded, removed, or recompiled under their feet, and they have little hope of being able to reproduce the same software environment elsewhere. We present GNU Guix and the functional package management paradigm and show how it can improve reproducibility and sharing among researchers with representative use cases.

The paper can be thought of as a followup to the recent experience report by Ricardo Wurmus.

We believe package management and reproducibility are key topics for HPC research. We are glad to have this opportunity to discuss the subject with researchers of the field.

About GNU Guix

GNU Guix is a functional package manager for the GNU system. The Guix System Distribution or GuixSD is an advanced distribution of the GNU system that relies on GNU Guix and respects the user's freedom.

In addition to standard package management features, Guix supports transactional upgrades and roll-backs, unprivileged package management, per-user profiles, and garbage collection. Guix uses low-level mechanisms from the Nix package manager, except that packages are defined as native Guile modules, using extensions to the Scheme language. GuixSD offers a declarative approach to operating system configuration management, and is highly customizable and hackable.

GuixSD can be used on an i686 or x86_64 machine. It is also possible to use Guix on top of an already installed GNU/Linux system, including on mips64el and armv7.

by Ludovic Courtès at July 01, 2015 10:05 AM

FSF Events

Richard Stallman to speak at SeaGL (Seattle, WA)

Richard Stallman will be delivering the keynote speech at this year's SeaGL, the 2015 Seattle GNU/Linux Conference. His speech will be nontechnical, admission is gratis, and the public is encouraged to attend.

Speech topic and start time to be determined.

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

July 01, 2015 06:30 AM