So, here I found how to do it: How to discard changes in VMWare player?

Q: Running a virtual machine, how can I ensure that the changes gets discarded after I close it?

A: Shutdown the VM cleanly. Edit the vmx and add this line if the VM uses a scsi-disk

scsi0:0.mode = "independent-nonpersistent"

or this if the VM uses an IDE-disk

ide0:0.mode = "independent-nonpersistent"

Alternatively, use this two lines:

snapshot.action = "autoRevert"
snapshot.disabled = "TRUE"

Several ways lead to Rome. Both ways should work, but don’t mix them.

the fact that, in this period of my life, I am living in Germany and I own a German credit card, doesn't mean that I can perfectly understand German. So why there is no way to change the language in your store applications to English or Italian?
It's so difficult to understand?

I bought my Mac in Germany and I requested an international keyboard. And I also use English on my laptop, because even if I am Italian native speaker, I prefer to use English on my computer. And... I was doing the same when I was living in Italy and Switzerland. The same question may be posed to the laptop sellers: why, if I buy a laptop in Germany I have to stick to local Windows language and keyboard layout? What is so difficult to understand in the fact that users may like to choose the language to use for programs and hardware they buy?

How am I supposed to buy anything from a website which doesn't speak my language? Even living in Germany I can use my internet banking in English: does this sounds strange to your company? In which century are you guys living? May I expect that an internet service speaks a second language despite where I live, or from where I pay?

Thanks.

Thinking top-down

First, when you write your code don't start from the implementation, but start from the client code. Today it is popular to speak about Test Driven Development, and how writing test code first (which is client code), drives you to a better design. In the same way you can write your back-end services starting from the front-end, from how the user interacts with the UI, and letting the implementation details to be driven from it. The internal design should emerge from the use cases, not viceversa. So, testing software early not only drives to more reliable applications but, same importantly, also leads to much better code: easier to understand, to extend and maintain. It is not a detail: in the software industry the code is your product!

I appreciate more a developer who writes code which is easy to follow, rather than developers who can easily understand messy code. Messy code comes from the bottom-up approach. The ability to deal with messy code, comes from the habit to write and deal with it. Real good developers are the one who developed a fine sense of the code smell. A good developer do not write code unless it is strictly necessary, and this is much easier if you start from the abstract idea.

Imagining the "model" at first means to predict what you are gonna need. It brings in constraints, and require you to take decisions, which will likely reveal to be wrong later.
I learned this when I started to work in eclipse. In eclipse you use a variable (which doesn't exist yet!) in your method, eclipse underscore it in red to say that there is a compilation error, then you do a "quick fix" and let the IDE to declare the variable for you. You call a method which do not yet exist, and let the IDE to implement the stub. This reverses your way to think. You will never write a useless method or variable again (at least this risk will be drastically reduced, and with some discipline you can easier keep things clean).

Instead of thinking before on the the details, you can focus on your business and write code which explain what your method is doing. And only after you will write the code specifying how to perform the functionality.
Starting focusing on a more abstract level helps making better applications for the users, and the code quality will also benefit.

For the notice, Wikipedia says that "bottom-up programming approach which is common in object-oriented languages such as C++ or Java". I agree with the guy who is defining this a «complete utter bull dung».

Writing readable code

Try to keep your code speaking, let the code be self explanatory, it's not that difficult... if you find yourself writing much comments to explain what an algorithm is doing, probably it means that your code is not readable. Comment in source code is documentation for developers; but the code itself, if it is understandable by another developer, is the best documentation. Avoid putting logs everywhere: it makes the code confuse, and difficult to maintain (how many times code changes and logs do not reflect anymore what's happening?). Put log statement in the strategic points: logging is a part of your application and also that should be carefully designed and thought as a feature. Don't put "debugging" everywhere, logging != debugging. Debug with your IDE, and write tests; it's hardly the case when you can understand what went wrong just from trace logs.

Once the code is written, it is going to be read dozen of times, and this is why it is so important that code is easy to read. Personally I prefer code which is understandable and performs well, over code which is messy and (maybe) perform super-fast. Most of the time messy "optimized" code is slower than simpler and more straightforward code.

Handling properly error/exceptional conditions

It looks like this is one of the hardest things to learn from software developers. And it's the source of many bugs. It's simple as that: catch the exception you can manage, and let the other pass through. Avoid "catching-and-rethrowing", avoid exception swallowing, and other amenity: there are plenty of articles about things you'd better never do. This one is quite comprehensive: Exception Handling Antipatterns. Make sure your software not only works well when everything goes fine, but also give the proper messages when something bad happens. This will also reduce the need to dig in log files just to discover that "a server is down" (when your application could just nicely tell that to the user, or inform the administrators!), and reduce the habit to have so much code for debug log statements.

