Planet Ubuntu

Subscribe to Planet Ubuntu feed
Planet Ubuntu -
Updated: 51 min 16 sec ago

Raphaël Hertzog: Freexian’s report about Debian Long Term Support, August 2018

9 hours 54 min ago

Like each month, here comes a report about the work of paid contributors to Debian LTS.

Individual reports

In August, about 220 work hours have been dispatched among 14 paid contributors. Their reports are available:

  • Abhijith PA did 5 hours (out of 10 hours allocated, thus keeping 5 extra hours for September).
  • Antoine Beaupré did 23.75 hours.
  • Ben Hutchings did 5 hours (out of 15 hours allocated + 8 extra hours, thus keeping 8 extra hours for September).
  • Brian May did 10 hours.
  • Chris Lamb did 18 hours.
  • Emilio Pozuelo Monfort did not manage to work but returned all his hours to the pool (out of 23.75 hours allocated + 19.5 extra hours).
  • Holger Levsen did 10 hours (out of 8 hours allocated + 16 extra hours, thus keeping 14 extra hours for September).
  • Hugo Lefeuvre did nothing (out of 10 hours allocated, but he gave back those hours).
  • Markus Koschany did 23.75 hours.
  • Mike Gabriel did 6 hours (out of 8 hours allocated, thus keeping 2 extra hours for September).
  • Ola Lundqvist did 4.5 hours (out of 8 hours allocated + 8 remaining hours, thus keeping 11.5 extra hours for September).
  • Roberto C. Sanchez did 6 hours (out of 18h allocated, thus keeping 12 extra hours for September).
  • Santiago Ruano Rincón did 8 hours (out of 20 hours allocated, thus keeping 12 extra hours for September).
  • Thorsten Alteholz did 23.75 hours.
Evolution of the situation

The number of sponsored hours decreased to 206 hours per month, we lost two sponsors and gained only one.

The security tracker currently lists 38 packages with a known CVE and the dla-needed.txt file has 24 packages needing an update.

Thanks to our sponsors

New sponsors are in bold.

No comment | Liked this article? Click here. | My blog is Flattr-enabled.

Categories: Linux

Daniel Pocock: What is the relationship between FSF and FSFE?

Tue, 09/18/2018 - 17:21

Ever since I started blogging about my role in FSFE as Fellowship representative, I've been receiving communications and queries from various people, both in public and in private, about the relationship between FSF and FSFE. I've written this post to try and document my own experiences of the issue, maybe some people will find this helpful. These comments have also been shared on the LibrePlanet mailing list for discussion (subscribe here)

Being the elected Fellowship representative means I am both a member of FSFE e.V. and also possess a mandate to look out for the interests of the community of volunteers and donors (they are not members of FSFE e.V). In both capacities, I feel uncomfortable about the current situation due to the confusion it creates in the community and the risk that volunteers or donors may be confused.

The FSF has a well known name associated with a distinctive philosophy. Whether people agree with that philosophy or not, they usually know what FSF believes in. That is the power of a brand.

When people see the name FSFE, they often believe it is a subsidiary or group working within the FSF. The way that brands work, people associate the philosophy with the name, just as somebody buying a Ferrari in Berlin expects it to do the same things that a Ferrari does in Boston.

To give an example, when I refer to "our president" in any conversation, people not knowledgeable about the politics believe I am referring to RMS. More specifically, if I say to somebody "would you like me to see if our president can speak at your event?", some people think it is a reference to RMS. In fact, FSFE was set up as a completely independent organization with distinct membership and management and therefore a different president. When I try to explain this to people, they sometimes lose interest and the conversation can go cold very quickly.

FSFE leadership have sometimes diverged from FSF philosophy, for example, it is not hard to find some quotes about "open source" and one fellow recently expressed concern that some people behave like "FSF Light". But given that FSF's crown jewels are the philosophy, how can an "FSF Light" mean anything? What would "Ferrari Light" look like, a red lawnmower? Would it be a fair use of the name Ferrari?

Some concerned fellows have recently gone as far as accusing the FSFE staff of effectively domain squatting or trolling the FSF (I can't link to that because of FSFE's censorship regime). When questions appear about the relationship in public, there is sometimes a violent response with no firm details. (I can't link to that either because of FSFE's censorship regime)

The FSFE constitution calls on FSFE to "join forces" with the FSF and sometimes this appears to happen but I feel this could be taken further.

FSF people have also produced vast amounts of code (the GNU Project) and some donors appear to be contributing funds to FSFE in gratitude for that or in the belief they are supporting that. However, it is not clear to me that funds given to FSFE support that work. As Fellowship representative, a big part of my role is to think about the best interests of those donors and so the possibility that they are being confused concerns me.

Given the vast amounts of money and goodwill contributed by the community to FSFE e.V., including a recent bequest of EUR 150,000 and the direct questions about this issue I feel it is becoming more important for both organizations to clarify the issue.

FSFE has a transparency page on the web site and this would be a good place to publish all documents about their relationship with FSF. For example, FSFE could publish the documents explaining their authorization to use a name derived from FSF and the extent to which they are committed to adhere to FSF's core philosophy and remain true to that in the long term. FSF could also publish some guidelines about the characteristics of a sister organization, especially when that organization is authorized to share the FSF's name.

In the specific case of sister organizations who benefit from the tremendous privilege of using the FSF's name, could it also remove ambiguity if FSF mandated the titles used by officers of sister organizations? For example, the "FSFE President" would be referred to as "FSFE European President", or maybe the word president could be avoided in all sister organizations.

People also raise the question of whether FSFE can speak for all Europeans given that it only has a large presence in Germany and other organizations are bigger in other European countries. Would it be fair for some of those other groups to aspire to sister organization status and name-sharing rights too? Could dozens of smaller FSF sister organizations dilute the impact of one or two who go off-script?

Even if FSFE was to distance itself from FSF or even start using a new name and philosophy, as a member, representative and also volunteer I would feel uncomfortable with that as there is a legacy of donations and volunteering that have brought FSFE to the position the organization is in today.

That said, I would like to emphasize that I regard RMS and the FSF, as the original FSF, as having the final authority over the use of the name and I fully respect FSF's right to act unilaterally, negotiate with sister organizations or simply leave things as they are.

