Benoit Perroud : concepts and cloud ready applications

Cassandra, hector, maven and tomcat

2011-08-05T22:48:00.005+02:00

Cassandra (v0.7 and 0.8), hector (version compatible with Cassandra), maven and tomcat bound together result in a warning at tomcat startup :

INFO: validateJarFile(/...<webappspath>.../WEB-INF/lib/servlet-api-2.5-20081211.jar) - jar not loaded. See Servlet Spec 2.3, section 9.7.2. Offending class: javax/servlet/Servlet.class

Nothing harmful here, but as we want to do things as clean as possible we should avoid violating Servlet Spec 2.3.

So running a dependency:tree help to find out the guilty dependency :

[INFO] +- me.prettyprint:hector-core:jar:0.8.0-2:compile
[INFO] | +- org.apache.cassandra:cassandra-all:jar:0.8.1:compile
[INFO] | | +- org.apache.cassandra.deps:avro:jar:1.4.0-cassandra-1:compile
[INFO] | | | \- org.mortbay.jetty:jetty:jar:6.1.22:compile
[INFO] | | | \- org.mortbay.jetty:servlet-api:jar:2.5-20081211:compile

Hum hum, org.mortbay.jetty:servlet-api:jar:2.5-20081211. We found the responsible of the problem.

Using <dependencymanagement> in our pom.xml file we will be able to mark this dependency as provided and the problem should flight away :

<dependencymanagement>
    <dependencies>
      <dependency>
        <groupId>org.mortbay.jetty</groupId>
        <artifactId>servlet-api</artifactId>
        <version>2.5-20081211</version>
        <scope>provided</scope>
      </dependency>
    </dependencies>
</dependencymanagement>

Build, deploy, and that's it !

NoSQL Overview @Webmardi

2011-03-07T14:32:00.001+01:00

Tuesday 1st of March 2011 I gave an overview of NoSQL at the Webmardi monthly event. The presentation was hosted by Webdoc. Thanks all for the warm welcome !

Some pictures :

The slides are available on Slideshare : NoSQL Overview, implementation free.

It is called "Implementation free" because I didn't want to focus on a particular implementation of a NoSQL datasore, but rather generalize concepts of "What is NoSQL". And it's a tricky answer to formulate :)

So what is NoSQL ? It's a family of datastores that does not have SQL as main data access pattern.

The presentation was hosted by Webdoc : http://www.webdoc.com.

Eventually Consistency demystified

2011-01-06T12:40:00.006+01:00

In my crusade into the NoSQL world, Eventually Consistency is everywhere. I want to demystify this property a little bit here.

But let's begin with an example to have the same base for the discussion :

Let "Node1", "Node2" and "Node3" be three nodes (servers) that are part of our distributed datastore.
Let "User A", "User B", "User c" be three users wanting to read and write data in our fictive distributed datastore.

At time (1), "User A" write the value "A" to "Node1". "Node1" will replicate asynchronously this value to both "Node2" and "Node3" (specific to my example).
At time (2) the write call of "Node A" returns. But the replication of value "A" hasn't been completely propagate to "Node2" and "Node3".
At time (3), "User B" and "User C" will read value "A" from "Node1" and "Node2" respectively. "User B" got the latest value (because it reads the node which initiate the update), "User C" will read either the old or the new version of "A", but without any guarantee regarding what it will read.

In a future time (5), "User B" and "User C" re-read value "A" and then got the same value. At this point of time, the datastore is consistent.

Immediate Consistency

In a Immediate Consistency, opposing Eventually Consistency, the write call from "User A" should wait till the replication is done on other nodes before returning, and replica nodes ("Node2" and "Node3") should be synchronized to expose the new value at the same time.

Moreover, if "Node1" is unable to talk to "Node2", the write replication will probably fail then the write call from "User A" will fail.

As we can notice, Immediate Consistency is hard to scale (see two-phase commit or paxos algorithm), because it increases the latency of the writes and makes the system not redundant to failure.

Trade-off for scaling writes

Eventually Consistency is then a trade-off for scaling writes that seems reasonable in certain use-cases.

DNSSEC NSEC3 domain hash computation algorithm

2010-12-23T10:38:00.004+01:00

DNSSEC is a DNS extension in order to authenticate and ensure integrity of DNS responses, in order to offers protection against DNS spoofing.

DNSSEC comes with two "denial of existence" mechanism : NSEC (RFCs 4033, 4034, 4035) and NSEC3 (RFC 5155).

Now how "denial of existence" works ?

When a query is performed on a non-existing domain, a specific answer is returned to the resolution client, given the closest domains that are alphabetically before and after the queried domain. But what is very sensible in this way of proving the non-existence of a domain is that we can easily enumerate the whole zone.

That's why NSEC3 was designed to prove the non-existence of a domain, but in the same time to avoid the zone walk through.
Instead of simply returning the closest domains, it returns a hash of the domains.

How to compute NSEC3 Hash ?

I will detail a little bit how this NSESC3 hash is computed :

I you have a look at a zone, you will find additional records, like NSEC3PARAM :

example.com. NSEC3PARAM 1 0 12 aabbccdd

The format of such record is composed of :

an algorithm field. 1 means SHA1
a flags field
an iterations field
a salt, represented as a sequence of case-insensitive hexadecimal digits.

Then the hashing algorithm is given by :

 IH(salt, x, 0) = H(x || salt), and
IH(salt, x, k) = H(IH(salt, x, k-1) || salt), if k > 0

With my example.com domain, the hash algorithm will be :

IH(fromHexStringToByte("aabbccdd"), toCanonicalWireFormat("example.com"), 12)

fromHexStringToByte is a base 16 decoder : fromHexStringToByte("aabbccdd") = [0xaa, 0xbb, 0xcc, 0xdd]. See RFC4648

toCanonicalWireFormat convert the domain in wire format using its canonical form : toCanonicalWireFormat("example.com") = [0x07, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00]. See RFC4034 (canonical form), RFC3845 (wire format)

And that's it, you are now able to compute the NSEC3 hash of your favourite domain. You just need to wait for NSEC3PARAM to be published in the respective zone to got all the necessary parameters :)

Using java.net.InetAddress.getByName() to validate an IP Address may be too permissive

2010-11-19T14:19:00.004+01:00

java.net.InetAddress.getByName() static function can be used for validating a given IP Address.

But doing that way you need to pay attention to certain side effects border values :

String ip = "1.2.3.4"; // valid IP Address
InetAddress address = InetAddress.getByName( ip );
Assert.assertEquals( ip, address.getHostAddress() ); // Pass. OK

String ip = "1.2.3"; // invalid IP Address
InetAddress address = InetAddress.getByName( ip );
Assert.assertEquals( ip, address.getHostAddress() ); // Pass. KO !

If you have a look a little deeper, you will see that 1.2.3 is transformed in 1.2.0.3, which after transformation become a valid IP Address.

Having that in mind, a IP Address validation function can look like :

public static boolean validateIpAddress( String anIpAddress ) {
 try {
  InetAddress address = InetAddress.getByName( anIpAddress );
  return address.getHostAddress().equals( anIpAddress );
 } catch (final UnknownHostException e) {
  return false;
 }
}

Moving from ELCA to Verisign

2010-10-09T13:46:00.003+02:00

I had a great time at ELCA Informatique SA, working for almost 3 years on Secutix, a complete ticketing system. But now it's time for me to move forward and see something else : different projects, different colleagues, different cultures, speak more English, nearer from home, and so on...

That's why I will move to Verisign, beginning the 2nd of November (the 1st is day off :)). Working on the heart of Internet (aka DNS) is some kind of child's dream which I will be able to realize ! I'm really excited to see how root name servers work, what's behind Registrars (aka registry), implementing DNSSEC or what means 1 billion transactions a day.

I really look forward to start there, and in the same time wish all the best to the Secutix team !

Dealing with old SSL certificats (algorithm check failed: MD2withRSA is disabled)

2010-08-02T11:19:00.004+02:00

I faced the problem of SSLHandShakeException, or "algorithm check failed: MD2withRSA is disabled" when upgrading above java 1.6.0_17.

The source of problem is well known, the MD2withRSA has been removed from the JVM because it is no more secure (References : CVE-2009-2409 deprecate MD2 in SSL cert validation, Sun java 1.6u17 release notes).

Lot of posts around the problem give the solution to update the certificate to use another signature algorithm, for example SHA1withRSA.

But what to do when the certificate is not under our hands ?

I will try to explain the problem and how I solved it.

Analyse the certificate's chain

First of all is to analyse the chain of certificate to see which one is using the deprecated algorithm.

The following command will print all the certificates in the chain and store them under the names level0.pem, level1.pem and so on.

openssl s_client -showcerts -connect xxxxxxxxxxxxxxxxx:443 < /dev/null | awk -v c=-1 '/-----BEGIN CERTIFICATE-----/{inc=1;c++} inc {print > ("level" c ".pem")}/---END CERTIFICATE-----/{inc=0}'; for i in level?.pem; do openssl x509 -noout -serial -subject -issuer -in "$i"; done

The output given in my case :

Cert1, serial=xxxxxxxxxxxxxxxxxxxxx
subject= xxxxxxxxxxxxxxxxxxxxxxxx
issuer= /C=ZA/O=Thawte Consulting (Pty) Ltd./CN=Thawte SGC CA
Cert2, serial=30000002
subject= /C=ZA/O=Thawte Consulting (Pty) Ltd./CN=Thawte SGC CA
issuer= /C=US/O=VeriSign, Inc./OU=Class 3 Public Primary Certification Authority
Cert3, serial=70BAE41D10D92934B638CA7B03CCBABF
subject= /C=US/O=VeriSign, Inc./OU=Class 3 Public Primary Certification Authority
issuer= /C=US/O=VeriSign, Inc./OU=Class 3 Public Primary Certification Authority

We have a chain of 3 certificates, Cert1 signed by Cert2 signed by Cert3 signed by Cert3 (selfsigned).

Note : the first error here is that the webserver gives explicitly the entire chain of certificates. Thus the change of any root certificate provided by the jre will not be taken into account automatically.

Digging into the details of the third certificate (openssl x509 -in level2.pem -text) show that this certificate is signed with the old algorithm :

Certificate:
Data:
Version: 1 (0x0)
Serial Number:
70:ba:e4:1d:10:d9:29:34:b6:38:ca:7b:03:cc:ba:bf
Signature Algorithm: md2WithRSAEncryption
Issuer: C=US, O=VeriSign, Inc., OU=Class 3 Public Primary Certification Authority
Validity
Not Before: Jan 29 00:00:00 1996 GMT
Not After : Aug 1 23:59:59 2028 GMT

So not only the way of providing the full chain is wrong in point of view of the server configuration, but the last certificate was never updated and thus still use the deprecated signature algorigthm.

Correct the certificate's chain

Now we have identified the weak link of the chain, what's the next step ?

The key point here is to correct the certificate's chain in order to make it more compliant to the standards :

As the third certificate is a well know root certificate (named verisignclass3ca in the jre cacerts), a working version of it is provided in the cacert of java sun (debian oriented commande line, with "changeit" as password) :

keytool -keystore /etc/java-6-sun/security/cacerts -exportcert -alias "verisignclass3ca" | openssl x509 -inform der -text

will output :

Certificate:
Data:
Version: 1 (0x0)
Serial Number:
3c:91:31:cb:1f:f6:d0:1b:0e:9a:b8:d0:44:bf:12:be
Signature Algorithm: sha1WithRSAEncryption
Issuer: C=US, O=VeriSign, Inc., OU=Class 3 Public Primary Certification Authority
Validity
Not Before: Jan 29 00:00:00 1996 GMT
Not After : Aug 2 23:59:59 2028 GMT

which is the same as before, but with sha1WithRSAEncryption instead of md2WithRSAEncryption.

Thus we can simply remove it from the chain and validate normally the certificate's chain with only Cert1 and Cert2. The validation from Cert2 to "verisignclass3ca" will be automagically done.

To be able to do this, we need to create a custom X509TrustManager which will behave the following :

if the certificate's serial is the one of Cert1 (serial=xxxxxxxxxxxxxxxxxxxxx), then remove the last certificate of the chain and revalidate.
In all other cases, validate normally the certificate's chain.

Thus the custom X509TrustManager act as delegate, with one little variation (note : if someone know a easier way to instantiate the default TrustManagerFactory of TrustManager, please leave me a comment). Refer to my article about blind SSL factory for httpClients to see how to pass a custom TrustManager to a SSL factory.

My custom X509TrustManager class will finally look as the follow :

public class CustomX509TrustManager implements X509TrustManager {

   X509TrustManager delegate = null;

   public CustomX509TrustManager(KeyStore keystore) throws NoSuchAlgorithmException, KeyStoreException, CertificateException {
    // Instantiate the default X509TrustManager
    TrustManagerFactory factory = TrustManagerFactory
           .getInstance(TrustManagerFactory.getDefaultAlgorithm());
       factory.init(keystore);
       TrustManager[] trustManagers = factory.getTrustManagers();
       if (trustManagers != null && trustManagers.length > 0) {
           for (int i = 0; i < trustManagers.length; i++) {
               TrustManager trustManager = factory.getTrustManagers()[i];
               if (trustManager instanceof X509TrustManager) {
                   delegate = (X509TrustManager) trustManager;
                   break;
               }
           }
       }
       if (delegate == null) {
           throw new CertificateException("Cannot found any instance of X509TrustManager");
       }
   }

   public X509Certificate[] getAcceptedIssuers() {
    if (delegate == null) {
        return null;
    } else {
        return delegate.getAcceptedIssuers();
    }
   }

   public void checkClientTrusted(final X509Certificate[] c, final String a)
                   throws CertificateException {
       if (delegate != null) {
        delegate.checkClientTrusted(c, a);
       } else {
        throw new CertificateException("Unable to validate this certificate (delegate is null).");
       }
   }

   public void checkServerTrusted(final X509Certificate[] c, final String a)
                   throws CertificateException {
    if (delegate != null) {
           // hardcoding test to be sure we are trying to validate the right certificate
           if (c.length == 3 && c[0].getSerialNumber().toString(16).equals(BADCERTIFICATESIGNATURE)) {
            c = new X509Certificate[] {c[0], c[1]};
           }
           delegate.checkServerTrusted(c, a);
    } else {
        throw new CertificateException("Unable to validate this certificate (delegate is null).");
    }
   }

   private static final String BADCERTIFICATESIGNATURE = "xxxxxxxxxxxxxxxxxxxx";
}

With this implementation I'm sure that the my invalid certificate will continue to work, and it cannot be faked (as it could be with a completely blind TrustManager). But I can also expect that when the provider will update its certificate, everything will continue to work as expected because all other certificates are still validate the regular way.

Java and certificate's mess : blind SSL factory for commons httpClient

2010-08-02T08:53:00.003+02:00

There are parts of Java which are not very "quick development" oriented. The side I want to illustrate here is dealing with SSL.

When the application is in early development stage, we don't want to bother with stuff like valid certificate. We don't want to get stuck for days because we haven't received valid development SSL certificate from Verisign or other "more trusted than me" monopoles. We just want to activate the "--no-check-certificate" à la wget, or "CURLOPT_SSL_VERIFYPEER" à la PHP.

Adding a new certificate in the cacert file is not so complicated, but it is not always possible on every computers (should developers have administrators rights on their computers ?), or break the debian pakage integrity and risk to be overridden at the next JRE update.

No, for development phase, a blind SSL factory is a good point for productivity. Simply DO NOT FORGET TO REMOVE IT in the integration or pre-production phase. Having valid and trusted SSL certificate in production is NOT an optional thing.

What is a blind SSL factory

A blind SSL factory is simply an SSL factory which will validate any certificate. Expirated, selfsigned, but also man-in-the-middled or forged certificates will be trusted.

Mike McKinney already explained how to create a blind SSL factory for LDAP connexions.

I will leverage his explanations to enable blind SSL factory for commons httpClient.

The start point is to create a TrustManager which will trust any certificate, and then give this TrustManager to the SSL factory. This will result in a blind SSL factory :)

Anonymous class that implements X509TrustManager :

class BlindX509TrustManager implements X509TrustManager
{
   public X509Certificate[] getAcceptedIssuers()
   {
       return null;
   }
   public void checkClientTrusted(final X509Certificate[] c, final String a)
   {
   }
   public void checkServerTrusted(final X509Certificate[] c, final String a)
   {
   }
}

Initializing the SSLContext to retrieve a SocketFactory :

SSLContext sc = SSLContext.getInstance("SSL");
sc.init(null, new TrustManager[] { new BlindX509TrustManager() }, new java.security.SecureRandom());
SocketFactory blindFactory = sc.getSocketFactory();

And finally the BlindSSLProtocolSocketFactory which implements the needed ProtocolSocketFactory of httpClient :

public class BlindSSLProtocolSocketFactory implements SecureProtocolSocketFactory
{
   public Socket createSocket(String host, int port, InetAddress clientHost, int clientPort) throws IOException,
       UnknownHostException
   {
       return blindFactory.createSocket(host, port, clientHost, clientPort);
   }
   public Socket createSocket(String host, int port, InetAddress localAddress, int localPort, HttpConnectionParams params)
       throws IOException, UnknownHostException, ConnectTimeoutException
   {
       if (params == null)
       {
           throw new IllegalArgumentException("Parameters may not be null");
       }
       int timeout = params.getConnectionTimeout();
       if (timeout == 0)
       {
           return createSocket(host, port, localAddress, localPort);
       }
       else
       {
           return ControllerThreadSocketFactory.createSocket(this, host, port, localAddress, localPort, timeout);
       }
   }
   public Socket createSocket(String host, int port) throws IOException, UnknownHostException
   {
       return blindFactory.createSocket(host, port);
   }
   public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException, UnknownHostException
   {
       return ((SSLSocketFactory) blindFactory).createSocket(socket, host, port, autoClose);
   }
   public boolean equals(Object obj)
   {
       return obj != null && obj.getClass().equals(getClass());
   }
   public int hashCode()
   {
       return getClass().hashCode();
   }
}

Everything tied up together, put into the classpath of the application, will override the https protocol with the BlindSSLProtocolSocketFactory and thus allow your code to connect any certificate !

public class BlindSSLProtocolSocketFactory implements SecureProtocolSocketFactory
{
 private static final Log LOG = LogFactory.getLog(BlindSSLProtocolSocketFactory.class);
 public BlindSSLProtocolSocketFactory()
 {
     blindFactory = createBlindSocketFactory();
 }
 public Socket createSocket(String host, int port, InetAddress clientHost, int clientPort) throws IOException,
         UnknownHostException
 {
     return blindFactory.createSocket(host, port, clientHost, clientPort);
 }

