DEV Community: Nick | OneThingWell.dev

Linux: Finding ASCII code of a key

Nick | OneThingWell.dev — Fri, 05 Apr 2024 11:54:16 +0000

You can use showkey command from kbd package to quickly find out an ASCII code of a key:

showkey -a

After that you you can press any number of keys to find out their ASCII codes (you can press CTRL+d to terminate the program).

Note: kbd package should be installed out-of-the-box on most Linux distributions, if you don't have it for some reason, you can install it with:

# deb-based (Debian, Ubuntu, Mint, Raspbian, Kali, etc.)
apt install kbd

# rpm-based (Fedora, CentOS, etc.)
dnf install kbd

# Arch
pacman -S kbd

# Alpine
apk add kbd

Alternatives

Alternatively, you can use the man page of ascii command (this should work both on Linux on BSD):

man ascii

I'll include the tables here for convenience:

       Oct   Dec   Hex   Char                      │ Oct   Dec   Hex   Char
       ────────────────────────────────────────────┼───────────────────────────
       000   0     00    NUL '\0' (null character) │ 100   64    40    @
       001   1     01    SOH (start of heading)    │ 101   65    41    A
       002   2     02    STX (start of text)       │ 102   66    42    B
       003   3     03    ETX (end of text)         │ 103   67    43    C
       004   4     04    EOT (end of transmission) │ 104   68    44    D
       005   5     05    ENQ (enquiry)             │ 105   69    45    E
       006   6     06    ACK (acknowledge)         │ 106   70    46    F
       007   7     07    BEL '\a' (bell)           │ 107   71    47    G
       010   8     08    BS  '\b' (backspace)      │ 110   72    48    H
       011   9     09    HT  '\t' (horizontal tab) │ 111   73    49    I
       012   10    0A    LF  '\n' (new line)       │ 112   74    4A    J
       013   11    0B    VT  '\v' (vertical tab)   │ 113   75    4B    K
       014   12    0C    FF  '\f' (form feed)      │ 114   76    4C    L
       015   13    0D    CR  '\r' (carriage ret)   │ 115   77    4D    M
       016   14    0E    SO  (shift out)           │ 116   78    4E    N
       017   15    0F    SI  (shift in)            │ 117   79    4F    O
       020   16    10    DLE (data link escape)    │ 120   80    50    P
       021   17    11    DC1 (device control 1)    │ 121   81    51    Q
       022   18    12    DC2 (device control 2)    │ 122   82    52    R
       023   19    13    DC3 (device control 3)    │ 123   83    53    S
       024   20    14    DC4 (device control 4)    │ 124   84    54    T
       025   21    15    NAK (negative ack.)       │ 125   85    55    U
       026   22    16    SYN (synchronous idle)    │ 126   86    56    V
       027   23    17    ETB (end of trans. blk)   │ 127   87    57    W
       030   24    18    CAN (cancel)              │ 130   88    58    X
       031   25    19    EM  (end of medium)       │ 131   89    59    Y
       032   26    1A    SUB (substitute)          │ 132   90    5A    Z
       033   27    1B    ESC (escape)              │ 133   91    5B    [
       034   28    1C    FS  (file separator)      │ 134   92    5C    \  '\\'
       035   29    1D    GS  (group separator)     │ 135   93    5D    ]
       036   30    1E    RS  (record separator)    │ 136   94    5E    ^
       037   31    1F    US  (unit separator)      │ 137   95    5F    _
       040   32    20    SPACE                     │ 140   96    60    `
       041   33    21    !                         │ 141   97    61    a
       042   34    22    "                         │ 142   98    62    b
       043   35    23    #                         │ 143   99    63    c
       044   36    24    $                         │ 144   100   64    d
       045   37    25    %                         │ 145   101   65    e
       046   38    26    &                         │ 146   102   66    f
       047   39    27    '                         │ 147   103   67    g
       050   40    28    (                         │ 150   104   68    h
       051   41    29    )                         │ 151   105   69    i
       052   42    2A    *                         │ 152   106   6A    j
       053   43    2B    +                         │ 153   107   6B    k
       054   44    2C    ,                         │ 154   108   6C    l
       055   45    2D    -                         │ 155   109   6D    m
       056   46    2E    .                         │ 156   110   6E    n
       057   47    2F    /                         │ 157   111   6F    o
       060   48    30    0                         │ 160   112   70    p
       061   49    31    1                         │ 161   113   71    q
       062   50    32    2                         │ 162   114   72    r
       063   51    33    3                         │ 163   115   73    s
       064   52    34    4                         │ 164   116   74    t
       065   53    35    5                         │ 165   117   75    u
       066   54    36    6                         │ 166   118   76    v
       067   55    37    7                         │ 167   119   77    w
       070   56    38    8                         │ 170   120   78    x
       071   57    39    9                         │ 171   121   79    y
       072   58    3A    :                         │ 172   122   7A    z
       073   59    3B    ;                         │ 173   123   7B    {
       074   60    3C    <                         │ 174   124   7C    |
       075   61    3D    =                         │ 175   125   7D    }
       076   62    3E    >                         │ 176   126   7E    ~
       077   63    3F    ?                         │ 177   127   7F    DEL

Compact tables in hex and decimal:

          2 3 4 5 6 7       30 40 50 60 70 80 90 100 110 120
        -------------      ---------------------------------
       0:   0 @ P ` p     0:    (  2  <  F  P  Z  d   n   x
       1: ! 1 A Q a q     1:    )  3  =  G  Q  [  e   o   y
       2: " 2 B R b r     2:    *  4  >  H  R  \  f   p   z
       3: # 3 C S c s     3: !  +  5  ?  I  S  ]  g   q   {
       4: $ 4 D T d t     4: "  ,  6  @  J  T  ^  h   r   |
       5: % 5 E U e u     5: #  -  7  A  K  U  _  i   s   }
       6: & 6 F V f v     6: $  .  8  B  L  V  `  j   t   ~
       7: ' 7 G W g w     7: %  /  9  C  M  W  a  k   u  DEL
       8: ( 8 H X h x     8: &  0  :  D  N  X  b  l   v
       9: ) 9 I Y i y     9: '  1  ;  E  O  Y  c  m   w
       A: * : J Z j z
       B: + ; K [ k {
       C: , < L \ l |
       D: - = M ] m }
       E: . > N ^ n ~
       F: / ? O _ o DEL

Note: This is a snapshot of the wiki page from OneThingWell.dev wiki, you can find the latest, fully formatted version here: onethingwell.dev/linux-finding-ascii-code-of-a-key.

Three great virtues of a programmer

Nick | OneThingWell.dev — Wed, 21 Dec 2022 16:14:52 +0000

In his book "Programming Perl" (also known as "Camel Book"), Larry Wall encourages us to develop these three great virtues of a programmer: laziness, impatience, and hubris.

There are many ways to interpret this, but in the second edition of the book, we have a glossary with definitions of these terms:

Laziness

The quality that makes you go to great effort to reduce overall energy expenditure. It makes you write labor-saving programs that other people will find useful, and document what you wrote so you don't have to answer so many questions about it. Hence, the first great virtue of a programmer. Also hence, this book. See also impatience and hubris. (page 609)

Impatience

The anger you feel when the computer is being lazy. This makes you write programs that don't just react to your needs, but actually anticipate them. Or at least pretend to. Hence, the second great virtue of a programmer. See also laziness and hubris. (page 608)

Hubris

Excessive pride, the sort of thing Zeus zaps you for. Also the quality that makes you write (and maintain) programs that other people won't want to say bad things about. Hence, the third great virtue of a programmer. See also laziness and impatience. (page 607)

I've seen a lot of criticism of this, especially in the context of the author and his design of Perl, but leaving that aside, I think there's some truth to this.

Almost all great programmers I've met had these virtues, at least to some degree (and in some sense of these words). A sort of pride or hubris is a huge motivator to improve things, to come up with something better. And the combination of impatience and laziness can help you to force yourself to find less wasteful, less broken ways.

That being said, I've also seen lousy programmers with these virtues, so I'm not sure I'd recommend actively developing them; but if you already do have them, maybe you can use them to your advantage.

Note: This is a snapshot of the wiki page from the BetterWays.dev wiki, you can find the latest, fully formatted version here: betterways.dev/three-great-virtues-of-a-programmer.

Finding out environment variables of the process on Linux

Nick | OneThingWell.dev — Fri, 21 Oct 2022 10:04:00 +0000

As you probably know, each process on Linux can define its own environment variables (which are by default inherited by child processes).

Let's create an example process and pass it two environment variables:

a=1 b=2 sleep 120 &
PID=$!

First, we're creating a process that will sleep for 120 seconds, then we're saving its process id (PID) in a variable named $PID.

We can read the initial variables from the /proc/$PID/environ file:

cat /proc/$PID/environ

Example output:

b=2a=1SHELL=/bin/bashWINDOWID=16831489QT_ACCESSIBILITY=1COLORTERM=rxvt-xpm ...

Since entries are separated by the null byte character ('\0'), the output is not very readable, so let's try to fix that:

sed -z 's/$/\n/' /proc/$PID/environ

-z option tells sed that new lines are separated by the null byte character, instead of the usual newline character - exactly what we need here.

That output is now more readable:

b=2
a=1
SHELL=/bin/bash
WINDOWID=16831489
QT_ACCESSIBILITY=1
COLORTERM=rxvt-xpm
...

Note: use this only for display purposes, entries are separated by the null byte character for a good reason - it's the only character that can't be part of the value.

Alternatives

Alternatively, we could also use ps for this purpose:

ps e -p $PID -ww

We're using e option to tell ps to show the environment variables after the command, -p to specify the process id, and -ww for wide output (unlimited width).

Example output (entries are separated by spaces):

 657114 pts/47   S      0:00 sleep 120 b=2 a=1 SHELL=/bin/bash WINDOWID=16831489 QT_ACCESSIBILITY=1 COLORTERM=rxvt-xpm ...

Updated values

As I mentioned earlier, /proc/$PID/environ contains only initial variables. If the process changes its environment, and you want to read updated variables, you'll need to do something like this:

echo 'p (char *) getenv("a")' | gdb -q -p $PID

The value should be included in the output:

(gdb) $1 = 0x7ffeddf781d4 "1"

Note: This is a snapshot of the wiki page from the BetterWays.dev wiki, you can find the latest, fully formatted version here: betterways.dev/finding-out-environment-variables-of-the-process-on-linux.

Creating a whole directory tree at once in Linux/Unix

Nick | OneThingWell.dev — Wed, 19 Oct 2022 15:22:00 +0000

Instead of creating each directory in the tree separately, you can use brace expansion to do this in a single line:

mkdir -p testdir/{subdir1/subdir11/{subdir111,subdir112},subdir2,subdir3}

If we check the result with tree testdir, the result should be as expected:

testdir
├── subdir1
│   └── subdir11
│       ├── subdir111
│       └── subdir112
├── subdir2
└── subdir3

6 directories, 0 files

This works in most shells today, including bash and zsh.

How does it work?

Brace expansion is a similar mechanism to filename expansion, but the generated filenames don't need to exist. For example, if we put echo in front of the above command:

echo mkdir -p testdir/{subdir1/subdir11/{subdir111,subdir112},subdir2,subdir3}

We'll see the expanded command:

mkdir -p testdir/subdir1/subdir11/subdir111 testdir/subdir1/subdir11/subdir112 testdir/subdir2 testdir/subdir3

Note: we have to use the mkdir's -p option to make the parent directories automatically, otherwise the command would fail.

Note: This is a snapshot of the wiki page from the BetterWays.dev wiki, you can find the latest, fully formatted version here: betterways.dev/creating-a-directory-tree-at-once-in-linux-unix.

CLI: Backing up and restoring file modification times

Nick | OneThingWell.dev — Tue, 27 Sep 2022 11:08:13 +0000

I recently needed to keep the exact file modification times as a part of a git repository. Since git doesn't support such functionality out of the box, I used a simple combination of find and touch commands as a part of the pre-commit hook.

Here are two versions of this approach, one with the stat command, and the other one with just the combination of find and touch.

1st version (stat)

find . -type f -exec stat -c 'touch -d "%y" "%n"' {} \; > restore_mtimes

Explanation:

Using the find command, we're recursively iterating over all files (-type f) in all subdirectories, starting from the current directory (.)
for each file, we're executing (-exec flag) the stat ... command (The string {} is replaced by the current file name)
we're using the formatted output of stat command (-c flag) to generate touch -d "%y" "%n" lines as a part of our restore script ("%y" is modification time, "%n" is file name).
we're redirecting the whole output of the find command to the restore_mtimes file

The resulting restore_mtimes file looks something like this:

touch -d "2022-09-26 15:55:10.127898032 +0200" "./f2"
touch -d "2022-09-26 15:55:11.651909078 +0200" "./f3"
touch -d "2022-09-26 15:55:06.751873534 +0200" "./f1"

You can execute this file to restore the original modification times (either by making it executable with chmod +x restore_mtimes or sourcing it directly with . restore_mtimes).

2nd version (find & touch)

Since we only need the file modification time, we could optimize things by removing the unnecessary call to the stat command, and simply use the modification time provided by find command:

find . -type f -printf 'touch -d "%t" "%p"\n' > restore_mtimes

"%t" is modification time, "%p" is file name
unlike with stat -c, we also need to explicitly add a newline character at the end

The time format returned by find is a bit different (but it should be also parsed correctly by touch):

touch -d "Mon Sep 26 15:55:10.1278980320 2022" "./f2"
touch -d "Mon Sep 26 15:55:11.6519090780 2022" "./f3"
touch -d "Mon Sep 26 15:55:06.7518735340 2022" "./f1"

Alternatives and additional things to consider:

VCS commit times

One alternative to backing up file modification times is reusing the last commit time from your versioning control system, e.g.: restoring file mtimes with git.

touch --no-create

In cases where you're planning to restore the modification times to a tree where some files may be deleted, it may be useful to add the --no-create flag (which will prevent touch from creating any new files).

Note: This is a snapshot of the wiki page from the BetterWays.dev wiki, you can find the latest, better formatted version here: betterways.dev/cli-backing-up-and-restoring-file-modification-times.

"Copy to Clipboard" functionality in plain JavaScript

Nick | OneThingWell.dev — Sun, 18 Sep 2022 14:20:27 +0000

In modern browsers, you can use Clipboard API to read and write to the system clipboard.

Clipboard API consists of four asynchronous methods:

navigator.clipboard.read() - reading arbitrary data
navigator.clipboard.readText() - reading text
navigator.clipboard.write() - writing arbitrary data
navigator.clipboard.writeText() - writing text

It's very easy to use the writeText() method to implement a simple "Copy to Clipboard" functionality.

HTML:

<input type="text" id="copy-text">
<button id="copy-btn">Copy to Clipboard</button>

JavaScript:

document.getElementById("copy-btn").addEventListener("click", function(e) {
  if (!navigator.clipboard) {
    console.error('Clipboard API is not available');
    return;
  }

  let text = document.getElementById("copy-text").value;
  navigator.clipboard.writeText(text).then(function() {
    console.log("Copied to clipboard");
  }, function(err) {
    console.error(err);
  })  
})

If you try to run this code, you should see "Copied to clipboard" text in the console after clicking the copy button.

Explanation

document.getElementById("copy-btn").addEventListener("click", function(e) {
  if (!navigator.clipboard) {
    console.error('Clipboard API is not available');
    return;
  }

First, we're attaching onclick event handler to our "#copy-btn" button, and checking navigator.clipboard is available. We don't want our code to break if it's not, so we will just log an error and return.

  let text = document.getElementById("copy-text").value;

  navigator.clipboard.writeText(text).then(function() {
    console.log("Copied to clipboard");
  }, function(err) {
    console.error(err);
  })

Then we're getting the text value from our "copy-text" input element, and using navigator.clipboard.writeText method to write it to the system clipboard. Keep in mind that writeText is an async method that returns a promise, and you need to use the promise API directly (like the above), or use async/await.

Common mistake I've seen often is to do something like this:

navigator.clipboard.writeText(text)
console.log("Copied to clipboard")

Which will log "Copied to clipboard" immediately after calling writeText (regardless if the operation was successful or not).

Permissions API

"clipboard-write" permission is automatically granted to pages when they are in the active tab, but if you need to explicitly check for the permission, you can use something like this:

navigator.permissions.query({ name: "clipboard-write" }).then(p => console.log(p.state))

Note: This is a snapshot of the wiki page from the BetterWays.dev wiki, you can find the latest, better formatted version here: betterways.dev/copy-to-clipboard-in-plain-javascript.

Simple, reliable, fast (in that order)

Nick | OneThingWell.dev — Thu, 15 Sep 2022 10:43:15 +0000

If I had to summarize my approach to software development in three words, the words "simple, reliable, fast" come to mind.

This phrase is my variation of Drew DeValut's "Simple, correct, fast: in that order" phrase. While "correct" is definitely a relevant word here, I think "robust" and "reliable" are more relevant.

So, let's try to first define the words "correctness", "robustness" and "reliability".

I'll use Matthew Wilson's definitions (from his "Quality Matters: Correctness, Robustness and Reliability" article), because I think they make the most sense in this context:

Correctness: The degree to which a software entity's behavior matches its specification.
Robustness: The adjudged ability of a software entity to behave according to the expectations of its stakeholders.
Reliability: The degree to which a software system behaves robustly over time.

While all three words are relevant in this context, in the practical sense robustness is more relevant than correctness, and reliability implies robustness over time.

The question is - how do we achieve these characteristics, and more importantly, how do we maintain them in the long term? Obviously, these characteristics are important for all software projects, but the vast majority of them end up having almost the opposite characteristics.

So, why do so many software projects fail in that regard? Complexity has a lot to do with it.

Complexity kills, and it's extremely easy to introduce additional complexity on every step of the way.

Simplicity first

"Simplicity is a great virtue but it requires hard work to achieve it and education to appreciate it. And to make matters worse: complexity sells better." (Edsger W. Dijkstra)

Simplicity-first approach definitely requires a lot of hard work, but it's almost a prerequisite for these characteristics:

robustness and reliability ("Simplicity is prerequisite for reliability" - Dijkstra)
performance (simple code is much easier to profile and optimize)
composability (try to make your design composable - when you have a complex problem, try to split it into smaller, simpler composable parts)

On the other hand, with more complex/intertwined solutions, even if you manage to temporary achieve those characteristics, it will be extremely hard (or impossible) to maintain them in the long term.

Note: This is a snapshot of the wiki page from the BetterWays.dev wiki, you can find the latest (better formatted) version here: betterways.dev/simple-reliable-fast.

Simple JavaScript template engine by (ab)using template literals

Nick | OneThingWell.dev — Mon, 12 Sep 2022 13:37:05 +0000

Templating inline strings is simple using ES6 template literals:

const a = "hello"
const b = "world"

console.log(`${a} ${b}`)
//hello world

But what if you have a string that can't be inlined (i.e. it comes from an external source)?

Here's the gist of the function I recently used for this purpose:

function tpl(str, props) {
    let names = Object.keys(props);
    let vals = Object.values(props);
    return new Function(...names, `return \`${str}\`;`)(...vals);
}