If you have questions or concerns about this topic, I would invite you to raise them on the LibrePlanet-discuss mailing list or feel free to email me directly.

Categories: Linux

Andres Rodriguez: MAAS 2.5.0 beta 1 released

Tue, 09/18/2018 - 03:05

Hello MAASters!

I’m happy to announce that MAAS 2.5.0 beta 1 has been released. The beta 1 now features

  • Complete proxing of machine communication through the rack controller. This includes DNS, HTTP to metadata server, Proxy with Squid and new in 2.5.0 beta 1, syslog.
  • CentOS 7 & RHEL 7 storage support (Requires a new Curtin version available in PPA).
  • Full networking for KVM pods.
  • ESXi network configuration

For more information, please refer to MAAS Discourse [1].


Categories: Linux

The Fridge: Ubuntu Weekly Newsletter Issue 545

Mon, 09/17/2018 - 18:12

Welcome to the Ubuntu Weekly Newsletter, Issue 545 for the week of September 9 – 15, 2018. The full version of this issue is available here.

In this issue we cover:

The Ubuntu Weekly Newsletter is brought to you by:

  • Krytarik Raido
  • Bashing-om
  • Chris Guiver
  • Wild Man
  • And many others

If you have a story idea for the Weekly Newsletter, join the Ubuntu News Team mailing list and submit it. Ideas can also be added to the wiki!

Except where otherwise noted, this issue of the Ubuntu Weekly Newsletter is licensed under a Creative Commons Attribution ShareAlike 3.0 License

Categories: Linux

Jonathan Riddell: kgraphviewer 2.4.3

Mon, 09/17/2018 - 06:16

KGraphViewer, your favourite visualiser of .dot files, has a new update.

  • Switch KgvPageLayout to QPageSize for page size handling
  • Avoid double top-level layout in KGVSimplePrintingPageSetup
  • Fix layout of page layout & size dialog
  • Remove unused dependency KIO
  • Fix minor typo
  • Update kgraphviewer docbook
  • Make sure the Graphviz library directories are known to the linker

Thanks to Pino, Michael, Yuri, Berkhard, Ben and translators for their continued gardening of this project.

Git tag v2.4.3a 4ff52f959f03291659db58554901d536356764e2


GPG Signature

Signed by Jonathan Riddell GPG key fingerprint ‘2D1D 5B05 8835 7787 DE9E  E225 EC94 D18F 7F05 997E’

Categories: Linux

Scarlett Gately Moore: KDE Akademy 2018

Sun, 09/16/2018 - 16:50

Yeah I am not in the picture, but I was there! You can find me over on the left there, where several of us were cut off Akademy was held in the lovely city of Vienna, Austria this year. Hats off to the akademy team for a great job!

This year at akademy I spent much of my time catching up with the Blue Systems team and meeting with the KDE Sysadmin team. I am happy to report Ben Cooksley is real! Due to my flights, I missed the first and last day. It was still a productive akademy. I attended some good sysadmin and KDE Neon BoFs . I also did a bit of volunteering

Even though I am mostly packaging for Debian directly these days, KDE Neon is still near and dear to my heart. I hope to be able to merge debian packaging into Neon soon so that we can have better collaboration within the team.

I met with Ben in regards to getting back into sysadmin/CI work. I am working on Appimage tooling for KDE Binary factory to begin. I hope to utilize the craft tooling to make everyone’s lives easier. This of course is on my free time, but do keep an eye out!

Despite my shortened akademy, I still am happy with the results. It was great to see everyone! See you again next year!

Related posts:
  1. I’m going to Akademy! Neon team and more..
  2. Another successful Akademy! Neon team BoF, snappy and more.
  3. KDE: Randa 2017! KDE Neon Snappy and more
Categories: Linux

Jono Bacon: Linus, His Apology, And Why We Should Support Him

Sun, 09/16/2018 - 16:12

Today, Linus Torvalds, the creator of Linux, which powers everything from smartwatches to electrical grids posted a pretty remarkable note on the kernel mailing list.

As a little bit of backstory, Linus has sometimes come under fire for the ways in which he has expressed feedback, provided criticism, and reacted to various scenarios on the kernel mailing list. This criticism has been fair in many cases: he has been overly aggressive at times, and while the kernel maintainers are a tight-knit group, the optics, particularly for those new to kernel development has often been pretty bad.

Like many conflict scenarios, this feedback has been communicated back to him in both constructive and non-constructive ways. Historically he has been seemingly reluctant to really internalize this feedback, I suspect partially because (a) the Linux kernel is a very successful project, and (b) some of the critics have at times gone nuclear at him (which often doesn’t work as a strategy towards defensive people). Well, things changed today.

In his post today he shared some self-reflection on this feedback:

This week people in our community confronted me about my lifetime of not understanding emotions. My flippant attacks in emails have been both unprofessional and uncalled for. Especially at times when I made it personal. In my quest for a better patch, this made sense to me. I know now this was not OK and I am truly sorry.

He went on to not just share an admission that this has been a problem, but to also share a very personal acceptance that he struggles to understand and engage with people’s emotions:

The above is basically a long-winded way to get to the somewhat painful personal admission that hey, I need to change some of my behavior, and I want to apologize to the people that my personal behavior hurt and possibly drove away from kernel development entirely. I am going to take time off and get some assistance on how to understand people’s emotions and respond appropriately.

His post is sure to light up the open source, Linux, and tech world for the next few weeks. For some it will be celebrated as a step in the right direction. For some it will be too little too late, and their animus will remain. For some they will be cautiously supportive, but defer judgement until they have seen his future behavior demonstrate substantive changes.

My Take

I wouldn’t say I know Linus very closely; we have a casual relationship. I see him at conferences from time to time, and we often bump into each other and catch up. I interviewed him for my book and for the Global Learning XPRIZE. From my experience he is a funny, genuine, friendly guy. Interestingly, and not unusually at all for open source, his online persona is rather different to his in-person persona. I am not going to deny that when I would see these dust-ups on LKML, it didn’t reflect the Linus I know. I chalked it down to a mixture of his struggles with social skills, dogmatic pragmatism, and ego.

His post today is a pretty remarkable change of posture for him, and I encourage that we as a community support him in making these changes.

