FOSDEM is one of the largest gatherings of Free Software contributors in the world and happens each February in Brussels (Belgium). One of the tracks will be the Desktops DevRoom (formerly known as “CrossDesktop DevRoom”), which will host Desktop-related talks.

We are now inviting proposals for talks about Free/Libre/Open-source Software on the topics of Desktop development, Desktop applications and interoperability amongst Desktop Environments. This is a unique opportunity to show novel ideas and developments to a wide technical audience.

Topics accepted include, but are not limited to: Enlightenment, Gnome, KDE, Unity, XFCE, LXQt, Windows, Mac OS X, software development for the desktop, general desktop matters, applications that enhance desktops and web (when related to desktop).

Talks can be very specific, such as the advantages/disadvantages of development with Qt on Wayland over X11/Mir; or as general as predictions for the fusion of Desktop and web in 5 years time. Topics that are of interest to the users and developers of all desktop environments are especially welcome. The FOSDEM 2014 schedule might give you some inspiration.

Please include the following information when submitting a proposal:

  • Your name
  • The title of your talk (please be descriptive, as titles will be listed with around 250 from other projects)
  • Short abstract of one or two paragraphs
  • Short bio (with photo)
  • Requested time: from 15 to 45 minutes. Normal duration is 30 minutes. Longer duration requests must be properly justified. You may be assigned LESS time than you request.

The deadline for submissions is December 7th 2014. FOSDEM will be held on the weekend of January 31st-February 1st 2015 and the Desktops DevRoom will take place on Sunday, February 1st 2015. Please use the following website to submit your proposals: https://penta.fosdem.org/submission/FOSDEM15 (you do not need to create a new Pentabarf account if you already have one from past years).

You can also join the devroom’s mailing list, which is the official communication channel for the DevRoom: desktops-devroom@lists.fosdem.org (subscription page for the mailing list)

The Desktops DevRoom 2015 Organization Team

Richard Moore blogged about setters/getters vs direct access to member variables and why encapsulation is good today. Ruby excels in this aspect, IMHO:

With Ruby your code is the same regardless you are accessing a variable or a method. This means something that now is a variable, you can transform it in the future in a method with calculates a value and the code accessing it does not change at all.
Imagine you have a method to print the volume of a bottle and you had stored the volumes in pints (Imperial units). Your code is:

volume = get_bottle_volume_from_database() # these are pints, you would be getting the "10" value from a database

puts "The volume is " + volume.to_s
=> The volume is 10

Now you want to move to international units (litres). You can do this:


def volume
return get_bottle_volume_from_database() * 0.473176475 # Transform from pints to litres
end

puts "The volume is " + volume.to_s # See? "volume" is a method here (it was a variable in the former example) but our code has not changed!

Of course this is a contrived example but keep in mind this syntax allows for all kinds of magic. For example, it makes Ruby on Rails feasible

Yesterday I released new versions of two of my open source projects: Javascript Browser Sniffer and XSPF for Ruby.

Version 0.5.1 of jsbrwsniff fixes the detection of Flash Player. It was not working with Flash Player >= 7.0 in Gecko browsers and not working at all in Internet Explorer due to a typo.

Version 0.3 of XSPF for Ruby is able to export XSPF playlists to M3U, SMIL, HTML and SoundBlox. These are minor features, but as a new dependency has been added (Ruby/XSLT), the version number has been upped to 0.3 instead of 0.2.1. I am currently developing the XSPF generator.

Lately there has been some talking in Ruby-Talk on how to send files using scp. Some people are doing just fine by calling scp with a pre-shared password, but I don’t like that approach and it doesn’t work for my purpose, so I did a bit of experimentation and found this code works:

require 'net/ssh'
require 'net/sftp'

class SSHAgent
 def initialize
    @agent_env = Hash.new
    agenthandle = IO.popen("/usr/bin/ssh-agent -s", "r")
    agenthandle.each_line do |line|
     if line.index("echo") == nil
         line = line.slice(0..(line.index(';')-1))
         key, value = line.chomp.split(/=/)
         puts "Key = #{key}, Value = #{value}"
         @agent_env[key] = value
     end
    end
 end
 def [](key)
    return @agent_env[key]
 end