Writing code in TDD also helps with this. Finally try to think "what could go wrong? and how my software will react?" before saying you've completed your tasks. Remember how do you feel when you get a cryptic blue screen, and how Windows gained the name to be a very buggy OS.

Don't become a bluescreen author.

Conclusions

I don't know if this is a good answer to the question. But it reflects quite well some of the things I feel very important when I write my code, and that's why I decided to write about this topic here.
And no, the interviewer didn't hire me :)

For the guys who do not know about iTunes and iPod/iPhone foolishnesses, the problem is that when connecting trough USB they are not exposing the filesystem as usb disk. The second problem is how iTunes memorizes files: they get renamed in 4 char lenght filenames under a 3 char lenght folder... so you have files like:

iTunes_Control/Music/F26/UBFF.mp3
iTunes_Control/Music/F26/UEBM.mp3
iTunes_Control/Music/F26/UIPQ.mp3
iTunes_Control/Music/F26/UWCJ.mp3
iTunes_Control/Music/F26/WGOH.m4a

As result of this, if you have songs belonging to different authors and coming from different albums, but you was keeping in the same folder to listen together... you can't specify to iTunes to play a folder as a playlist, because folder and filenames gets chaotically "reorganized" when imported in iTunes. iTunes, then uses id3 tags to expose views to the user, grouping by author or album title, etc.

To connect to iPod filesystem with Linux, you need to jailbreak the iPhone or the iPod touch, and have OpenSSH running on it. It is not very difficult, but, afaik it's the only way to access remotely to the iPod filesystem, through network (wifi).

Once done that, you need to mount the filesystem using ssh protocol; this can be done with sshfs, which is the ssh protocol support for FUSE (Filesystem in USEr space) which allows you to mount several type of local or remote filesystem without needing root privileges.

$ sudo apt-get install sshfs

Then I created a folder under my ~/Music folder where to mount my iPod media

$ mkdir ~/Music/iPod

At last I made a bash script to mount and unmount the iPod media to the folder I just created. This is the content:

#! /bin/bash

case "$1" in
mount)
        echo -n foobar | sshfs root@Luigi-R-Viggianos-iPod.local:/private/var/mobile/Media/ ~/Music/iPod -o password_stdin
	;;

umount)
        fusermount -u -z ~/Music/iPod
	;;

*)
	echo "Usage: `basename $0` {mount|umount}"
	exit 1
	;;
esac

In the above script "foobar" is the password to use to ssh-connect as root on my ipod. Unfortunately I did not succeed in using public key authentication, even modifying the sshd configuration on the ipod, I do not know why... So I had to specify the password in the script.
The Luigi-R-Viggianos-iPod.local is the hostname used by my iPod. Alternatively you can use the ip address, but when you change network you will need to update the script; the hostname usually gets recognized in different WIFIs and mapped to corresponding ip address.

To get the ip address of the iPod connected to WIFI, there are some programs downloadable on the apple store, one is called, with much of fantasy, "IP Address". To know the hostname of the ipod, just connect to it through ssh, and you will see that displayed on the bash prompt line, in my case: "Luigi-R-Viggianos-iPod:~ root#", unfortunately apples likes to have weird unix system on their devices so you don't have basic commands like 'hostname' or files like /etc/hostname to check... did I already said that I hate OSX...?

At this point what I do is just running the script:

$ ipod mount
or
$ ipod umount

to mount or unmount the iPod to ~/Music/iPod folder. The iPod needs to be attached to a power source, the laptop trough usb or to a docking station, otherwise it will disable the WIFI connection when it goes on stand by; but the file access is fully wireless.

To play files, you need to launch Amarok or Rhytmbox and import the folder ~/Music/iPod. I use Rhytmbox and it indexes the folder. When the folder is mounted I can see the music on my iPod, and when it is not, the music just disappears.

If you want to export an album of MP3 files from the iPod, you just need to select files from Rhytmbox and drag and drop into Nautilus (filesystem browser). But you will have the weird names for the MP3 files set by iTunes. To batch rename the files you can install and use id3ren, which lets you to customize (-template option) how the filename should be renamed (using album title, song title, author, etc):

$ sudo apt-get install id3ren
$ id3ren -template='%a - %t - %s.mp3' *

If you like to backup the music on your iPod just use rsync or cp. But I don't know how to import new songs in the weird filesystem-format used by iTunes... For this, possibly the easiest solution is to use iTunes on Windows or OSX using VMWare, until Apple does not decide to release iTunes on Linux.