Or, (a slightly less readable) one-liner version:

const tpl = (str, props) => new Function(...Object.keys(props), `return \`${str}\`;`)(...Object.values(props))

Example:

console.log(tpl('${a} ${b}', {a: 'hello', b: 'world'}))
//hello world

Explanation

So, we are defining a function called tpl:

function tpl(str, props) {
    let names = Object.keys(props);
    let vals = Object.values(props);
    return new Function(...names, `return \`${str}\`;`)(...vals);
}

The first two lines are self-explanatory - we are just extracting keys and values from the passed-in props object.

In the last line, we are dynamically creating a function from a string. Instead of doing eval, we are using the Function constructor, which is a much safer alternative.

Our new (dynamically generated) function receives a list of names of our props keys, and returns the same passed-in str string but delimited with backtick characters (basically, we are turning our "external" string into an inline template string).

After that, we just need to call our new function with a list of values.

Function.call alternative

We could simplify things by doing something like this instead of extracting names and values:

new Function(`return \`${str}\`;`).call(props)

But then we would need to use ${this.a} instead of just ${a}.

Caching

Each time you're calling the Function constructor, the function body needs to be parsed (some overhead), but it would be very easy to do some caching based on the value of str.

Note: This is a snapshot of the wiki page from the BetterWays.dev wiki, you can find the latest (better formatted) version here: betterways.dev/simple-javascript-template-engine-by-ab-using-template-literals.

