# check that name is a valid variable name:
# note: this code does not support variable_name[index]
shopt -s globasciiranges
[[ "$name" == [a-zA-Z_]*([a-zA-Z_0-9]) ]] || exit

value='babibab'
eval "$name"='$value'  # carefully escape the right-hand side!
echo "$var_37"  # outputs “babibab”

Pour avoir la description d'une méthode version bytecode :

import java.lang.reflect.Constructor;
import java.lang.reflect.Executable;
import java.lang.reflect.Method;
import java.util.concurrent.ThreadPoolExecutor;

public class ByteCodeDescriptor {

    public static void main(String... args) {

        Class clazz = ThreadPoolExecutor.class;

        String result=     ByteCodeDescriptor.getDescriptorForClass(clazz);
        System.out.println("class = " + result);

        for (Method m : ThreadPoolExecutor.class.getMethods()) {
            String resultM= ByteCodeDescriptor.getDescriptor(m);
            System.out.println("method = " + m);
            System.out.println("method result = " + m.getName() + resultM);
        }

        for (Constructor c :     ThreadPoolExecutor.class.getConstructors()) {
        String resultM= ByteCodeDescriptor.getDescriptor(c);
        System.out.println("constructor = " + c);
        System.out.println("constructor result = " + resultM);
    }

}

static String getDescriptorForClass(final Class c)
{
    if(c.isPrimitive())
    {
        if(c==byte.class)
            return "B";
        if(c==char.class)
            return "C";
        if(c==double.class)
            return "D";
        if(c==float.class)
            return "F";
        if(c==int.class)
            return "I";
        if(c==long.class)
            return "J";
        if(c==short.class)
            return "S";
        if(c==boolean.class)
            return "Z";
        if(c==void.class)
            return "V";
        throw new RuntimeException("Unrecognized primitive "+c);
    }
    if(c.isArray()) return c.getName().replace('.', '/');
    return ('L'+c.getName()+';').replace('.', '/');
}

static String getDescriptor(Executable e) {
    String s = "(";
    for (final Class c : e.getParameterTypes())
        s += getDescriptorForClass(c);
    s += ')';
    if (e instanceof Method) {
        Method m = (Method) e;
        return m.getName() + s + getDescriptorForClass(m.getReturnType());
    } else if (e instanceof Constructor) {
        Constructor c = (Constructor) e;
        return "<init>" + s + getDescriptorForClass(void.class);
    }
    throw new RuntimeException("Unrecognized primitive "+e);
}
}

File extensions can be (very) loosely seen as a type system.

.pem

stands for PEM, Privacy Enhanced Mail; it simply indicates a base64 encoding with header and footer lines. The contents of the PEM are detailed in the header and footer line - .pem itself doesn't specify a data 

.key

can be any kind of key, but usually it is the private key - OpenSSL can wrap private keys for all algorithms (RSA, DSA, EC) in a generic and standard PKCS#8 structure, but it also supports a separate 'legacy' structure for each algorithm, and both are still widely used even though the documentation has marked PKCS#8 as superior for almost 20 years; both can be stored as DER (binary) or PEM encoded, and both PEM and PKCS#8 DER can protect the key with password-based encryption or be left unencrypted;

.csr or .req or sometimes .p10

stands for Certificate Signing Request as defined in PKCS#10; it contains information such as the public key and common name required by a Certificate Authority to create and sign a certificate for the requester, the encoding could be PEM or DER (which is a binary encoding of an ASN.1 specified structure);

.crt or .cer

stands simply for certificate, usually an X509v3 certificate, again the encoding could be PEM or DER; a certificate contains the public key, but it contains much more information (most importantly the signature by the Certificate Authority over the data and public key, of course).

.p12 or .pfx

is a PKCS#12 defined key store, commonly password protected. It can contain trusted certificates, private key(s) and their certificate chain(s), but also other information such as secret keys and (very uncommonly) other personal information; .p12 is usually binary / DER encoded. PKCS#12 has lots of options plus extensions (i.e. attribute OIDs) with varying support, so it is not safe to assume that every P12 file will work in anything that uses (some) P12 files.

.crl

is a Certificate Revocation List which is defined within the X.509v3 certificate specifications, and this is usually DER encoded as well.

Specify a custom private key :

Add a specific configuration for your host in ssh config

Host myname.gitlab.com
    Hostname gitlab.com
    IdentityFile /home/myuser/.ssh/keys.d/id_rsa_git
    IdentitiesOnly yes

Test SSH :

ssh -Tvvv git@myname.gitlab.com

Git command :

git clone git@myname.gitlab.com:yourrepo.git

La vraie taille des pays

All in one backup : to restore from a local server file.
Put the .wpress file in :

<wp_home>/wp-content/ai1wm-backups

Microsoft à fond pour le support Linux :) :)

find the latest modified files recursively :

find . -type f -exec stat --format '%Y :%y %n' "{}" \; | sort -nr | cut -d: -f2- | head

Dans un remote debugger :

this.getClass().getResource('/' + String.class.getName().replace('.', '/') + ".class")

-XX:NativeMemoryTracking=summary

which produces an overview of the memory usage by the components of the JVM. It actually gives a pretty good picture of the "cost" of having a JVM.

Enabling detailed native memory tracking (NMT) causes a 5% to 10% performance overhead. The summary mode merely has an impact in memory usage as shown below and is usually enough.
It is necessary to note that while the above command indicate a scale in KB for the JVM it really means KiB.

JVM native memory tracking report

$ jcmd $(pidof java) VM.native_memory

Example of output :

Native Memory Tracking:
Total: reserved=7168324KB, committed=5380868KB                               
-                 Java Heap (reserved=4456448KB, committed=4456448KB)        
                        (mmap: reserved=4456448KB, committed=4456448KB)

-                     Class (reserved=1195628KB, committed=165788KB)         
                        (classes #28431)                                 
                        (  instance classes #26792, array classes #1639)
                        (malloc=5740KB #87822)
                        (mmap: reserved=1189888KB, committed=160048KB)
                        (  Metadata:   )
                        (    reserved=141312KB, committed=139876KB)
                        (    used=135945KB)
                        (    free=3931KB)
                        (    waste=0KB =0.00%)
                        (  Class space:)
                        (    reserved=1048576KB, committed=20172KB)
                        (    used=17864KB)
               ....