 public Socket createSocket(String host, int port, InetAddress localAddress, int localPort, HttpConnectionParams params)
         throws IOException, UnknownHostException, ConnectTimeoutException
 {
     if (params == null)
     {
         throw new IllegalArgumentException("Parameters may not be null");
     }
     int timeout = params.getConnectionTimeout();
     if (timeout == 0)
     {
         return createSocket(host, port, localAddress, localPort);
     }
     else
     {
         return ControllerThreadSocketFactory.createSocket(this, host, port, localAddress, localPort, timeout);
     }
 }
 public Socket createSocket(String host, int port) throws IOException, UnknownHostException
 {
     return blindFactory.createSocket(host, port);
 }
 public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException, UnknownHostException
 {
     return ((SSLSocketFactory) blindFactory).createSocket(socket, host, port, autoClose);
 }
 public boolean equals(Object obj)
 {
     return obj != null && obj.getClass().equals(getClass());
 }
 public int hashCode()
 {
     return getClass().hashCode();
 }
 private SocketFactory blindFactory = null;
 private static SocketFactory createBlindSocketFactory()
 {
     try
     {
         SSLContext context = SSLContext.getInstance("SSL");
         context.init(null, new TrustManager[] { new BlindX509TrustManager() }, null);
         return context.getSocketFactory();
     }
     catch (Exception e)
     {
         LOG.error(e.getMessage(), e);
         throw new HttpClientError(e.toString());
     }
 }
}

And to regirster the new protocol as the default https protocol :

Protocol.registerProtocol("https", new Protocol("https", (ProtocolSocketFactory) new BlindSSLProtocolSocketFactory(), 443));

Please note that if you want only access a selfsigned certificate you have better to use EasySSLProtocolSocketFactory from httpClient contibs. It still validate the selfsigned certificate, so expired or bad certificate will be denied.

Implementing unique constraints with Cassandra

2010-04-25T10:30:00.001+02:00

I was talking about my "Doodle clone with Cassandra backend" in a previous post, I want to explain a little bit how I implement 2 kinds of constraints with Cassandra.

Unique name constrain

When subscribing to a poll, a unique constraint on the name of the subscriber is applied. There is a first check in Javascript in the GUI, but there is also a check of the uniqueness of the names on the server side.

Before going deeper, I just need to say a word about the structure used :

To store the subscribers, I use a SuperColumnFamily, with the ID of the poll as key. For a poll having key "1234", it gives me something like :

"1234" => {
"subscriberKey1" => { name = "subscriberName1", options = ... }
"subscriberKey2" => { name = "subscriberName2", options = ... }
...
}

The trick about the subscriberKey* is to generate a unique ID based on a timestamp in order to be sorted by Cassandra.
The key will be something like : currentTimestamp - ClusterNodeId - ThreadId. Adding the ThreadId into the key give me the guarantee that using the System.currentTimeMillis() will be unique, because the processing will unfortunately take more than a millisecond :)

Using this key, I will write the subscriber row with ConsistencyLevel.QUORUM, and then I will read all the rows till the one I have inserted (with ConsistencyLevel.QUORUM again).
At this point I use Cassandra magic (rows are ordered) to be sure that I have selected all the subscribers they subscribe before the current one.
I remains me to check manually the uniqueness of the name. If another row has the same name, I will simply remove the current subscriber.

Limiting the number of subscribers per option

Another constraint I have implemented is the limitation of the number of subscribers per option.

The principle is the same as the unique name constraint : I count the number of previously inserted subscriber.
One point to keep in mind is that we can read a row with a duplicated name, which will be deleted later so it should not be taken into account for the actual constraint. This mean that we need to check if we are not counting duplicated names in this constraint too...

But the good news about this constraint is that it show a way to implement counters in Cassandra. Maybe I will write another post about this topic. The bad news is that we need to check the duplicated names in several places.

Limitation of the model

Complexity : adding more constraints grows the complexity in O(n^2), as every new constraints (duplicated names) should be implemented into every other constraints (limitation of subscribers per option).

Scalability : this model will scale very well for billions of polls with some tens of users. The inverse, some tens of polls with billions of users, needs a lot of resources for checking constraint, which will make the performance drop.

Doodle clone with Cassandra backend

2010-04-24T19:45:00.003+02:00

I follow Cassandra's activity for some months now, and I decided to try it. But what better than developing a small application to test real needs ?

That's what I did with my "Doodle clone with Cassandra backend".

What is Cassandra ?

According to the main page,

Cassandra is a highly scalable, eventually consistent, distributed, structured key-value store

Why a Doodle clone ?

I'm working during my free time on an event manager software, so it was a good pretext to analyze Doodle business :)
It appears to be quite simple, so it was a good starting point.

Which features to implement ?

I added the following feature to the doodle clone :

Easy (easier) to create polls
Login free, secret key based administration
No options limitation
Email feedback when someone subscribe the poll (if email provided)
No duplicate name of the subscribers
An optional limitation of the number of subscribers per options

Have a look !

Go to http://doodle.noisette.ch and try it, the result is really surprising.

Disclaimer

There is absolutely no affiliation with Doodle, neither any idea to become the next Doodle. The goal of this application is purely academic, and it is deployed as is, without any guarantee.

Don't be abused by the term "commodity hardware"

2010-04-05T13:13:00.004+02:00

NoSQL paradigm claims to build clusters of "commodity hardware". But don't be abused by this term : "commodity hardware" is not your living room's computer. Commodity hardware is two slots' computer, 16+GB RAM, (ten)giga ethernet, raid5 hard disks.

Commodity hardware is not 500$ computers. It's 5000$ computers. But building a 10 nodes' cluster for 50'000$ is still really cheap.

And remeber : clusters' primary bottlneck is I/O. Both disk and network. So there is no place for virtualisation here.

Sequences scalability

2009-12-30T11:46:00.007+01:00

Sequences are central part of most computer systems. They are used both in technical part (generate unique identifier for object) and in business part (count the remaining free tickets which can be sold).

When the load on the application goes higher, sequences become quickly central bottlenecks of systems. So the goal here is to first categorize different types of sequences and then gives some keys to see how sequences be distributed to increase their scalability, and hence the global scalability of the whole system.

Characteristics of sequences :

Order : the number generate should be used in a given order (ascendant or descendant), or the order do not matter. I will talk about ordered or unordered sequence.

Missing values : some values can be missing in the sequence. For example the sequence miss the value 4 should not alter the behavior of the application. I will talk about continued or discontinued sequence.

Finite sequence : all the values of the sequence are know and countable. Countable sequences are particular case of finite sequence where the sequence has a reasonable amount of values, and thus could be represented by one object per values. I will talk about finite or infinite sequence, and countable sequence.

Key to distribute sequences

Discontinued sequences are easy to scale : the application can pick numbers n by n in the sequence, reducing the amount of calls to the sequence by n. Good example for of discontinued sequences are objects identifier generators.

Unordered sequences are also easy to scale : a counter can be decomposed in n subcounter, picking at random one of the subcounter to increment or decrement will reduce the contention on one counter by n. A typical example is a quantity of object to sell. N subcounters are initialized with the sum is the total amount to sell. The object cannot be sold anymore when every subcounters are at 0.

Countable sequences can be scaled by representing every value of the sequence as a single object in the database. Updating an unused object is a easy task.

Finaly infinite, continued ordered sequence are very hard to scale because synchronization between all callers is required, so a single point of contention is mandatory.

Conclusion

Sequences are choke point in most systems, but as we saw above they can scale relatively simply with two simple tricks : read number n by n instead of 1 by 1, or decompose a counter in n subcounters.

Call different services, use the first to reply

2009-11-15T20:44:00.006+01:00

The needs

My needs were the following : I have an arbitrary amount of webservices to call, but I don't know, for a particular query, which one will return the answer. More than that, some are slower and others are faster, but again, I don't know which is the fastest for my particular query.

So what I will do is to parallelize the queries, and use the value of the first which return my a good value.

Use an Executor

The first component to implement such a requirement is an Executor.

The Executor will run all my queries, in as many threads as I want, permitting to fine tune the behavior of the system.

As many queries will input the system and will be translated in many more threads, it is important to use a limited amount of threads to not crash the system.

Synchronization on result

A specific object will be used to synchronize the result : the first result will be returned to the caller, letting the running threads die, and no more threads will be run for this query.

Some basic primitive for concurrent programming (java.util.concurrent) will be used, such as CountDownLatch : the caller will block on the latch, and once a thread will find the answer, it will set the value into the result and count down the latch. The caller will be freed and the value will be available.

Watchdog if all the queries fail

One point to not forget is if every queries fail, the caller should be informed of this fail.

A watchdog will be used : it will block till all the threads executing the query will finish, and will then be run. Its only task is to free the caller. This one will continue the processing, but the result will not be available. This will be the responsibility of the caller to run user code to handle this special case.

Strong requirements

The requirements are the following :

Use as little synchronization as possible
Use as much concurrent primitives (java.util.concurrent) as possible
Do it as generic as possible

Java implementation

The interesting part of the implementation is given here below.

The Executor is simply an java.util.concurrent.Executor. I'm not good enough to implement a better solution than they do.

The result object is composed of the following attributes :

public class FutureResult {
private T result;
private boolean done;
private AtomicInteger threadCount = new AtomicInteger(0);
private CountDownLatch latch = new CountDownLatch(1);
}

A generic type for the value, a AtomicInteger to count how many other threads are working on this result, and a latch to make the caller wait.

The watchdog class will simply wait till all the threads are finish and free the caller if it is not already the case :

class WatchDogRunnable implements Runnable {
public void run() {
while (result.hasThreadsWorking()) {
synchronized (result) {
result.wait(2000);
}
}
latch.countDown();
}
}

And finally an abstract callable worker which can be easily extended to run the wanted tasks. The call function will increment the AtomicInteger, do the work if it is not already done, if a result is found, free the caller, decrement the AtomicInteger and return the value if it is set. Not that the worker implementation will implement the callInternal function.

public abstract class AbstractCallableWorker
implements Callable {
private FutureResult result;
public final T call() {
result.setOneMoreThread();
if (!result.isDone()) {
T callResult = callInternal();
if (callResult != null) {
setResult(callResult);
latch.countDown();
}
}
result.setOneLessWorkingThead();
return result.getResult();
}
protected abstract T callInternal();
}

Everything put together, you can implement as much worker as you want and call as many webservice as you want, with the only guaranty to get the caller continue with the fastest service to reply !

Clustering Jackrabbit 1.5.x with DataStore configuration

2009-11-14T21:36:00.004+01:00

Jackrabbit is the reference implementation of JSR-170 : JCR, Java Content Repository.

One day we felt the needs to run a Jackrabbit repository in a clustered environment for reliability. So a JCR runs on two separated servers, backed by the an Oracle db and a NFS shared datastore.

It exists some difficulties to run such architecture, mainly because both JCR nodes (JCR1 and JCR2) do not know each others. So if we insert some content on one node, it takes some time before we can read it on the other node.

In Jackrabbit 1.5.x, Session.refresh do not work correctly, so we need to do some trick to enable cluster (synchronization) features.

First of all, we add a custom ServletFilter which handle the GET (read) request and transform it on a HEAD one (test if the content exists) using apache.commons.HttpClient.

If the return of the query says the content exists, then we run the normal request. If the content do not exists, we way for some arbitrary time and relaunch the HEAD request.

This filter will let enough time to the node to synchronize itself, and then perform the query in the right way.

Other possibilities like HEAD on the current node and then HEAD on a different node should also be possible, but this will require every nodes to know about every other nodes. No the best idea.

One another tricky point is to store all the content to the configured datastore. Be carefull to not rely on a JNDI persistence manager, but be sure to use a subclass of a bundle persistence manager, otherwise you will have some surprise with the size of the database.

Des nombres à usage unique (nonce)

2009-01-17T18:24:00.007+01:00

Afin de répondre à une problématique de transmission d'informations sensibles sur un réseau pas sûr (Internet donc...), une solution est l'utilisation de nonce, diminutif de number used once, nombre à usage unique.

Ils sont utilisé pour mettre du sel dans des informations sensibles qui seront ensuite hashées et transmises en clair sur le réseau. Mais leur efficacité n'est effective seulement si on a la garantie qu'un même nonce ne va jamais être utilisé 2 fois !

Exemple type : vous développez un service d'authentification, mais celui-ce ne peut se faire sur du SSL. Vous souhaitez toutefois que si une personne intercepte les informations, elle ne puisse pas les réutiliser pour s'identifier à son tour.

Le seul hashage du mot de passe ne suffisant pas car la personne qui a interceptée le mot de passe hashé pourra rejouer la séquence pour simuler sa connexion, une solution est de hasher le mot de passe concaténé au nonce (du style sha256("#" + mot de passe + "#" + nonce + "#")), puis de transmettre le nom d'utilisateur, le nonce utilisé et le résultat du hashage. Le serveur disposera ainsi de toutes les informations pour vérifier si le mot de passe utilisé pour le hashage était effectivement correcte ou pas. Les prochaines requêtes faites avec ce nonce seront systématiquement refusées.

C'est pour faciliter l'accès à ces nombres que je mets à disposition un petit service de génération de nombre à unique, accessible publiquement à l'adresse

http://nonce.noisette.ch/next

Chaque appel à cette url retourne un chaine de 32 caractères composées des lettres a-z, A-Z et les chiffres 0-9. Notez que les chaines retournées sont donc senible à la casse.

Le nombre de nonce possible est donc (26+26+10)^32 = 2.27 * 10^57, soit à peu près 6-parasite, ou beaucoup plus que d'atomes dans l'univers.

A utiliser sans modération pour toute application nécessitant la transmission d'informations sensibles sur un réseau non sécurisé.

Edit (06.01.2011) : GAE ne supporte plus le proxying, vous pouvez essayer l'app directement sur http://noisette-nonce.appspot.com/.

Implémentation d'un serveur proxy HTTP

2008-06-08T20:00:00.000+02:00

La question à la base de cet article est la suivante :

Comment faire pour que mes concurrents ne soient pas au courant que j'observe (très) régulièrement une section particulière de leur site internet ?

La première étape bien évidemment est de la légitimer cette question. Comment un concurrent pourrait savoir que je consulte régulièrement son site ?

La réponse est simple. Prenons un cas concret pour illustrer : ELCA Informatique possède les plages d'adresses ips 193.72.144.0 - 193.72.147.255 (bloc /22 = 1024 ips, hosté chez Cablecom) et 193.73.238.0 - 193.73.238.255 (bloc /24 = 256 ips, hosté chez Sunrise)

Ce genre d'info se trouve très facilement via un mélange whois, traceroute et autres informations DNS.

Une fois qu'on a ces ips, il suffit de rechercher dans les logs les hits faits par ces ips et on pourra dresser un profil précis des intérêts des collaborateurs d'ELCA sur notre site.

Donc comment faire pour éviter cette traçabilité ?

Connexion Internet à adresse ip dynamique (xDSL)

Une première solution est d'utiliser une connexion xDSL pour toutes les connexions humaines à Internet, et de dédier exclusivement les plages d'ips fixes et repérables aux services de l'entreprise. Cette pratique est de plus en plus courante, surtout avec l'arrivée des connexions VDSL et de boitiers qui permettent d'agréger plusieurs lignes xDSL afin d'une part d'avoir un redondance, et d'autre part de partager la somme des débits des lignes entre les utilisateurs. Le seul détail concernant cette solution est de vérifier que l'adresse ip change réellement, faute de quoi il faudrait forcer ce changement.

Serveur proxy

Une autre solution, que je vais détailler ici car elle est plus intéressante d'un point de vue ingénierie informatique, est de faire passer le traffic des utilisateurs par un proxy. Par proxy j'entends tout type de connexion indirect à Internet, donc autant les serveurs proxy HTTP, SOCKS, etc que les réseaux de proxy comme par exemple Tor.
Le fait d'accéder à Internet par l'intermédiaire d'un proxy permet de visualiser un site avec une adresse ip qui n'est pas notre, mais appartient à un prestataire de ce genre de service. Cependant l'anonymité à 100% n'existe pas : il existera toujours un intermédiaire qui saura qui a accédé où. La confiance des intermédiaires est donc de mises dans cette configuration.

Il existe une grande quantité de serveur proxy logiciel de qualité, open source ou commercial, comme par exemple Squid, Privoxy, Apache mod_proxy, etc... Mais une fois de plus, l'utilisation d'un logiciel existant nous priverait du plaisir de développer de notre propre implémentation.

Principe de base

Le principe d'un serveur proxy est donc d'intercepter la requête d'un navigateur, d'ouvrir une connexion vers le site cible, transmettre la requête original, lire le résultat et finalement renvoyer ce résultat au navigateur.

Protocole HTTP

La partie centrale d'un serveur proxy HTTP réside sa compréhension du protocole HTTP. Celui-ci comporte des particularités qui vont être détaillées.

Le serveur proxy va recevoir une requête du navigateur, dont la première ligne comporte l'action à exécuter, l'url de la cible et une éventuelle version du protocole utilisé :

GET http://www.noisette.ch/ HTTP/1.0

Cette première ligne va donc directement nous renseigner sur le serveur cible à connecter. Le reste de la requête est composée de lignes de header, contenant diverses informations sur la requête comme le navigateur utilisé ou le referer (en français on dit comment ?).

Transfer de la requête au serveur cible

La prochaine étape est le transfert de la requête au serveur cible. A ce moment on peut éventuellement modifier ou enlever des headers du client, voir en ajouter d'autres. Plus précisément, il peut être intéressant de filtrer tous les headers des clients qui pourraient trahir l'utilisateur du proxy (information leakage).
Reste la lecture du résultat, qui n'est de loin pas la partie la plus triviale.

Ne pas bufferiser la lecture du résultat

L'implémentation d'un serveur proxy dans laquelle on lit le résultat en entier (via un lib du style httpclient) avant de l'envoier ensuite au navigateur n'est à mon avis pas bonne : le délai entre la requête et la réponse risque d'en prendre un coup, surtout pour les grosses pages.
L'idée est donc de retourner directement les bytes lus du serveur web au client.

En pseudo code, ca donne quelque chose du style :

 // fromWeb : InputStream du socket de la connexion vers le serveur source
// toBrowser : OutputStream du socket de la connexion vers le browser
while ((i = fromWeb.read(buffer)) != -1) {
  toBrowser.write(buffer, 0, i);
  toBrowser.flush();
}

Fermeture des connexions

La fermeture des connexions est très importante afin de libérer les ressources et ne pas avoir un serveur qui explose après 20 requêtes. Facile en théorie, la fermeture de la connexion est la sous partie non triviale. Dans la mesure où le serveur ne ferme pas systématiquement la connexion à la fin du transfert si il reçoit un header "Connection: keep-alive", il faut détecter quand la réponse du serveur est complète pour pouvoir fermer la connexion.