Accepting these personal challenges is tough, particularly for someone in his position. Linux is a global phenomenon. It has resulted in billions of dollars of technology creation, powering thousands of companies, and changing the norms around of how software is consumed and created. It is easy to forget that Linux was started by a quiet Finnish kid in his university dorm room. It is important to remember that just because Linux has scaled elegantly, it doesn’t mean that Linus has been able to. He isn’t a codebase, he is a human being, and bugs are harder to spot and fix in humans. You can’t just deploy a fix immediately. It takes time to identify the problem and foster and grow a change. The starting point for this is to support people in that desire for change, not re-litigate the ills of the past: that will get us nowhere quickly.

I am also mindful of ego. None of us like to admit we have an ago, but we all do. You don’t get to build one of the most fundamental technologies in the last thirty years and not have an ego. He built it…they came…and a revolution was energized because of what he created. While Linus’s ego is more subtle, and thankfully doesn’t extend to faddish self-promotion, overly expensive suits, and forays into Hollywood (quite the opposite), his ego has naturally resulted in abrupt opinions on how his project should run, sometimes plugging fingers in his ears to particularly challenging viewpoints from others. His post today is a clear example of him putting Linux as a project ahead of his own personal ego.

This is important for a few reasons. Firstly, being in such a public position and accepting your personal flaws isn’t a problem many people face, and isn’t a situation many people handle well. I work with a lot of CEOs, and they often say it is the loneliest job on the planet. I have heard American presidents say the same in interviews. This is because they are the top of the tree with all the responsibility and expectations on their shoulders. Put yourself in Linus’s position: his little project has blown up into a global phenomenon, and he didn’t necessarily have the social tools to be able to handle this change. Ego forces these internal struggles under the surface and to push them down and avoid them. So, to accept them as publicly and openly as he did today is a very firm step in the right direction. Now, the true test will be results, but we need to all provide the breathing space for him to accomplish them.

So, I would encourage everyone to give Linus a shot. This doesn’t mean the frustrations of the past are erased, and he has acknowledged and apologized for these mistakes as a first step. He has accepted he struggles with understanding other’s emotions, and a desire to help improve this for the betterment of the project and himself. He is a human, and the best tonic for humans to resolve their own internal struggles is the support and encouragement of other humans. This is not unique to Linus, but to anyone who faces similar struggles.

All the best, Linus.

The post Linus, His Apology, And Why We Should Support Him appeared first on Jono Bacon.

Categories: Linux

Benjamin Mako Hill: Lookalikes

Sun, 09/16/2018 - 12:18

Was my festive shirt the model for the men’s room signs at Daniel K. Inouye International Airport in Honolulu? Did I see the sign on arrival and subconsciously decide to dress similarly when I returned to the airport to depart Hawaii?

Categories: Linux

Ubuntu Podcast from the UK LoCo: S11E27 – Twenty-Seven Bones - Ubuntu Podcast

Fri, 09/14/2018 - 08:00

This week we’ve been moonlighting on other podcasts and started using DuckDuckGo. Trend Micro get booted from the Apple Store, Intel adopts an AMD display standard, a cheesy history of Linux gaming is published, Amazon Echo now Looks at you and we round up the community news.

It’s Season 11 Episode 27 of the Ubuntu Podcast! Alan Pope, Mark Johnson and Martin Wimpress are connected and speaking to your brain.

In this week’s show:

That’s all for this week! You can listen to the Ubuntu Podcast back catalogue on YouTube. If there’s a topic you’d like us to discuss, or you have any feedback on previous shows, please send your comments and suggestions to or Tweet us or Comment on our Facebook page or comment on our Google+ page or comment on our sub-Reddit.

Categories: Linux

David Tomaschik: Course Review: Software Defined Radio with HackRF

Fri, 09/14/2018 - 01:00

Over the past two days, I had the opportunity to attend Michael Ossman’s course “Software Defined Radio with HackRF” at Toorcon XX. This is a course I’ve wanted to take for several years, and I’m extremely happy that I finally had the chance. I wanted to write up a short review for others considering taking the course.

Course Material

The material in the course focuses predominantly on the basics of Software Defined Radio and Digital Signal Processing. This includes the math necessary to understand how the DSP handles the signal. The math is presented in a practical, rather than academic, way. It’s not a math class, but a review of the necessary basics, mostly of complex mathematics and a bit of trigonometry. (My high school teachers are now vindicated. I did use that math again.) You don’t need the math background coming in, but you do need to be prepared to think about math during the class. Extracting meaningful information from the ether is, it turns out, an exercise in mathematics.

There’s a lot of discussions of frequencies, frequency mixers, and how frequency, amplitude, and phase are related. Also, despite more than 20 years as an amateur radio operator, I finally understand dB properly. It’s possible to understand reasonably without having to do logarithms:

  • +3db = x2
  • +10db = x10
  • -3db = 1/2
  • -10db = 1/10

In terms of DSP, he demonstrated extracting signals of interest, clock recovery, and other techniques necessary for understanding digital signals. It really just scratches the surface, but is enough to get a basic signal understood.

From a security point of view, there was only a single system that we “attacked” in the class. I was hoping for a little bit more of this, but given the detail in the other content, I am not disappointed.

Mike pointed out that the course primarily focuses on getting signals from the air to a digital series of 0 an 1 bits, and then leaves the remainder to tools like python for adding meaning and interpretation of the bits. While I understand this (and, admittedly, at that point it’s similar to decoding an unknown network protocol), I would still like to have gone into more detail.

Course Style

At the very beginning of the course, Mike makes it clear that no two classes he teaches are exactly the same. He adapts the course to the experience and background of each class, and that was very evident from our small group this week. With such a small class, it became more like a guided conversation than a formal class.

Overall, the course was very interactive, with lots of student questions, as well as “Socratic Method” questions from the instructor. This was punctuated with a number of hands-on exercises. One of the best parts of the hands-on exercises is that Mike provides a flash drive with a preconfigured Ubuntu Linux installation containing all the tools that are needed for the course. This allows students to boot into a working environment, rather than having to play around with tool installation or virtual machine settings. (We were, in fact, warned that VMs often do not play well with SDR, because the USB forwarding has overhead resulting in lost samples.)

