Thoughts Pad

Look mon! Umit has featured “The Bourne Ultimatum” movie!

Movie Directors are going to love UmitMapper and the NetworkInventory for their high-tech movies when we get it integrated into Umit. And we’re going to love to see them using it. Lol

During my last year at University, I spent about the whole year studying economics game theory, in order to make my thesis about friend-to-friend networks and best pratices for overlay and sharing networks. Game theory is a very interesting topic, and can lead us to choose better strategies based on the problem enviroment, rules and possible odds (or rewards) you can get from each possible strategy. Unfortunatelly, some games doesn’t have good odds for every player in the game, and when we can’t change the rules nor the environment that enforces the odds, we have to take the least worse strategy even when it is far from been optimal. Fortunatelly, sometimes we’re able to change the rules in order to create an environment capable of giving good odds for every player in the game (at least for fair players…).

That’s why the odds stands for: reward the fair player, and enforce bad ones to play fairly.

During this GSoC mid-term evaluation of students performance, I’ve been thinking about the odds of the game we have to play here, and realized some rules that could improve the competition quality and reduce project failures.

I know many mentors will feel familiarised with this situation: One of the students disapper for 2, 3 weeks and appear right before the mid-term evaluation saying that he is way behind the schedule because of problem x and y, and asks for a chance to continue working on the project. But, It is not possible for mentors to know for sure if he is going to do something
if he let Google pay him. This totally looks like a problem we can solve with game theory.