Setting up a simple SOCKS proxy tunnel over SSH

Nick | OneThingWell.dev — Sat, 10 Sep 2022 14:58:27 +0000

If you have any kind of Linux/Unix server accessible over SSH, it's very easy to use it as a simple proxy server. This can be useful to bypass content filters and other restrictions on your local Internet connection. Even the cheapest Linux/BSD VPS options will be more than enough for this.

This feature is built into OpenSSH, and you don't need to install any additional software, or do any additional configuration.

All you need to do is open an ssh connection from the client side with a dynamic port forwarding option:

ssh -D 1080 myserver

-D option tells ssh to use the local 1080 port for dynamic, application-level port forwarding. In a practical sense, this means that your ssh client will act as a SOCKS 4/5 server on that port.

Depending on your configuration, you may also need to specify an SSH port and user (i.e. ssh -p 2222 myuser@myserver, but in that case, you may want to consider setting up a host profile in your ~/.ssh/config file instead).

After that, all you need to do is tell your browser to use a SOCKS proxy on localhost:1080.

Browser setup

In Firefox, you can set SOCKS proxy in Settings / Network Settings / Configure Proxy Access to the Internet - Manual proxy configuration:

SOCKS Host: localhost
Port: 1080
SOCKS v5

With Google Chrome/Chromium, you need to start the browser with --proxy-server argument:

chromium --proxy-server="socks5://localhost:1080"

Non-interactive / scripting use

If you don't want the SSH client to open an interactive session, you can prevent it from executing the shell with -N flag, and -f flag to put it into the background, i.e.:

ssh -N -f -D 1080 myserver

If you want to automatically restart the connection when necessary, you can use autossh tool (the syntax is the same):

autossh -N -f -D 1080 myserver

Putty

If you're using Putty instead of CLI ssh client, you need to add 1080 as a source port and select Dynamic as a forwarding option under Connection / SSH / Tunnels.

Relevant ssh options

     -D [bind_address:]port
             Specifies a local “dynamic” application-level port forwarding.
             This works by allocating a socket to listen to port on the local
             side, optionally bound to the specified bind_address.  Whenever a
             connection is made to this port, the connection is forwarded over
             the secure channel, and the application protocol is then used to
             determine where to connect to from the remote machine.  Currently
             the SOCKS4 and SOCKS5 protocols are supported, and ssh will act
             as a SOCKS server.  Only root can forward privileged ports.  Dy‐
             namic port forwardings can also be specified in the configuration
             file.

             IPv6 addresses can be specified by enclosing the address in
             square brackets.  Only the superuser can forward privileged
             ports.  By default, the local port is bound in accordance with
             the GatewayPorts setting.  However, an explicit bind_address may
             be used to bind the connection to a specific address.  The
             bind_address of “localhost” indicates that the listening port be
             bound for local use only, while an empty address or ‘*’ indicates
             that the port should be available from all interfaces.

     -N      Do not execute a remote command.  This is useful for just for‐
             warding ports.

     -f      Requests ssh to go to background just before command execution.
             This is useful if ssh is going to ask for passwords or
             passphrases, but the user wants it in the background.  This im‐
             plies -n.  The recommended way to start X11 programs at a remote
             site is with something like ssh -f host xterm.

             If the ExitOnForwardFailure configuration option is set to “yes”,
             then a client started with -f will wait for all remote port for‐
             wards to be successfully established before placing itself in the
             background.