Dans une grande majorité des réponses, la taille de la réponse est spécifiée via un header "Content-Length: 82". Il suffit donc de lire autant de bytes que nécessaire et la connexion peut être fermée. Mais quelques réponses ne vont pas retourner de taille. C'est le cas par exemple lors du streaming d'un fichier. Dans ce cas il faut lire la réponse jusqu'à ce que le serveur ferme lui-même la connexion.

Transfer-Encoding: chunked

Une autre difficulté à la lecture de la réponse est l'encodage chunked. Dans ce mode de transfert, le serveur sépare la réponse en plusieurs parties, les chunks. Ca lui permet d'envoyer une partie de la réponse tout en calculant la suite. Par exemple Google utilise ce mode de réponse : les 2-3 premiers résultats sont dans un cache direct, et Google les retourne dans un premier chunk. Puis il doit aller chercher les 7-8 autres dans un deuxième cache, opération un peu plus coûteuse, qui se fait pendant que le navigateur du client lit ce premier chunk. Ca permet au serveur de ne pas attendre d'avoir entièrement cherché les 10 résultats, et de profiter du temps de transfert avec le client. Du point de vu du client, une fois qu'il a fini de lire le premier chunk, les suivants sont prêts à être lus. L'impression de fluidité est donc parfaite. Mais malheureusement peu d'implémentations tirent intelligemment profit de ce type de transfert.

En pratique, la réponse d'une encodage chunked donne quelque chose du style :

taille du chunk en hexa \r\n
données \r\n
taille du prochain chunk \r\n
données \r\n
...
0\r\n
\r\n

Pour lire la réponse, il faut donc lire la taille du chunk, lire les données du chunk, lire la taille du prochain chunk, etc jusqu'à ce qu'on ait un chunk de taille null, signifiant la fin de la réponse.

HTTP/1.1 200 OK¶
Date: Fri, 31 Dec 1999 23:59:59 GMT¶
Content-Type: text/plain¶
Transfer-Encoding: chunked¶
¶
1a¶
abcdefghijklmnopqrstuvwxyz¶
10¶
1234567890abcdef¶
0¶
¶

Caching

Prochaine étape dans l'implémentation d'un serveur de cache utile est efficace, c'est l'ajout d'une couche de cache au niveau du proxy : le serveur cible va retourner une information sur la date de dernière modification de la page. Cette indication peut être utilisé pour retourner la page mise en cache plutôt que de relire la réponse du serveur.

Authentification

Dernier point important si on met un serveur proxy sur internet, il faut ABSOLUMENT implémenter un ACL (access control list) afin de restreindre l'accès et l'utilisation du proxy aux personnes authentifiées uniquement. Faute de quoi votre tout beau serveur proxy sera vitre trouvé et utilisé par des personnes malveillantes pour spammer, consulter des sites illégaux etc.

Prochaine étape : au travail !

Mettre à mal un réseau d'entreprise avec Outlook (TM, R & CO)

2008-06-05T06:21:00.004+02:00

Suite à une expérience involontaire d'un collègue de travail, on a eu 30 ordinateurs bloqués une quinzaine de minute :

Notre serveur SVN envoie un mail à chaque commit à une mailinglist interne, à laquelle une trentaine de collaborateurs est abonné. Le commit incriminé était certes quelque peu conséquent, une colonne ajoutée dans un fichier CSV de 5000 lignes, mais la conséquence était désastreuse !

Le mail faisait ~ 5Mb, et le diff du commit était formaté en HTML. Tous les collaborateurs qui ont cliqué sur le mail avec le preview activé n'ont pas eu d'autre choix que de tuer Outlook après avoir eu l'ordinateur bloqué un bon moment.

Moi qui n'était déjà pas un grand amoureux d'Outlook et de son immense capacité à accomplir des recherches performante parmi les mails, me voici comblé.

Mais pourquoi donc autant d'entreprise s'accrochent-ils à ce logiciel ? Dans tous les cas, si vous voulez forcer un peu la main pour le passage à un autre logiciel, vous savez ce qu'il reste à faire.

Une liste de USER AGENTS parsable

2008-02-23T13:42:00.000+01:00

Il est toujours utile d'avoir sous la main une liste de USER AGENTS facilement parsable.

La mienne, qui ne contient que des USER AGENTS ^Mozilla/.* se trouve à l'adresse http://www.noisette.ch/useragents/. Elle est mises-à-jour journalièrement sur la base des navigateurs qui se connectent sur mon serveur, tous sites confondus. Elle va donc suivre l'évolution des numéros de version des Firefox et autres IE...

Cette liste, couplée à la fonction url_get_contents définie antérieurement, permet facilement de disposer d'un USER AGENT pour faire ce qu'il est possible de faire avec un USER AGENT généré :)

Illustration en PHP :

$useragents = explode("\n", url_get_contents('http://www.noisette.ch/useragents/list.txt'));
$useragent = $useragents[rand(0, count($useragents) - 1)];

De la concurrence des requêtes SQL

2008-02-18T12:53:00.000+01:00

Sans cité Montaigne, voici un cas académique dans lequel la concurrence des requêtes SQL est souvent oubliée.

Nous avons une table hits qui contient 4 champs : une date (nommé date), une clé étrangère pointant vers un objet du système (nommée object_id) et un compteur implémenté sous ca forme la plus simple : un entier (nommé counter). Puisqu'on travail avec une framework qui implémente de l'active record on ajoute un champ id qui fera office de clé primaire.
A chaque utilisation de l'objet référencé par la clé étrangère on souhaite incrémenter le compteur et recommencer à 0 tous les minuits afin d'avoir un historique journalier de l'utilisation de l'objet. Alors comme on a quand même un peu réfléchi à la performance du système (un billet sur le sujet est en préparation), on définit un index composé des champs date et object_id. Puis on définit la fonction suivante, donnée ci-dessous en pseudo-code, qui incrémente notre compteur et insère un nouveau tuple si aucun n'existe pour le jour courant :

void function hit ( int $object_id ) {
  SELECT FROM hits WHERE object_id = $object_id AND date = NOW()
  if (row_exists)
      UPDATE hits SET counter = counter + 1 WHERE  object_id = $object_id AND date = NOW()
  else
      INSERT INTO hits (object_id, date, counter) VALUES ($object_id, NOW(), 1)
}

Tout se passe bien jusqu'au jour où on se rend compte qu'il y a plusieurs lignes par objet et par jour dans la base de données.

Ce problème vient du fait qu'il peut se passer un temps indéterminé entre la requête SELECT et l'INSERT. Si à 00h01 2 requêtes sont faites en même temps sur le même objet, il est fort probable que 2 requêtes SELECT soient faites avant un INSERT, et donc les 2 tests if (row_exists) vont retourner faux et 2 INSERT seront fait.

Les solutions pour résoudre ce problème sont multiples, elles passent de la redéfinition de la clé primaire en date, object_id plutôt que notre champ id, ce qui aurait comme comportement de faire échouer le 2ème INSERT, erreur qui pourrait être capturée et traitée spécifiquement. Une autre solution serait de mettre un verrou sur la fonction, chose très aisée en Java avec le mot-clé synchronized. La fonction deviendrait void synchronized function hit(int object_id), évitant ainsi ce type de problème de concurrence.

Dans tous les cas les applications web sont aussi (voir même plus) soumises aux problèmes de concurrence, et l'expérience nous montre que la technique de l'autruche de même que les phrases du style "Il ne PEUT PAS y avoir 2 requêtes en même temps" sont à bannir absolument.

Vos données sont-elles réellement privées ?

2008-01-29T11:16:00.000+01:00

Donnez des informations pour exister

Le principe premier du Web 2.0 est la participation des utilisateurs. Pour les sites sociaux comme MySpace et Facebook, où la participation se calcule en quantité d'informations données sur soi-même.

Collecte indirecte d'informations

L'aspect de collaboration entre les membres résulte en une masse d'information indirecte enregistrée souvent au dépend de la personne ciblée :

Facebook par exemple enregistre des informations sur vous par rapport aux détails que donnent vos amis (appelé Social map) : à chaque ajout de nouvel ami, vous avez la possibilité de spécifier comment vous l'avez connu. Grâce à ce système subtile, mon profile Facebook sait maintenant que j'ai fini l'EPFL en 2007, que je fais partie d'autres associations, ... alors que je n'ai rien renseigner sur ces sujets précis.

Le business des données personnelles

Le fait d'être encouragé à compléter son profil qui n'est complet qu'a 88% comme nous l'indique de manière bien visible Linkedin n'est pas entièrement désintéressé : le fait de connaitre précisément ses utilisateurs et d'en dresser des profils augmentent largement les marges sur les revenus publicitaires qui seront mieux ciblés donc plus percutant donc plus intéressant pour l'utilisateur. Revenus publicitaires qui sont, rappelons-le, le business model principal des ces sites sociaux.

Protection des données

L'aspect à ne pas perdre de vu si on utilise ce genre de sites, c'est que ça n'est pas une simple cas à cocher "Rendre mon profil privé" qui protègera réellement les données de votre profile : les données sont chez une personne tierce qui d'un jour à l'autre peut décider d'en faire autre chose. Ou, comme c'est le cas sur MySpace, une vulnérabilité du site permet d'outerpasser cette coche ridicule...

La réponse au titre du billet est clairement NON ! Le fait de déposer vos données sur un service externe quelconque ne les rendent pas privées. Donc soit vous ne mettez que des informations réellement publiques sur votre profil, soit vous faites confiance à 100% au service et vous ne vous demanderez pas d'où viennent les données sur vous retrouvées dans la nature...

Ils en parlent

Faille de sécurité qui perment de voir les photos privée d'un profil sur Myspace : http://www.wired.com/politics/security/news/2008/01/myspace_torrent
Nos données personnelles sur Facebook : http://standblog.org/blog/post/2008/01/10/De-lavenir-de-Facebook-et-de-nos-donnees-personnelles
Système de publicité intrusive sur Facebook : http://www.infos-du-net.com/actualite/12304-facebook-publicite-internautes.html

Je télécharge mes MP3 et les écoute légalement.

2007-12-30T22:39:00.000+01:00

Le parlement et le conseil national ont accepté le 5 Octobre 2007 presque sans aucune résistance une loi fédérale sur le droit d'auteur et les droits voisins.

Pour toute question à propos du référendum lancé, que dit en passant j'encourage fortement à signer, rendez-vous sur le site No Swiss DMCA.
Je n'essayerai pas non plus de déterminer à quelles mesures techniques, notées efficaces, le texte de loi fait peut bien faire référence.

Cette loi, plus précisément l'article 39a alinéa 4 donné ci-après, combiné à l'approbation du Tribunal fédéral (TF) sur l'introduction d'une redevance sur les supports numériques (baladeurs MP3, iPod et autres enregistreurs à disques durs) entrée en vigueur au 1er septembre 2007, me mène à la conclusion suivante :

Je vais télécharger de la musique sur mon réseau peer-to-peer préféré, ripper des CDs et retirer les DMA de mes MP3 restants (autrement dit : contourner les mesures techniques efficaces) et l'écouter (exclusivement) sur mon baladeur MP3 récemment acquis. Celui-ci étant taxé, je m'affranchis de toute autre taxe, et je deviens entièrement légal. Idem pour les divx !

Art 39a
4 L’interdiction de contourner ne peut pas frapper celui qui contourne une mesure technique efficace exclusivement dans le but de procéder à une utilisation licite.

PS : cet article n'est pas illégale au sens de l'Art 39a 3a, c'est-à-dire que cet article ne fait pas promotion visant à contourner des mesures techniques efficaces.
PPS : la critique de la double imposition à une taxe sur les droits d'auteurs des musiques achetées sur un online music shop et écoutées sur un baladeur taxé fera l'objet d'un autre article.

Offrir un réseau wifi ouvert pour rentabiliser sa connexion Internet

2007-12-30T22:31:00.000+01:00

J'écrivais il y a un bon moment comment un administrateur réseau peu scrupuleux pouvait arrondir ses fins de mois en détournant les publicités des sites visités par les utilisateurs
interne.

Cette technique s'adapte très simplement à un réseau wifi ouvert...

Mais attention au click through rate trop élevé :)

Twitter, un vrai service Web 2.0 (le retour)

2007-12-15T16:14:00.000+01:00

Pour commencer j'ose espérer que le 2ème degré du message précédent a été perçu.

Twitter est selon moi un vrai service Web 2.0, c'est-à-dire qu'il ne sert à rien. On n'est pas plus heureux en l'ayant découvert et ça ne fait pas avancer la société de l'utiliser.

Mais au-delà de considération subjectives à son sujet, les technologies et les techniques d'addiction mises en oeuvre sur ce site sont suffisamment intéressantes pour être discutées ici :

Premièrement les méthodes de publication disponibles sont autant multiples que variées :

Interface web,
SMS,
IM (client jabber),
...

On voit d'entrée que le service est fait pour être mis-à-jour en permanence, très facilement par IM quand on est devant un ordinateur relié à Internet, mais aussi via des dispositifs mobiles une fois le clavier de l'ordinateur hors de porté. Ainsi un utilisateur peut à tout moment renseigner ses lecteurs virtuels et potentiels sur ce qu'il est en train de faire. L'aspect mise-à-jour via téléphone portable est très important, car il permet de modifier le statut lors des sorties, donc quand c'est le plus croustillant.

Un aspect important pour renforcer l'addiction est la possibilité d'émettre un rappel (SMS ou email) en cas de non mise-à-jour prolongée.

Deuxièmement les différents formats de lecture possibles sont aussi standard que tendance : on retrouve ainsi la "social timeline" sur sa page personnelle au style très épuré Web 2.0 et le fameux flux RSS. La communauté de lecteurs n'est pas en reste non plus, avec son lot de features pour se créer un réseau d'amis.

Pour conclure sur cet article plutôt bullshit'stisant pour reprendre les termes d'autres, je dirais que mis à part le côté "sert-à-rien" il pourrait remplacer à merveille les blogs que les jeunes s'efforcent d'utiliser de la manière dont Twitter oblige, la possibilité de mettre les photos en mois. Et que le côté publication d'activité via IM est réellement bien fait.

Twitter, un vrai service Web 2.0

2007-12-15T13:24:00.000+01:00

D'abord il y a eu les blogs, qui permettaient de raconter sa vie
passionnante de tous les jours, puis maintenant il y a Twitter, qui force de
résumer sa vie passionnante en 140 caractères.

Comme je n'ai pas une vie passionnante, 140 caractères sont longtemps suffisant pour expliquer que je vais au travail, je suis bloqué sur un problème en PHP, j'ai vu un site super, j'ai mangé au Delectis à midi et que "Tien, c'est déjà 16h30 alors je vais rentrer".

Donc je vous invite tous à retrouver le fil RSS de ma vie La vie au format RSS de Benoit Perroud.

Getting Things Done® (GTD® aussi) : le sydrome du "Ca c'est fait !"

2007-12-15T11:12:00.000+01:00

Un mot très en vogue en ce moment (cf Google trend sur getting things done), GTD® est une méthodologie d'organisation des tâches quotidiennes à accomplir. Dévoilée dans un livre écrit par David Allen publié en 2001, Getting Things Done®, the art of stress-free productivity, elle reprend un certain nombre de choses connues en matière de gestion du temps mais les systématise dans un processus structuré, gage d'efficacité.

Cette systématique est intéressante car elle peut nous faire prendre conscience de la méthodologie que peut-être certain utilisaient déjà et ainsi nous amener à y réfléchir en vue de l'optimiser à nos besoins.

L'objectif de GTD® est de porter toute la créativité et l'énergie sur la seule action qu'on a délibérément choisi de faire et d'approcher au mieux un état de productivité sans stress annoncé.

Les 2 concepts mis en exergue par cette théorie sont les suivants :

Les tâches sont interdépendantes
Les priorités des tâches dépendent d'un contexte

Fort de ce constat, GTD® nous donne une systématique pour

recenser les tâches et les reporter sur des listes par sujet,
identifier celle qui peuvent être exécutées immédiatement et les reporter sur une TODO list
les réaliser dans un ordre de priorité dépendant du contexte (temps à disposition, état de fatigue, endroit, ...).

