For most people of my generation, the phone system is broken. And it is not all about costs or devices: as Andreas Klinger once said, telephone numbers are a disgrace to our generation.
His main point, one I agree with, is the disconnect between phone numbers and the identity of the people behind them. He says:
I have friends that have three numbers in their signature. US, UK, local-european-country-no-one-knows. This whole system assumes I want to call their cellphones. Which is not true – I want to call them. The people behind that numbers, simcards and devices…
Andreas stresses the need for a means to reach people regardless of where they are, what phone operator they are using or other details that are insignificant from the point of view of the caller.
In the era of email and, now, social networks, phone numbers are a legacy of the old days. Especially since the introduction of personal mobile phones, they often constitute an unnecessary level of abstraction between us and the person we are trying to reach.
As Andreas points out, what modern phones would need is an identity system to abstract phone numbers out of the way, just like DNS does with IP addresses.
While this is a significant problem that needs solving, it would require some infrastructure to be in place, as you can see by looking at the scenarios explored in the post.
However, there is a smaller problem that can actually be addressed with resources that already are in place. And I am sure we all experienced it at least once.
Continue reading Can we get rid of unknown phone numbers?
A while ago I wrote about a few problems we were having with the way our issue tracker was misused and concluded that the tools we use have a crucial role in directing our behavior towards good or bad behavior patterns.
One of the major pain points I mentioned was linked to the many duplicate issues we were seeing and listed one possible solution to reduce the number of duplicate issues that were being raised. After reading my post, my friend Mattia came to me saying “Good point, why don’t we just build it?“. Well, we did.
Continue reading Preventing (some) duplicate bug reports in Redmine
I spend most of my days at work on powerful IDEs like Eclipse or Netbeans, tools so advanced in functionalities that their feature lists span over several pages. Their power, however, has its own drawbacks: their memory consumption is measured in the gigabytes, and running them on underpowered computers is the most frustrating of experiences. Issues that any Java developer on Earth will have to face, sooner or later.
Having grown frustrated by Eclipse being too slow on my 4 years old work laptop (I will not comment on this), I decided to drop the IDE for a while, switching to an extremely powerful editor that offered me the one thing that matters the most to me: blazing fast navigation between different source files.
Of course I knew I would miss some of Eclipse’s advanced features but I wanted to give it a try, especially since Andraz’s post left me with a bit of curiosity: how much the tools we use affect our abilities? And why IDEs are so used by desktop developers while they are not so popular with web frontend developers who generally use scripting languages?
A commonly accepted explanation is that it is easier to write IDEs for static languages, when lots of information is known at compile time. It is easier to extract information from the code and use it to build powerful and useful features.
However, after a few weeks of experimentation, I ended up with a slightly different point of view on the whole matter: the popularity of IDEs for Java encouraged coding conventions would not be so widely accepted if the majority of coders used a plain text editor to edit their source files. Those conventions grew so popular that that today Java appears to be designed to be used with an IDE. Let me give a few examples.
Continue reading Do languages shape IDEs or IDEs shape languages?
Summary: accepting objections is one of the most valuable skills a manager can learn, and yet the role models we get fail to highlight this
As many other geeks, I have always been fascinated by aviation and its history. One of the things that kept intriguing me was a simple question: what could cause the dramatic decline in the number of plane crashes attributable to pilot error?
I recently found an answer to that question in a How We Decide by Jonah Lehrer, crediting two different factors for the increased safety.
Continue reading Building a culture of objection
Looking for a job in the tech sector is a challenge. A lot has been written about the process itself and its quirks, ranging from programming puzzles to whiteboard interviews. However, there are still a few details that are often overlooked by most companies and can make a significant difference for perspective applicants.
Even when recruiters try to do all they can to make the application and hiring process as easy as possible, it is extremely common that the jobs or careers sections of their websites do not contain all the information applicants would need to make an informed choice. And when the information is present, it is often arranged in a way that is not effective or clear enough.
This article contains a selection of the most frequently neglected details; information that is valuable for applicants but, for a combination of good and bad reasons, is often hidden or not present at all.
If your company is hiring, try to figure out how easily a candidate can find an answer to these questions by looking at your website:
If the answer to any of these questions does not come immediately, the careers section of your website may be cleverly designed and communicate a great image of your company, but it is probably disconnected from the needs of its users: the people you are trying to hire.
Continue reading Hiring: you are doing it wrong
As I already had the chance to write in a previous post, I really appreciate distributed version control systems; I consistently use them at work and for many of my side projects. I typically switch between git and mercurial repositories, with the former being my primary choice lately, and there is one specific command that always troubles me when I do that: pull.
There is one wonderful piece of inconsistency between the two systems, one that often leads to confusion for new adopters and unnecessary hassle for experienced users. If you are familiar with both systems, you may already be thinking about the culprits. If you are not, you may be more careful about the pull and fetch commands after reading this post.
Continue reading Design horror: same command, different meanings
Last Friday, a blog post on Channel 9 announced Achievements for Visual Studio, an extension for the Microsoft IDE that tracks the actions of programmers as they write code and unlocks badges based on their behaviour.
Now that the concept of gamification has become (even too much) mainstream, it is not surprising that this is not the first time an idea like this is proposed. Jason Rudolph has published an excellent blog post about programming achievements. Websites like coderwall already inspect source code repositories on GitHub and others in order to build achievement-based profiles for coders. There even is an earlier project, called Strokes, that added achievements and challenges to Visual Studio.
Introducing mainstream achievement support right within the IDEs, however, can have a stronger effect on the way we write software, as those tools can inspect code right while we are writing it. The strong link between action and reward lead to a stronger feeling of accomplishment when we earn those achievements, and programmers are likely to be receptive towards game mechanics (most of us have a background as gamers). But there is more than that.
Continue reading How achievements can improve software quality
While issue trackers originate as tools to manage projects more effectively, during the last years of work I have been through some situations where their misuse backfired.
Tools originally conceived to improve workflows and project lifecycle became a significant burden for the team using them, occasionally making difficult situations even worse.
This post is a collection of bad patterns I have seen happening. It is not a survey of all the possible situations that can occur. It is not meant to be an argument against issue trackers (if it tells anything, it will probably be about the teams I was part of), but rather an overview of things that went wrong because of the way a particular team used those systems.
In retrospective, most of the problems were due to a lack of discipline and experience of the project teams, and they are less frequent – if present – in a team of seasoned professionals. But, while training and education can certainly help, I would love to consider a different aspect: the issue tracking systems were not helping as they could have.
Here is a summary of the most common and annoying problems I encountered
I would love to build on top of each negative experience, with a constructive attitude, by exploring how a better designed system could induce a better behavior.
Continue reading We need smarter issue trackers
I still remember one of the most interesting questions I have been asked last year when I was interviewing for a Software Engineering position:
How would you explain to a 12 years old what an API is?
At first, I was surprised: it certainly sounded like an uncommon question for a Software Engineering interview. And yet I tried to answer as best I could, trying to come up with a concise definition that could convey what I meant, but without assuming any specialist knowledge about computers and software.
As I progressed with the interview, it became evident what kind of ability my interviewer was trying to test.
Continue reading Want to get better at your job? Spend time with children
I didn’t want to go through the hassle of setting up Apache on my Mac, though, and I was looking for some quick alternative to installing a local web server. After some Googling, I found a wonderful one liner that did the job, provided that you have Python installed.
Open a Terminal window and go to the directory containing the files you want to serve and run:
python -m SimpleHTTPServer
or, if you are using Python 3,
python -m http.server
you will then be able to access your files on http://localhost:8000/. (You can specify a different port number by passing the number as last argument, just remember that you need root permissions to open sockets on ports lower than 1024.)