Gah ! Dire que je cherche depuis hier...

systemctl stop firewalld ; pkill -f firewalld ; systemctl start firewalld

Hier, j'ai releasé la v0.2.6 de Qompoter, a C++/Qt dependency manager. Outre les améliorations apportées au truc (recherche récursive des paquets, numéros de versions flous du genre v1.*, recherche des paquets dans Inqlude), cela m'a aussi permis de découvrir les scripts d'auto-complémetion Bash ! Et je surkiffe taper qompoter tab tab et voir la liste des actions possibles apparaître "install export inqlude jsong". C'est beau Linux.

Qompoter a atteint un niveau de maturité suffisant pour les petits projets, alors n'hésitez pas ! Vos retours sont les bienvenues.

A partager.

Something wrong

git reflog
# you will see a list of every thing you've done in git, across all branches!
# each one has an index HEAD@{index}
# find the one before you broke everything
git reset HEAD@{index}
# magic time machine

I accidentally committed to the wrong branch!

# undo the last commit, but leave the changes available
git reset HEAD~ --soft
git stash
# move to the correct branch
git checkout name-of-the-correct-branch
git stash pop
git add . # or add individual files
git commit -m "your message here"
# now your changes are on the correct branch

Oui, quelqu'un paie un nom de domaine chaque année pour ça. Merci quand même :-)

Très pratique le fichier .qmake.conf.

Pour me rappeler, je m'essai aux résumés.

Prefer NRVO to RVO

* RVO = return-value optimization

MyData myFunction() {
    return MyData(); // Create and return unnamed obj
}
MyData abc = myFunction();

With RVO, the C++ standard allows the compiler to skip the creation of the temporary, treating both object instances—the one inside the function and the one assigned to the variable outside the function—as the same. This usually goes under the name of copy elision. But what is elided here is the temporary and the copy.

• NRVO = named return-value optimization

MyData myFunction() {
  MyData result;           // Declare return val in ONE place
  if (doing_something) {
    return result;       // Return same val everywhere
  }
  // Doing something else
  return result;           // Return same val everywhere
} 
MyData abc = myFunction();

Named Return Value Optimization is similar but it allows the compiler to eliminate not just rvalues (temporaries), but lvalues (local variables), too, under certain conditions.

But many compilers are actualy failing to apply NRVO with the following code:

 MyData myFunction() {
    if (doing_something)
        return MyData();     // RVO expected

    MyData result;

    // ...
    return result;           // NRVO expected
} 
MyData abc = myFunction();

So previous example has to be preferred.

Return parameters by value whenever possible

Surprisingly, don’t use "out-parameters" but prefer "return-by-value", even if it implies creating a small struct in order to return multiple values. I will check that, because it seems strange to me.

“out” parameter pointers force a modern compiler to avoid certain optimisations when calling non-inlined functions.

Prefer:

struct fractional_parts {
    int numerator;
    int denominator;
};

fractional_parts convertToFraction(double val) {
    int numerator = /*calculation */ ;
    int denominator = /*calculation */ ;
    return {numerator, denominator}; // C++11 braced initialisation -> RVO
}
auto parts = convertToFraction(val);
use(parts.nominator);
use(parts.denominator);

than:

void convertToFraction(double val, int &numerator, int &denominator) {
    numerator = /*calculation */ ;
    denominator = /*calculation */ ;
}

int numerator, denominator;
convertToFraction(val, numerator, denominator); // or was it "denominator, nominator"?
use(numerator);
use(denominator);    

Cache member-variables and reference parameters

Prefer:

template <class T> 
complex<T> &complex<T>;::operator*=(const complex<T> &a) {
   T a_real = a.real, a_imag = a.imag;
   T t_real =   real, t_imag =   imag; // t == this
   real = t_real * a_real – t_imag * a_imag;
   imag = t_real * a_imag + t_imag * a_real;
   return *this;
}

than:

template <class T> 
complex<T> &complex<T>;::operator*=(const complex<T> &a) {
   real = real * a.real – imag * a.imag;
   imag = real * a.imag + imag * a.real;
   return *this;
}

It seems the example is too simple to really understand the benefits. I do not want to make my code more complex for such a simple case... I do not like this advice.

Organise intelligently member variables

Due to the CPU caches mechanisms (blocks of 64-byte), it is propose to organise member variables in a class as follow:

• Move the most-frequently-used member-variables first
• Move the least-frequently-used member-variables last
• If variables are often used together, group them near each other
• Try to reference variables in your functions in the order they’re declared

Why not...

Gah !

# !$ references the last argument of the previous command.
mate _posts/2011/2011-04-12-terminal-strings.mdown
git add !$
tumblr !$

# Now more complex, let's copy the second argument
# !! references the last command, and :2 the second arg. 
echo foo bar baz
echo !!:2 # outputs "bar"

# Batshit crazy
# !?baz? references the last command containing baz, :0-1 grabs the two first args
echo !?baz?:0-1 # should output "echo foo"

Un nouveau service de Fog Creek : HyperDev. Ils sont fous fous, et ils savent bien rendre utiles une idée balbutiante.