Une fois la tâche accomplie, GTD® propose une phase de revue durant laquelle la tâche est notée comme faite (le fameux syndrome du "Ca c'est fait !", qui n'est en réalité rien qu'un petit vu sur la TODO list mais qui procure une satisfaction bien au-delà du consentement, mais là je m'égare...) et le cycle organisationnel peut recommencer.

GTD® ne propose pas de support spécifique pour la liste des tâches à accomplir (TODO list), mais précise que le moyen utilisé doit être fiable.

Une petite corollaire de GTD® que je trouve intéressantes est que les tâches prenant moins de 2 minutes sont faites immédiatement. Car "moins de 2 minutes" est à peu près le temps pris pour la gestion organisationnelle de la tâche.

Pour ceux qui comme moi pensent que la curiosité n'est pas toujours un vilain défaut :

http://www.davidco.com/what_is_gtd.php
http://fr.wikipedia.org/wiki/Getting_Things_Done
http://wiki.43folders.com/index.php/Productivity_pr0n

Getting Things Done® et GTD® sont des marques déposées depuis 2005.

60 millions de hashes md5 !

2007-12-09T22:50:00.000+01:00

Sur mon petit projet de revserse md5 lookup database, je viens de dépasser les 60'000'000 de hashes md5 dans la base de données interne, qui fait maintenant 4.2 GB.

En gros j'ai introduit dans la base tous les hashes de 4 lettres composés des caractères a-z, A-Z, 0-9, ., -, _, !, $, *, %, &, /, (, ), =, ?, #, @, +, ", [, ], {, }, et tous les hashes de 5 lettres composés de caractères a-z.

On remarque que sur l'échantillon généré les hashes sont bien uniformément répartis, mais on a une préférence non significative pour les hashes commençant pas 0x46.

La prochaine étape est les hashes de 5 à 7 lettres composés des caractéres a-z et 0-9, ce qui nous fait ~80'000'000'000 de hashes supplémentaires...
Ensuite je prendrais les dictionnaires Openoffice afin de générer les hashes de mots existants.

Happy md5 cracking sur md5.noisette.ch.

Fonction url_get_contents en PHP

2007-11-25T21:00:00.000+01:00

Plutôt que d'utiliser un bien moche file_get_contents($url) où $url est une url, je vous propose une petite fonction url_get_contents($url) utilisant l'extension curl de PHP qui permet aussi bien de télécharger le contenu d'une url via GET que POST :

function url_get_contents($url, $post = null) {
 $curl = curl_init();
 curl_setopt ($curl, CURLOPT_URL, $url);
 curl_setopt ($curl, CURLOPT_USERAGENT, $_SERVER['HTTP_USER_AGENT']);
 curl_setopt ($curl, CURLOPT_HEADER, 0);
 curl_setopt ($curl, CURLOPT_RETURNTRANSFER, 1);
 curl_setopt ($curl, CURLOPT_SSL_VERIFYPEER, 0);
 //curl_setopt ($curl, CURLOPT_FOLLOWLOCATION, 1); // if no safe_mode neither open_basedir

 if (is_array($post)) {
     curl_setopt ($curl, CURLOPT_POST, 1);
     curl_setopt ($curl, CURLOPT_POSTFIELDS, $post);
 }

 $html = curl_exec ($curl);
 curl_close ($curl);
 return $html;
}

L'utilisation est réellement simple :

$content = url_get_contents('http://www.noisette.ch');

Reverse MD5 databases aggregator

2007-11-25T20:48:00.000+01:00

J'écrivais il y a à peu près une année un message à propos des reverses MD5 et de la problématique que ces bases de données posent.
Suite à un message au sujet de l'utilisation de Google comme base de données de hash (en anglais), j'ai remis à jour mon aggrégateur de revse MD5.

Il questionne maintenant pas moins de 8 bases de données en plus de sa base de données propre, et permet maintenant de recevoir un mail quand le hash est trouvé après-coup.

Une petite API est disponible pour intégrer le service dans vos propres applications, notemment pour déterminer si un mot de passe sera crackable en O(1).

Happy md5 cracking sur md5.noisette.ch.

Contourner le blocage du port SMTP

2007-10-09T17:26:00.000+02:00

Votre provider bloque le port tcp/25 (SMTP) et donc vous ne pouvez pas envoyer de mails via votre serveur mail préféré ?

Une solution toute simple mais qui nécessite d'avoir un compte shell sur un serveur quelconque (qui peut être votre ordinateur local), qu'on va nommer srv_shell dans cet exemple, est de faire un tunnel entre votre ordinateur local, le srv_shell et votre serveur de mail préféré, appelé srv_mail ici.

La commande à exécuter sur votre ordinateur local est la suivante :

ssh -NL 2525:srv_mail:25 user@srv_shell

L'utilisation d'un clé ssh est encouragée.

Ensuite dans votre logiciel d'envoi de mail préféré il suffit de spécifier comme serveur sortant localhost sur le port 2525.

Et hop la sécurité le côté ennuyeux à ce type de sécurité mis en place par l'administrateur est bypassé. J'y reviendrai d'ailleurs dans un autre article, car il m'est arrivé récemment ce genre de mésaventure : ip fixe avec serveur Exchange + Storm Worm = blacklistage de l'ip...

Une deuxième solution pourrait venir à l'esprit si on possède son propre serveur dédié, mais je vais expliquer pourquoi cette solution est à bannir au plus vite.

La deuxième idée est d'utiliser un logiciel comme rinetd ou redir, qui ont pour but de rediriger le traffic adressé à un port vers un autre. Donc tout ce qui arriverait sur le port 2525 de srv_shell serait redirigé vers le port 25 du srv_mail. Le problème de cette solution est quand les deux serveurs srv_shell et srv_mail sont les mêmes, la connexion sur le port 25 est redirigé par la même machine, le service mail va donc recevoir une connexion depuis localhost. Et comme la très grande majorité des services mails sont configurés pour que localhost puisse envoyer sans restrictions des mails, cette configuration ouvre un open-relay. Quiconque trouve ce port 2525 sur votre serveur pourra l'utilisé pour spammer le monde entier -> la redirection de port sur un serveur mail est donc à bannir.

Création manuelle d'un botnet "localisé"

2007-10-08T14:09:00.000+02:00

Une méchante idée m'est venue en lisant un article de Slashdot : Cracked Linux Boxes Used to Wield Windows Botnets.

Afin de se composer un réseau de botnets, il serait extrêmement simple à une personne malveillante de vendre des routers ADSL modifiés (rootkités) sur des sites comme Ebay ou Ricardo en Suisse. L'utilisation pour l'acheteur pourrait être strictement similaire, au point qu'il ne se douterait pas que quelqu'un d'autre à la main sur son nouveau routeur.

Dans cet ordre d'idée, on voit de plus en plus de router ADSL se faire rootkiter à la suite d'un piratage d'un ordinateur. La raison principale : un mot de passe par défaut... Idem pour les connexions wireless : on la casse (l'histoire d'une journée pour du WEP avec du matériel correct) avant de s'attaquer au router !

En résumé, il serait presque rentable de se monter un botnet "localisé" et persistant, car placé dans des endroits stratégiques.

Deux petites recommandations pour éviter toutes mauvaises surprises : TOUJOURS modifier le mot de passe de vos routeurs (quitte à le noter dessous, le pirates devant hacker votre webcam et le robot téléguidé du petit frère pour réussir à placer le mot de passe dans le champs de vision de la webcam), et abandonner les connexions wireless...

La surjection, nouvelle maladie ?

2007-09-28T07:14:00.000+02:00

La prochaine fois que vous allez chez le médecin, dites-lui que vous souffrez d'une surjection et que je avez besoin d'un injection pour retrouver un état stable de bijection...

Implémentation paresseuse du "Visitor pattern" en PHP

2007-09-24T19:35:00.000+02:00

Sans m'étendre sur les bienfaits du Visitor pattern, dont le but est de séparer un algorithme de sa structure de données, je souhaite proposer ici une implémentation paresseuse mais possible en PHP.

En théorie ce pattern repose sur 2 interfaces qui permettent de faire un double dispatch (appeler depuis un objets visitable la fonction lui correspondant dans le visiteur) :

Visitable qui contient une fonction apply(Visitor $v)
Visitor qui contient une fonction visit(Visitable $v)

Puisqu'en PHP il n'est pas possible de faire de la surcharge de paramètres de fonction (polymorphisme), il faut donc appeler les fonctions différemment selon les types de structure de données.

En Java :

interface Visitor {
    void visit(Wheel wheel);
    void visit(Engine engine);
    void visit(Body body);
    void visit(Car car);
}
abstract class Visitable {
    void apply(Visitor visitor) {
        visitor.apply(this);
    }
}

En PHP :

interface Visitor {
    public function visitWheel($wheel);
    public function visitEngine($engine);
    public function visitBody($body);
    public function visitCar($car);
}
interface Visitable {
    public function apply(Visitor $visitor);
}

On remarque donc qu'en PHP on devra réécrire toutes les fonctions apply pour qu'elles appellent la fonction visit___ correspondant à leur type.
Mais paresseux comme je suis, la redéfinition de la fonction apply pour chaque visitable me parait un tâche trop répétitive et ennuyeuse. L'idée sous-jacente est de faire un dispatch dynamique en fonction du type du visitable, de la façon suivante :

abstract class Visitable {
    public function visit(Visitable $visitable)
    {
        $func = array(&$this, 'visit' . get_class($visitable));
        if (!is_callable($func)) {
            trigger_error('[' . get_class($this) . '] Class ' . get_class($this) . ' has no visit' . get_class($visitable) . ' function', E_USER_ERROR);
        }
        call_user_func($func, $visitable);
    }
}

Ainsi le visiteur devrait implémenter les fonctions standards visitWheel, visitEngine, ... mais leur dispatching devient automatique !

Mis à part la lourdeur de la fonction call_user_func, le reste de cette implémentation dynamique reste intéressante.

Références :
http://en.wikipedia.org/wiki/Visitor_pattern
http://en.wikipedia.org/wiki/Double_dispatch#Double_dispatch_is_more_than_function_overloading

Plus d'information pour les intéressés :
http://www.polyglotinc.com/reflection.html
http://www.javaworld.com/javaworld/javatips/jw-javatip98.html

Offre d'emploi : customer care

2007-09-18T14:58:00.000+02:00

Ma petite startup, leader en suisse romande sur le marché des logiciels immobiliers, recherche un nouveau collaborateur afin d'assurer le support technique et la formation de ses nombreux clients.

Plus concrètement, le poste consisterait à répondre par téléphone/email aux questions techniques et d'assurer la formation des nouveaux clients sur les logiciels.

Le profile recherché est le suivant :

Langue maternelle française, bon niveau en allemand un plus
Excellentes capacités en communication, autant orales qu'écrites
Bonne capacité à comprendre et résoudre les problèmes
Capacité de travailler sur plusieurs tâches en parallèle
Bonne compréhension de l'architecture client-serveur

Les postulations peuvent être directement adressées à info _A_T_ migtechnology _P_O_I_N_T_ ch.

Algue? piézo-phosphorescente

2007-09-16T16:57:00.000+02:00

Mercredi 12 septembre 2007, tard le soir, plage de Vieux-boucaux dans les Landes française.

Nous étions alors en vacances entre amis. Une soirée des plus tranquilles, avec comme il se doit un passage sur la plage pour boire quelque breuvage local. Cadre peu crédible pour la suite de l'histoire si nous n'avions pas été 9 à être témoin du phénomène que nous avons découvert ce soir-là.

C'est en s'approchant de l'océan qu'on aperçut des points lumineux autour de nos pas. Des points d'une légère lumière bleutée s'illuminaient à chaque pression de nos pieds sur le sol dans un rayon d'une vingtaine de centimètres, avant de disparaitre 3 secondes plus tard.
Phénomène qui nous a émerveillé une bonne partie de la soirée, mais qui reste un mystère pour nos esprits curieux...

Une hypothèse d'une algue ou d'un organisme piézo-phosphorescent est de mise, car les points de couleurs apparaissaient dans une zone semblable à la zone de compression imposée par nos pas...

Mais les hypothèses les plus folles ont été imaginées sous cette nuit claire et chargée d'étoiles filantes.

Générateur automatique de visualisation de site

2007-08-20T22:01:00.000+02:00

Un nom qui ne donne pas très bien en français, mais j'ai développé avec une petite équipe un générateur automatique de visualisation de site.

Le principe est simple : on donne une url au générateur qui nous retourne une image qui est une copie d'écran du site qu'on aurait eu dans notre navigateur. Le coeur du générateur utilise le moteur Gecko pour le rendu de la page web.

Une démo du service de génération de visualisation de site est disponible en ligne, et l'idée est de développer une puissant API pour interfacer le service. L'idée principale de l'API est d'utiliser une url de callback qui permettra au service directement de retourner l'image une fois générée afin d'éviter au client de devoir poller pour controler si l'image est créée ou pas.

Les possibilités du service sont les suivantes :

Taille des images paramétrables (120x90, 160x120, 320x240, 640x480, 1024x768)
Format d'image JPEG ou PNG
Ajout de délai avant la capture (pour les sites en flash par exemple)
Mise-à-jour hebdomadaire, mensuelle ou annuelle des captures

Les feedbacks sont bien évidemment encouragés, et d'autres news sur l'API & CO suivront.

Uniqid ou la contre-intuitivité des arguments

2007-08-16T13:07:00.000+02:00

D'après le manuel PHP, le prototype de la fonction uniqid est le suivant :

string uniqid ( [string prefix [, bool more_entropy]] )

Le deuxième paramètre à l'air réellement intéressant, dans la mesure où il assure une meilleure unicité de la chaine produite. Une propriété qui de toute évidence nous intéresse si on utilise cette fonction uniqid.

Sans s'étendre sur la probabilité de collision entre les 2 appels (ce que j'étendrai plus longuement dans un autre article), je voulais juste montrer la différence de vitesse d'exécution qu'induisait ce paramètre more_entropy. Un petit script faisant 100 appels à uniqid avec une valeur possible du paramètre, nous donne le résultat suivant (!) :

100 * uniquid(mt_rand()) en 0.799283981323 seconde
100 * uniquid(mt_rand(), true) en 0.00346183776855 seconde

Chose extrêmement intéressante, le temps d'exécution de la fonction est 3 ordres de grandeurs en dessous si on demande une meilleures unicité du résultat.

La question obligée est donc : pourquoi est-ce que cette fonctionne ne prend pas par défaut cette option, puisqu'elle a tous les avantages (meilleures résultats, plus rapide) ?

Types ENUM avec MySQL

2007-08-13T09:20:00.000+02:00

Toujours en train de travailler avec MySQL, et encore pour un bon moment, voici une particularité du type enum :

Soit un champ field2 :

`field2` enum('0','1') NOT NULL default '0'

Soit une requête :

SELECT * FROM ... WHERE ... AND field2 = 1

Le résultat de cette requête est intéressant dans le sens où MySQL va sélectionner tous les tuples dont la valeur du champ field2 vaut '0'. Pourquoi cela ? Parce qu'en passant le 1 sous forme d'entier, MySQL va l'associer à la première valeur de l'énumération, '0' donc. Dans le même ordre d'idée WHERE ... AND field2 = 2 sélectionnera tous les tuples dont field2 vaut '1'.

La requête

SELECT * FROM ... WHERE ... AND field2 = '1'

fournira quant à elle la juste réponse. Attention donc avec les types des valeurs, surtout en PHP...

Mysql NT vs Unix : quand les systèmes de fichier font des différences

2007-08-06T12:51:00.000+02:00

La question posée ici est la suivante : le nom des tables dans une base de données MySQL est-il sensible à la casse ou pas ?

La réponse dépend du système sur lequel le serveur tourne... Et cette différence vient même d'une manière plus intrinsèque du système de fichier sur lequel repose la base de données.

Explication :

Pour MySQL, une base de données est un répertoire du même nom dans lequel se trouvent des fichiers représentant les tables. Le nom des fichiers est naturellement identique aux tables, à l'extension prêt.

Pour savoir sur une base existe, MySQL va chercher si le répertoire correspondant existe. Du même principe pour accéder à un table il va ouvrir le fichier lié.

Sur un système de fichier Unix, ext3 ou reiserfs par exemple, un fichier base1/table1.MYI n'est pas le même que base1/tAbLe1.MYI, donc une requête "SELECT * FROM table1" ou "SELECT * FROM tAbLe1" ne produira pas le même résultat. Sur un système de fichier NTFS par contre, les chemins ci-dessus pointeront vers le même fichier, et donc les 2 requêtes précédents fonctionneront.

En conclusion, le nom des bases et tables MySQL sont sensibles à la casse sur un système Unix, et non sensible à la casse sur un système Windows.

Citer Montaigne quand on parle d'informatique

2007-05-14T09:21:00.000+02:00

Chose pas forcément aisée, mais Jean Véronis, professeur de linguistique et d'informatique à l'université de Montpellier y est parvenu à merveille jeudi 18 janvier, dans la capsule de Monsieur Pain.

"Scrobbler" Tome II, jeudi 18 janvier 2007

La capsule, une émission à écouter et ré-écouter...

Je sers mon pays...

2007-04-06T13:27:00.000+02:00

Joyeuses Pâques !

Pendant que les uns vont profiter du climats printanier annoncé pour ce week-end de Pâques, d'autres remplissent leurs obligations de citoyens en gardant un parc véhicule (4 piranha 8x8, 3 eagles et quelques duros) ...

Un ingénieur, un vrai

2007-04-06T12:43:00.000+02:00

Samedi 31 mars a eu lieu la cérémonie de remise des diplômes : la Magistrale. Très belle cérémonie, en collaboration avec le cirque StarLight qui animaient les pauses inter-discours. Même Paul Allen était présent et serrait la main de tous les nouveaux ingénieurs. Non là je fabule un peu sur la poignée de main, mais Paul était bien présent et nous a fait un discours de 40 minutes. Une galerie de photo de la Magistrale 2007 est disponible.

Puis fut le temps de la remise des diplômes, donc du passage sur scène et de la photo de la volée "Master in Computer Science Printemps 2007".

Et petite cerise sur le gâteau, qui est aussi l'aboutissement du travail régulier que j'ai fourni tout au long de mon travail de Master, j'ai reçu le prix de la Société Suisse des entreprises en qualité de deuxième meilleure moyenne du cycle Master de la faculté d'Informatique. Voilà une ligne de plus à ajouter à mon CV :)

Camp de ski avec l'école primaire de Prez-vers-Noréaz

2007-03-31T12:53:00.000+02:00

La semaine du 26 au 30 mars 2007 a eu lieu le camp de ski de l'école primaire de Prez-vers-Noréaz à Villars-sur-Ollon. Une semaine magnifique retransmise en mots et en images sur le site de l'école de Prez-vers-Noréaz.

Travail de Master : quelques chiffres (suite)

2007-03-13T09:31:00.000+01:00

Quelques chiffres supplémentaires pour mon travail et mon Master en général :

Note finale du travail de Master : 6 (sur 6 donc :))
Moyenne de Master (sur 93 crédits) : 5.79
Et pas une note en dessous de 5.

Je tenais juste à remercier Marius Erni, Dominique Bongard et Samuel Gmehlin grâce à qui j'ai réussi à me surpasser durant ces presque 2 ans de Master.

Bon anniversaire !

2007-02-24T09:17:00.000+01:00

Avec pas mal de retard, hop une année de plus. Ca me fait maintenant 20 ans et 6 ans d'expérience :)

Travail de Master : quelques chiffres

2007-02-22T09:21:00.000+01:00

Rendu vendredi 16 février 2007 à 11h10 et défendu le vendredi suivant, soit le 23 février à 10h30, voici quelques chiffres au sujet de mon travail de Master :

Analyse et ingénierie inverse de récepteur satellite Free-To-Air

Le projet se déroulait sur 24 semaines, donc 120 jours. Retranchés des 8 jours de vacances dont j'ai pu jouir, ça nous fait 112 jours de travail effectif.

Au final un rapport de 70 pages, 17'426 mots pour 109'036 caractères, et une présentation de 45 minutes supportée par 44 slides encouragé par 300 visites de mon superviseur.

Mon projet c'est aussi 10'000 lignes de code réparties dans 4 projets (dont IDA Pro et Mame) écrites en 1000 heures de travail grâce à 100 litres de Coca-cola Light. C'est aussi 200 heures de trajets en voiture, 16'800 km parcourus sur l'autoroute A12 entre Matran et Lausanne-Blécherette, 384 mails envoyés en interne et 1640 mails en externe, donc une moyenne de plus de 27 mails envoyés par jour.

Tout cela pour un travail dont je suis entièrement satisfait, quant par le cadre de travail offert par l'équipe du CSO Office du groupe Kudelski que par les résultats intéressants que j'ai développés.

Et bien entendu la note finale que je vous laisse deviner reflète la qualité du travail :)

Article de L'Objectif

2007-02-14T12:50:00.000+01:00

Je suis dans le journal L'Objectif paru vendredi 9 février 2007. Je vous laisse découvrir l'article, en précisant que les noms correspondant à la photo sont faux. Il ne s'agit pas de Frédéric Neukomm derrière à gauche, mais bien Miguel Egger, un employé.

Digression sur l'incohérence entre les discours et les actions

2007-02-04T23:56:00.000+01:00

L'argent n'est pas une finalité, mais un moyen.