Have fun.

Some little look and feel changes, contact groups support, nothing really new, except for the native 64bit support. And I hope it will be more stable.

Download it from here: http://www.skype.com/download/skype/linux/

I updated it because the old 32bit version recently is very unstable on my system. Maybe due to some library and kernel update from Ubuntu.

After the update you'll need to reconfigure sound settings. And you know how tricky is it on Linux... but with some luck was quite easy on my macbook pro 5.1 running ubuntu: select "HDA NVidia, ALC885 Analog Front speakers (front:CARD=NVidia, DEV=0)" as device for everything, and if you have a system like mine it could work :) . Good luck!

This article is divided in following steps

1. Installing Subversion
2. Installing Apache
3. Configuring Apache with SSL
4. Configuring Subversion with Apache (and SSL)
5. Installing Trac

You may choose for example to see how to install Apache and SSL, or having Apache plus subversion without Trac.
Steps are voluntary isolated, and will require more operations than, for instance, issuing an "apt-get install trac" that will download and install all the packages in one step; but this will hopefully allow the readers to choose picking one section and forget about unneeded components.
I'll not explain what Subversion is, or what SSL is, etc. Ask google, for this info: I just say that for your software project you may need a server with those tools ready for your team.

Requirements

You need Ubuntu 9.04, in my case I used the "server edition" 64bit, while installing I used the minimal server mode pressing F4 to have a system as lighter as possible. But possibly this tutorial should be valid for Debian and previous Ubuntu version; but I have not verified that: if you do, post a comment to report your experience.

Preparation

After installing your server you have to ensure that apt system is up to date with available software on the repositories. Type the following command:

$ sudo apt-get update

upgrading installed packages may be a good idea to do now:

$ sudo apt-get upgrade

Answer Yes if asked to download and install the upgrades.

1. Installing Subversion

From the command line type the command:

$ sudo apt-get install subversion

If everything went fine you should able to verify the Subversion version installed with following command:

$ svn --version
svn, version 1.5.4 (r33841)
   compiled Aug  7 2009, 02:02:06

