The acronymn in the title stands for:

Debian Ubuntu Community Conference – Italy

and that’s, to my knowledge, the first of its kind… but definitely not the last.

First of all, big kudos to the people behind the organization of this wonderful event (in totally casual order):

  • the men and women behind FSUG Italia (Free Software User Group Italy) (I can’t remember all your names, apologies, but I think you know who you are!)
  • Luca Bruno (kaeso) from the Debian Italian community
  • Paolo Sammicheli (xdatap1) from the Ubuntu Italian community (and Monia too! also for their hospitality!)
  • the men and the women from the Perugia hacklab “Projectz on Island”
  • the Maths Department of the University of Perugia
  • Stefano Zacchiroli for being there with us
  • all the men and women that were there!!!

The DUCC-IT has been a remarkably experience: seeing gold old friends, and meeting new people from the FLOSS world, and in particular from Debian and Ubuntu, is always great.

DUCC is a joint Debian – Ubuntu conference born from an idea of the FSUG guys (if I’m not totally wrong) (I was wrong, thanks Zack for the heads up!) at the last UDS from Stefano, Paolo, and Sergio Zanchetta. Debian and Ubuntu hackers sharing the stage in their expertise fields, talking about what they love the most with the people from the other side of the barricade (if you pass me the expression).

I really loved the idea and the experiment of sharing my talk with somebody else (Francesca Ciceri in my case) from the Debian community. I think we should try to repeat it more often: it’s a great way to work more closely together even outside of the normal workflow we all stick to.

I have a lot of things to say about these last two days, but can’t make up my mind to find the right words… As usual, it’s sad to leave such great people after some wonderful days together, we don’t always know when we are going to see each other again.

Just to try to sum it up, ‘cause words are really hard on me tonight:

  • We decided that we will be holding another DUCC-IT next year (where and when not yet decided)
  • We are going to open a neutral “forum” (mailing list or whatever) where our two communities can talk together (something that doesn’t have the Debian or Ubuntu word in it) (Stefano, if you will ever read this: remember to open the alioth project! 🙂 )
  • When the next DUCC-IT meeting will arrive, we have to know where and when the next one will be held
  • After the Debian / Ubuntu Women talk, we need to take more action, and we need to have a women space again in our next meetings
  • I hope the FSUG people, or whoever is behind the DUCC-IT acronym, will not kill me: to all the Debian and Ubuntu communities out there, take the DUCC-IT acronym, replace IT with your local country code, and repeat this experience with your local Debian/Ubuntu communities.
  • My photo-stream of the conference
Annunci

I should have blogged more about it, but I already suck at blogging (I have to improve this), and also the Internet connection was not really working well with my computer at the conference (now I’m using the hotel connection!).

One world: AWESOME.

My first GUADEC, and I’m really enjoying it.

A lot of interesting talks, lots of great people, and also lots of work to do.

We had the documentation workshop the day before GUADEC started, and it has turned out really cool and interesting: lots of people are interested in documentation, users and developers documentation; and this is absolutely great!

We had interesting discussions with the Anjuta developer, the Evolution developers, people from Openismus, and many other I can’t probably even remember the names (apologies for that!).

Phil and I have also been working quite a lot in these days: Phil on the what is going to be the new GNOME users help, me mostly on the Rhythmbox docs.

Today we will have the BoF room at GUADEC for us and we will brainstorm a lot on new topics for the GNOME users help. If you want to help us out, or just to hang around and see how we work, please join us!

Last but not least: there are rumors about having a developers documentation hackfest, probably in Berlin, thanks to Openismus. It’s not confirmed yet, but it would be absolutely great! (I hope I can have days off from work to help out with that too).

Sweating and sweating, I’m trying to get this post out… it’s 12 days that I can only use one hand: I dislocated my right shoulder, and will be like that for the next few days, wearing this tutor thing that keeps my arm blocked, and keeps me very well warm (not that in this period I needed that…).

But I’m not writing for that, I’m writing for this:

Yeah, the Ubuntu for Non-Geeks: 4th Edition.

I think it is better if I leave you to our own Phil Bull blog post describing the book, since he’s one of the author:

http://philbull.livejournal.com/55089.html

I had the opportunity to read the book while I was reviewing it (thanks to Phil that mentioned my name to someone!), and I have to sat that it is a very well written book, easy on you. A worth read if you are moving your first steps in the Linux and Ubuntu world. Spread the voice, it’s a really good book!

Oh, and by the way, I’ll be at GUADEC! (I’m really looking forward to my first GUADEC!) And remember, we are holding a documentation workshop on Tuesday the 27!

A big thank goes to the GNOME Foundation!

(Time taken to write this blog post: almost 20 minutes…)

I just got my brand new Nexus One (thanks to a friend of mine, ‘cause in Italy we can’t buy it), and since I’m kind of a picky translator that enjoy taking a look at how things have been translated into my own language, I was looking at the Italian translation of my Nexus One.

Well, first it is nice to have a localization even if you can’t really buy the phone in Italy, but there are things that made me laugh. When you add a contact in the Nexus One, you are asked for the “Given name” of that person: in Italian it has been translated a little bit too literally in “Nome fornito”. 🙂 That really made me laugh!

I’m pretty sure that a Free Translator would have never done that! We Rock the World!