Cette phrase qui résonne dans ma tête depuis sa rédaction par Tristan Nitot, directeur de Mozilla Europe (voir l'article en question : les revenus du projet Mozilla), est le départ de cette digression sur mon dégout par rapport à la société capitaliste actuelle.

Quand un projet fonctionne, quel qu'il soit, tout le monde veut sa part du gâteau et en tirer les bénéfices. Les exemples sont nombreux. Ils passent par la Fondation Mozilla (discuté sur un précédent billet : La liberté a un prix), ou récemment en discutant avec mon père d'une jeune gymnaste à l'artistique, dotée d'un énorme talent, qui ne trouve pas d'entrainements adaptés à son niveau dans notre canton et qui s'entraine donc ailleurs, et concours maintenant sous les couleurs de cet autre canton. La finalité pour cette gymnaste est sa progression et son épanouissement, où elle s'entraine et qui elle représente n'est qu'une question de gout et de couleurs. La finalité dans cette histoire doit revenir à la jeune fille, et non pas à l'entraineur du club dans lequel par chance elle s'est présentée un jour... Ce genre d'attribution de finalité n'est que trop souvent appliqué. En politique je n'en parle même pas...

La question devrait plutôt être :

Quelle est la finalité de mon combat (action, engagement) ? Mon propre confort ou celui des autres, de la société, de celui/celle pour qui je me bats ou de ce pour quoi je me bats ? Est-ce que ça va plus me rapporter à moi qu'à la personne que j'aide ?

Est-ce que je suis le cheminement "Faites comme je dis et pas comme je fais" (cf les beaux discours sur l'environnement faits par des dirigeants venus en jet privés lors du WEF), ou "C'est l'intention qui compte" ?

Autant de points qui me révoltent en silence. Autant d'efforts gaspillés par les seuls caprices de gens plus fortunés... J'entendais à la radio un témoignage d'une personne concernant l'éventuelle introduction d'une taxe de circulation au centre de Montreux : "Moi je gagne très bien ma vie, et je me réjouis d'avoir les routes [du centre de Montreux] pour moi tout seul."
Ne comprenez vous pas dans ces propos les fondements même du socialisme ? Le partage des richesses, le cout de la vie en fonction du revenu ? Comment justifier la différence de la proportion de la TVA (de 7.6% chez nous) sur un litre de lait par exemple pour quelqu'un qui gagne 150'000.- par rapport à quelqu'un qui gagne 60'000 ? Tellement d'idée qui sont simplement balayées par des arguments populistes qui dit par exemple "Si vous votez pour nous, nous améliorerons les conditions de vie en limitant le chômage grâce au durcissant la loi sur les étrangers", mais en cachant à la vox populi que ce "nous" fera passer par la même occasion un tarif dégressif des impôts et des avantages fiscaux pour les grandes fortunes. Comment garder un avis objectif, un esprit critique quand la politique passe par du markéting de masse, ne tenant plus compte des idées à défendre mais les moyens mis en place pour la faire passer.

La vanité. C'est par ce nom que l'homme est mauvais. Par ce nom que l'homme pille peu scrupuleusement la planète. Par ce nom que l'homme est prêt à tuer son voisin si il peut y gagner une miette de terre. Par ce nom que certains hommes sont honteusement riche. Par ce nom que l'homme a asservi l'homme, qu'il a massacré l'homme, qu'il a violé l'homme.
C'est par ce nom que les bonnes actions ne durent pas longtemps et finissent par se transformer en corruption. C'est ce nom que je maudis tous les matins...

PEAR::Mail_Queue2

2007-02-01T13:53:00.000+01:00

C'est annoncé officiellement par le mainteneur actuel du projet, je prête mes 10 doigts pour le développement du paquet PEAR::Mail_Queue2, qui est une réécriture de PEAR::Mail_Queue. En effet ce dernier souffre, comme on peut le lire sur l'interface reportant les bugs, de problèmes internes assez ennuyeux et qui ne peuvent pas être corrigés sans casser la compatibilité arrière (backward compatibility, ou BC pour les intimes).

Comme le paquet PEAR::Mail_Queue est noté comme stable, la BC doit être gardée, d'où le paquet Mail_Queue2.

Au menu :

Destinataires multiples,
Processing concurrent,
Management des erreurs,
Meilleure gestion du buffer de queue,
Multithreading (!, mais uniquement pour Unix)
SMTP persistante,
... (et tout ce qui me passera par la tête et sur la mailinglist) ...

Tarpitting, ou comment faire perdre de l'argent aux spammers

2007-01-25T16:09:00.000+01:00

Le tarpitting (désolé maman pour l'utilisation d'un mot d'anglais de plus dans mes billets) est un concept émergeant dans le domaine de la protection des mails.

Comme on s'aperçoit qu'on est mal embranché pour réduire la quantité de spam (voir We are loosing this war badly), des solutions en désespoir de cause se mettent petit à petit en place : autant essayer d'ennuyer le plus possible les spammers, en ajoutant un délai lors de la réception d'emails. La constatation est simple : si pour délivrer un mail, on ajoute un temps d'attente d'une seconde, l'utilisateur normal ne sera pas pénaliser car il n'est pas à une seconde près, mais le spammer qui envoie 1'000'000 de spam se verra pénaliser d'un million de seconde d'attente, soit plus de 11 jours. Bien sûr il ~~peut~~va paralléliser l'envoi de ses mails, mais cela ne va réduire que linéairement son temps de pénalité.

De plus en plus de solution de la sorte voient le jour (principalement les systèmes de greylisting implémentent le tarpitting), et personnellement j'encourage fortement ce genre de solutions : si le mail courant est détecté comme du spam (pour éviter de reproduire ce couteux temps d'attente aux mailing "propres"), je temporise sa réception.

Spammers, chez moi vous allez perdre votre argent, car le temps, c'est de l'argent !

De la sécurité des sessions PHP

2007-01-19T16:00:00.000+01:00

Dans la majorité des espaces requierant une authentification sur un site web, le soin du suivi de l'utilisateur est laissé aux sessions, ces petits cookies qui viennent se placer chez le client afin de permettre à l'application web de le reconnaitre lors du passage à la page suivante.

Ce modèle de sécurité a du être imaginé à cause de la nature "connexionless" du protocole HTTP, c'est-à-dire la fermeture de la connexion TCP au serveur entre 2 chargements de page consécutifs (contrairement aux modèles de connexions "continues").

Malheureusement différentes techniques pour voler ces informations de sessions existent, elles se nomment credential token stealing, et sont souvent réalisables grâce à des failles de type XSS.

Cet article va expliquer quel est le point faible des sessions, ainsi que présenter une solution pour en améliorer la sécurité. Un exemple d'implémentation sera une fois de plus donné en PHP.

Problèmes des sessions

Le problème lié aux sessions est que l'identité de l'utilisateur, une fois identifiée, repose entièrement sur ce cookie. Si une personne malveillante parvient à obtenir la valeur du cookie, elle pourra alors se faire passer pour la personne légitime aux yeux de l'application.

Meilleure emprunte (fingerprint)

Une première amélioration est d'associer la valeur du cookie à d'autres éléments qu'une personne malveillante ne peut pas modifier : l'ip de connexion, la signature du navigateur, etc...
Tous ces éléments combinés ensemble donnent ce qu'on appelle l'emprunte de la session, et tous ces éléments sont nécessaires pour pouvoir usurper une identité. La principale difficulté est l'adresse ip de connexion, mais si la personne malveillante est sur le même sous-réseau que la personne légitime, l'adresse ip n'est plus un problème. Autre désavantage d'un fingerprinting étendu, si la personne légitime est sur une connexion à adresse ip dynamique, elle devra se réauthentifier à chaque changement d'adresse ip.

ID de session temporaire

Une autre amélioration est la regénération dynamique de la valeur du cookie. A chaque nouvelle connexion, on test si l'utilisateur est légitime, et on génère une nouvelle valeur qu'on lui envoie.
Si une personne malveillante arrive à voler un cookie, sa valeur ne sera que temporaire et dès le prochain chargement de page, la valeur volée devient obsolète.
Mais cela est aussi vrai à l'inverse, si la personne malveillante arrive à usurper l'identité avant que la personne légitime ne redemande une page, c'est la personne légitime qui sera déconnectée du site.

Implémentation en PHP

Une combinaison des 2 méthodes améliorera la sécurité des sessions, sans pour autant la rendre infaillible.

Voici une petite implémentation en PHP :

<?php
/*
* Inspirated from SecureSession class
* initially written by Vagharshak Tozalakyan <vagh@armdex.com>
*/
class SecureSession {

  private $_check_browser;
  private $_check_ip_blocks = 0;
  private $_padding = '*ftt56+g zwc%&gh7/3-lf%254*6c_qm';
  private $_regenerate_id = true;
  private $_session_var_name = __CLASS__;

  public function _construct($check_browser = true, 
    $check_ip_block = 0, $regenerate_id = true)
  {
    $this->_check_browser = $check_browser;
    $this->_check_ip_block = $check_ip_block;
    $this->_regenerate_id = $regenerate_id;
    
    $_SESSION[$this->_session_var_name] = $this->_fingerprint();
    $this->_regenerateId();
  }

  public function isValid()
  {
    $this->_regenerateId();
    return (isset($_SESSION[$this->_session_var_name])
      && $_SESSION[$this->_session_var_name] == $this->_fingerprint());
  }

  private function _fingerprint()
  {
    $fingerprint = "";
    if ($this->_check_browser) {
      $fingerprint .= $_SERVER['HTTP_USER_AGENT'];
    }
    if ($this->_check_ip_blocks) {
      $num_blocks = min(abs(intval($this->check_ip_blocks)), 4);
      $blocks = explode('.', $_SERVER['REMOTE_ADDR']);
      for ($i=0; $i<$num_blocks; $i++) {
        $fingerprint .= $blocks[$i] . '.';
      }
    }
    return sha1($fingerprint . $this->_padding);
  }

  private function _regenerateId()
  {
    if ($this->_regenerate_id && function_exists('session_regenerate_id')) {
      session_regenerate_id(true);
    }
  }
}

?>

A quoi juge-t-on qu'on est trop "geek" ?

2007-01-18T16:12:00.000+01:00

Voilà que je me surprends à ajouter subtilement des ; à la fin des lignes d'une lettre de demande de congé pour l'armée...

Cette fois mes craintes se justifient : je suis vraiment un geek.

Une authentification sur les serveurs smtp des providers

2007-01-17T12:47:00.000+01:00

Non content de perdre la guerre du spam, les providers contre-attaques.

Relayé par Rags, voici le mail explicatif de Green :

Chers clients de green.ch

Dans le cadre d'un projet commun, les 4 grands fournisseurs de service internet en
Suisse (Bluewin, Cablecom, green.ch et Sunrise) mettent en place des mesures pour
combattre l'affluence massive des spams. La 1.ère étape est l'imposition de
l'authentification du serveur SMTP (Simple Mail Transfert Protocole). Cela signifie
que votre programme eMail, pour la récéption et l'envoi des emails, doit toujours
s'authentifier au niveau du serveur mail avec un nom d'utilisateur et mot de passe.

Il est possible que cela soit déjà le cas à votre niveau. Pour être sûr, nous vous
invitons à procéder à une vérification.

Le guide pour le paramétrage exacte ainsi que la configuration de votre compte eMail
se trouve ici: http://dtg.green.ch nous vous invitons à suivre la démarche pas à
pas.

Si vous utilisez exclusivement le Webmail pour vos eMails, vous ne devez rien
entreprendre.

Il est préférable d'effectuer le contrôle tout de suite afin de vous assurer que vos
eMails seront aussi envoyés à l'avenir.

Nous vous remercions de votre coopération.

Avec nos meilleures salutations

Votre équipe de support de green.ch

Les clients des providers vont donc immédiatement devoir modifier les paramètres de leur compte mail sortant afin d'y ajouter une authentification.

Cette authentification a deux effets :

premièrement elle est ABSOLUMENT INUTILE contre l'envoi de spam, puisque les malwares qui envoient du spam passent très majoritairement par des open-proxies, ou se connectent directement sur le smtp du MX du domaine.
deuxièmement elle force à avoir une adresse email @<super_provider_de_luxe>, ce qui rend les clients dépendant d'eux, car il est pénible de changer une adresse email déjà diffusée à tous ses amis/contacts. Elle empêche de ce fait le confort d'utilisation que nous fourni des adresses email comme Gmail (à noter que le webmail n'est pas touché par cette restriction).

A mon humble avis, cette solution a dû être trouvée par les économistes du top management et ne sert qu'à se donner un semblant de paraitre d'essayer de combattre le spam, tout en fidélisant de force leur clients.

De ce point de vue, chapeau, il n'aurait jamais été si facile de faire passer la pilule sans cet argument de combattre le spam. D'un point de vu efficacité réelle, autant dire que c'est même pas un pet de constipé dans l'eau, c'est de la poudre aux yeux sans poudre. J'espère simplement que vous, chers providers, avez pensé à renforcer vos équipes de

hotline

, et que vous les avez former pour répondre à la question : "Je reçois toujours autant de spam, que faire ?".

Je serais tellement content de pouvoir expliquer mon ~~poing~~ point de vue à un décideur d'une de ces entreprises...

Les 7 règles fondamentales en sécurité

2007-01-16T16:07:00.000+01:00

Très souvent oubliées ou minimisées, voici les 7 règles fondamentales en sécurité :

Least privilege : on ne donne que le privilege minimum
Defense in depth : on protége à tous les niveaux
Choke point : on emprunte qu’un seul chemin pour aller au but
Weakest link : la sécurité globale est égale à la sécurité du maillon le plus faible
Default deny : plutôt que d’énumérer les cas pas permis, au risque d’en oublier, on énumère les cas permis.
User participation : on éduque les utilisateurs par rapport à la sécurité
Simplicity : on applique le principe de simplicité

A appliquer sans modération !

Statistiques fournies par FeedBurner

2007-01-15T12:30:00.000+01:00

Je suis relativement content de mon blog sur Blogger.com, les principaux problèmes que j'y vois sont :

Pas la possibilité de faire des trackbacks
Pas de statistiques de fréquentation.

Le premier problème n'a pas l'air prêt de se régler, le deuxième peut en revanche être contourner en passant par Feedburner.

Chose faite, il serait bien d'actualiser vos bookmarks de feed et s'abonner à http://feeds.feedburner.com/BenoitPerroud plutôt que l'alternative de Blogger.

Form flooding

2007-01-14T23:34:00.000+01:00

Les formulaires sont un des points vulnérables d'une application web, car c'est notamment à travers eux que les "clients" peuvent injecter des données dans l'application.

De plus, même si le formulaire est suffisamment protégé contre l'injection de données, qu'elle soit XSS, SQL, string format ou autre, le formulaire reste vulnérable à un flood :

Comment réagit votre formulaire si un client bien authentifié décide de poster 1'000'000 de fois le formulaire ?

Ce genre d'attaque peut avoir des effets très néfastes...

Il y a plusieurs méthodes pour s'en prémunir, et je vais en présenter une qui, contrairement au captcha, ne requiert pas d'intervention de la part de l'utilisateur (on ne peut pas faire de captcha dans un webservice...), mais protège tout de même notre formulaire.

On va donc attribuer à chaque formulaire un identifiant unique, qui est entré dans une table (ou en var de session) conjointement avec un timestamp. L'identifiant nous permettra d'éviter (au pire de remarquer) la soumission multiple du même formulaire, et grâce au timestamp, nous pourrons mesurer le temps entre le chargement de la page contenant le formulaire et son renvoi au serveur, temps qui ne devrait pas être inférieur à une voir plusieurs secondes pour un utilisateur humain, selon la taille du formulaire.

En recevant le formulaire, le serveur peut donc contrôler si :

1. Le formulaire est valide, i.e. l'identifiant du formulaire est valide
2. Le formulaire n'a pas été envoyé plusieurs fois.
3. Le délai de soumission du formulaire n'est pas trop élevé pour une session donnée.

L'implémentation de cette solution est elle aussi multiple, mais j'en donne un exemple ci-dessous :


__toString(); ?> ...
*
* if (isset($_POST)) {
*   $canary = Form_Protector::factory($_POST);
*   if (!$canary->is_valid()) {
*     if ($canary->exists()) {
*       // le canary n'existait pas dans la db, afficher un message d'erreur et recharger la page
*     } else {
*       // le formulaire a été posté trop rapidement, on peut donc compter le nombre de soumissions durant les 5 dernières minutes, et prendre une des actions suivante
*       // --> soit on blacklist l'ip un moment,
*       // --> soit on sleep(30) pour temporiser (tarpitting)
*     }
*   } else {
*     // le canary est valide, tout est bien dans le meilleur des mondes.
*   }
* }
*/

define("_TIME_TO_SUBMIT_FORM", 2); // temps que l'utilisateur fait pour submiter un formulaire
class Form_Protector {

protected $_canary;
protected $_ip;
protected $_date_request;
protected $_date_request;
protected $_exists = false;

public static $input_name = 'form_protector_canary';

protected function __construct($canary = 0, $ip = "") {
  $this->_ip = $_SERVER['REMOTE_ADDR'];
  if ($canary === 0) {
    $this->_canary = rand();
    $this->_insert();
  } else {
    $this->_canary = $canary;
    if ($ip !== "") $this->_ip = $ip;
    $this->_load();
  }
}

protected function _load() {
  $query = sprintf("SELECT * FROM form_protector
    WHERE canary = %d AND ip = '%s'" . int_val($this->_canary),
    mysql_real_secape($this->_ip));
  // query,
  // load $this->_date_request, $this->_date_request = time();
  // si pas un champ est retourné, on passe $this->_exists à true; et on UPDATE ... SET date_response = $this->_date_request
}

protected function _insert() {
$this->_date_request = time();
$query = sprintf("INSERT INTO form_protector (canary, ip, date_request) VALUES (%d, %s, %d)", int_val($this->_canary), mysql_real_secape($this->_ip), $this->_date_request);
// query
// si pas d'erreur : $this->_exists = true;
}

public function is_valid() {
if ($this->_date_request + _TIME_TO_SUBMIT_FORM <>_exists;
}
public function __toString() {
return '<input value="' . $this->_canary . '" name="form_protector_canary" type="hidden">';
}

public static factory($params = NULL) {
if (is_array($params) && isset($params[self::$name])) {
 $canary = $params[self::$name];
} else {
 if ($params === NULL) {
  $canary = 0;
 } else {
  $canary = $params;
 }
}
return new Form_protector($canary);
}
}

?>

We are losing this war badly

2007-01-14T18:20:00.000+01:00

Ou "Quand les RFCs sont trop difficiles à comprendre..."

Quand un serveur SMTP se connecte à un autre pour envoyer un mail, il doit s'annoncer. Cela fait parti du protocole SMTP définit dans la RFC 2821

- Connexion TCP à <server_destinataire> (telnet <server_destinataire> 25 pour simuler le comportent)
- HELO <server_name> (ou EHLO dans le cas de ESMTP)

Ce HELO <server_name> est une petite politesse introduite dans le protocole, mais qui permet, en plus de choisir la version de SMTP lors de l'échange, d'ajouter des tests pour détecter le spam.

En effet, à l'heure actuelle la plupart des moteurs SMTP utilisés pour envoyer du spam ne s'annoncent pas correctement. Le <server_name> est très souvent remplacé par une chaine de caractères aléatoires.
Si on part du principe qu'un serveur mail légitime a une adresse ip fixe, la correspondance entre l'ip inverse de <server_name> et de l'ip de la connexion du serveur serait un très bon test pour contrer le spam. Le problème devient un cauchemar quand même des providers ne configurent par correctement leurs serveurs SMTP :

Received: from smtp-auth-be-03.sunrise.ch (mail-proxy-be-01.sunrise.ch [194.158.229.48])
        (using TLSv1 with cipher DHE-RSA-AES256-SHA (256/256 bits))
        by dns3.omne-serveurs.net (Postfix) with ESMTP id 342991EEE10
        for ; Sun, 31 Dec 2006 02:16:16 +0100 (CET)

Dans cet exemple, il s'agit d'un serveur Sunrise qui s'annonce smtp-auth-be-03.sunrise.ch, et dont l'ip est 194.158.229.48. C'est presque juste, le seul détail est que le reverse de 194.158.229.48 est mail-proxy-be-01.sunrise.ch.

Received: from swip.net (mailfe05.tele2.ch [212.247.154.136])
        by dns3.omne-serveurs.net (Postfix) with ESMTP id 0173F763C3C
        for ; Wed, 10 Jan 2007 07:54:31 +0100 (CET)

Dans ce deuxième exemple, la configuration est pire : le serveur qui se connecte avec l'ip 212.247.154.136, s'annonce comme étant swip.net, alors que le reverse de swip.net est 212.247.156.1.

En résumé, parce que les personnes qui administrent des serveurs mails ne sont pas un peu plus scrupuleux, comme il est dit dans cet article

We are losing this war badly

Nabuchodonosor, Roi de Babylone, écrivez-moi cela en 4 lettres.

2007-01-11T07:32:00.000+01:00

Nabuchodonosor, Roi de Babylone, écrivez-moi cela en 4 lettres.

Cette expression est ma dernière signature en date, et comme d'habitude personne ne comprend son sens profond, alors je me vois contrains de l'expliquer.

Le but de cette phrase est de faire paraitre quelque chose compliqué alors qu'elle ne l'est en réalité pas (tout le monde peut écrire cela en 4 lettres : c e l a. Pas besoin d'être roi de Babylone pour le faire).

Il en est de même dans beaucoup de domaine de l'ingénierie, où des gens ont la fâcheuse tendance à compliquer des concepts simples (pour justifier leur travail, pour faire plus vendeur, ou pour n'importe quelle autre raison qui m'échappe). Il y a bien évidement des cas où cette complication est nécessaire (pour un obfuscateur de code source par exemple), mais retenons et appliquons la devise d'Albert Einstein :

Faites les choses aussi simple que possible, mais pas plus simple.

Optimisation du nombre de requêtes SQL dans les collections d'objets et relation n-m

2007-01-09T00:10:00.000+01:00

L'orientation objet de PHP n'est plus contestable, mais les problèmes d'optimisation persistent.

Par exemple le malheureusement célèbre n+1 pattern, qui fait que pour afficher une liste de n objets, le + 1 étant la requête qui sélectionne tous les ids des objets à instancier, n + 1 requêtes SQL seront effectuées.

De même dans des relations n-m, la majorité des implémentations sélectionnent les n objets (en n + 1 requêtes donc), puis pour chacun on sélectionne les m objets de la relation. On obtient donc n * m + 1 requêtes.

Le but de cet article est de présenter deux techniques qui, combinées, réduisent les n * m + 1 requêtes en n + m + 1.

Les deux techniques que je vais illustrer ici se nomment object caching et grouped fetching. Elles se combinent très bien, ce qui permet d'optimiser drastiquement les performances d'un script PHP, du points de vue I/O (moins de requêtes), vitesse d'exécution et même mémoire utilisée (les objets ne sont pas dupliqués).

Object caching :

Le principe de l'object caching est de rendre le constructeur de l'objet privé (au pire protégé) et de l'instancier au moyen d'une factory. Puis on ajoute à la classe un tableau statique dans lequel les références des objets instanciés seront placés. La factory va donc regarder dans le tableau de références si l'objet existe, et si ça n'est pas le cas elle va le créer, l'ajouter au tableau et le retourner.


class A {
 protected static $objects_cache = array();

 public static function factory($id, $class = __CLASS__)
 {
   if (array_key_exists($id, $class::$objects_cache)) {
     return $class::$objects_cache[$id];
   } else {
     $o = new $class($id);
     $class::$objects_cache[$id] = $o;
     return $o;
   }
 }
}

Cette solution pourrait encore être améliorée si les objets pouvaient être partagés entre toutes les instances de PHP. Ce n'est pas le cas à cause de l'architecture share nothing de PHP, et c'est un des points forts des serveurs d'applications.
Un autre désavantage de ce concept, si on a un script qui tourne suffisamment longtemps pour que le grabage collector se lance, est que tous les objets créés sont toujours référencés, même ceux qui pourraient être des candidats potentiels à la finalisation. Ce problème est résolu dans d'autres langages, en Java par exemple grâce aux références faibles (WeakReference).

Grouped fetching

Le principe du grouped fetching, dérivé d'une solution proposée par notre ami Colder, est de charger les données des objets de manière asynchrone et en bloque. Quand un objet est instancié, il est marqué comme non chargé, et sa référence est placée dans un tableau global de la classe. Puis lors d'un accès à un champ non chargé, la classe va sélectionner dans la base de données tous les objets instanciés mais pas encore chargés. Plus on retarde les accès aux attributs d'un objet, plus on va paralléliser les requêtes SQL.


class A {
 private static $_to_load = array();
 private $_is_loaded = false;
 public function __construct($id)
 {
   $this->id = $id;
   self::$_to_load[$id] = $this;
 }

 public function __get($attribut)
 {
   if (!$this->_is_loaded) {
     self::_groupedLoad();
   }
   return $this[$attribut];
 }

 private function _setLoaded()
 {
   $this->is_loaded = true;
 }

 private static function _groupedLoad()
 {
   $ids = implode(', ', self::$_to_load);
   $query = 'SELECT * FROM ' . self::$_table . ' WHERE id IN ( ' . $ids . ' ) ';
   $res = db_query($query);
   while ($row = $res->getNext()) {
     self::_to_load[$row['id']]->_initByArray($row);
     self::_to_load[$row['id']]->_setLoaded;
   }
 }
}

L'overhead de ce concept est très faible (un tableau de références supplémentaire), et le nombre d'accès à la base de données sont grandement réduit. Mais le problème de la finalisation des objets se repose aussi.

Lettre au père Noël

2007-01-08T12:19:00.000+01:00

Trouvé sur linuxfr, tellement plein de vrai que je suis obligé de broadcaster :

Lettre au père Noël

Samourai

2007-01-07T22:24:00.000+01:00

Et voici un autre jeu à boire intéressant, appris sur le tas dans de sombres circonstances, et dont l'issue fut fatale pour plus d'un d'entre nous. Il s'appelle Samourai , et le principe est très simple : des personnes autour d'une table devant accomplir chacun leur tour une ou plusieurs actions.

Les actions sont simples, elles consistent à désigner la personne suivante à réaliser l'action, à ~~boire un verre de vodka cul-sec~~ réaliser un gage ou faire un action collective.

Le nom des actions étant normalement en japonais, je me permets d'y faire ici une transcription phonétique.

L'action la plus simple consiste à désigner son voisin direct par un coup de coude latéral, le poing du bras donnant le coup de coude dans la paume l'autre main, en criant "Hi-ha". La seule contrainte sur cette action est qu'elle doit se faire dans la même direction que le coup de coude reçu (donc on reçoit un coup de coude du coté gauche et on renvoie un coup de coude sur notre droite, respectivement le coté gauche de notre voisin).

La deuxième action permet de désigner n'importe quelle personne autour de la table. Cela se fait en tendant sa main bien droite en direction de cette personne et en criant "Katana".

L'action "Oups" permet de faire sauter le tour du voisin dans lequel l'action de se déplace. Elle se réalise en décrivant un cercle de la taille d'un ballon de foot avec ses 2 mains.

L'action pour bloquer le coup de coude et faire repartir le mouvement dans le sens contraire s'appelle "Wasaï". Elle se réalise en plaçant devant soi son avant-bras à la verticale et son poing contre son coude opposé, le tout en criant "Wasaï". Si on reçoit un "Hi-ha" par la gauche, on doit lever son avant-bras droite, de manière à avoir le coude gauche à l'horizontal pour répondre à son voisin de gauche.

Les 2 prochaines actions peuvent être exécuter en plus de l'action de base, et tous les autres joueurs doivent y répondre :
Si le jour crie "Aligato", les autres joueurs joignent leurs mains dans un signe de prière, s'inclinent vers le joueur qui a prononcé ce mot et réponde "Aligato san".
De même si le joueur crie "Samourai", les autres joueurs imitent l'action de resserrer un noeud autour de la taille en criant "Hou".

Puis vient le moment du gage. Le joueur qui exécute incorrectement un action cité doit donc ~~boire un verre~~ exécuter un gage. Avant son gage, il doit prononcer "Arakiri", que tout le monde doit applaudir, puis il doit remercier Yogi à la fin du gage. Si ces 2 parties du gage sont mal exécutées, le gage entier doit être refait.

Dernière action en date, similaire à "Katana", le joueur désigne un autre joueur en criant "Nikon". Le joueur visé doit alors viser un autre joueur en imitant d'avoir un appareil photo dans les mains et crie "click-clack".

A noter qu'il serait judicieux d'introduire progressivement les règles, avec dans l'ordre :

"Hi-ha"
"Wasaï"
"Oups"
"Samourai"
"Katana"
"Aligato"
"Nikon"

~~Bonne guerre~~ Bon jeu !

De l'art d'éviter les requêtes SQL inutiles

2007-01-07T19:25:00.000+01:00

Dans le domaine de l'optimisation, une chose simple à faire est d'essayer de réduire au strict minimum le nombre de requêtes à faire à la base de données.

Je souhaite simplement rendre attentif au problème posé par les procédures embarquées et autres tirggers :

Dans le cas d'une mise-à-jour d'un objet mappé sur une table d'une base de données, les champs de l'objet sont remplacés (après nettoyage...) par ceux du formulaire. On pourrait donc penser qu'il est inutile de faire un SELECT juste après un UPDATE, car les données mises-à-jour sont celles fournies.

Cela est vrai sans compter sur les triggers déclenchés en cas de mises-à-jour : sans un SELECT après l'UPDATE, certains champs peuvent contenir des données fausses car non traitées par le trigger. Les champs auto-timestamp de Mysql sont un exemple tout simple de trigger à ne pas oublier...

Bonne année (2007) !

2007-01-04T07:53:00.000+01:00

Version geek :

<?php

if (date('n') === 1
    && ($day = date('j')) >= 1 && $day < 10) {
    echo '<p>Bonne année ' . date('Y') . ' à tous !</p>';
}

?>

Version "Le Chat" :

Meilleurs voeux pour toute la vie.. Comme ça c'est fait une
fois pour toutes !

Surchages de méthodes statiques en PHP

2006-12-30T11:06:00.000+01:00

Un tout petit exemple pour exposer le problème :

class A {
  public static function f() {
    echo get_class();
  }
}

class B extends A {}

A::f();
B::f();

A::f() va afficher A, par contre B::f() va aussi afficher A, alors que la réponse attendue serait B.

Ce comportement est connu des développeurs OO, peut s'avérer ennuyeux dès qu'on utilise des fonctions statiques surchargées, car les appels à self::une_fonction() (une_fonction est donc une méthode statique) dans le parent résulteront toujours à un appel de la méthode du parent, et non pas celle surchargée dans le fils. La raison est que self dans la classe parente représente le parent, comme c'est aussi le cas dans d'autres langages OO.
Illustrons les limites de ce comportement avec la mise en place d'une factory toute simple :

class A {
  ...
  public static function create($params) {
    $class = get_class();
    return new $class($params);
  }
}
class B extends A {}
$b = B::create($myparams);

$b contiendra toujours un objet de classe A, car get_class retournera toujours A.

L'idée pour palier à cette limitation est donc simplement d'ajouter un argument à la fonction create de A, qui sera la classe à instancer :

class A {
  ...
  public static function create($params, $class = __CLASS__) {
    return new $class();
  }
}
class B extends A {
  public static function create($params, $class = __CLASS__) {
  return parent::create($params, $class);
  }
}
$b = B::create($myparams);

Avec cette petite adaptation, $b sera bien un objet B.

De manière plus général, si on envisage d'utiliser des fonctions statiques surchargées, PHP nous permet de gérer l'héritage en passant la classe en argument et en appelant la fonction statique au moyen de la macro call_user_func :

class A {
  protected static une_fonction($arg) { return $arg + 1; }
  ...
  public static function create($params, $class = __CLASS__) {
    $res = call_user_func(array($class, 'une_fonction'), $args);
  ...
  }
}
class B extends A {
  protected static une_fonction($arg) { return $arg + 2; }
  public static function create($params, $class = __CLASS__) {
  return parent::create($params, $class);
  }
}
$b = B::create($myparams);

Grâce à cette macro call_user_func, B::create appellera donc bien B::une_fonction.

Spam image

2006-12-21T08:30:00.000+01:00

Selon une analyse menée par une société spécialisée dans la sécurité informatique, le spam image a augmenté de façon impressionnante en un an, passant de 4,8 % du spam global en octobre 2005 à 25 % un an plus tard. Loin d'être en recul, le volume global du spam est passé de 31 milliards de messages par jour à 61 milliards sur la même période. De plus la taille moyenne des messages a elle aussi augmenté, passant de 8,9 Ko à 13 Ko. Le spam consomme donc désormais 819 téraoctets de bande passante par jour !

En attendant que d'efficaces techniques de prévention du spam image soient mises au point, n'hésitons pas à désactiver l'affichage automatique des images dans notre gestionnaire de courrier, ce sera déjà une première défense. Et ayons toujours en tête que le but des spammeurs est moins de vous vendre quelque chose que de vous arnaquer purement et simplement...

Ryzom, un MMORPG désormais libre

2006-12-19T11:42:00.000+01:00

Un fait peu habituel secoue l'univers du libre ces derniers jours : le rachat de la propriété intellectuelle (code source, monde, ...) du jeu de type MMORPG nommé Ryzom afin de la libérer.

Cette initiative, soutenue par la FSF elle-même qui y joue un important rôle de mécène, montre à quel point l'univers du libre est réactif et motivé, mais pointe le doigt sur un fondement de notre société capitaliste :

La liberté a un prix.

On peut donc en déduire comme corolaire qu'il faut gagner de l'argent pour rester libre.

Et tout le paradoxe du serpent qui se mort la queue apparait quand on prend le cas la Fondation Mozilla, qui gagne de l'argent grâce a des partenariats avec notamment Google, faits incompris et fortement critiqués par beaucoup de monde (actualité sur par exemple 1 et 2, critiques dans la blogoshpère).

Une petite illustration logique pour toutes les personnes qui n'auraient pas compris l'intérêt de la Fondation Mozilla :

Il faut gagner de l'argent pour être libre.
La fondation Mozilla gagne de l'argent.
Donc la fondation Mozilla est libre.

Reverse MD5

2006-12-18T16:34:00.000+01:00

La fonction MD5 est une fonction dit à sens unique, c'est-à-dire que ne connaissant que la sortie, il est difficile de trouver l'entrée qui a produit cette sortie.

C'est pourquoi des reverse md5 databases sont apparues sur Internet. Leur principe est tout simple : c'est une grande base de données contenant la pair (texte, hash). Ainsi on peut la questionner du hash recherché et elle nous retourne le texte correspondant si il est connu.

La base de données doit donc être remplie avant de pouvoir produire des réponses, mais une fois qu'elle contient suffisamment de données, les recherches peuvent commencer à être intéressantes. Les techniques des remplissages sont simples, elles vont du parcours de pages web ou de dictionnaires pour rechercher des mots quelconques à l'ajout manuel par des utilisateurs.

J'ai rapidement fait une petite application qui questionne plusieurs des ces reverse md5 databases, qui elle est disponible à l'addresse http://md5.noisette.ch/form.php

Elle se base sur la toute petite API suivante : http://md5.noisette.ch/?hash=<le_hash_en_hex> qui retourne du XML

<md5lookup>
<hash></hash>
<string></string>
</md5lookup>

L'approche est très alléchante car une fois le hash dans la base de données, les réponses sont fournies en O(1). Les mots de passe stockés en md5 peuvent donc être retrouvés extrèmenent rapidement.
La contre-partie de cette approche est qu'elle nécessite beaucoup de hash précalculé avant d'être utilisable, et donc produira une énorme base de données :
Le md5 étant sur 128 bits, on pourrait avoir une table de 2^^128 entrées, pour peu qu'on ne prenne pas en compte les doublons. Donc rien que pour les hash, il nous faudrait ~5*10^^39 bytes de stockage = ~5000 téra de téra de téra bytes. Enfin juste pas possible quoi. Si on fait le raisonnement inversion on se dit que notre serveur a 200Gb d'espace disque, on peut donc stocker 12.5 milliards de hash, donc 12.5 milliards de possibilités de mots de passe = un peu plus de 2^^33 possibilités. On est loin des 2^^128...

En résumé, c'est une approchoe time / memory tradoff 100% mémory :)

Gentoo sur la PS3

2006-12-07T12:15:00.000+01:00

Dans la famille "Tchötégik", voici un petit cookbook sur "Comment installer une Gentoo sur sa PS3" :

http://whitesanjuro.googlepages.com/

L'intérêt, en plus d'être purement académique car les jeux ne tournent pas (encore) sur cet OS et d'étudier le hardware contenu dans la console, est plutôt de démontrer la flexibilité de Gentoo à s'adapter à n'importe quel type d'environnement.

Une nouvelle bulle internet en formation ?

2006-12-06T11:50:00.000+01:00

Cette question défraie la chronique ces jours, et j'ai trouvé qu'elle méritait un petit article. Non pas pour en expliquer les raisons ou essayer de deviner la date de son éclatement, d'autre le font mieux que moi, mais parce que je suis tombé sur la citation suivante :

L’avantage avec les bulles [économique], c’est qu’elles peuvent toujours se dégonfler avant d’éclater.
Mais l’inconvénient avec les bulles, c’est que les gens croient vraiment qu’elles peuvent se dégonfler avant d’éclater...

Qui, bien qu'amusante, a le mérite d'être entièrement fondée à l'heure ou les entreprises 2.0 sont formées sur une base de levée de fonds dans le seul but d'être revendue dès l'ombre du début d'un éventuel profit à l'horizon.

Recrutement Google, étape #2

2006-11-29T09:29:00.000+01:00

Mardi 28 novembre je me suis rendu dans les locaux de Google à Zürich afin de procéder à la suite du processus de recrutement. L'heure de rendez-vous, fixée à 10h00, n'étant pas trop contraignante, j'ai pris le train à Neyruz à 07h45 pour arriver à 09h38 à Zürich, et finalement 9h45 à Freigutstrasse 12, 8002 Zurich.

Le bâtiment est une ancienne banque privée, de couleur rosé et dont le style s'apparenterait au début du 20ème siècle. La porte d'entrée est fermée à clé, et il faut s'annoncer avant de pouvoir entrer. Puis une fois à l'intérieur, il faut s'inscrire sur un terminal et signer sur une tablette, et un badge autocollant est directement imprimé.

L'intérieur du bâtiment est plutôt blanc, avec du parquet sur le sol, mais ce qui frappe c'est les accessoires (poufs, ballons, coussins) de couleurs vives disposés un peu partout. On se croirait en plein jardin d'enfants. Seul les 2 écrans 20 pouces par place de travail rappellent qu'on est bien dans une entreprise de services.

Ma journée s'est composée de 4 entretiens techniques et d'un repas avec Peter, un des deux ingénieurs qui m'avait interviewé à l'EPFL.

Les questions posées étaient de nouveau très algorithmiques, principalement axées sur l'organisation des données en arbre ou table de hashage, tout en tenant compte de l'ordre de complexité des fonctions proposées.

Un exercice a retenu mon attention et je souhaite vous en faire partager mon expérience :

La donnée est simple : un personne se tient en bas d'un escalier de N marches. A chaque pas, il peut monter une ou deux marches. Combien de possibilités de configuration de trajets différents a-t-il pour monter l'escalier ?

L'illustration ci-dessous schématise le problème.

Le raisonnement approprié pour ce problème est de se dire que pour atteindre une marche n, la seule possibilité est d'être passé par la marche n-1 ou n-2, et donc le nombre de chemin pour arriver sur la marche n est la somme des possibilités d'arriver sur les cases n-1 et n-2.
On a donc la formule de récurrence suivante :
F_n = F_{n − 1} + F_{n − 2}
qui devrait nous faire penser à la suite de Fibonacci.

La suite de la question est simplement : comment peut-on calculer de manière efficace une telle suite ?

Il est possible de calculer une suite de Fibonacci de manière itérative, et donc d'une complexité de O(n), mais ce que je ne savais pas c'est qu'il existe une manière encore plus efficace pour calculer en O(log(n)) !

Cette solution repose sur deux propriétés : l'expression matricielle du problème, et le calcul de puissance.

La suite de Fibonacci peut donc s'exprimer sous la forme matricielle suivante :

Ce qui nous amène à l'expression suivante :

On voit apparaitre un matrice 2x2 élevée à la puissance n. On peut donc utiliser l'algorithme square-and-multiply (donné ci-dessou) pour la calculée, qui lui est en O(log(n)).

CQFD. Des questions ? Des remarques ?

Je suis reparti vers 15h30, fatigué mais content. Je devrais avoir une réponse dans le courant de la semaine prochaine quant à leur envie de m'engager ou pas.

Suite au prochain (et peut-être dernier) épisode...

I'm the 58,920,569 richest person on earth!

2006-11-24T09:31:00.000+01:00

Avec mon revenu actuel tout à fait moyen pour la Suisse (un peu moins de 4000.- brut / mois), je fais partie des 1% personnes les plus riches du monde, d'après le site GlobalRichList.

Imaginez ce que ça sera quand je toucherai mon salaire de ministre ;)

Plus sérieusement, voici une preuve criante que les richesses sont mal réparties.

Arriverons-nous à faire en sorte que la fossé qui sépare les riches des autres ne s'élargisse pas trop ? Un défi pour l'avenir autant important que l'environnement...

Bug de l'an 2038

2006-11-22T13:31:00.000+01:00

Le format Unix pour les dates, c'est-à-dire le nombre de secondes depuis le 1er janvier 1970, est une très bonne chose car ça représentation est très compact, on peut facilement comparer 2 dates, calculer des intervalles, etc.

Le seul problème qui en découle est que son implémentation sous forme d'entier, 32 bits sur la majorité des systèmes actuels, et condamné à subir un integer overflow, et ce dans un peu plus de (2^^32 / 3600 / 24 / 365 =) 136 ans à partir de la date de référence si la date est codée en entier non signé, (2^^31 / 3600 / 24 / 365 =) 68 ans si le codage est signé, c'est-à-dire vers l'an 2106 ou 2038 respectivement.
Il nous reste de beaux jours devant nous, mais cela montre à quel point on est incapable de ne pas reproduire le bug de l'an 2000...

Quand Internet remplace les systèmes experts

2006-11-17T08:17:00.000+01:00

Un article paru dans Info-du-net parlant de l'élaboration de diagnostiques pour des maladies montre à quel point la base de données "Internet" peut devenir utile en cas d'utilisation judicieuse :

Un système expert est une base de données de règles et de conditions qui nous amène, en posant des questions sur les symptômes, à un diagnostique précis du problème. C'est donc une base de données contenant tous les symptômes possibles, avec des relations entre eux, que l'on peut questionner. Un système expert n'est utile que si il contient une liste exhaustive des symptômes.

On remarque donc directement une ressemblance frappante avec Internet (ou du moins un moteur de recherche tel que Google) : une base de données que l'on peut questionner.

Internet devient donc un système expert grâce à la contribution des gens dans leurs domaines d'application. Toutefois la différence entre un système expert et Internet, c'est que la base du premier est constituée par des spécialistes et, si elle n'est pas exhaustive, elle est au moins fiable, alors que n'importe bien que la base Internet se met à jour en temps réel, n'importe qui peut y contribuer, même ceux qui n'y connaissent rien au domaine...

Entretien d'embauche avec Google

2006-11-16T07:58:00.000+01:00

Les RH de Google m'ont contacté il y a maintenant 3 semaines afin de me faire passer la première étape de leur entretien d'embauche.

L'interview, technique, c'est déroulé en 2 parties de 45 minutes chacune, durant lesquelles un ingénieur Google m'a posé des questions techniques. Apparemment il n'y avait pas un nombre défini de questions, mais tant qu'une réponse jugé satisfaisante était trouvée, on passait à une autre, inventée on the fly mais en relation avec notre CV.

Voici un petit aperçu des 10 questions auxquelles j'ai réussi à répondre. Elles sont traduites en franglais_geek1 pour les besoins du billet, et je n'y fait figurer que celles que j'ai trouvé intéressantes ou qui sont faciles d'exposer sur un blog :

Implémentez en C la fonction assert(i > 0) de manière à ce que la condition "i > 0" soit affichée en cas d'erreur
Même chose en C++, afin que le code suivant soit bien formé :
assert(i > 0) << "message" << i ;
Triez un tableau d'un million d'entier (int sur 4 bytes) stockée sur un disque dur en ne disposant qu'une mémoire de 2 MB. Comment vous y prenez vous ?
Implémentez une classe qui contient 3 méthodes :
- void push(int)
- int pop()
- int minimum()
dont les 3 méthodes s'exécute avec une complexité en O(1)
Trouvez une méthode efficace qui permet de détecter une boucle dans une liste chainée, sans pouvoir modifier les éléments de la liste ni recopier en entier la liste.

Les questions sont posées sans temps de préparation, ni ordinateur ou autres documents d'aide. On remarquera que les réponses, une fois connue, ne sont pas si compliquées qu'elles en auraient l'air.

1. Première hypothèse, avant que l'expert ne précise que la condition "i > 0" doit être affichée :

void assert (int cond) {
  if (cond == 0) {
    printf("Erreur");
    exit(1);
  }
}

Le problème se corse quand il s'agit d'afficher textuellement "i > 0", car en passant par un argument, il sera évalué avant d'être passer par valeur, donc on perd toute chance de pouvoir l'afficher. Ma deuxième version en passant un pointeur de fonction en paramètre s'est vite avérée fastidieuse, et l'idée d'utiliser par une marco et ses possibilités de manipulation de strings m'a soudain frappée, pour finalement donner quelque chose :

#define assert(cond) if ((cond) == 0) { \
  printf("Erreur "); \
  printf(#(cond)); \
  exit(1); \
}

2. Une fois la première question complétée, la deuxième est devenue triviale : il suffit d'ajouter cout à la fin de la macro pour que si la condition était différente de 0, on continue avec cout.

#define assert(cond) if ((cond) == 0) { \
  printf("Erreur "); \
  printf(#(cond)); \
  exit(1); \
} \
cout

3. 1 million d'entiers sur 4 bytes nous fait 4MB, donc trop pour tenir en entier dans la mémoire. Il faut donc partager le tableau en 2, trier chaque partie en utilisant n'importe quel algorithme de tri, puis fusionner les 2 tableaux à l'aide d'un tri par fusion.

4. La complexité en O(1) nous suggère directement l'utilisation d'une liste chainée. Push et pop deviennent donc trivial, push ajoute l'élément à en tête de liste, pop retourne en enlève le premier élément de la liste.
Le problème se pose maintenant pour la méthode qui retourne le minimum, qui est doit aussi se faire en O(1). Il est donc impossible de faire une recherche, car aucune méthode de recherche n'est en O(1). L'idée est donc de maintenir une deuxième liste chainée qui contiendra ces minimums. Donc on modifie push pour tester si la valeur à ajouter est plus petite OU EGALE au minimum, et si c'est le cas on ajoute aussi l'élément dans la liste des minimums, et pop pour enlever l'élément de la liste des minimums si cet élément est le minimum.

En pseudo Java ça nous donne quelque chose du style :

LinkedList l;
LinkedList m;
void push (int e) {
  if (e <= m.top()) {
    m.push(e);
  }
  l.push(e);
}
int pop() {
  int e = l.pop();
  if (e == l.top()) {
    l.pop();
  }
  return e;
}
int minimum() {
  return m.top();
}

5. La solution trivial qui est de marquer les noeuds parcourus n'est pas envisageable, car elle sous-entendrait de modifier le contenu des noeuds, ce qui n'est justement pas possible.
Une bonne solution est donc d'inverser les liens en parcourant la liste, et si on revient au noeud initial on sera sûr d'avoir une boucle. En parcourant la liste dans l'ordre inverse et en réinversant les liens, il est possible de remettre la liste dans l'état qu'on avait avant de débuter la recherche. A noter qu'il est impératif de s'assurer qu'un seul processus n'accède à la liste en simultané, car durant la recherche la liste est modifiée.

2 entretiens sur 6, prochain épisode pour bientôt j'espère...

PHP Multithread

2006-11-08T14:37:00.000+01:00

Non, faire tourner PHP en multithread n'est pas un mythe !
C'est possible de lancer des processus fils grâce au module pcntl, et à les synchroniser avec le module sémaphore, de préférence en ligne de commande (la doc précise que leur utilisation en module apache peut amener à des résultats erronés).

Voici donc un petit article qui démontre par un exemple comment implémenter un démon multithread en PHP.

Covoiturage

2006-10-11T08:24:00.000+02:00

Premier jour de covoiturage. Tout c’est bien passé, à part une petite frayeur dans un bouchon.

Je ne peux pas encore me prononcer sur les effets à long terme du covoiturage, mais j’ai déjà trouvé que c’était plus sympa le trajet à 2. L'heure de trajet est passée bien plus vite, et suivant les personnes qui accompagnent, les échanges peuvent être intéressants et constructifs.

Dès la semaine prochaine on charge 2 personnes supplémentaires.

On a l’air vachement moins égoïste à 2-3 dans une voiture…

Un serveur en overload

2006-10-11T07:53:00.000+02:00

Quels sont les signes qu'un serveur est en overload ?

La réponse est relativement simple un outil de monitoring tel que mrtg ou maintenant rrdtool est installé sur le serveur.

Considérons le graphique suivant :

Il représente la charge d'un serveur sur une moyenne journalière, avec en y le % de charge. Dès juillet, l'augmentation de la charge non négligeable que subit le serveur est un signe qu'il faut envisager rapidement un remplacement par une machine plus puissante. L'augmentation est linéaire, elle nous permet donc une bonne projection et donc une bonne prévision de quand le serveur arrivera à une charge moyenne de 100%.

Les billets de mon ancien blog

2006-10-10T22:54:00.000+02:00

Comme je l'ai dit ici, je compte utiliser régulièrement ce blog. Et en fonction du temps disponible, je vais faire revivre d'ancien billet qui sont partis aux oubliettes en même temps que mon ancien blog.

Ne soyez donc pas surpris de voir des billets qui commencent par "Initialement posté sur Noisette.ch", ce billet vont s'entremêler aux nouveaux.

Linked In

2006-10-02T11:51:00.001+02:00

Après avoir reçu plusieurs invitations d'amis et collègues, j'ai finalement rejoins la grande famille de LinkdeIn, sur lequel vous pouvez consulter mon profile et mes connexions : http://www.linkedin.com/in/benoitperroud

Je ne sais pas encore si ce site va me servir pour trouver un futur emploi, mais j'ai trouvé le concept intéressant, et je compte bien arriver à plus de 90% dans toutes les options :)

Les algorithmes de recherche binaire et par fusion sont bogués

2006-09-29T08:45:00.000+02:00

C'est la constatation alarmante qu'a fait Joshua Bloch, Software développeur chez Google, dans son article Nearly All Binary Searches and Mergesorts are Broken (Presque tous les algorithme de recherche binaire et par fusion sont bogués) et il en explique précisément la cause.

Il cite en exemple la méthode binarySearch de la librairie java.util.Arrays, qu'il a lui même écrit avant de quitter Sun.

La ligne contenant ce bug est la suivante :

int mid = (low + high) / 2;

Le bug en question est un "bête" integer overflow qui peut apparaître si on manipule un tableau de l'ordre de plus de 2^30 éléments.

Le plus dérangeant dans cette histoire banale est que ce genre de bug, pourtant trouvé dans une routine de peu de lignes, est passé inaperçu pendant près de 60 ans.

Cet exemple démontre très précisément qu'il est impossible d'écrire du code sans bugs, et que donc les prochaines améliorations seront plus d'en limiter les conséquences que de les éradiquer.

Gentoo avec Apache2 + PHP5 + Suexec + FastCGI (dynamic)

2006-09-26T08:10:00.001+02:00

FastCGI est un concept tout à fait intéressant qui permet, dans le cadre de PHP, d'allier rapidité et sécurité. Il permet conjointement d'avoir la rapidité de mod_php avec la sécurité de PHP/CGI, notemment en terme de droits d'utilisateurs.
Je ne vais pas vous refaire une série de benchmark comme c'est le cas sur beaucoup d'autre site, mais je viens de réaliser un article explicant en détail l'installation, la configuration et surtout les problèmes qu'on peut rencontrer avec la mise en place PHP, FastCGI dynamique et Suexec :

Configuration de PHP avec FastCGI et Suexec pour Apache2

Pourquoi les mots "Chers Concitoyens"

2006-09-26T08:10:00.000+02:00

Je ne souhaite pas vraiment m'étendre sur des discours politiques car ceux-ci ne sont pas ma tasse de thé, et encore moins dans l'esprit que je compte tenir sur mon blog.

Mais au lendemain des votations fédérales sur le durcissement du droit d'asile, le préfix "con" du terme concitoyens retrouve tout son sens.

La question est donc lancée : « Mais qu’avez-vous donc fait ? ». Seul l’avenir nous le dira...

Mes cours de Master : terminés

2006-09-21T08:08:00.000+02:00

Alors que mon travail de diplôme est déjà bien entamé, je voulais juste m'arrêter un peu sur mes résultats du Master à l'EPFL.

Le détail des notes peut être trouvé sur mon site : Mes notes de Master, et il y a 2 choses importantes à relever : 5.57 de moyenne (sur 6) sur l'année, et aucune note en dessous de 5.

Ce que j'aimerais montrer par là, ce n'est pas combien je suis fort et tout, loin de moi cette idée narcissique, mais plutôt qu'avec de la motivation et de la persévérance, on arrive à nos fins (et en passant faire un clin d'oeil à certains détracteurs du redoublement dans les universités, mais une réponse plus complète viendra peut-être dans un autre billet, intitulé quelque chose comme "L'apprentissage par l'échec").

La motivation est une capacité merveilleuse dont nous a dotés mère Nature, grâce à laquelle on peut bouger des montagnes. La motivation donne des ailes, décuple les forces, mais ne serait qu'un feu de paille si la persévérance ne prenait pas la relève. La persévérance, elle, est plutôt une discipline de vie, une force mentale qui, si elle est utilisée à outrance, se transforme rapidement en obstination.

J'ai appris, après deux échecs, à dompter ma motivation, puis j'ai cultivé ma persévérance pour finalement arriver là ou j'en suis aujourd'hui, en train de faire mon travail de diplôme dans le groupe Kudelski. Et je suis convaincu que refaire la deuxième année était pour moi la meilleure chose, tant cette année est importante sur le plan théorique. Finir une branche avec juste la moyenne, c'est suffisant, mais à mes yeux actuels ça n'est pas assez pour prétendre avoir compris les finesses de la matière et pouvoir tisser des liens avec d'autres branches. J'ai réussi à le faire grâce au travail, et ça se ressent à beaucoup de niveaux.

Le travail n'est pas une source de frustration, bien au contraire. Et la recette en est bien simple :

Immergez-vous dans un projet,
Adoptez un état d'esprit positif et la motivation grandira d'elle-même,
Fixez-vous des objectifs à court et moyen terme pour favoriser la persévérance.

Système de réécriture d'URL (URL Rewriting)

2006-09-20T08:08:00.000+02:00

Les systèmes de réécriture d'URL posent rapidement des problèmes de scalabilité pour un site générant un trafic respectable (genre dès 1000 visiteurs uniques par jour). Je l'ai déjà exprimé dans un précédent article : Mambo 404 SEF, et souhaite maintenant apporter un design de solution.

Une technique relativement simple pour palier à ce problème de VARCHAR non- ou mal -indexable est d'introduire une variable aléatoire dans l'URL, variable à partir de laquelle la vrai URL sera chargée : www.domaine.com/14523623423/news/ma_premiere_news.html
L'important dans cet URL est donc la variable 14523623423, alors que ce qui se situe après n'a aucune importance et peut être modifié à souhait (on remarque aussi ici que cette technique permet rapidement de mettre un place de l'URL flooding, utilisants des URLs de toute sorte pour pointer sur la même page. Attention à ne pas en abuser, car on risque de voir son site se faire bannir des moteurs de recherche).

La requête SQL devient donc

SELECT realurl FROM redirections WHERE urlid = 14523623423

Mieux ça non ? Le problème évoqué ici est en fait global à tout design de base de données : les champs utilisés sans intervention d'un utilisateur dans une condition devraient toujours être de type entier ou un dérivé. Car même si les chaines de caractères sont relativement rapide lors des tests, la réaction à haute charge est très souvent mauvaise...

La vie d'un Troll

2006-09-16T08:06:00.000+02:00

Un Troll, en informatique, est une polémique acharnée et sans fin (souvent sur un forum ou une mailing liste). La nature du Troll n'est jamais constructive , et, comme le disait Tristan Nitot, le Troll ne grossit que si on le nourrit. Si on l'ignore il se meurt de lui-même.

Le nom Troll vient d'analogies aux mondes fantatstiques, notamment Donjon et Dragon dans lequel les Trolls ont une grande capacité de régénération.

Si vous voyez un Troll, partez en courant. Au mieux il ne vous fera que perdre du temps...

Explication du Troll en DB.

Les quinze jours décisifs des cours à option

2006-09-15T08:05:00.000+02:00

Texte à paraître dans la brochure de valorisation du Collège des Humanités de l'EPFL

Le processus de décision qui conduit les étudiants à choisir tel ou tel cours à option, au terme des deux semaines qui précèdent l’inscription définitive, est loin d’être aussi anecdotique qu’il n’y paraît. En effet, de tels libres choix ont souvent une influence décisive sur l’orientation future d’une carrière.

Un sérieux instrument statistique à l’appui, les six auteurs de l’étude ont interpellé leurs camarades sur la perception de leurs propres compétences face au cours envisagé, l’intérêt suscité, l’utilité estimée, les qualités du professeur, la difficulté du cours, le degré d’autonomie et les liens sociaux entretenus entre étudiants. 62 personnes, soit 43 hommes et 19 femmes, ont répondu. Cette enquête devrait éclairer les processus de décision mais aussi offrir aux enseignants un outil de réflexion sur les moyens à leur disposition pour stimuler la motivation intrinsèque des étudiants, sans laquelle il n’y a pas d’apprentissage optimal.

La première bonne nouvelle qui se dégage des résultats obtenus repose sur le fait que les étudiants opèrent majoritairement des choix qui épousent au mieux leur plaisir et leur intérêt. Les chiffres sont éloquents : la volonté de maîtriser un nouveau domaine qui séduit, donc de relever un nouveau défi, passe nettement avant des objectifs de performance liés à des critères de type utilitaire.

Mais l’un des points les plus intéressants que l’étude met au jour concerne les étudiants dits « faiblement auto-efficaces », c’est-à-dire ceux qui doutent de leur capacité à maîtriser une branche. Face à ce « public réticent », les professeurs sont capables de renverser la vapeur et de convaincre durant ces deux semaines cruciales, mais à trois conditions : qu’ils clarifient les buts du cours, favorisent le comportement autonome de leurs étudiants et privilégient l’écoute de leurs besoins personnels. C’est effectivement autour de ces trois axes que s’articule l’auto-détermination des étudiants, caractérisée par le goût du risque, une ouverture plus grande à l’apprentissage, et donc une motivation plus élevée.

Tiré de : L’influence des deux premières semaines de cours, avant l’inscription définitive, sur la motivation autonome des étudiants à choisir un cours et le rôle de l’auto-efficacité dans ce choix

Auteurs : Loana Chatelain,Benoît Perroud, étudiant en informatique
Laura Derksen, Sarah Emery, François-Xavier Meuwly, étudiants en mathématiques
Guillaume Schmit, étudiant en microtechnique

Sous la direction de Fabrizio Butera et Régis Scheidegger, faculté des sciences sociales et politiques, Université de Lausanne

Comment gagner à l'Euromillion

2006-09-15T08:04:00.001+02:00

Ou plutôt : Quels numéros jouer à la loterie ?

Si j'étais un joueur de loterie assidu, mon principal problème serait de trouver chaque semaine des numéros différents pour compléter mon année de naissance et celle de ma copine. Cette semaine, je serais tenté de jouer des numéros comme le 2, 4, 21 ou 37, car le Pape est mort le 2 du 4 à 21h37.

Mais l'idée d'utiliser random.org m'est apparue en écrivant un autre article (Un espace d'administration par email).

Quoi de mieux que de se faire générer ses numéros par un vrai générateur aléatoire ?

Pour l'Euromillion par exemple, essayez :

Bon jeu et bonne chance !

Réflexion sur le comportement des gens sur la route

2006-09-15T08:03:00.000+02:00

Un accident sur l'autoroute provoque deux bouchons. C'est du moins l'expérience que j'ai vécu hier en rentrant du travail.

Oui j'ai bien dit deux bouchons, un naturellement du côté où la circulation est perturbée, mais c'est là que la problématique se pose, il provoque aussi un bouchon en sens inverse...

La raison en est aussi simple que malheureuse, c'est que les gens, dans leur immense indélicatesse, freinent pour regarder ce qu'il s'est passé (en l'occurrence une voiture carbonisée sur le toit, vu qu'on roulait au pas j'ai aussi tourné la tête), et pour se dire :

Oh il n'a pas de chance celui-là, mais il devait certainement mal conduire, ce qui n'est pas mon cas.

Mais ils ne se sont pas rendu compte que ceux de derrière ont dû planter sur les freins afin de ne pas les emboutir, et qu'en l'état de surcharge de trafic actuel, le moindre ralentissement peut devenir un danger redoutable.

Mais tout ce complique quand d'autres personnes, encore moins intéressés par le malheureux sort de conducteur de la voiture accidentée et ses éventuels passagers, commence à dépasser par la droit. Et je ne ferai aucun commentaire sur les voitures, de taille inversement proportionnelle à leur capacités sociales, dans lesquelles ces gens roulent.

En l'espace de quelques secondes, c'est donc un tableau tout à fait représentatif de notre société qui s'est peint de lui-même sur une autoroute...

Envoyer un mail pour créer automatiquement un message

2006-09-14T07:58:00.000+02:00

Voilà une petite fonction intégrée au sein du site qui va faire au moins un heureux. Car mes idées de billets surviennent forcément à des moments où je n'ai pas de connexion internet. Et comme il est impossible de rédiger un billet hors-ligne avec blogger (Quelqu'un me souffle que des plugins ont été fait pour palier à ce problème), l'envoie de mails est pour moi une facilité appréciée.

Pourquoi un blog sur blogger.com et pas sur noisette.ch ?

2006-09-14T07:54:00.000+02:00

La question est simple : avec tous les moyens que j'ai à disposition pour héberger mon propre blog, pourquoi est-ce que je l'héberge sur blogger.com ?

La réponse ne l'est certes un peu moins, mais voici quelques points important de ma décision :

L'indexation du blog est plus rapide et meilleure sur blogger.com, et donc mon Wiki de 2 noisettes en bénéficiera des retombées
La manipulation des données, notamment des dates est impossible sur blogger.com, les articles ici postés témoignent d'une plus grande crédibilité
La curiosité de tester ce qui pousse autant de personne de se tourner vers blogger.com

J'espère simplement que ce choix nous (les lecteurs de mes tickets intéressants et moi-même) sera effectivement profitable, et dans le cas contraire un remaniement de mon blog est toujours possible.

Après le pull, le blog

2006-09-14T07:51:00.000+02:00

Ca fait maintenant plus d'une année que j'ai acheté un pull blogger.com, alors je fête ça en me créant un vrai blog. Ca risque de déplaire à ma maman qui n'est pas pour ce genre de pratique, mais quand je lui aurai démontré le bienfondé des blogs, peut-être approuvera-t-elle au moins celui-ci...

L'union fait la force

2006-06-06T07:55:00.000+02:00

Initialement posté sur Noisette.ch par KillerWhile le 05.06.2005

Si on en croit le sens commun, plus on est de personne pour tirer à une corde, plus on tire fort sur la corde.

Cette constatation est vrai dans le sens ou si une personne tire sur une corde et lève 120 kilos, deux personnes n'auront aucun problème à lever plus.

Là où le dicton atteint ces limites, c'est quand on prédit que si une personne lève 120 kilos, 2 personnes en lèvent 240 kilos, 3 personnes 360 kilos, et ainsi de suite.

Un expérience menée initialement par Ringelmann en 1913 puis par Ingham et al. en 1974 montrent qu'une personne en groupe lève 20% de moins que seul.

En résumé, 2 personnes soulèvent plus qu'une, mais proportionnellement, un personne soulève plus que 2.

(Mon colloque (the economist) me souffle que ça s'appelle un rendement décroissant. En psychologie sociale, on parle de paresse sociale...)

404 SEF, un mode Mambo génial ... en apparence

2006-04-25T08:07:00.000+02:00

Initialement posté sur Noisette.ch par KillerWhile le 29.04.2006

404 SEF est un composant de Mambo/Joomla qui a pour but de permettre de disposer d'adresses amicales (userfriendly) pour afficher les pages. Sur le papier, c'est vraiment super utile car ça permet une bonne indexation auprès des moteurs de recherche. En pratique, c'est un calvaire pour les administrateurs des serveurs sur lesquelles tourne ce composant.

Explication : un page www.domaine.com/news/ma_premiere_news.html va devoir faire une requête dans la base de données pour savoir vers quelle url réelle news/ma_premiere_news.html pointe. Ca signifie une requête du style

SELECT realurl from jos_redirection WHERE fakeurl = 'news/ma_premiere_news.html'

Cette requête, qui recherche donc une valeur dans un champs VARCHAR et donc ne peut pas utiliser d'index, est vraiment sous-optimale et devient un syphon en terme de ressources sql.

Une chose à faire donc : changer de composant de réécriture d'url (je n'en ai malheureusement pas encore de nouveau à proposer) ou s'en passer.

Diffusion pour du pognon

2006-01-20T08:07:00.000+01:00

Initialement posté sur Noisette.ch par KillerWhile le 19.01.2006

Sous ce terme quelque peu familier je cherche à informer et mettre en garde les internautes contre les '''ventes pyramidales'''.

Cette pratique a trouvé comme nouveau filon de diffusion les réseaux peer-to-peer, par lequel une grande masse de personne peut être rapidement touchée. Ainsi de nombreux fichiers contiennent des messages publicitaire évocateur qui promettent de gagner beaucoup en ne faisant pas grand chose.

Cette pratique, pratiquée depuis le siècle passé avec les célèbres chaines de lettre, en plus d'être illégale en vertu des lois sur le commerce, n'est jamais gagnante pour l'utilisateur final.

Le problème (ou l'avantage, ça dépend d'où on se place) de ce concept, c'est qu'il est très simple d'en comprendre le principe, qui théoriquement fonctionne à merveille (Si on doit versé 1€ à 6 personnes, puis se placer en 6ème position, qu'on envoie cette liste à 10 personnes qui eux l'enverrons à 10 autres, on gagne 10€ au premier niveau, puis 100€, puis 1000€, etc jusqu'au 6ème niveau ou vous toucheriez 1'000'000€. Alléchant, non), mais qu'il est plus dur d'en percevoir les limitations.