Copyright (C) 2000-2008 CollabNet.
Subversion is open source software, see http://subversion.tigris.org/
This product includes software developed by CollabNet (http://www.Collab.Net/).

The following repository access (RA) modules are available:

* ra_neon : Module for accessing a repository via WebDAV protocol using Neon.
  - handles 'http' scheme
  - handles 'https' scheme
* ra_svn : Module for accessing a repository using the svn network protocol.
  - with Cyrus SASL authentication
  - handles 'svn' scheme
* ra_local : Module for accessing a repository on local disk.
  - handles 'file' scheme

For now, let's stop here: how to create the Subversion repository, configure the users etc. Will be explained later in conjunction with Apache2 configuration. Maybe I'll write something on how to deal with svnserve, svnadmin, and user access control, in another article.

Later we will see how to create a repository, configure it with apache and HTTP basic authentication.

2. Installing Apache

To install apache 2 type the command:

$ sudo apt-get install apache2

When finished you should be able to connect with the browser at http://localhost and see the message "It works!". Or you may verify that at the command line installing and using curl:

$ sudo apt-get install curl
$ curl http://localhost
<html><body><h1>It works!</h1></body></html>

3. Configuring Apache with SSL

Now we want to configure apache to run HTTPs.
Following command will enable ssl Apache2 module with a2enmod (cryptic name for "Apache2 enable module":

$ sudo a2enmod ssl

The previous command will suggest you to restart apache to let it to reload the configuration; ignore that message for now.

We need to enable the HTTPS port (443). Edit /etc/apache2/ports.conf and ensure that port 443 is defined as follows:

$ sudo vi /etc/apache2/ports.conf

# If you just change the port or add more ports here, you will likely also
# have to change the VirtualHost statement in
# /etc/apache2/sites-enabled/000-default
# This is also true if you have upgraded from before 2.2.9-3 (i.e. from
# Debian etch). See /usr/share/doc/apache2.2-common/NEWS.Debian.gz and
# README.Debian.gz

NameVirtualHost *:80
Listen 80

<IfModule mod_ssl.c>
    # SSL name based virtual hosts are not yet supported, therefore no
    # NameVirtualHost statement here
    NameVirtualHost *:443
    Listen 443
</IfModule>

I added the clause NameVirtualHost *:443 in the for SSL; this is not strictly necessary but it will be useful later if you want to have a VirtualHost for trac and other development services.

Now we need to configure the SSL site. Fortunately we have already the configuration file for that, we just need to enable it with a2ensite (cryptic name for "apache2 enable site")

$ sudo a2ensite default-ssl

Again, the above command will suggest to reload apache configuration to activate the changes. This time the suggestion is almost right. As we made several changes I prefer to restart apache with following command:

$ sudo /etc/init.d/apache2 restart
 * Restarting web server apache2                                                                                              apache2: Could not reliably determine the server's fully qualified domain name, using 127.0.1.1 for ServerName
 ... waiting apache2: Could not reliably determine the server's fully qualified domain name, using 127.0.1.1 for ServerName

If everything went fine you should see the above warning. You can ignore it, unless you want to configure the ServerName for your server. But this is out of scope, so do a search on Google, or consult an Apache expert.

So, if everything went fine, now we should be able to connect to our server through SSL.
You can use firefox or curl, as before, but this time the URL will be https://localhost

$ curl -k https://localhost
<html><body><h1>It works!</h1></body></html>

the -k option is to ignore certification validation. Also firefox will complain that our certificate is invalid, but you can add it to exceptions and it will nomore bug you with those messages.

If everything went fine, now we should have Apache2, HTTP and HTTPs ready.

4. Configuring Subversion with Apache (and SSL)

First of all, we need to install the Subversion modules for Apache2.

$ sudo apt-get install libapache2-svn

They will be enabled by default. So you don't need to run a2enmod.

We only need to configure a repository. Let' say our project is called 'myproject'.

First of all, let's decide where our svn repositories will be created. I like /var/local/svn :

$ sudo mkdir /var/local/svn

Then let's create the repository using following procedure:

$ sudo mkdir /var/local/svn/myproject
$ sudo chown www-data:www-data /var/local/svn/myproject
$ sudo -u www-data svnadmin create /var/local/svn/myproject

Above commands will ensure that the user www-data (which is the apache user) can fully access the repository for reading and updating it.

We need to configure the repository in Apache. Edit /etc/apache2/mods-available/dav_svn.conf using:

$ sudo vi /etc/apache2/mods-available/dav_svn.conf

And add a section like the following one:

<Location /svn/myproject>
  DAV svn
  SVNPath /var/local/svn/myproject
  AuthType Basic
  AuthName "My Project Subversion Repository"
  AuthUserFile /etc/subversion/myproject.passwd
  <LimitExcept GET PROPFIND OPTIONS REPORT>
    Require valid-user
  </LimitExcept>
</Location>

In the above file we indicated that, at the location svn our repository should respond. And for updating the repository we want a valid user. As per above configuration anonymous consultation is allowed; but you can disable it commenting with a leading '#' the lines <LimitExcept ... and </LimitExcept> or just removing them as in following example:

<Location /svn/myproject>
  DAV svn
  SVNPath /var/local/svn/myproject
  AuthType Basic
  AuthName "My Project Subversion Repository"
  AuthUserFile /etc/subversion/myproject.passwd
  #<LimitExcept GET PROPFIND OPTIONS REPORT>
    Require valid-user
  #</LimitExcept>
</Location>

The above configuration indicates to Apache that even for consulting the repository we want a valid user.
But valid users need a password, and in fact we indicated a password file for our repository called /etc/subversion/myproject.passwd. So let's create a password file with a couple of users:

$ sudo htpasswd -c /etc/subversion/myproject.passwd luigi
$ sudo htpasswd /etc/subversion/myproject.passwd mario

The -c option indicates that the password file should be created as new; and it is only necessary for the first user. Be aware of the fact that -c overwrites the existing password file without asking anything. Personally I think this is a quite stupid behavior, but that's the way it is.

Now we should be ready.

Let's reload apache configuration to make the changes effective:

$ sudo /etc/init.d/apache2 reload

and let's test with the browser that our svn repository is now accessible through HTTP and HTTPs at following urls:

http://localhost/svn/myproject/

https://localhost/svn/myproject/

We can also use curl to verify it is working:

$ curl http://username:password@localhost/svn/myproject/
<html><head><title>myproject - Revision 0: /</title></head>
<body>
 <h2>myproject - Revision 0: /</h2>
 <ul>
 </ul>
 <hr noshade><em>Powered by <a href="http://subversion.tigris.org/">Subversion</a> version 1.5.4 (r33841).</em>
</body></html>

$ curl -k https://username:password@localhost/svn/myproject/
<html><head><title>myproject - Revision 0: /</title></head>
<body>
 <h2>myproject - Revision 0: /</h2>
 <ul>
 </ul>
 <hr noshade><em>Powered by <a href="http://subversion.tigris.org/">Subversion</a> version 1.5.4 (r33841).</em>
</body></html>

Now we can also download our project using svn

$ svn co https://localhost/svn/myproject myproject --username luigi

"luigi" is obviously my username, substitute it with yours.
The first time it will prompt for accepting the SSL certificate, answer to accept it permanently (p). Then it will optionally ask you for the password, type it.
We can also test that modifying the remote repository is working with:

$ svn mkdir -m "created the trunk for the project" https://localhost/svn/myproject/trunk --username luigi

It will answer: Committed revision 1. If so, we've done.

5. Installing Trac

To install trac files and required dependencies, type the following command:

$ sudo apt-get install trac
$ sudo apt-get install libapache2-mod-python

Let's create the directories for trac web folder:

$ sudo mkdir /var/local/trac
$ sudo chown www-data:www-data /var/local/trac

edit Apache configuration file for one of your enabled sites (in this example I modify the default http one, but you can choose to put trac on HTTPS modifying default-ssl)

$ sudo vi /etc/apache2/sites-enabled/000-default

and add the following lines at the end of the file, before the </VirtualHost> tag:

        <Location /projects>
                SetHandler mod_python
                PythonInterpreter main_interpreter
                PythonHandler trac.web.modpython_frontend
                PythonOption TracEnvParentDir /var/local/trac
                PythonOption TracUriRoot /projects
                PythonOption PYTHON_EGG_CACHE /tmp
        </Location>

        # use the following for one authorization for all projects
        # (names containing "-" are not detected):
        <LocationMatch "/projects/[[:alnum:]]+/login">
            AuthType Basic
            AuthName "trac"
            AuthUserFile /etc/trac/trac.passwd
            Require valid-user
        </LocationMatch>

Create a password file for trac users (if you want you can reuse or link the passwd file used for subversion repositories)

$ sudo htpasswd -c /etc/trac/trac.passwd luigi
$ sudo htpasswd  /etc/trac/trac.passwd mario
... continue this way for all your users.

Create the trac environment for your project:

$ sudo -u www-data trac-admin /var/local/trac/myproject initenv

It will ask you some questions related to your project. Here's my answers in blue

Project Name [My Project]> My Project
Database connection string [sqlite:db/trac.db]> [Just press Enter to accept the default]
Repository type [svn]>  [Just press Enter to accept the default]
Path to repository [/path/to/repos]> /var/local/svn/myproject

Now let's restart apache:

$ sudo /etc/init.d/apache2 restart

Check that trac works properly connecting the browser to http://localhost/projects or use curl to verify that the url is responding properly as we did before. This url should display a link to "My Project", click on it and you should see the project home page. Clicking on login the browser should ask you to provide username and password as recently defined with htpasswd command.

Last thing to do: add yourself as administrator for Trac. This will enable the Admin menu and allow to do much of the administration operations from the web, that you could also do at the command line with trac-admin tool.
Execute the following command:

$ sudo -u www-data trac-admin /var/local/trac/myproject permission add luigi TRAC_ADMIN

This will make the username 'luigi' administrator for the project.

You can tune additional configuration settings in Trac to enable email notification, change the project logo, etc. Everything you need to know is on Trac website. For the configuration check here: http://trac.edgewall.org/wiki/TracIni

Hope everything went fine. Enjoy your development!

What is the best comment in source code you have ever encountered?

A fun read. I'm trying hard to keep myself to post some snippet; fortunately I've not enough reputation on StackOverflow to post answers :)

Noticeable good things: the trackball, the easiness to setup the Bluetooth connectivity. The rest, is totally crap. Also, I read of people complaining that after a while the trackball gets dirty and stops working. And it's very hard to clean up and restore it working. Uhm...

One thing to add, just to relief those thinking that I'm getting an anti-apple guy¹: I also don't like the "paste" function binded to the middle-mouse click on Linux. I often get accidental pastes in source code for that "feature". And, of course, there's not an easy way to disable it: as far as I understood the only way is to trick on Xorg configuration. But... the good thing is that Linux evolves, and this will probably be fixed before or later (and it should be the time!!!); it seems to me that OSX is bound to legacy usability errors that they call "features", and they never go forward on those points. Think different: I'm trying but thinking wrong is not pleasant.
I cannot see the time when Ubuntu will be working fine on new MacBooks hardware.

¹ Apple's hardware is cool, it's the software that sucks!

It's the best note taking application I've ever seen. Give it a try.

Update: latest version:
Mono 2.2
Tomboy 0.13.4