Mike made heavy use of the poster pad in the room, diagramming waveforms and information about the processes involved in the SDR architecture and the DSP done in the computer. This works well because he customizes the diagrams to explain each part and answer student questions. It also feels much more engaging than just pointing at slides. In fact, the only thing displayed on the projector is Mike’s live screen from his laptop, displaying things like the work he’s doing in GNURadio Companion and other pieces of software.

If you have devices you’re interested in studying, you should bring them along with you. If time permits, Mike tries to work these devices into the analysis during the course.

Tools Used Additional Resources Opinions & Conclusion

This was a great class that I really enjoyed. However, I really wish there had been more emphasis on how you decode and interpret the unknown signals, such as discussion of common packet types over RF, any tools for signals analysis that could be built either in Python or in GNURadio. Perhaps he (or someone) could offer an advanced class that focuses on the signal analysis, interpretation, and “spoofing” portions of the problem of attacking RF-based systems.

If you’re interested in doing assessments of physical devices, or into radio at all, I highly recommend this course. Mike obviously really knows the material, and getting a HackRF One is a pretty nice bonus. Watching the videos on his website will help you prepare for the math, but will also result int a good portion of the content being duplicated in the course. I’m not disappointed that I did that, and I still feel that I more than made good use of the time in the course, but it is something to be aware of.

Categories: Linux

Tiago Carrondo: Episódio 02 – Notícias

Thu, 09/13/2018 - 19:17

Desta feita temos um novo episódio exclusivamente dedicado a notícias: KDE Plasma em portáteis ARM, novidades sobre o Ubuntu 18.10 Cosmic Cuttlefish, e uma revolução para gamers com milhares de jogos para windows agora disponíveis em GNU/Linux.

Atribuição e licenças

A imagem: “***BREAKING NEWS*** Cityhall Collapsed” por Daniel Novta está licenciada nos termos da licença: CC BY 2.0

A música do genérico é: “Won’t see it comin’ (Feat Aequality & N’sorte d’autruche)”, por Alpha Hydrae e está licenciada nos termos da CC0 1.0 Universal License.

Este episódio está licenciado nos termos da licença: Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0), cujo texto integral pode ser lido aqui. Estamos abertos a licenciar para permitir outros tipos de utilização, contactem-nos para validação e autorização.

Categories: Linux

Stephen Kelly: API Changes in Clang

Thu, 09/13/2018 - 16:45

I’ve started contributing to Clang, in the hope that I can improve the API for tooling. This will eventually mean changes to the C++ API of Clang, the CMake buildsystem, and new features in the tooling. Hopefully I’ll remember to blog about changes I make.

The Department of Redundancy Department

I’ve been implementing custom clang-tidy checks and have become quite familiar with the AST Node API. Because of my background in Qt, I was immediately disoriented by some API inconsistency. Certain API classes had both getStartLoc and getLocStart methods, as well as both getEndLoc and getLocEnd etc. The pairs of methods return the same content, so at least one set of them is redundant.

I’m used to working on stable library APIs, but Clang is different in that it offers no API stability guarantees at all. As an experiment, we staggered the introduction of new API and removal of old API. I ended up replacing the getStartLoc and getLocStart methods with getBeginLoc for consistency with other classes, and replaced getLocEnd with getEndLoc. Both old and new APIs are in the Clang 7.0.0 release, but the old APIs are already removed from Clang master. Users of the old APIs should port to the new ones at the next opportunity as described here.

Wait a minute, Where’s me dump()er?

Clang AST classes have a dump() method which is very useful for debugging. Several tools shipped with Clang are based on dumping AST nodes.

The SourceLocation type also provides a dump() method which outputs the file, line and column corresponding to a location. The problem with it though has always been that it does not include a newline at the end of the output, so the output gets lost in noise. This 2013 video tutorial shows the typical developer experience using that dump method. I’ve finally fixed that in Clang, but it did not make it into Clang 7.0.0.

In the same vein, I also added a dump() method to the SourceRange class. This prints out locations in the an angle-bracket format which shows only what changed between the beginning and end of the range.

Let it bind

When writing clang-tidy checks using AST Matchers, it is common to factor out intermediate variables for re-use or for clarity in the code.

auto valueMethod = cxxMethodDecl(hasName("value")); Finer->addMatcher(valueMethod.bind("methodDecl"));

clang-query has an analogous way to create intermediate matcher variables, but binding to them did not work. As of my recent commit, it is possible to create matcher variables and bind them later in a matcher:

let valueMethod cxxMethodDecl(hasName("value")) match valueMethod.bind("methodDecl") match callExpr(callee(valueMethod.bind("methodDecl"))).bind("methodCall") Preload your Queries

Staying on the same topic, I extended clang-query with a --preload option. This allows starting clang-query with some commands already invoked, and then continue using it as a REPL:

bash$ cat cmds.txt let valueMethod cxxMethodDecl(hasName("value")) bash$ clang-query --preload cmds.txt somefile.cpp clang-query> match valueMethod.bind("methodDecl") Match #1: somefile.cpp:4:2: note: "methodDecl" binds here void value(); ^~~~~~~~~~~~ 1 match.

Previously, it was only possible to run commands from a file without also creating a REPL using the -c option. The --preload option with the REPL is useful when experimenting with matchers and having to restart clang-query regularly. This happens a lot when modifying code to examine changes to AST nodes.


Categories: Linux

Daniel Pocock: What is the difference between moderation and censorship?

Thu, 09/13/2018 - 15:09

FSFE fellows recently started discussing my blog posts about Who were the fellowship? and An FSFE Fellowship Representative's dilemma.

Fellows making posts in support of reform have reported their emails were rejected. Some fellows had CC'd me on their posts to the list and these posts never appeared publicly. These are some examples of responses received by a fellow trying to post on the list:

The list moderation team decided now to put your email address on moderation for one month. This is not censorship.

One fellow forwarded me a rejected message to look at. It isn't obscene, doesn't attack anybody and doesn't violate the code of conduct. The fellow writes:

+1 for somebody to answer the original questions with real answers
-1 for more character assassination

Censors moderators responded to that fellow:

This message is in constructive and unsuited for a public discussion list.

Why would moderators block something like that? In the same thread, they allowed some very personal attack messages in favour of existing management.

Moderation + Bias = Censorship