Note: This is a snapshot of the wiki page from the BetterWays.dev wiki, you can find the latest (better formatted) version here: betterways.dev/setting-up-a-simple-socks-proxy-tunnel-over-ssh.

Inxi - Finding out hardware configuration on Linux

Nick | OneThingWell.dev — Thu, 08 Sep 2022 11:42:01 +0000

Inxi is a great tool you can use to find out the system and hardware information on a Linux system.

If you're using Debian/Ubuntu-based distribution, you can install it with:

apt install inxi

On rpm-based distros, you can use:

dnf install inxi

On Arch Linux, you can install inxi package from AUR.

You can use inxi --recommends to check if you need to install additional dependencies.

Basic use

If you run just the inxi command, you'll get a quick summary like this:

CPU: Single Core Intel Xeon (Skylake IBRS) (-MCP-) speed: 2100 MHz 
Kernel: 4.19.0-12-amd64 x86_64 Up: 649d 1h 15m Mem: 350.9/1947.2 MiB (18.0%) 
Storage: 19.07 GiB (11.9% used) Procs: 87 Shell: bash 5.0.3 inxi: 3.0.32

To get a full summary, you can use -F or --full flag, i.e. inxi -F:

System:    Host: s Kernel: 4.19.0-12-amd64 x86_64 bits: 64 Console: tty 0 Distro: Debian GNU/Linux 10 (buster) 
Machine:   Type: Kvm System: BetterWays product: vServer v: 20171111 serial: 8711068 
           Mobo: N/A model: N/A serial: N/A BIOS: BetterWays v: 20171111 date: 11/11/2017 
