// lvalues:
  //
  int i = 42;
  i = 43; // ok, i is an lvalue
  int* p = &i; // ok, i is an lvalue
  int& foo();
  foo() = 42; // ok, foo() is an lvalue
  int* p1 = &foo(); // ok, foo() is an lvalue

  // rvalues:
  //
  int foobar();
  int j = 0;
  j = foobar(); // ok, foobar() is an rvalue
  int* p2 = &foobar(); // error, cannot take the address of an rvalue
  j = 42; // ok, 42 is an rvalue

http://thbecker.net/articles/rvalue_references/section_01.html

https://www.tutorialdocs.com/article/nodejs-performance.html

Prevent multiple definitions in header files

When there definitions in a header file that can not be made twice, the code below should be used. A header file may be included twice other include files include it, or an included file includes it and the source file includes it again.

To prevent bad effects from a double include, it is common to surround the body in the include file with the following (where MYHEADER_H is replaced by a name that is appropriate for your program).

#ifndef MYHEADER_H
#define MYHEADER_H
	// This will be seen by the compiler only once 
#endif /* MYHEADER_H */

http://www.fredosaurus.com/notes-cpp/preprocessor/ifdef.html

Log Levels

• TRACE - during development, comment before commit to vcs
• DEBUG - run in local machine
• INFO - log all actions by user, system scheduled event
• WARN - potential error
• ERROR - error conditions
• FATAL - critical errors

https://www.scalyr.com/blog/the-10-commandments-of-logging/

Pointers are more powerful than references in the sense that they allow two things that references don’t: nullability and rebinding.

Summary

• References cannot be null and cannot rebind
• std::reference_wrapper cannot be null but can rebind
• Pointers can be null and can rebind (and can do low-level address manipulations)
• boost optional references can be null and can rebind (but are incompatible with std::optional)

https://www.fluentcpp.com/2018/10/02/pointers-references-optional-references-cpp/

http://www.cs.cmu.edu/~gilpin/c++/performance.html

Examples (TL;DR)

Find files containing "foo", and print the line matches in context:

ag foo

Find files containing "foo" in a specific directory:

ag foo path/to/directory

Find files containing "foo", but only list the filenames:

ag -l foo

Find files containing "FOO" case-insensitively, and print only the match, rather than the whole line:

ag -i -o FOO

Find "foo" in files with a name matching "bar"

ag foo -G bar

Find files whose contents match a regular expression:

ag '^ba(r|z)$'

Find files with a name matching "foo":

ag -g foo

https://www.mankier.com/1/ag

My favourite theme: clean

https://ohmyz.sh/
https://www.howtoforge.com/tutorial/how-to-setup-zsh-and-oh-my-zsh-on-linux/

$ dnf install gdm
$ systemctl disable lightdm
$ systemctl enable gdm
$ reboot

https://unix.stackexchange.com/questions/86221/how-can-i-lock-my-screen-in-gnome-3-without-gdm

Dataframe access (performance)

loc only work on index

# label based, but we can use position values
# to get the labels from the index object
df.loc[df.index[2], 'ColName'] = 3

iloc work on position

# position based, but we can get the position
# from the columns object via the `get_loc` method
df.iloc[2, df.columns.get_loc('ColName')] = 3

ix You can get data from dataframe without it being in the index

at get scalar values. It's a very fast loc
Works very similar to loc for scalar indexers. Cannot operate on array indexers. Can! assign new indices and columns.

Advantage: over loc is that this is faster.
Disadvantage: is that you can't use arrays for indexers.

# label based, but we can use position values
# to get the labels from the index object
df.at[df.index[2], 'ColName'] = 3

iat Get scalar values. It's a very fast iloc
Works similarly to iloc. Cannot work in array indexers. Cannot! assign new indices and columns.

Advantage: over iloc is that this is faster.
Disadvantage: is that you can't use arrays for indexers.

# position based, but we can get the position
# from the columns object via the `get_loc` method
IBM.iat[2, IBM.columns.get_loc('PNL')] = 3

https://stackoverflow.com/questions/28757389/pandas-loc-vs-iloc-vs-ix-vs-at-vs-iat
http://pyciencia.blogspot.com/2015/05/obtener-y-filtrar-datos-de-un-dataframe.html