Even links to the public list archives are giving errors and people are joking that they will only work again after the censors PR team change all the previous emails to comply with the censorship communications policy exposed in my last blog.

Fellows have started noticing that the blog of their representative is not being syndicated on Planet FSFE any more.

Some people complained that my last blog didn't provide evidence to justify my concerns about censorship. I'd like to thank FSFE management for helping me respond to that concern so conclusively with these heavy-handed actions against the community over the last 48 hours.

The collapse of the fellowship described in my earlier blog has been caused by FSFE management decisions. The solutions need to come from the grass roots. A totalitarian crackdown on all communications is a great way to make sure that never happens.

FSFE claims to be a representative of the free software community in Europe. Does this behaviour reflect how other communities operate? How successful would other communities be if they suffocated ideas in this manner?

This is what people see right now trying to follow links to the main FSFE Discussion list archive:

Categories: Linux

Simos Xenitellis: How to run Julia on Jupyter in a LXD container

Thu, 09/13/2018 - 12:54

Julia is a computer language well-suited for scientists, engineers and students. I wrote the following introduction a couple of days ago.

Learning the Julia computer language on Ubuntu

In this post we are going to see how to use Julia in the Jupyter interactive environment. This means that you run Julia commands in your browser and get the output in your browser. It is much more comfortable than using a terminal window and the command line.

First, we create a LXD container and install Julia in there. Then, we add the IJulia package which is the package for Jupyter support. Subsequently, we expose the network port of Jupyter to the host so that we can view it with our Web browser.

Installing Julia in a LXD container

First, launch a ubuntu:18.04 container. We call the container julia.

$ lxc launch ubuntu:18.04 julia
Creating julia
Starting julia

Then, get a shell into the container and install Julia according to the following abbreviated instructions.

$ lxc exec julia -- sudo --user ubuntu --login
To run a command as administrator (user "root"), use "sudo ".
See "man sudo_root" for details.


Here we are installing Julia.

ubuntu@julia:~$ wget
ubuntu@julia:~$ tar xfa julia-1.0.0-linux-x86_64.tar.gz
ubuntu@julia:~$ ls -l julia-1.0.0/bin/
total 28
-rwxr-xr-x 1 ubuntu ubuntu 47280 Aug 9 01:02 julia
ubuntu@julia:~$ ./julia-1.0.0/bin/julia
| Documentation:
| Type "?" for help, "]?" for Pkg help.
| Version 1.0.0 (2018-08-08)
| Official release

julia> versioninfo()
Julia Version 1.0.0
Commit 5d4eaca0c9 (2018-08-08 20:58 UTC)
Platform Info:
OS: Linux (x86_64-pc-linux-gnu)
CPU: Intel(R) Core(TM) i5-5287U CPU @ 2.90GHz
LIBM: libopenlibm
LLVM: libLLVM-6.0.0 (ORCJIT, broadwell)

julia> exit()

Now, Julia is installed in the LXD container and we are able to move to the next step, setting up Jupyter.

Setting up the Julia kernel for Jupyter

We follow the instructions at the IJulia Julia package page. Specifically,

julia> using Pkg julia> Pkg.add("IJulia")
Cloning default registries into /home/ubuntu/.julia/registries
Cloning registry General from ""
Updating registry at ~/.julia/registries/General
Updating git-repo
Resolving package versions…
Installed SoftGlobalScope ─ v1.0.5
Installed VersionParsing ── v1.1.2
Installed Conda ─────────── v1.0.1
Installed ZMQ ───────────── v1.0.0
Installed BinaryProvider ── v0.4.2
Installed IJulia ────────── v1.11.1
Installed Compat ────────── v1.1.0
Installed MbedTLS ───────── v0.6.0
Installed JSON ──────────── v0.19.0
Updating ~/.julia/environments/v1.0/Project.toml
[7073ff75] + IJulia v1.11.1
Updating ~/.julia/environments/v1.0/Manifest.toml


[4ec0a83e] + Unicode
Building Conda ──→ ~/.julia/packages/Conda/m7vem/deps/build.log
Building ZMQ ────→ ~/.julia/packages/ZMQ/ABGOx/deps/build.log
Building MbedTLS → ~/.julia/packages/MbedTLS/Qo8TN/deps/build.log
Building IJulia ─→ ~/.julia/packages/IJulia/k5o7j/deps/build.log