Il y a un nombre limité de participants potentiel (le 1'000'000 de personne qui vous donne 1€ va vouloir à son tour touver 1'000'000 de personnes chacune, ce qui nous fait 1'000'000'000'000 (il faudrait donc 1'000 milliards de personnes, sachant que la terre en compte 7, il faut trouver 993 milliards d'extra-terrestres). Donc tôt ou tard (mais plutôt tôt que tard), il n'y aura plus suffisamment de monde pour participer à la chaine, qui s'arrêtera et toute la base de la pyramide n'aura pas reçu 1 seul €.

Tout l'argent que vous gagner, quelqu'un d'autre l'a perdu. Si vous gagner 1000€, 1000 personnes ont perdu 1€. Même si les montants des pertes ne sont pas importants, le montant total peut représenter de lourdes pertes économiquement parlant.

Référence sur Wikipedia (en anglais) :

Et une autre très bonne référence : http://members.impulse.net/~thebob/Pyramid.html

Fribot 2005

2005-07-19T08:12:00.000+02:00

Initialement posté sur Noisette.ch par KillerWhile le 18.07.2005

Après 2 premières manches lamentables, on finit toute de même à la 3ème place en étant la seule équipe à faire tomber toutes les quilles en moins de 3 minutes. L'équipe, composée de Christoph Walker, Sébastien Perroud (mon grand frère) et Thierry Gachet à la mécanique, et de Marius Erni et moi à la programmation gagne aussi le prix du meilleur code, en utilisant toutes les techniques possibles avec l'API Lejos sur le microprocesseur RCX.

Fribot est un concours de robot sur une journée, où le but est de construire et programmer un robot lego Mindstorm pour qu'il accomplisse une tâche présentée le matin même.
Le but cette année avait un petit gout de Eurobot, car on travaillait sur le même plateau de jeu. Il fallait mettre 2 ballons de rugby dans un trou, traverser un pont et descendre de quilles de l'autre côté. Le tout en un temps maximum de 3 minutes.

Marius et Benoit Après une première phase de réflexion, Marius et moi attaquons le code. On divise le jeu en 3 parties : une partie pour pousser les balles de rugby, une autre pour traverser le pont, et la dernière pour descendre les quilles et ne pas quitter le plateau de jeu.
Nos 2 premières manches ont été catastrophiques : une balle de poussée à la première, et rien du tout à la deuxième... On décide alors de réimplémenter tout le code avec des Behavior et un Arbitrator. La technique s'avère payante, d'une part parce que le robot n'a plus du tout un comportement aléatoire, mais d'autre part il nous permet de descendre 10 quilles lors de la 3ème manche, et nous permet d'accéder à la petite finale, ou on a simplement cartonné en faisant tomber une balle de rugby et les 16 quilles !

Et nous procure une joie non dissimulée, ainsi que le prix du meilleur code.

Gagner de l'argent grâce aux botnets

2004-08-24T08:04:00.000+02:00

Initialement posté sur Noisette.ch par KillerWhile le 23.08.2004

Définition

Les botnets sont des réseaux d'ordinateurs reliés à internet, sur lesquels ont été installés des logiciels à l'insu de leurs propriétaires. Ces zombies réagissent à des instructions précisent, permettant principalement de paralyser des sites par des attaques pas déni de service ou de relayer des spams en grande quantitée.

Voir aussi la définition d'un Botnet sur Wikipedia.

Construction

A l'heure actuelle, entre les exploits publiques et les proof of concept, beaucoup d'exemple de codes existent sur internet à partir desquels on peut infecter des machines pour construire son botnet.

Rémunération

Illégales
Deux méthodes illégales sont actuellement utilisées pour tirer profit d'un botnet :

Le racket de site : on lance un dos sur un site et on arrête uniquement si le webmaster paie une rançon. C'est risqué mais en ciblant bien les victimes, ca peut rapporter gros.
La revente de services à d'autres tiers.

Légales !
D'autres techniques sont un peu plus légales, mais je ne m'y aventurerais quand même pas :
Utiliser son botnet pour augmenter le trafic (raisonnablement) sur un site web, et générer par la même occasion des cliques sur des publicités présentes sur le site.
Bien que cette technique puisse aussi être utilisée pour faire payer cher un annonceur, une utilisation plus rationnelle permettrait de se générer de gros revenus (de l'ordre du millier d'euro par mois).

Résumé

Benoit Perroud : concepts and cloud ready applications

Cassandra, hector, maven and tomcat

More Interview Questions

NoSQL Overview @Webmardi

Eventually Consistency demystified

DNSSEC NSEC3 domain hash computation algorithm

Using java.net.InetAddress.getByName() to validate an IP Address may be too permissive

Moving from ELCA to Verisign

Dealing with old SSL certificats (algorithm check failed: MD2withRSA is disabled)

Java and certificate's mess : blind SSL factory for commons httpClient

Implementing unique constraints with Cassandra

Doodle clone with Cassandra backend

Don't be abused by the term "commodity hardware"

Sequences scalability

Call different services, use the first to reply

Clustering Jackrabbit 1.5.x with DataStore configuration

Des nombres à usage unique (nonce)

Implémentation d'un serveur proxy HTTP

Mettre à mal un réseau d'entreprise avec Outlook (TM, R & CO)

Une liste de USER AGENTS parsable

De la concurrence des requêtes SQL

Vos données sont-elles réellement privées ?

Je télécharge mes MP3 et les écoute légalement.

Offrir un réseau wifi ouvert pour rentabiliser sa connexion Internet

Twitter, un vrai service Web 2.0 (le retour)

Twitter, un vrai service Web 2.0

Getting Things Done® (GTD® aussi) : le sydrome du "Ca c'est fait !"

60 millions de hashes md5 !

Fonction url_get_contents en PHP

Reverse MD5 databases aggregator

Contourner le blocage du port SMTP

Création manuelle d'un botnet "localisé"

La surjection, nouvelle maladie ?

Implémentation paresseuse du "Visitor pattern" en PHP

Offre d'emploi : customer care

Algue? piézo-phosphorescente

Générateur automatique de visualisation de site

Uniqid ou la contre-intuitivité des arguments

Types ENUM avec MySQL

Mysql NT vs Unix : quand les systèmes de fichier font des différences

Citer Montaigne quand on parle d'informatique

Je sers mon pays...

Un ingénieur, un vrai

Camp de ski avec l'école primaire de Prez-vers-Noréaz

Travail de Master : quelques chiffres (suite)

Bon anniversaire !

Travail de Master : quelques chiffres

Article de L'Objectif

Digression sur l'incohérence entre les discours et les actions

PEAR::Mail_Queue2

Tarpitting, ou comment faire perdre de l'argent aux spammers

De la sécurité des sessions PHP

A quoi juge-t-on qu'on est trop "geek" ?

Une authentification sur les serveurs smtp des providers

Les 7 règles fondamentales en sécurité

Statistiques fournies par FeedBurner

Form flooding

We are losing this war badly

Nabuchodonosor, Roi de Babylone, écrivez-moi cela en 4 lettres.

Optimisation du nombre de requêtes SQL dans les collections d'objets et relation n-m

Lettre au père Noël

Samourai

De l'art d'éviter les requêtes SQL inutiles

Bonne année (2007) !

Surchages de méthodes statiques en PHP

Spam image

Ryzom, un MMORPG désormais libre

Reverse MD5

Gentoo sur la PS3

Une nouvelle bulle internet en formation ?

Recrutement Google, étape #2

I'm the 58,920,569 richest person on earth!

Bug de l'an 2038

Quand Internet remplace les systèmes experts

Entretien d'embauche avec Google

PHP Multithread

Covoiturage

Un serveur en overload

Les billets de mon ancien blog

Linked In