PS: does somebody know how Google handle the Nexus One translation? Just got mine, so I’ve not start to look at all those things…

For your eye pleasure, directly from the Desktop Help Summit, the 10 top things you shouldn’t do when writing documentation. Enjoy.

Hi guys,

Top 10 things not to do with your docs:

Reading the interface back
————————–
∘ Don’t document the entire interface – it’s safe to assume certain
things are obvious and don’t need to be discussed.
∘ Don’t read back the interface – people can figure out that the Open
button opens something.

Not aiming at a consistent level of technical expertise
——————————————————-
∘ Say something basic and something advanced in the same sentence, e.g.
“Click Open to open the document” in the same sentence as “you need to
install GRUB after you partition.”

Verbosity
———
∘ Explaining things at great length, in the same topic as where you give
the instructions.
∘ Just link off to a conceptual topic instead.
∘ Assume people will skim – don’t make them read loads of intro before
you get to the instructions.

Incorrect level of formality
—————————-
∘ It’s OK to use contractions.
∘ Still use reasonably formal language (i.e. don’t be crazy or overly
friendly), but don’t make it sound dry. it should flow.

Lack of context
—————
∘ Need to give context so people understand what is going on.
Confidence.
∘ Don’t just write a big list of commands.

Over-use of screenshots
———————–
∘ Only use them to illustrate a point.
∘ Don’t need to use them everywhere, the user is probably looking at the
screen anyway.

Leaving out steps or using too many steps
—————————————–
∘ Need to choose the appropriate level of detail. No need for one step
per mouse movement.
∘ Likewise, don’t miss things out if they seem obvious, just cover them
very briefly.

Documenting things which no-one cares about
——————————————-
∘ Document things that people need to know about, don’t just scratch an
itch.

Putting more than one topic in one document
——————————————-
∘ Results in long, rambling documents.
∘ Confusing, difficult to link to, overlap.
∘ Users confused by irrelevant, buried information.

Don’t talk down to or patronise your users
——————————————
∘ Using phrases like “obviously” can make people feel bad if it’s not
actually obvious.

If anyone can find one or two examples of any of these mistakes, that
would be cool.

Does anything come to your mind?

Oh, BTW, buttons are on the left.

Wow, I haven’t update this blog since November… long time ago!

I have to say to work has pretty much sucked up my life: have been very busy there (and probably will be more in the future). The cool part is that I have been working with different technologies, most of them unfortunately had to deal with Windows, some of them with both Windows and Linux, but it has been fun.

I’ve been playing around with JNA (Java Native Access), a bridge between the JVM and the underlying operating system: like JNI, but easier to use since what you only need to write is Java code. It all started with the problem of killing a process tree in Windows having only the root process PID: Windows, unlike Linux, will kill only that process PID, and the rest of the tree will be detached from where it was, staying alive.

The old way of killing a Windows process in our software was achieved with some kind of ActiveX magic (voodoo-poison, I say) and the use of the small Windows utility taskkill. Moving to use Windows functions to create processes, taskkill couldn’t be used anymore: what I experienced were strange behaviors (not always killing all the processes), and also lots of BSOD (still don’t know the exact cause, but removing the use of taskkill resolved the issue). Finding a way to kill a process tree in Windows has been a hard task: looking into MSDN is kind of a mystic experience. I find it a mess. But as always, when you find the solution to your problem, you find it easy and wonder why you didn’t think first about that.

So, to sum it up, if you need to create a process that spawns other processes, and you need to kill that process tree, these are the Windows functions from the kernel32.dll I used:

There are other things it is necessary to take into account, like the creation of the necessary structures, but basically you need to create a job object, create the process and attach it to the job object, and when it’s necessary, terminate the job object. All of this has been done with JNA, writing only Java, and is pretty robust: I tested it on a remote computer for 7 continuous days, creating and killing more than 500000 processes in batch of 4-5 processes at a time, processes that didn’t last more than 5-6 seconds (I even tested it for 3 days with 2-3 hours long processes).

An interesting part has been finding a way to check if a process was still alive, or had completed its run or had already been killed. The first implementation for this was using GetHandleProcessCount. Basically this functions checks how many handles a Windows process still has open, but with such many processes being created in a short timespan, I experienced OutOfMemory exceptions in the JVM (probably caused by many JNA Pointer objects being created and not cleaned up in time by the GC, but I didn’t investigate the cause). The solution has been using the WaitForSingleObject function, monitoring its return state. I only hope the API will not change with some of the too many Windows updates…

Now I’m playing with some really cool stuff: numpy and scipy. I’m trying to “embed” Python into our software, or at least to use numpy and scipy libraries and routines to avoid having to write complex mathematical algorithms when there are already valid and strong ones out there, and also to be able to write internal routines in an easier way with Python. I’m running some comparative tests right now (my computer at the office is still running): I’m trying to see if the same algorithm written in Java is slower or faster than the numpy/scipy internal functions. Right now I’m doing 1500 iterations over square matrices ranging from 10×10 to 700×700 calculating the determinant, and tomorrow I’ll implement the inverse of the matrix. Right now, looks like numpy is faster than Java on matrices from 150×150 and up.

Funny times ahead… also because on March 19th I’ll be heading to Chicago for the Desktop Help Summit with Shaun, Paul, Jim and other cool guys! Looking forward to that!