julia> using IJulia
[ Info: Precompiling IJulia [7073ff75-c697-5162-941a-fcdaad2a7d2a]

The necessary software has been installed. Now we launch the Jupyter Notebook Web service in the following way.

julia> notebook(detached=true)
Process(setenv(/home/ubuntu/.julia/packages/Conda/m7vem/deps/usr/bin/jupyter notebook --NotebookApp.iopub_data_rate_limit=2147483647; dir="/home/ubuntu"), ProcessRunning)

julia> exit()

We are almost ready to use our Web browser to open the Notebook page.

Getting the Jupyter Notebook token

By default, the Jupyter Notebook requires the users to be authenticated and in this case, you need to have a special token in order to access the Notebook. Here is the token, and URL to use to get directly access to the Notebook.

ubuntu@julia:~$ ./.julia/packages/Conda/m7vem/deps/usr/bin/jupyter notebook list
Currently running servers:
http://localhost:8888/?token=40306ed2c602ecc5e64d2619c2d7f03aa8534f44106c353e :: /home/ubuntu

Note the the Jupyter Notebook is listening on the container’s localhost at port 8888. But how can our host’s browser access that port? See next.

Creating a LXD proxy device to the Julia container

We need to proxy the TCP port 8888 at the container (interface: lo) to the loopback of the host. Here is how we do this with the LXD proxy device. We create a proxy device called port8888, which links together the container’s TCP port 8888 to the host’s TCP port 8888. The exist port is the one in the container, and LXD creates the port 8888 on the host. In this way, the Web browser on your desktop can access the Jupyter Notebook with Julia, using the exact URL from the previous section.

$ lxc config device add julia port8888 proxy listen=tcp:localhost:8888 connect=tcp:localhost:8888
Device port8888 added to julia

If instead you want to make the Jupyter Notebook also accessible by any computer at your local network, you can create instead the following proxy device. We remove the old device and create a new one. With changed the listen option, and specified to LXD to listen on all network interfaces on the host.

$ lxc config device remove julia port8888
Device port8888 removed from julia
$ lxc config device add julia port8888 proxy listen=tcp: connect=tcp:localhost:8888
Device port8888 added to julia Using the Jupyter Notebook for Julia

We have done the hard work, let’s open up the browser and visit the Jupyter Notebook URL. In my case, the URL that was given earlier is


Here is the web page.

Jupyter Notebook first page.

That was the first page. We have not created a Notebook yet and we are about to create it now. Click on the New button (at the right), then select Julia 1.0.0.

Creating a new Notebook for Julia 1.0.0.

Finally, here is Julia in a Jupyter Notebook!

Julia in a Jupyter Notebook.

At this point, we can run Julia commands in here. See how to do that in the next section.

Using the Julia Jupyter Notebook

When you type a Julia command in the green box, you need to press Shift+Enter so that it gets executed. In the following screenshot, we install the Plots package.

Installing the Plots package. Notice the [*] in the screenshot.

The [*] in the screenshot means that the command is still running and we should wait for the command to complete. When the command Pkg.add(“Plots”) is completed the * will become a number, and in this case the number 3 (that is, the third command we have run).

Let’s plot something using the default plotting back-end, whichever that is.

Creating a plot in a Jupyter Notebook.

We will stop the post here. There is a workflow on how to manage Jupyter Notebooks. This, currently untitled, Notebook has been autosaved. You may set a name. You can see the Notebook in the first tab of the browser which shows the files in Jupyter.


We have seen how to set up a LXD container to start a Jupyter Notebook instance in order to run Julia commands. In this way, you can use the browser to manage all commands and avoid getting back to the terminal window.

You can also setup the container so that the Jupyter Notebook gets autostarted when you reboot your computer. See for some hints on that.

Simos Xenitellis
Categories: Linux

Lubuntu Blog: Lubuntu Development Newsletter #11

Wed, 09/12/2018 - 19:13
This is the eleventh issue of The Lubuntu Development Newsletter. You can read the last issue here. Changes General This list is a bit short because we have been focusing on general, behind-the-scenes (and admittedly tedious) administration tasks, but we plan on ramping up development progress in time for the next newsletter. Desktop Experience We […]
Categories: Linux

Benjamin Mako Hill: Disappointment on the new commute

Wed, 09/12/2018 - 10:53

Imagine my disappointment when I discovered that signs on Stanford’s campus pointing to their “Enchanted Broccoli Forest” and “Naria”—both of which that I have been passing daily on my new commute—merely indicate the location of student living groups with whimsical names.

Categories: Linux

Simos Xenitellis: Learning the Julia computer language on Ubuntu

Tue, 09/11/2018 - 14:36

There is yet another computer language, called Julia. What’s special with Julia, you may ask? It is a language specifically suited for tasks of scientists, engineers and students. Compared to a general purpose programming language, Julia has built-in those complex data types that you need in science. For example, multidimensional matrices are built-in in Julia.

In the following we are going to see

  • how to set up Julia 1.0.0 on Ubuntu
  • how to use Julia and learn the core language
  • how to add packages to Julia
Setting up Julia on Ubuntu

The current stable version of Julia is 1.0. It has been released recently after a lot of work. The previous stable version was 0.6. Many tutorials and add-on packages may not be fully up-to-date with version 1.0. However, this version 1.0 appears to be a big milestone to the project, therefore this is the one we are trying here.

Currently, the easiest way to install Julia is to use one of the pre-compiled installation packages from the download page.

There is a snap package called julia-stable (fmind), however you can use it only to test only the built-in features of the language. It has not been configured to access the Internet (therefore cannot install packages), does not embed the curl command that the Julia package manager needs, and also most Julia packages have dependencies like the Python3 language (PyPlot) and a web browser (Plots). These dependencies are not included. Ideally, a Julia snap package would need to have the classic confinement to work properly. I have not seen yet a request yet on for classic confinement for Julia.

Let’s go to the Julia Download page and get the appropriate pre-compiled tarball (Generic Linux Binaries for x86, 64-bit).

$ cd
$ wget
$ tar xvfa julia-1.0.0-linux-x86_64.tar.gz
$ ls -l julia-1.0.0/bin/
total 48
-rwxr-xr-x 1 myusername myusername 47280 Aug 9 04:02 julia

Let’s put this path (~/julia-1.0.0/bin/) into the $PATH so that we can invoke julia from any directory. Then, use the source shell command to read again the .profile configuration file. After that, we are ready to run Julia.

$ echo PATH=\$PATH:~/julia-1.0.0/bin/ >> ~/.profile
$ source ~/.profile

Here is our first run of Julia!

Running Julia for the first time.

To exit, you can either run exit() or press Ctrl-D.

There is one more important detail before we actually do useful things with Julia. Julia 1.0 has a new package manager to install Julia packages. This package manager used to be called Pkg3 but now it has replaced the old package manager called Pkg, and reuses the old name Pkg. During this change, the Pkg package is not autoloaded when you run Julia, and you need to load it whenever you run Julia. Older Julia tutorials assume that the Pkg package is already loaded, therefore if we do not fix this issue, you may find it frustrating when learning the language. Therefore, let’s autoload Pkg. To do so, we edit the Julia 1.0 startup file startup.jl, and add in there the instruction using Pkg.$ mkdir ~/.ju

$ mkdir -p ~/.julia/config/
$ echo "using Pkg" >> ~/.julia/config/startup.jl

That’s it. Let’s use Julia now.

Using Julia

Here is the HelloWorld, in Julia. We also show how to exit.

HelloWorld in the Julia computer language.

Julia has similar commands  to all sort of tasks that you can do with a general-purpose programming language. Here are some recommended tutorials to get you started.

When you learn Julia, you learn the core Julia language, and then you learn useful available packages that help you perform your tasks. In the following we cover issues that you may get when you setup and use packages in Julia.

Adding packages

What makes Julia really useful, is that there are many packages to choose from. There are almost 2000 available Julia packages. You can make a better sense as to which packages are more important by viewing the list of top Julia packages.


In the following we do plots. There is a dedicated Julia Plots website for this, and explains that we need to install the basic Plots package, and then select a plotting back-end. In the following, Plots automatically selected the GR plotting back-end.

Here is the current state of Julia 1.0 support of the plotting back-ends.

  • GR. Supported in Julia 1.0, and invokes the program gksqt to view the graph. That’s a QT application. When it starts, it shows a small window that you can resize in order to view the plot.
  • PyPlot. Not supported yet in Julia 1.0. It gets compiled but fails when you try to actually create a plot.
  • PlotlyJS. Supported in Julia 1.0. Invokes your Web browser to show the plot. Has Javascript code in the plot that helps to view, pan, save, etc. See the PlotlyJS page on how to install the dependencies.
  • UnicodePlots. Supported in Julia 1.0. Uses Unicode characters  (text) to display the plots. Their page has many easy-to-use examples.
  • Gadfly. Almost supported in Julia 1.0. Follow this bug report to figure out when this back-end gets fully supported in Julia.

Here are some screenshots of plots.

Generated with the plotlyJS backend. When you hover the mouse pointer at the top of the plot, you get extra tools like saving to PNG, panning, resizing, zoom and more. Generated with the UnicodePlots backend. Makes use of available Unicode characters to give the illusion of a graph in text mode. I think these are Braille Unicode characters. Generated with the GR backend. The histogram command was histogram(randn(10000)). Summary

This has been an introduction to Julia. You can use the online environments to run Julia programs, or you can also try to run on your Ubuntu.  Evaluate Julia and see whether learning this computer language will be useful to you.

Simos Xenitellis
Categories: Linux

The Fridge: Ubuntu Weekly Newsletter Issue 544

Mon, 09/10/2018 - 16:42

Welcome to the Ubuntu Weekly Newsletter, Issue 544 for the week of September 3 – 9, 2018. The full version of this issue is available here.

In this issue we cover:

The Ubuntu Weekly Newsletter is brought to you by:

  • Krytarik Raido
  • Chris Guiver
  • Wild Man
  • Bashing-om
  • And many others

If you have a story idea for the Weekly Newsletter, join the Ubuntu News Team mailing list and submit it. Ideas can also be added to the wiki!

Except where otherwise noted, this issue of the Ubuntu Weekly Newsletter is licensed under a Creative Commons Attribution ShareAlike 3.0 License

Categories: Linux

Sebastian Dröge: GStreamer Rust bindings 0.12 and GStreamer Plugin 0.3 release

Mon, 09/10/2018 - 05:41

After almost 6 months, a new release of the GStreamer Rust bindings and the GStreamer plugin writing infrastructure for Rust is out. As usual this was coinciding with the release of all the gtk-rs crates to make use of all the new features they contain.

Thanks to all the contributors of both gtk-rs and the GStreamer bindings for all the nice changes that happened over the last 6 months!

And as usual, if you find any bugs please report them and if you have any questions let me know.

GStreamer Bindings

For the full changelog check here.

Most changes this time were internally, especially because many user-facing changes (like Debug impls for various types) were already backported to the minor releases in the 0.11 release series.


The biggest change this time is probably the inclusion of bindings for the GStreamer WebRTC library.

This allows using building all kinds of WebRTC applications outside the browser (or providing a WebRTC implementation for a browser), and while not as full-featured as Google’s own implementation, this interoperates well with the various browsers and generally works much better on embedded devices.

A small example application in Rust is available here.


Optionally, serde trait implementations for the Serialize and Deserialize trait can be enabled for various fundamental GStreamer types, including caps, buffers, events, messages and tag lists. This allows serializing them into any format that can be handled by serde (which are many!), and deserializing them back to normal Rust structs.

Generic Tag API

Previously only a strongly-typed tag API was exposed that made it impossible to use the wrong data type for a specific tag, e.g. code that tries to store a string for the track number or an integer for the title would simply not compile:

let mut tags = gst::TagList::new(); { let tags = tags.get_mut().unwrap(); tags.add::<Title>(&"some title", gst::TagMergeMode::Append); tags.add::<TrackNumber>(&12, gst::TagMergeMode::Append); }

While this is convenient, it made it rather complicated to work with tag lists if you only wanted to handle them in a generic way. For example by iterating over the tag list and simply checking what kind of tags are available. To solve that, a new generic API was added in addition. This works on glib::Values, which can store any kind of type, and using the wrong type for a specific tag would simply cause an error at runtime instead of compile-time.

let mut tags = gst::TagList::new(); { let tags = tags.get_mut().unwrap(); tags.add_generic(&gst::tags::TAG_TITLE, &"some title", gst::TagMergeMode::Append) .expect("wrong type for title tag"); tags.add_generic(&gst::tags::TAG_TRACK_NUMBER, &12, gst::TagMergeMode::Append) .expect("wrong type for track number tag"); }

This also greatly simplified the serde serialization/deserialization for tag lists.

GStreamer Plugins

For the full changelog check here.


The main change this time is that all the generic GObject subclassing infrastructure was moved out of the gst-plugin crate and moved to its own gobject-subclass crate as part of the gtk-rs organization.

As part of this, some major refactoring has happened that allows subclassing more different types but also makes it simpler to add new types. There are also experimental crates for adding some subclassing support to gio and gtk, and a PR for autogenerating part of the code via the gir code generator.

More classes!

The other big addition this time is that it’s now possible to subclass GStreamer Pads and GhostPads, to implement the ChildProxy interface and to subclass the Aggregator and AggregatorPad class.

This now allows to write custom mixer/muxer-style elements (or generally elements that have multiple sink pads) in Rust via the Aggregator base class, and to have custom pad types for elements to allow for setting custom properties on the pads (e.g. to control the opacity of a single video mixer input).

There is currently no example for such an element, but I’ll add a very simple video mixer to the repository some time in the next weeks and will also write a blog post about it for explaining all the steps.

Categories: Linux

Daniel Pocock: An FSFE Fellowship Representative's dilemma

Mon, 09/10/2018 - 02:33

The FSFE Fellowship representative role may appear trivial, but it is surprisingly complicated. What's best for FSFE, what is best for the fellows and what is best for free software are not always the same thing.

As outlined in my blog Who are/were the FSFE Fellowship?, fellows have generously donated over EUR 1,000,000 to FSFE and one member of the community recently bequeathed EUR 150,000. Fellows want to know that this money is spent well, even beyond their death.

FSFE promised them an elected representative, which may have given them great reassurance about the checks and balances in the organization. In practice, I feel that FSFE hasn't been sincere about this role and it is therefore my duty to make fellows aware of what representation means in practice right now.

This blog has been held back for some time in the hope that things at FSFE would improve. Alas, that is not the case and with the annual general meeting in Berlin only four weeks away, now is the time for the community to take an interest. As fellowship representative, I would like to invite members of the wider free software community to attend as guests of the fellowship and try to help FSFE regain legitimacy.

Born with a conflict of interest

According to the FSFE e.V. constitution, as it was before elections were abolished, the Fellows elected according to §6 become members of FSFE e.V.

Yet all the other fellows who voted, the people being represented, are not considered members of FSFE e.V. Sometimes it is possible to view all fellows together as a unit, a separate organization, The Fellowship. Sometimes not all fellows want the same thing and I have to view them each as individuals.

As the representative of this organization, The Fellowship and the individual fellows, I feel there is a strong ethical obligation for me to do what is best for The Fellowship and each fellow.

Yet as the constitution recognizes me as a member of FSFE e.V., some people have also argued that I should do what is best for FSFE e.V.

What happens when what is best for The Fellowship is not in alignment with what is best for FSFE e.V.?

It is also possible to imagine situations where doing what is best for FSFE e.V. and doing what is best for free software in general is not the same thing. In such a case the representative and other members may want to resign.

Censorship of the Fellowship representatives by FSFE management

On several occasions I've been told that my communications to fellows need to be censored adapted to help make money. For example, when I asked for an email to be sent to all fellows in February about the risk of abolishing elections, the president warned:

"people might even stop to support us financially"

if they found out about the constitutional changes. He subsequently subjected my email to censorship modification by other people.

This was not a new theme: in a similar discussion in August 2017 about communications from the representatives, another senior member of the executive team had commented:

"It would be beneficial if our PR team could support in this, who have the experience from shaping communication in ways which support retention of our donors."

A few weeks later, on 20 March, FSFE's management distributed a new censorship communications policy, requiring future emails to prioritize FSFE's interests and mandating that all emails go through the censors PR team. As already explained, a representative has an ethical obligation to prioritize the interests of the people represented, The Fellowship, not FSFE's interests. The censorship communications policy appears deliberately incompatible with that obligation.

As the elected representative of a 1500-strong fellowship, it seems obscene to me that my communications to the people I represent are subject to censorship by the very staff I'm supposed to be scrutinizing. The situation is even more ludicrous when the organization concerned claims to be an advocate of freedom.

This gets to the core of our differences: FSFE appeared to be hoping a representative would be a stooge, puppet or cheerleader who's existence might "support retention of ... donors". I never imagined myself like that. Given the generosity of fellows and the large amounts of time and money contributed to FSFE, I feel obliged to act as a genuine representative, ensuring money already donated is spent effectively on the desired objectives and ensuring that communications are accurate. FSFE management appear to hope their clever policy document will mute those ambitions.

Days later, on 25 March, FSFE management announced the extraordinary general meeting to be held in the staff office in Berlin, to confirm the constitutional change and as a bonus, try to abruptly terminate my own term as representative. I felt all these sudden changes were not happening by coincidence, rather, it came across as a nasty reprisal for February's email about constitutional changes. I had simply been trying to fulfill my ethical obligations to fellows and suddenly I had become persona non grata.

When I first saw this termination proposal in March, it really made me feel quite horrible. They were basically holding a gun to my head and planning a vote on whether to pull the trigger. For all purposes, it looked like gangster behavior happening right under my nose in a prominent free software organization.

Both the absurdity and hostility of these tactics was further underlined by taking this vote on my role behind my back on 26 May, while I was on a 10 day trip to the Balkans pursuing real free software activities in Albania and Kosovo, starting with OSCAL.

In the end, while the motion to abolish elections was passed and fellows may never get to vote again, only four of the official members of the association backed the abusive motion to knife me and that motion failed. Nonetheless, it left me feeling I would be reluctant to trust FSFE again. An organization that relies so heavily on the contributions of volunteers shouldn't even contemplate treating them, or their representatives, with such contempt. The motion should never have been on the agenda in the first place.

Bullet or boomerang?

In May, I thought I missed the bullet but it appears to be making another pass.

Some senior members of FSFE e.V. remain frustrated that a representative's ethical obligations can't be hacked with policy documents and other juvenile antics. They complain that telling fellows the truth is an act of treason and speaking up for fellows in a discussion is a form of obstruction. Both of these crimes are apparently grounds for reprisals, threats, character assassination and potentially expulsion.

In the most outrageous act of scapegoating, the president has even tried to suggest that I am responsible for the massive exodus from the fellowship examined in my previous blog. The chart clearly shows the exodus coincides with the attempt to force-migrate fellows to the supporter program, long after the date when I took up this role.

Senior members have sent me threats to throw me out of office, most recently the president himself, simply for observing the basic ethical responsibilities of a representative.

Leave your conscience at the door

With the annual general meeting in Berlin only four weeks away, the president is apparently trying to assemble a list of people to throw the last remaining representative out of the association completely. It feels like something out of a gangster movie. After all, altering and suppressing the results of elections and controlling the behavior of the candidates are the modus operandi of dictators and gangsters everywhere.

Will other members of the association exercise their own conscience and respect the commitment of representation that was made to the community? Or will they leave their conscience at the door and be the president's puppets, voting in block like in many previous general meetings?

The free software ecosystem depends on the goodwill of volunteers and donors, a community that can trust our leaders and each other. If every free software organization behaved like this, free software wouldn't exist.

A president who conspires to surround himself with people who agree with him, appointing all his staff to be voting members of the FSFE e.V. and expelling his critics appears unlikely to get far promoting the organization's mission when he first encounters adults in the real world.

The conflict of interest in this role is not of my own making, it is inherent in FSFE's structure. If they do finally kill off the last representative, I'll wear it like a badge of honor, for putting the community first. After all, isn't that a representative's role?

As the essayist John Gardner wrote

“The citizen can bring our political and governmental institutions back to life, make them responsive and accountable, and keep them honest. No one else can.”

Categories: Linux