Here are the goals:
- GSoC is intended to help the open source community, by affording students and mentors to create and improve open source projects
- Mentoring orgs want that help, because money is what moves any project forward, and GSoC is a huge help
- Students want to have their names associated with Google, with their own killer open source software and get paid for that (money and t-shirt

And the odds:
- If a student works hard until the midterm, he receives the 2k
grant, and continues his work
- If a student doesn’t reach the midterm eval with a good status
(behind the schedule), two choices are left to mentors:
1 – Trust on student and let google pay him, hopefully that the
student is going to make until the deadline
2 – Drop student, and avoid his midterm payment

The problem is that many students are on GSoC seeking for the money only (that’s why so many are so desperate about the payment delay), and when they reach the midterm and see that they are not going to make it, the best strategy they have is begging for another chance,
get the 2k and give-up his project. This strategy is the best for him, but the worst for Google, Organizations and other students, because:
1 – Google doesn’t want to pay for nothing. Google wants more open source. That’s the main goal of the GSoC
2 – Organizations will be left without the project and the student contributions, and the mentor will have spent his time almost for nothing (almost, because the US$500 counts a lot)
3 – To accept this student, I had to dismiss another that know would give anything to be were this student stands. The bad student wasted his chance, wasted another student chance and wasted the money and time of you guys at Google for nothing.
4 – The bad student receives 2,5k for nothing and is happy because of that

Mentors also tend to choose this strategy, because there is a little chance that student is going to make it until the end of GSoC. Actually, mentors wants so much to have the project the students were allocated, that they give that chance because the strategy of dropping him is even worse than trust him.

My sugestion, based in this analysis, is to change the rules to avoid this strategy, and still
guarantee the goals of Google and Mentoring organizations. But, how can we manage to achieve that?

At midterm eval, if a student is dismissed because he didn’t made his work, the mentoring organization receives his money in order to use it to improve the software design, usability, buy equipments for testings and improve the software, offer that money as a bounty for another person that is willing to solve the problem the bad student left behind, etc. If mentors had that choise, here are the odds:
1 – Students will be afraid of don’t be aproved at midterm, and will be encouraged of working hard before it. As they want the money, they will work harder to have it.
2 – If a student still didn’t make enough to be aproved at midterm, mentors will have another strategy that is better for Google and Organization that is dismiss the student and use his money to make better open source software for the whole community, and the Google’s money served his purpose even with student failure, and mentors will have the opportunity to give another chance to a studnet he dismissed to get the bad one.

I can think about a lot of things that the project needs and can benefit with this money, and the whole community can also benefit from it instead of wasting it with an unresponsive student that wasted his chance to change something in the open source world. With this
student’s money organizations could pay for design, books, website, servers, offer the bad student’s money as a bounty to have the problem solved and a whole load of other things that the project needs.

I don’t know if the Google folks are going to agree with my point of view, but I just wanted to share my thoughts and maybe help improve GSoC rules, reducing the amount of projects that fails. Agreeing or not, Google is still rocking a lot with Summer of Code, and I only have to say thank you for the opportunity I’ve been having these years.

Cheers!

Thinking that with a really optimized, organized and structured code you’ll make your software the newest killer app ever? Been fast and stable is just a couple of the requisites users look for while choosing their software. Among all the requirements that users instintivelly looks for in a software, usability is the most decisive of them.

A software with poor usability makes user feel angry and disapointed about the software. Imagine that someone is trying to use your software in a low profile machine, and he starts missing some clicks because a process he is trying to do is very confusing and has many steps based on clicks and keystrokes to be accomplished… Gather this with the fact that he is in a hurry and his boss is mad about the time he spents to do something with the software. I don’t believe this person will ever love your software, nor he is going to indicate it to his friends, even if the underlying code of this software is well structured, organized and optimized. (This kind of software is not recomended for persons with cardiac problems)

We have a lot of effort trying to spread software development techniques all arround, but few trying to spread usability, acessibility and internationalization techniques. Keep in mind that your software is used by human beings, and usability really matters.

Spend some time reading some Human Interface Guidelines, choose one and stick with it. Also, make interface test suites and watch how your users work with your software. Try to count how much time they spend doing some tasks, and how can you decrease the time spent on each task. Try to make your interface as clean as possible, and keep in mind the KISS concept.

Some of these advices I didn’t have time (yet) to make on Umit, like interface test suites and watch how users are working with Umit. But I had some experience on interface test suites at my job and realized how important they are for software development and software usability improvement.

Although I’m not an expert on usability (yet), trust me: your software is not about code, but people and their desires…

For those of you interested on taking a look (or should it be a “hear”?) on the podcast I had with my friend Leslie Hawthorn[1], here goes the link[2]. Yeah… I was a bit nervous, and I missed some words… Also, we had a problem with skype at the time of the interview, and was kinda hard to come out with it. Anyway, hope you have good time with it!

There is another post at Google Summer of Code blog talking about some stats arround the Brazillian comunity[3] on open source and GSoC.

The last weeks, I’ve been playing on Umit trying to improve a little bit it’s usability and hunting some bugs for the next stable release which is going to happen at the same time Umit is getting integrated with Nmap officially[4]! Level Up for Umit!

Next Monday (28th May), the Summer of Code will officially begin, and keyboards will get really hot all arround the world. It won’t be different with us at Umit, and students didn’t wait until the official beginning of Summer of Code to start hacking their projects! Stay tunned to the Umit Project blog[5] to get some update about their projects. Soon the community will have brand new toys to play arround with Umit.

Cheers!

[1] – http://www.bengoodger.com/hawthornlandings/index.html
[2] – http://googlesummerofcode.blogspot.com/2007/05/umit-project.html
[3] – http://googlesummerofcode.blogspot.com/2007/05/brasilians-in-google-summer-of-code.html
[4] – http://umitproject.blogspot.com/2007/05/umit-as-official-nmap-frontend.html
[5] – http://umitproject.blogspot.com

Yes… That’s the name of that almost best seller book (I said best seller, but I didn’t mean best book), and I used it as this post’s title. Actually, I don’t mean to talk much about that book, neither I mean to read it.

Most part of those who look forward to read that book, do that with the hope of finding the answer of how to have a money tree in the backyard. First, I would like to state that I believe that money doesn’t come without hard work. You can work hard, and make something that give you loads of money after that, but not with the initial hard work stuff. So, even if that book can tell you the secret of making some money grow in a tree (and I tell you in advance that this is not the secret inside that book), I would still believe that there are better ways to earn some money. The best of them (and the only one I know so far) is working. Impressed?

Now, what about earning more money working the same? That’s the secret (not the secret of “The Secret”, but the secret I’m telling you right now by my own)!

Think about it… What if you could do more work in less time? You could work more, and make more money. Too obvious, uh? Sure it is!

Now that you know that, start thinking: are you working fast enough? This is a boolean question, which can return only True or False. So, here is how we should handle the output:

• True – “Yes! I’m working fast. Thanks”: Ok! You’re a fast working guy, but you still should consider stay tunned to stuffs that can make you work even faster.
• False – “No! My work goes like a slug.”: Well… you need to analyze your environment, machine and tools. That’s all about increasing your work rate. And, IMHO, tools are decisive on that matter. You can work in a nice and fresh aired place, with the Mac Pro of your dreams and still wonder how you could make your job faster. That’s true that you can go really fast with a good tool, and awful machines and environment (my case), but think about working in a nice place programming C++ with notepad…

So, “The Secret”, for those of you thinking about earning money with more work, is working more in less time. Find a way to get a better environment, machines and tools.

Finding or creating a better environment, means setting up a place in which you feel confortable, with a good desk, chair, etc.

Well… Finding a good machine is up to you! Try to find one with specific features that are favorable on increasing your WORK speed, not a machine that is favorable on increasing your GAMES speed. First, try to earn money, and than, try to find something to waste your money with (after you have it, please! And pay cash!).

About tools, I can suggest Umit if you’re a network admin trying to find a better way to keep track of your machines in your network (lol , but if you’re a programmer, try Python and related frameworks (Zope, Turbo Gears, Django, etc.). That’s what I’ll try to share on a speech I’ll give at UNIVERSO with some Information System students.

So it came the time which I decided to dedicate my time on porting Umit to Maemo, and make a package for it. This is a long time history, which started about a year or so and which I want to see it concluded for two reasons:

1. I want to be able to run Umit on my Nokia770 (which is getting old now with the N800 release)
2. One of the Umit’s main goals is portability. I believe that a Maemo porting is another step forward to accomplish this goal.

If you are thinking about acquiring a handheld, I urge you to take a look on Nokia’s internet tablets. Those devices run Maemo (which is Linux). I know it’s needless to say, but I’ll do anyway: it runs Python 2.5 and Gtk… and soon, you’ll be able to run Umit on it also!

This week I created a new branch at Umit’s repository, called hildon in which I’ll be making the necessary modifications. Contributions are welcome!

If you don’t feel like exporting the branch to check what I’ve been making there, and run it on your device to see how is it looking now, I can list what I’ve done here:

• Made a really simple function to detect if the program is running on Maemo or not
• Converted the main window to HildonWindow (when running the app on Maemo)
• Put the main menu and the main toolbar in their right places

Few work done until now, but soon it will be over. Also, I would like to announce that soon I’ll be releasing Umit 0.9.4. It will feature some bug fixes and installation process improvements. The new windows installer will also come with updated dependencies, including Python2.5 and latest Gtk version. These fixes should ease the task of creating packages for Umit.

Currently, I won’t be able to release a Mac installer, but I’m looking forward to have a chance to do such installer soon (please, consider soon as been “until the end of this GSoC”).

Finally I could release the list of selected students for this Summer of Code. Unfortunately, I couldn’t select everyone I wanted, and I had to let go many talented students.

I hope that the selected students have conscience of this matter, and work hard to show the world that they really deserved that slot in the Summer of Code, returning really good and useful stuff to the community. I really believe they’re going to rock this Summer, and that’s why I chose them.

BTW, the list of accepted students can be found here and here.

Soon, I’ll be announcing the address of the mailing lists and the IRC channel I said I was going to create for project discussions.

Cheers!

This very first post is intended to:

1. Start this blog with something
2. Say that the final result of the Google Summer of Code is almost ready. I’m just waiting for one remaining student. Stay tunned…

Cheers!