CPU:       Topology: Single Core model: Intel Xeon (Skylake IBRS) bits: 64 type: MCP L2 cache: 16.0 MiB 
           Speed: 2100 MHz min/max: N/A Core speed (MHz): 1: 2100 
Graphics:  Device-1: driver: bochs-drm v: N/A 
           Display: server: No display server data found. Headless machine? tty: 237x63 
           Message: Unable to show advanced data. Required tool glxinfo missing. 
Audio:     Message: No Device data found. 
Network:   Device-1: Intel 82371AB/EB/MB PIIX4 ACPI type: network bridge driver: piix4_smbus 
           Device-2: Red Hat Virtio network driver: virtio-pci 
           IF: eth0 state: up speed: -1 duplex: unknown mac: 96:00:00:80:bb:5e 
Drives:    Local Storage: total: 19.07 GiB used: 2.27 GiB (11.9%) 
           ID-1: /dev/sda vendor: QEMU model: HARDDISK size: 19.07 GiB 
Partition: ID-1: / size: 18.60 GiB used: 2.27 GiB (12.2%) fs: ext4 dev: /dev/sda1 
Sensors:   Missing: Required tool sensors not installed. Check --recommends 
Info:      Processes: 88 Uptime: 649d 1h 19m Memory: 1.90 GiB used: 351.8 MiB (18.1%) Init: systemd runlevel: 5 Shell: bash 
           inxi: 3.0.32

If for some reason you get weird output, you can turn off colors with -c 0.

Output

The default behavior is to just output the information to the screen (--output screen is implied).

But we also can output the information to json/xml files, which can be very useful for scripting/programming purposes.

You can use inxi -F --output json --output-file /tmp/inxi.json to get a json file:

{
  "001#Partition": [
    {
      "001#ID": "/",
      "007#uuid": "4236cc65-d07b-4264-8ae6-ff71b870d7cc",
      "006#label": "N/A",
      "003#used": "2.27 GiB (12.2%)",
      "005#dev": "/dev/sda1",
      "002#size": "18.60 GiB",
      "004#fs": "ext4"
    }
  ],
  "000#CPU": [
    {
      "000#Topology": "Single Core",
      "002#bits": 64,
      "001#model": "Intel Xeon (Skylake IBRS)",
      "004#L2 cache": "16.0 MiB",
      "003#type": "MCP"
    },
    {
      "008#1": "2100",
      "005#Speed": "2100 MHz",
      "006#min/max": "N/A",
      "007#Core speed (MHz)": ""
    },
    {
      "009#Flags": "3dnowprefetch abm adx aes apic arat avx avx2 avx512bw avx512cd avx512dq avx512f avx512vl bmi1 bmi2 clflush clwb cmov constant_tsc cpuid cpuid_fault cx16 cx8 de erms f16c fma fpu fsgsbase fxsr hle hypervisor ibpb ibrs invpcid invpcid_single lahf_lm lm mca mce md_clear mmx movbe msr mtrr nopl nx ospke pae pat pcid pclmulqdq pdpe1gb pge pku pni popcnt pse pse36 pti rdrand rdseed rdtscp rep_good rtm sep smap smep ssbd sse sse2 sse4_1 sse4_2 ssse3 syscall tsc tsc_deadline_timer tsc_known_freq vme x2apic xgetbv1 xsave xsavec xsaveopt xtopology"
    }
  ]
}

If you get an error message like Error 80: The required json Perl module is not installed: Cpanel::JSON::XS OR JSON::XS, you need to install libjson-xs-perl package.

xml:

inxi -F --output xml --output-file /tmp/inxi.xml

In case you see something like Error 80: The required xml Perl module is not installed: XML::Dumper, you need to install libxml-dumper-perl package.

If you need to just export textual info, you use normal output redirection (you can disable colors with -c 0, but inxi will usually do that automatically if the connected output is not interactive terminal):

inxi -c 0 -F > /tmp/inxi.txt

Specific categories

If you're interested only in specific categories, you can limit the output with the following flags (the same works for json/xml output):

Audio info - inxi -A:

Audio:     Message: No Device data found.

CPU info - inxi -C:

CPU:       Topology: Single Core model: Intel Xeon (Skylake IBRS) bits: 64 type: MCP L2 cache: 16.0 MiB 
           Speed: 2100 MHz min/max: N/A Core speed (MHz): 1: 2100

Drives info - inxi -D:

Drives:    Local Storage: total: 19.07 GiB used: 2.27 GiB (11.9%) 
           ID-1: /dev/sda vendor: QEMU model: HARDDISK size: 19.07 GiB

Graphics info - inxi -G:

Graphics:  Device-1: driver: bochs-drm v: N/A 
           Display: server: No display server data found. Headless machine? tty: 237x63 
           Message: Unable to show advanced data. Required tool glxinfo missing.

Machine info - inxi -M:

Machine:   Type: Kvm System: BetterWays product: vServer v: 20171111 serial: 8711068 
           Mobo: N/A model: N/A serial: N/A BIOS: BetterWays v: 20171111 date: 11/11/2017

Network info - inxi -N:

Network:   Device-1: Intel 82371AB/EB/MB PIIX4 ACPI type: network bridge driver: piix4_smbus 
           Device-2: Red Hat Virtio network driver: virtio-pci

And, of course, you can combine multiple categories - inxi -C -D:

CPU:       Topology: Single Core model: Intel Xeon (Skylake IBRS) bits: 64 type: MCP L2 cache: 16.0 MiB 
           Speed: 2100 MHz min/max: N/A Core speed (MHz): 1: 2100 
Drives:    Local Storage: total: 19.07 GiB used: 2.27 GiB (11.9%) 
           ID-1: /dev/sda vendor: QEMU model: HARDDISK size: 19.07 GiB

Weather

If that's not enough, inxi can also show you the weather info with inxi -w:

Weather:
  Report: temperature: 29.4 C (85 F) conditions: Scattered clouds 
  Locale: current time: Sun 04 Sep 2022 02:40:34 PM CEST (Europe/Berlin) 
  Source: WeatherBit.io

(you can specify the location with -W switch)

Alternatives

A lot of this information can be found in /proc, which doesn't require any additional tool.

Another popular script you may want to check is called neofetch.

Note: This is a snapshot of the wiki page from the BetterWays.dev wiki, you can find the latest (better formatted) version here: betterways.dev/inxi-finding-out-hardware-configuration-on-linux.

Functional core, imperative shell

Nick | OneThingWell.dev — Mon, 29 Aug 2022 10:17:00 +0000

I'm going to assume that you're at least somewhat familiar with basic functional programming concepts, but as a quick reminder:

A pure function is a function that:

is referentially transparent - it will always return the same output for the same input
have no side effects - it doesn't affect the outside world

This brings us a lot of benefits (referential transparency, unit testing, they are easier to reason about) and we should split as much functionality as possible into pure functions, but how do we get there?

