1&1, un service client plutôt distant…

Internet — Tags :, — admin @ 15:00

Après une surcharge au niveau des téléchargements sur notre petit espace gratuit que nous avait alloué Free, j’ai décidé de migrer vers un nouvel hébergeur. Ayant un ami chez 1&1 qui pouvait me parrainer, j’ai accepté d’aller chez eux. Notre ancien blog était localisé sur Free, et on avait acheté le domaine nathetnico.fr à partir de Gandi qui faisait une simple redirection. J’en ai profité pour faire migrer notre blog et ait commencé un transfert de domaine entre Gandi et 1&1.

3 semaines plus tard, ne recevant aucune nouvelle de la part de 1&1, j’ai décidé de prendre les choses en main et d’essayer de les contacter. C’est alors que je me suis heurté à un mur bien sourd! Le premier écran était pourtant assez encourageant!!

Leur numéro de téléphone étant assez cher, j’ai cherché, en vain, une adresse email pour leur écrire. Après de nombreuses recherches sur leur FAQ assez mal fait, je tentais de correspondre avec eux directement.

Voici ce que l’on rencontre lorsque l’on cherche désespérément une personne a qui demander de l’aide…

C’est alors que l’on doit rentrer un simple code de vérification pour pouvoir envoyer un email. Ce genre de code de vérification est d’habitude utilisé pour éviter que des scripts envoient des emails automatiquement (évitant ainsi que des malins envoient un peu trop d’emails à la fois). Mais la, j’avais l’impression que le service client avait plutôt utilisé ce procédé pour écarter toutes les personnes essayant de les joindre!! J’ai passé plus de 30 mins avant de me décourager, j’ai demandé à qq amis d’essayer mais sans résultat… On confond les 0 et les O, les 1, les l, les L, les |… Et vous, y arriverez-vous, ou trouverez vous le service client de 1&1 tout aussi distant que moi?

[edit] : ils ont apparemment modifié leur système et ça a enfin l’air de fonctionner…

Ecrire en Latex facilement

Etudes, Internet — Tags : — admin @ 17:08

Le Latex… Certains scientifiques l’appelleront leur “langage fétiche” car il leur permet entre autres de faire de très belles formules sur des pages web. En fait, le LaTeX est plutôt une collection de macro-commandes permettant une mise en forme du processeur de texte Tex. (en fait, le nom LaTeX vient de l’informaticien américain Leslie Lamport et du processeur Tex).

Il existe sur Internet un site très intéressant qui permettait de créer facilement ses formules mathématiques en Latex : http://www.codecogs.com/components/equationeditor/equationeditor.php

Vous pourrez ainsi visualiser le résultat automatiquement, puis directement écrire du Latex dans votre code HTML, en attendant que les tags deviennent un standard!!

Allez hop on va résoudre un petit problème sympa pour le plaisir :
Combien de fois (x) doit-on plier une feuille de papier pour atteindre la lune?
épaisseur d’une feuille (p) = 0.2mm
distance terre-lune (d) = 370000km
Ceci revient à résoudre l’inéquation suivante : p * 2^x > d
On passe au log en faisant attention à l’inéquation: x > \frac{\lg d - \lg p}{\lg 2} puis x > \frac{\lg (\frac{d}{p})}{\lg 2}

On fait l’appli numérique :

x > \frac{\lg (\frac{3.7*10^8}{0.0002})}{\lg 2}

Ce qui nous donne :

x >= 41 car x \epsilon \textrm{N}

Voila… Je vous laisse prendre une feuille de papier et la plier 41 fois pour atteindre la lune.

Ces longs raccourcis

C/C++ — Tags :, , — admin @ 9:58

Certains raccourcis peuvent parfois ralonger certaines routes. Par example, il est souvent requis d’échanger deux variables entre elles. Pour peu que cet échange doive avoir lieu au sein d’une boucle, disons pour un affichage fluide par ex., on va chercher à en optimiser l’échange.

De manière logique, on pense de suite à utiliser une variable intermédiaire :

  1. void main()
  2. {
  3.    int a = 0;
  4.    int b = 1;
  5.    int c;
  6.  
  7.    // swap utilisant une 3e variable
  8.    c = a;
  9.    a = b;
  10.    b = c;
  11. }

Cette méthode a beau avoir certains défauts, elle est en tout cas très clair.

Il y a pourtant plus court à écrire :

  1. void main()
  2. {
  3.    int a = 0;
  4.    int b = 1;
  5.  
  6.    // en une ligne!
  7.    a+=b-=a=b-a;
  8. }

Ou du moins c’est ce que l’on pourrait croire… Regardons le code assembleur généré par les deux corps de programmes précédents:

Swap à 3 variables :

  1. push        edi                         ; preparer de la place
  2. push        esi                         ; pour 3 variables
  3. push        ebx  
  4. cmp         dword ptr ds:[00312E08h],0
  5. je          00000011
  6. call        78ACB4AF
  7. xor         esi,esi                     ; a = 0
  8. xor         edi,edi                     ; b = 0
  9. xor         ebx,ebx                     ; c = 0
  10. xor         esi,esi                     ; a = 0
  11. mov         edi,1                       ; b = 1
  12. mov         ebx,esi                     ; c = a
  13. mov         esi,edi                     ; a = b
  14. mov         edi,ebx                     ; b = c

Swap en une ligne :

  1. push        edi                         ; preparer de la place
  2. push        esi                         ; pour 2 variables
  3. cmp         dword ptr ds:[003F2E08h],0
  4. je          00000010
  5. call        7963B4AF
  6. xor         esi,esi                     ; a = 0
  7. xor         edi,edi                     ; b = 0
  8. xor         esi,esi                     ; a = 0
  9. mov         edi,1                       ; b = 1
  10. mov         eax,edi                     ; eax = reg. temporaire
  11. sub         eax,esi                     ; eax = b - a
  12. mov         esi,eax                     ; a = b - a
  13. sub         edi,esi                     ; b = b - a
  14. add         esi,edi                     ; a = a + b

On économise peut-être du tps en n’allouant pas de place pour une troisième variable, on le paye plus tard. Au final, le swap en une seule ligne prendra légèrement plus de temps que le swap sur 3 lignes. Plus important encore, le swap en une ligne est beaucoup moins lisible… Autant donc travailler clairement!!

Remarque :
Il existe une version optimale d’un échange de deux variables, détaillée ici : http://en.wikipedia.org/wiki/XOR_swap . Certains diront que cette version n’est pas entièrement portable… Mais ca reste à prouver, je l’ai vu tourner un peu partout… La technique consiste à utiliser la commande XOR qui est plus rapide que la commande MOV, comme ceci:

  1. void main()
  2. {
  3.    int a = 0;
  4.    int b = 1;
  5.  
  6.    // avec des Xor :
  7.    a = a ^ b;
  8.    b = a ^ b;
  9.    a = a ^ b;
  10. }

Ce qui donne :

  1. push        edi  
  2. push        esi  
  3. cmp         dword ptr ds:[00212E08h],0
  4. je          00000010
  5. call        7974B4AF
  6. xor         esi,esi
  7. xor         edi,edi
  8. xor         esi,esi
  9. mov         edi,1
  10. xor         esi,edi
  11. xor         edi,esi
  12. xor         esi,edi

Encore une fois, la lisibilité n’est pas optimale, à moins d’être habitué à faire des XOR!

This work is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.
(c) 2012 Random namespace | powered by WordPress with Barecity