end

agent = SSHAgent.new
ENV["SSH_AUTH_SOCK"] = agent["SSH_AUTH_SOCK"]
ENV["SSH_AGENT_PID"] = agent["SSH_AGENT_PID"]
system("/usr/bin/ssh-add")

Net::SSH.start( '192.168.1.12',
        :username=>'pgquiles',
        :compression_level=>0,
        :compression=>'none'
       ) do |session|
                 session.sftp.connect do |sftp|
             sftp.put_file("bigvideo.avi", "bigvideo.avi")
            end
end

I was using a passwordless private key for this experiment. Should you want to use a password-protected private key, you might want to set the DISPLAY and SSH_ASKPASS environment variables or use a smartcard reader and the ‘-s reader’ parameter.

The SSHAgent class comes from a public paste (I don’t know who its author is or the license that code is under).

Lastly, there is an undesired behaviour in Net::SFTP: when you use the put_file method it loads the whole file in memory, therefore you need loads of memory if you want to send big files. I’ve tried a naive fix (iterating writes) but it didn’t work (it complains about “no such file”, I think it’s a channels-related issue). Jamis Buck, the author of Net::SFTP, told me he currently has no time to fix this issue. In case you feel brave enough, the offending method starts in line 202 in

net-sftp-1.1.0/lib/net/sftp/session.rb.

Best introduction to ‘continuations’. Ever. Do not even try to understand this one.
Summarizing:

  • Continuations are like bookmarks: "hey Joe, come here and start again from this point". The context in which you invoke the code after the continuation point is the context you are currently, not the context you had when you defined the continuation. It’s easy to see it with this code in Ruby:

    arr = [ "Freddie", "Herbie", "Ron", "Max", "Ringo" ]
    hello_var = "hello1"
    puts(hello_var)
    callcc{|$cc|}
    message = arr.shift
    hello_var = "hello2"
    puts(message)
    puts(hello_var)
    $cc.call unless message =~ /Max/

    The output is:

    hello1
    Freddie
    hello2
    Herbie
    hello2
    Ron
    hello2
    Max
    hello2
    
  • Closures give you the lexical context you had when you defined the closure, including values of variables.

Lately I’ve been playing with Korundum. It’s nice, it works very well and combined with KDevelop it’s a very powerful RAD.

The big problem is the lack of documentation: I’ve read Caleb Tennis’ Rapid GUI development with QtRuby and it’s a wonderful introduction, but I miss a book going deeper into QtRuby/Korundum. This is not to say it’s worthless, quite the contrary: it’s the best $8.5 I’ve spent in months.

However, the “enterprise” learning is coming from reading others’ source code (I’ve been googling for qtruby, korundum; searching Rubyforge, etc) and from Richard Dale (via #qtruby in freenode). Once again, thank you so much Richard for such a good development environment!

Today they arrived, after two weeks crossing the ocean: Code Complete, 2nd Edition and Programming Ruby, The Pragmatic Programmers Guide 2nd Edition.

I have really big expectations from Code Complete, everybody keeps saying it’s a wonderful book and McConnell is a genius of software development management. Hope to learn at least 10% what he knows 🙂

I also have big expectations from Ruby, but not because of the language per se but because of Ruby on Rails. If everything goes fine, in a few weeks I will be leading a very big project where I will need to develop a web application really fast, and RoR seems to be the right choice here. I tried Subway (it uses Python, a language I am more familiar with), but it just does not compare to RoR, maybe in a few years.

These books didn’t came alone, they were in good company: What do you care what other people think? by Richard P. Feynman, Perfectly Reasonable Deviations From The Beaten Track: The Letters Of Richard P. Feynman and The Elegant Universe by Brian Greene (yes, I know it’s in Spanish, but it’s soooo expensive in Spanish!)