One technique that can help us get there is called the "Functional core, imperative shell". As the name says, the idea is to separate the effectful, imperative code into the outer shell and keep the inner core pure (functional core).

Purely functional languages will nudge you in that direction due to their design (i.e. IO monads), but you can use and benefit from this technique in pretty much every programming language.

If you're reading this guide, there's a good chance that you know at least some JavaScript. So, we're going to go with that.

In some ways, JavaScript is also kind of nudging us in this direction. You've probably used async functions. While they are generally nicer to use than callbacks or promises directly, you soon realize that they don't really play nicely with the rest of your codebase - values inside promises are a very different beast from normal values, and functions which return promises are very different from normal functions.

This is the important part. Instead of trying to mix those two concepts throughout our codebase (and infect almost everything in the process), the idea is that we take and isolate those async (and impure) stuff into the outer shell, so we can keep our core nice and clean.

Here's a very simple example that should look familiar if you ever used something similar to express.js:

// imperative shell
async function handler(req, res) {
    var users = await fetchUsers()
    var projects = await fetchProjects()

    var result = render(transformData(users, projects))

    res.send(result)
}

// functional core
function transformData(users, projects) {}

function render(model) {}

So, we have two parts:

Imperative shell

handler is an express-like request handler function, which represents our outer imperative shell. You can do pretty much what you want here - usually, you need to first get the data from somewhere (impure part), then transform data (pure part), then send the result (impure part).

Functional core

transformData and render are pure functions - you should have all the needed data ready before calling into the functional core, as these functions will use only what they'll get in the parameters.

This example is arbitrary, but here are a few points which may help you to understand it:

transformData function transforms (normalizes and prepares) the fetched data for rendering - you can see the returned data as a form of ViewModel - the data is organized in a way that we need for our view and if the outside data format ever changes, we just need to change the mapping function
render function takes that model and returns rendered html string - it can call other pure functions which return html parts (i.e. similar to the concepts of components or partial views)

As you can see, the idea itself is very simple, but it can take some effort (depending on the nature of the problem you're solving - i.e. IO-heavy code is harder to organize this way).

Note: This is a snapshot of the wiki page from the BetterWays.dev wiki, you can find the latest (better formatted) version here: betterways.dev/functional-core-imperative-shell.

Forcing a browser to download a file (HTML and server side)

Nick | OneThingWell.dev — Fri, 26 Aug 2022 15:21:00 +0000

When a user clicks a normal HTML link to a file:

<a href="path/to/file.ext">

Browsers will usually try to open the file directly (inline) instead of opening the file download dialog.

You can use HTML5 download attribute to tell modern browsers to open the download dialog instead:

<a href="path/to/file.ext" download>

You can also specify the suggested filename the user will see in the download dialog:

<a href="path/to/file.ext" download="myfile.ext">

If you specify just the file name (without the extension), the extension will usually be inferred from the original filename (this example will still suggest "myfile.ext" in most browsers):

<a href="path/to/file.ext" download="myfile">

Limitations and workarounds

Nowadays, download attribute is supported in all mainstream browsers, but there's an important limitation: this attribute only works for same-origin URLs (protocol, port, and host have to match), and the blob: and data: schemes.

Besides the download attribute, there's not much else you can do to force this behavior from the client side, but you can on the server side.

Including the Content-Disposition header in the HTTP response will have a similar effect to download attribute (but without this limitation):

Content-Disposition: attachment; filename=file.ext

You'll also need to send the Content-type header and the actual file contents.

In PHP, that would look something like this:

header('Content-Disposition: attachment; filename="downloaded.pdf"');
header('Content-type: application/pdf');
readfile('test.pdf');

But to avoid the performance overhead, I recommend doing that on the webserver level instead of the app level.

nginx

For nginx this could be as simple as:

add_header Content-Disposition 'attachment; filename="file.ext"';

Note: nginx will usually send the correct Content-type header automatically, but you can override that if needed:

add_header Content-Type 'application/pdf'

For a more general case, you could send a generic application/octet-stream header and Content-Disposition without a filename:

location /myloc {
        if ($request_filename ~* ^.*?\.(pdf|zip|docx)$) {
            add_header Content-Disposition attachment;
            add_header Content-Type application/octet-stream;
        }
    }

Combination of download attribute and Content-Disposition header

If both the download attribute and Content-Disposition header are present and both define the filename, the filename defined in the header will have priority.

In the case of Content-Disposition: inline header (which tells the browser to display the contents inline - as a part of the page), the download attribute will have the priority (for the same-origin URLs).

Note: This is a snapshot of the page from the BetterWays.dev wiki, you can find the latest (better formatted) version here: betterways.dev/forcing-a-browser-to-download-a-file.