Christos Margiolis: Writings

PostgreSQL 15 and pgAdmin4 on FreeBSD

Thu, 07 Sep 2023 00:00:00 +1200

Tested on FreeBSD 13.2. This article is also mirrored on the FreeBSD Wiki.

PostgreSQL

Install PostgreSQL:

# pkg install postgresql15-server postgresql15-client

Enable the PostgreSQL service:

# sysrc postgresql_enable="YES"

Initialize PostgreSQL and start the service:

# /usr/local/etc/rc.d/postgresql initdb
# service postgresql start

Make sure the service is running properly on IPv4 and IPv6 port 5432:

$ sockstat -46 | grep 5432

Set a password for the default postgres user:

# passwd postgres

Create an owner user for your database:

# su - postgres
$ createuser admin
$ createdb foo_db -O admin

Inside the psql prompt, set an encrypted password for admin and grant exclusive access to foo_db to the admin user:

$ psql foo_db
foo_db=# alter role admin with encrypted password 'yourpassword';
foo_db=# grant all privileges on database foo_db to admin;
foo_db=# exit
$ exit

Make PostgreSQL listen to all addresses, instead of just localhost.

# vi /var/db/postgres/data15/postgresql.conf

Uncomment the listen_addresses line and set it to:

listen_addresses = '*'

Change the security settings:

# vi /var/db/postgres/data15/pg_hba.conf

Go to the bottom of the file and set trust to md5 for all existing entries:

# TYPE  DATABASE        USER            ADDRESS                 METHOD

# "local" is for Unix domain socket connections only
local   all             all                                     md5
# IPv4 local connections:
host    all             all             127.0.0.1/32            md5
# IPv6 local connections:
host    all             all             ::1/128                 md5
# Allow replication connections from localhost, by a user with the
# replication privilege.
local   replication     all                                     md5
host    replication     all             127.0.0.1/32            md5
host    replication     all             ::1/128                 md5

Also, allow remote IPv4 and IPv6 connections to our new database as admin only:

# Allow remote connections to foo_db as admin
host    foo_db          admin           0.0.0.0/0               md5
host    foo_db          admin           ::/0                    md5

Restart the service:

# serivce postgresql restart

pgAdmin4

Install the needed packages:

# pkg install python py39-pip py39-virtualenv py39-sqlite3 ca_root_nss openjpeg rust

Upgrade pip to the latest version:

$ pip install --upgrade pip

Initialize the virtualenv for pgAdmin4 in your home directory:

$ cd
$ virtualenv pgadmin4

Enter the virtualenv and install pgAdmin4. This will take a while:

$ . pgadmin4/bin/activate
(pgadmin4) $ pip install pgadmin4

Create a local config file:

(pgadmin4) # mkdir -p /var/lib/pgadmin /var/log/pgadmin
(pgadmin4) $ cp pgadmin4/lib/python3.9/site-packages/pgadmin4/config.py pgadmin4/lib/python3.9/site-packages/pgadmin4/config_local.py
(pgadmin4) $ vi pgadmin4/lib/python3.9/site-packages/pgadmin4/config_local.py

Inside config_local.py, edit the following values:

DEFAULT_SERVER = '0.0.0.0'
DEFAULT_SERVER_PORT = 5050

Start pgAdmin4 (always inside the virtualenv) and set up your account:

(pgadmin4) # pgadmin4
Email address: you@mail.com
Password: yourpassword
Retype password: yourpassword

Open a web browser and enter pgAdmin4 (replace the IP with the appropriate one) and log in with the email and password you just entered in the pgadmin4 prompt:

http://192.168.1.11:5050

Inside the web interface, go to File -> Preferences -> Binary Paths and under the PostgreSQL Binary Path section, check PostgreSQL 15 and set the binary path to /usr/local/bin/. Then click Save.

From now on, you can run pgadmin4 in the background like so:

(pgadmin4) # pgadmin4 &

Upgrading pgAdmin4

To upgrade pgAdmin4, you only have to delete and reinstall the virtualenv:

$ cd
$ rm -rf pgadmin4
$ virtualenv pgadmin4
$ . pgadmin4/bin/activate
(pgadmin4) $ pip install --upgrade pgadmin4

You also have to re-create config_local.py and set DEFAULT_SERVER (see above).

Inline function tracing with the kinst DTrace provider

Tue, 18 Jul 2023 00:00:00 +1200

Quick background

DTrace is a framework that gives administrators and kernel developers the ability to observe kernel behavior in real time. DTrace has modules called “providers”, that perform a particular instrumentation in the kernel (and sometimes userland) using “probes”.

kinst is a new low-level DTrace provider co-authored by Christos Margiolis and Mark Johnston for the FreeBSD operating system, which allows the user to trace arbitrary instructions in kernel functions. It is part of the base system as of FreeBSD 14.0.

kinst probes take the form of kinst::<function>:<instruction>, where <function> is the kernel function to be traced, and <instruction> is the offset to the instruction, relative to the beginning of the function, and can be obtained from the function’s disassembly. If the <instruction> field is left empty, kinst will trace all instructions in that function. Unlike FBT, kinst can also trace the entry and return points of inline functions (see Inline function tracing).

The origin of the name is inspired from an early paper written by A. Tamches and B. Miller discussing a tracing tool they developed called “KernInst”.

Usage

Find the offset corresponding to the third instruction in vm_fault() and trace it, printing the contents of the RSI register:

# kgdb
(kgdb) disas /r vm_fault
Dump of assembler code for function vm_fault:
   0xffffffff80f4e470 <+0>:     55      push   %rbp
   0xffffffff80f4e471 <+1>:     48 89 e5        mov    %rsp,%rbp
   0xffffffff80f4e474 <+4>:     41 57   push   %r15
...

# dtrace -n 'kinst::vm_fault:4 {printf("%#x", regs[R_RSI]);}'
  2  81500                       vm_fault:4 0x827c56000
  2  81500                       vm_fault:4 0x827878000
  2  81500                       vm_fault:4 0x1fab9bef0000
  2  81500                       vm_fault:4 0xe16cf749000
  0  81500                       vm_fault:4 0x13587c366000
  ^C

Trace the return point of critical_enter(), which is an inline function:

# dtrace -n 'kinst::critical_enter:return'
dtrace: description 'kinst::critical_enter:return' matched 130 probes
CPU     ID                    FUNCTION:NAME
  1  71024                spinlock_enter:53
  0  71024                spinlock_enter:53
  1  70992                uma_zalloc_arg:49
  1  70925    malloc_type_zone_allocated:21
  1  70994                uma_zfree_arg:365
  1  70924             malloc_type_freed:21
  1  71024                spinlock_enter:53
  0  71024                spinlock_enter:53
  0  70947         _epoch_enter_preempt:122
  0  70949           _epoch_exit_preempt:28
  ^C

Inline function tracing

How it works

To trace inline functions, libdtrace makes use of the DWARF Debugging Standard, to detect if the function specified is an inline call. If it is, D syntax is transformed to create kinst probes for each of the inline copies found. All work is done in libdtrace, instead of kinst(4). This feature has been added to FreeBSD with this patch.

Contrary to how kinst expects a <function>:<instruction> tuple to create probes, for inline functions, <instruction> is replaced by entry and return.

Syntactic transformations

Suppose the user wants to trace a probe of the form:

kinst::<func>:<entry|return>
/<pred>/
{
	<acts>
}

libdtrace sees that we have specified entry or return, instead of an offset, which is what a regular kinst probe would look like, so it loops through all loaded kernel modules and parses their DWARF and ELF info to see if this function is an inline — if not, the probe is converted to an FBT one, so that we don’t duplicate FBT’s functionality in kinst:

# dtrace -dn 'kinst::malloc:entry {exit(0);}'
fbt::malloc:entry
{
        exit(0x0);
}

dtrace: description 'kinst::malloc:entry ' matched 1 probe
CPU     ID                    FUNCTION:NAME
  2  31144                     malloc:entry

If the function however is an inline, libdtrace will find all calls refering to this function and create new probes for each one of the inline copies found.

# dtrace -dn 'kinst::cam_iosched_has_more_trim:entry { printf("\t%d\t%s", pid, execname); }'
kinst::cam_iosched_get_trim:13,
kinst::cam_iosched_next_bio:13,
kinst::cam_iosched_schedule:40
{
	printf("\t%d\t%s", pid, execname);
}

dtrace: description 'kinst::cam_iosched_has_more_trim:entry ' matched 4 probes
CPU     ID                    FUNCTION:NAME
  0  81502          cam_iosched_schedule:40     2       clock
  0  81501          cam_iosched_next_bio:13     2       clock
  2  81502          cam_iosched_schedule:40     2       clock
  1  81502          cam_iosched_next_bio:13     0	kernel
  1  81503          cam_iosched_schedule:40     0	kernel
^C

There can also be both inline and non-inline definitions of the same function. In this case, kinst creates an additional FBT probe for the non-inline definition.

The -d flag used in these examples to dump the D script after libdtrace has applied syntactic transformations, has been added to DTrace in commit 1e136a9cbd3a.

Heuristic for calculating the `entry` and `return` offsets

libdtrace reuses parts of the mechanism implemented in my inlinecall(1) program, which finds and prints all call sites of a given inline function:

$ ./inlinecall vm_page_mvqueue /usr/lib/debug/boot/kernel/kernel.debug
/usr/src/sys/vm/vm_page.c:4142
        [0xffffffff80f91541 - 0xffffffff80f91599]       /usr/src/sys/vm/vm_page.c:4195  vm_page_readahead_finish()
        [0xffffffff80f915f5 - 0xffffffff80f91603]       /usr/src/sys/vm/vm_page.c:4195  vm_page_readahead_finish()
        [0xffffffff80f9163d - 0xffffffff80f916c2]       /usr/src/sys/vm/vm_page.c:4184  vm_page_activate()
        [0xffffffff80f916cd - 0xffffffff80f916e5]       /usr/src/sys/vm/vm_page.c:4184  vm_page_activate()
        [0xffffffff80f916fe - 0xffffffff80f91747]       /usr/src/sys/vm/vm_page.c:4195  vm_page_deactivate()
        [0xffffffff80f91750 - 0xffffffff80f91768]       /usr/src/sys/vm/vm_page.c:4195  vm_page_deactivate()
        [0xffffffff80f94a59 - 0xffffffff80f94aa9]       /usr/src/sys/vm/vm_page.c:4195  vm_page_reclaim_contig_domain()
        [0xffffffff80f94de4 - 0xffffffff80f94df9]       /usr/src/sys/vm/vm_page.c:4195  vm_page_reclaim_contig_domain()
        [0xffffffff80f9661e - 0xffffffff80f96667]       /usr/src/sys/vm/vm_page.c:4202  vm_page_deactivate_noreuse()
        [0xffffffff80f96670 - 0xffffffff80f96688]       /usr/src/sys/vm/vm_page.c:4202  vm_page_deactivate_noreuse()
        [0xffffffff80f9669e - 0xffffffff80f966ea]       /usr/src/sys/vm/vm_page.c:4212  vm_page_launder()
        [0xffffffff80f966f3 - 0xffffffff80f9670b]       /usr/src/sys/vm/vm_page.c:4212  vm_page_launder()
        [0xffffffff80f96d4c - 0xffffffff80f96dac]       /usr/src/sys/vm/vm_page.c:4212  vm_page_advise()
        [0xffffffff80f96dac - 0xffffffff80f96e07]       /usr/src/sys/vm/vm_page.c:4202  vm_page_advise()

Most of the entries above appear twice but with different boundaries:

        [0xffffffff80f9163d - 0xffffffff80f916c2]       /usr/src/sys/vm/vm_page.c:4184  vm_page_activate()
        [0xffffffff80f916cd - 0xffffffff80f916e5]       /usr/src/sys/vm/vm_page.c:4184  vm_page_activate()

This means that the inline copy’s boundaries are split into more than one parts, which can be caused by having early returns inside the inline function. By using this assumption, we can deduce that the entry point of the function is 0xffffffff80f9163d, and each of the upper boundaries are the return points (i.e 0xffffffff80f916c2 and 0xffffffff80f916e5), so we end up with one entry and two return trace points.

However, this is not exactly true, because the final return address given by DWARF corresponds to the instruction after the actual return instruction. We can verify this in GDB using the two return addresses from the example above:

# kgdb
(kgdb) disas vm_page_activate
...
   0xffffffff80f916c0 <+144>:   jmp    0xffffffff80f91673 <vm_page_activate+67>
   0xffffffff80f916c2 <+146>:   add    $0x8,%rsp			<-- first address given by DWARF
...
   0xffffffff80f916e0 <+176>:   call   0xffffffff80bed360 <panic>	<-- last instruction
									<-- second address should be here

It turns out that 0xffffffff80f916e5 is, in fact, outside vm_page_activate() altogether!

(kgdb) x/i 0xffffffff80f916e5
   0xffffffff80f916e5:  data16 cs nopw 0x0(%rax,%rax,1)

After running a couple of tests, I came to the conclusion that there are two possible cases with return addresses:

If the inline copy’s DIE has DW_AT_lowpc and DW_AT_highpc set, the return address is always outside the inline function’s boundaries.
If the inline copy’s DIE has DW_AT_ranges set, only the last return address is outside the inline function’s boundaries.
Combining the two bullets above, if the return address of the inline function is the same as the upper boundary of the caller function, it’s outside both the inline copy’s and the caller function’s boundaries.

In order to fix this, we have to go one instruction back whenever we come across one of those 3 cases.

Finally the entry offset is calculated as:

inline_bound_lo - caller_bound_lo

And the return one, including the modifications (if any) discussed above, as:

inline_bound_hi - caller_bound_lo

These offsets are then used to create regular kinst probes of the form kinst::<func>:<instruction>, which is what kinst actually expects:

# dtrace -dn 'kinst::vm_page_mvqueue:entry,kinst::vm_page_mvqueue:return'
dtrace: description 'kinst::vm_page_mvqueue:entry,kinst::vm_page_mvqueue:return' matched 22 probes
kinst::vm_page_readahead_finish:33,
kinst::vm_page_readahead_finish:121,
kinst::vm_page_activate:13,
kinst::vm_page_deactivate:14,
kinst::vm_page_reclaim_contig_domain:1961,
kinst::vm_page_deactivate_noreuse:14,
kinst::vm_page_launder:14,
kinst::vm_page_advise:236,
kinst::vm_page_advise:332,
kinst::vm_page_readahead_finish:220,
kinst::vm_page_activate:146,
kinst::vm_page_activate:176,
kinst::vm_page_deactivate:87,
kinst::vm_page_deactivate:115,
kinst::vm_page_reclaim_contig_domain:2041,
kinst::vm_page_reclaim_contig_domain:2884,
kinst::vm_page_deactivate_noreuse:87,
kinst::vm_page_deactivate_noreuse:115,
kinst::vm_page_launder:90,
kinst::vm_page_launder:118,
kinst::vm_page_advise:330,
kinst::vm_page_advise:421
{
}

CPU     ID                    FUNCTION:NAME
  3  95381              vm_page_activate:13 
  3  95389             vm_page_activate:146 
  2  95381              vm_page_activate:13 
  2  95389             vm_page_activate:146 
  1  95387               vm_page_advise:332 
  1  95400               vm_page_advise:421 
  1  95387               vm_page_advise:332 
  1  95400               vm_page_advise:421 
  1  95387               vm_page_advise:332 
^C

Using DWARF to find call sites of inline functions

Tue, 07 Feb 2023 00:00:00 +1200

What is DWARF?

From the DWARF Debugging Standard’s documentation:

This document defines a format for describing programs to facilitate user source level debugging. This description can be generated by compilers, assemblers and linkage editors. It can be used by debuggers and other tools.

Debugging information entries (DIEs) are represented as a tree, one per compilation unit (CU). Each DIE has a tag (DW_TAG_*, see DWARF PDF Figure 1) denoting its class, and attributes (DW_AT_*, see DWARF PDF Figure 2) denoting its various characteristics, associated with it.

The next entry of a DIE is a child DIE. If a DIE doesn’t have children, the next entry is a “sibling”.

Consider the following structure:

CU1 (DW_TAG_compile_unit)
	func1 (DW_TAG_subprogram)
		DW_AT_foo
		DW_AT_bar
		func2 (DW_TAG_subprogram)
			DW_AT_foo
			DW_AT_bar
	myvar (DW_TAG_variable)
		DW_AT_foo
		DW_AT_bar
CU2 (DW_TAG_compile_unit)
	...

CU1 has func1 and myvar as chidren and CU2 as siblings. func1 has func2 as a child.

The debug file can be generated by compiling with the -g option. To dump DWARF info you can use readelf -wi <file> and dwarfdump <file>.

Inline functions in DWARF

DIEs of inline function declarations have the DW_TAG_subprogram tag and the DW_AT_inline attribute. DIEs of inline copies of this function will have the DW_TAG_inlined_subroutine tag.

Attributes inline copies can have include:

DW_AT_abstract_origin: DIE offset to the inline declaration.
DW_AT_call_file: Integer denoting the file the function is called in.
DW_AT_call_line: File line.
DW_AT_call_column: File column.
DW_AT_low_pc and DW_AT_high_pc: Lower and upper call boundaries. Explained in the next section.
DW_AT_ranges: Explained in the next section.

For example, if we dump the DWARF info for my FreeBSD kernel:

$ readelf -wi /usr/lib/debug/boot/kernel/kernel.debug > ~/foo

We find that vfs_freevnodes_dec gets inlined:

 <1><1dfa144>: Abbrev Number: 94 (DW_TAG_subprogram)
    <1dfa145>   DW_AT_name        : (indirect string) vfs_freevnodes_dec
    <1dfa149>   DW_AT_decl_file   : 1
    <1dfa14a>   DW_AT_decl_line   : 1447
    <1dfa14c>   DW_AT_prototyped  : 1
    <1dfa14c>   DW_AT_inline      : 1

Inline copies will have DW_AT_abstract_origin point to the declaration’s DIEs offset, in this case 0x1dfa144. If we look for 0x1dfa144, we do indeed find a few inline copies.

 <3><1dfe45e>: Abbrev Number: 24 (DW_TAG_inlined_subroutine)
    <1dfe45f>   DW_AT_abstract_origin: <0x1dfa144>
    <1dfe463>   DW_AT_low_pc      : 0xffffffff80cf701d
    <1dfe46b>   DW_AT_high_pc     : 0x38
    <1dfe46f>   DW_AT_call_file   : 1
    <1dfe470>   DW_AT_call_line   : 3458
    <1dfe472>   DW_AT_call_column : 5

 <3><1dfd2e2>: Abbrev Number: 58 (DW_TAG_inlined_subroutine)
    <1dfd2e3>   DW_AT_abstract_origin: <0x1dfa144>
    <1dfd2e7>   DW_AT_ranges      : 0x1f1290
    <1dfd2eb>   DW_AT_call_file   : 1
    <1dfd2ec>   DW_AT_call_line   : 3405
    <1dfd2ee>   DW_AT_call_column : 3

  ...there are more

As I described in the first section, a debug file may consist of multiple CUs that define the same inline function. We want treat each CU independently, that is, each inline copy is handled relative to its CU.

Calculating call boundaries

There are 2 cases we have to take care of when calculating the actual call boundaries of an inline copy.

The DIE has `DW_AT_low_pc` and `DW_AT_high_pc`

 <3><1dfe45e>: Abbrev Number: 24 (DW_TAG_inlined_subroutine)
    <1dfe45f>   DW_AT_abstract_origin: <0x1dfa144>
    <1dfe463>   DW_AT_low_pc      : 0xffffffff80cf701d
    <1dfe46b>   DW_AT_high_pc     : 0x38
    <1dfe46f>   DW_AT_call_file   : 1
    <1dfe470>   DW_AT_call_line   : 3458
    <1dfe472>   DW_AT_call_column : 5

In this case, the lower boundary is low_pc and the upper boundary is low_pc + high_pc, which, for the DIE shown in this example, the boundaries are:

low = 0xffffffff80cf701d
high = 0xffffffff80cf701d + 0x38 = 0xffffffff80cf7055

The DIE has `DW_AT_ranges`

 <3><1dfd2e2>: Abbrev Number: 58 (DW_TAG_inlined_subroutine)
    <1dfd2e3>   DW_AT_abstract_origin: <0x1dfa144>
    <1dfd2e7>   DW_AT_ranges      : 0x1f1290
    <1dfd2eb>   DW_AT_call_file   : 1
    <1dfd2ec>   DW_AT_call_line   : 3405
    <1dfd2ee>   DW_AT_call_column : 3

This is a bit more involved. DW_AT_ranges refers to the .debug_ranges section found in debug files. We can dump the ranges:

$ dwarfdump -N /usr/lib/debug/boot/kernel/kernel.debug
.debug_ranges
 Ranges group 0:
                ranges: 3 at .debug_ranges offset 0 (0x00000000) (48 bytes)
                        [ 0] range entry    0x00000019 0x00000073
                        [ 1] range entry    0x0000007e 0x00000106
                        [ 2] range end      0x00000000 0x00000000
 Ranges group 1:
                ranges: 3 at .debug_ranges offset 48 (0x00000030) (48 bytes)
                        [ 0] range entry    0x00000022 0x0000006a
                        [ 1] range entry    0x0000007e 0x00000106
                        [ 2] range end      0x00000000 0x00000000
 ...

If we search for 0x1f1290 (the inline copy’s ranges), we find its range group:

 Ranges group 38809:
                ranges: 3 at .debug_ranges offset 2036368 (0x001f1290) (48 bytes)
                        [ 0] range entry    0x000025c8 0x000025f9
                        [ 1] range entry    0x0000261a 0x00002621
                        [ 2] range end      0x00000000 0x00000000

To get the call boundaries, we add each range entry’s boundaries to the DW_AT_low_pc of the root DIE of the CU. The root DIE is found programmatically, but I happen to know that in this case, the root DIE is:

 <0><1dee9fb>: Abbrev Number: 1 (DW_TAG_compile_unit)
    <1dee9fc>   DW_AT_producer    : (indirect string) FreeBSD clang version 13.0.0 (git@github.com:llvm/llvm-project.git llvmorg-13.0.0-0-gd7b669b3a303)
    <1deea00>   DW_AT_language    : 12	(C99)
    <1deea02>   DW_AT_name        : (indirect string) /usr/src/sys/kern/vfs_subr.c
    <1deea06>   DW_AT_stmt_list   : 0x6cb448
    <1deea0a>   DW_AT_comp_dir    : (indirect string) /usr/obj/usr/src/amd64.amd64/sys/GENERIC
    <1deea0e>   DW_AT_low_pc      : 0xffffffff80cf4020
    <1deea16>   DW_AT_high_pc     : 0xde3d

Finally, we end up with the following boundaries:

low = 0xffffffff80cf4020 + 0x000025c8 = 0xffffffff80cf65e8
high = 0xffffffff80cf4020 + 0x000025f9 = 0xffffffff80cf6619

low = 0xffffffff80cf4020 + 0x0000261a = 0xffffffff80cf663a
high = 0xffffffff80cf4020 + 0x00002621 = 0xffffffff80cf6641

Finding the caller function

There are cases where we want to know which function an inline function is being called from. Because DWARF does not encode that information, we’ll have to scan ELF symbol tables.

$ readelf -s /usr/lib/debug/boot/kernel/kernel.debug

Since we know the inline copy’s boundaries, we only have to find which symbol’s boundaries the inline copy is inside. In other words, the following condition has to be met:

sym_lower_bound <= inline_lower_bound <= inline_upper_bound <= sym_upper_bound

Because searching through ELF symbol tables manually and doing calculations by hand would take too long, the best way to do this is programmatically through LibELF.

inlinecall(1)

I wrote a little program that does everything I talked about in this post automatically. It works on FreeBSD as-is, and most likely needs some modification to get it to work on other platforms.

The program takes an inline function name and a debug file as arguments:

inlinecall <function> <file>

And outputs the results in the following form:

cu1_func_declaration_file:line
	[low_bound - high_bound]	inline_copy1_file:line	caller_func()
	[low_bound - high_bound]	inline_copy2_file:line	caller_func()
	...
cu2_func_declaration_file:line
	...
...

For example:

$ inlinecall critical_enter /usr/lib/debug/boot/kernel/kernel.debug
/usr/src/sys/sys/systm.h:175
        [0xffffffff809eb51f - 0xffffffff809eb526]       /usr/src/sys/kern/kern_intr.c:1387      intr_event_handle()
/usr/src/sys/sys/systm.h:175
        [0xffffffff80a051f4 - 0xffffffff80a05208]       /usr/src/sys/kern/kern_malloc.c:431     malloc_type_freed()
        [0xffffffff80a0514c - 0xffffffff80a0515b]       /usr/src/sys/kern/kern_malloc.c:388     malloc_type_zone_allocated()
/usr/src/sys/sys/systm.h:175
        [0xffffffff80a263c4 - 0xffffffff80a263d3]       /usr/src/sys/kern/kern_resource.c:509   rtp_to_pri()
/usr/src/sys/sys/systm.h:175
        [0xffffffff80a28f59 - 0xffffffff80a28f5f]       /usr/src/sys/kern/kern_rmlock.c:775     _rm_assert()
        [0xffffffff80a29087 - 0xffffffff80a2908d]       /usr/src/sys/kern/kern_rmlock.c:801     _rm_assert()
        [0xffffffff80a29eb0 - 0xffffffff80a29eb7]       /usr/src/sys/kern/kern_rmlock.c:645     _rm_rlock_debug()
        [0xffffffff80a28c4b - 0xffffffff80a28c5a]       /usr/src/sys/kern/kern_rmlock.c:160     unlock_rm()
...more

Nested inline functions

inlinecall(1) resolves nested inline functions recursively:

$ ./inlinecall critical_enter /usr/lib/debug/boot/kernel/kernel.debug
/usr/src/sys/sys/systm.h:175
        [0xffffffff80a19d7a - 0xffffffff80a19d8b]       /usr/src/sys/sys/buf_ring.h:80  drbr_enqueue()
/usr/src/sys/sys/systm.h:175
        [0xffffffff80a6387a - 0xffffffff80a6388b]       /usr/src/sys/sys/buf_ring.h:80  drbr_enqueue()
...

Looking at the definition of critical_enter()’s caller function in buf_ring.h:

static __inline int
buf_ring_enqueue(struct buf_ring *br, void *buf)
{
	...
	critical_enter();
	...
}

Even though inlinecall(1) reported that critical_enter() is called from drbr_enqueue() in buf_ring.h:80, we see that it’s called from buf_ring_enqueue() instead, but buf_ring_enqueue() is also an inline function:

$ ./inlinecall buf_ring_enqueue /usr/lib/debug/boot/kernel/kernel.debug
/usr/src/sys/sys/buf_ring.h:63
        [0xffffffff80a19d7a - 0xffffffff80a19dcd]       /usr/src/sys/net/ifq.h:337      drbr_enqueue()
        [0xffffffff80a19ddc - 0xffffffff80a19e18]       /usr/src/sys/net/ifq.h:337      drbr_enqueue()
        [0xffffffff80a19e1f - 0xffffffff80a19e3b]       /usr/src/sys/net/ifq.h:337      drbr_enqueue()
/usr/src/sys/sys/buf_ring.h:63
        [0xffffffff80a6387a - 0xffffffff80a638cd]       /usr/src/sys/net/ifq.h:337      drbr_enqueue()
        [0xffffffff80a638dc - 0xffffffff80a63918]       /usr/src/sys/net/ifq.h:337      drbr_enqueue()
        [0xffffffff80a6391f - 0xffffffff80a6393b]       /usr/src/sys/net/ifq.h:337      drbr_enqueue()
/usr/src/sys/sys/buf_ring.h:63
        [0xffffffff80d1f81a - 0xffffffff80d1f879]       /usr/src/sys/net/ifq.c:57       drbr_enqueue()
        [0xffffffff80d1f91d - 0xffffffff80d1f964]       /usr/src/sys/net/ifq.c:57       drbr_enqueue()
        [0xffffffff80d1f9dd - 0xffffffff80d1f9f5]       /usr/src/sys/net/ifq.c:57       drbr_enqueue()
/usr/src/sys/sys/buf_ring.h:63
        [0xffffffff80ff07ba - 0xffffffff80ff080d]       /usr/src/sys/net/ifq.h:337      drbr_enqueue()
        [0xffffffff80ff081c - 0xffffffff80ff0858]       /usr/src/sys/net/ifq.h:337      drbr_enqueue()
        [0xffffffff80ff085f - 0xffffffff80ff087b]       /usr/src/sys/net/ifq.h:337      drbr_enqueue()

Here drbr_enqueue() is defined twice — once in ifq.h and once in ifq.c. The definition in ifq.h is also an inline definition, and in ifq.c it’s a non-inline one. We know that buf_ring_enqueue() is called from the non-inline version of drbr_enqueue(), otherwise inlinecall(1) would have reported the function which calls the inline version of drbr_enqueue().

Rolf Dobelli: Avoid the News

Sat, 24 Dec 2022 00:00:00 +1200

The article was written by Rolf Dobelli. I reformatted it to HTML and added a table of contents, because I couldn’t find a non-PDF version of it.

Prologue

This article is the antidote to news. It is long, and you probably won’t be able to skim it. Thanks to heavy news consumption, many people have lost the reading habit and struggle to absorb more than four pages straight. This article will show you how to get out of this trap — if you are not already too deeply in it.

News is to the mind what sugar is to the body

We are so well informed and yet we know so little. Why?

We are in this sad condition because 200 years ago we invented a toxic form of knowledge called “news.” The time has come to recognize the detrimental effects that news has on individuals and societies, and to take the necessary steps to shield yourself from its dangers.

At core, human beings are cavemen in suits and dresses. Our brains are optimized for our original hunter-gatherer environment where we lived in small bands of 25 to 100 individuals with limited sources of food and information. Our brains (and our bodies) now live in a world that is the opposite of what we are designed to handle. This leads to great risk and to inappropriate, outright dangerous behavior.

In the past few decades, the fortunate among us have recognized the hazards of living with an overabundance of food (obesity, diabetes) and have started to shift our diets. But most of us do not yet understand that news is to the mind what sugar is to the body. News is easy to digest. The media feeds us small bites of trivial matter, tidbits that don’t really concern our lives and don’t require thinking. That’s why we experience almost no saturation. Unlike reading books and long, deep magazine articles (which requires thinking), we can swallow limitless quantities of news flashes, like bright-colored candies for the mind.

Today, we have reached the same point in relation to information overload that we faced 20 years ago in regard to food intake. We are beginning to recognize how toxic news can be and we are learning to take the first steps toward an information diet.

This is my attempt to clarify the toxic dangers of news – and to recommend some ways to deal with it. I have now gone without news for a year, so I can see, feel and report the effects of this freedom first hand: less disruption, more time, less anxiety, deeper thinking, more insights. It’s not easy, but it’s worth it.

My good friend Nassim Nicholas Taleb, author of The Black Swan, was one of the first people to recognize news consumption as a serious problem. I owe many of the following insights to him.

No 1 — News misleads us systematically

News reports do not represent the real world.

Our brains are wired to pay attention to visible, large, scandalous, sensational, shocking, people-related, story-formatted, fast changing, loud, graphic onslaughts of stimuli. Our brains have limited attention to spend on more subtle pieces of intelligence that are small, abstract, ambivalent, complex, slow to develop and quiet, much less silent. News organizations systematically exploit this bias.

News media outlets, by and large, focus on the highly visible. They display whatever information they can convey with gripping stories and lurid pictures, and they systematically ignore the subtle and insidious, even if that material is more important. News grabs our attention; that’s how its business model works. Even if the advertising model didn’t exist, we would still soak up news pieces because they are easy to digest and superficially quite tasty.

The highly visible misleads us.

Take the following event. A car drives over a bridge, and the bridge collapses. What does the news media focus on? On the car. On the person in the car. Where he came from. Where he planned to go. How he experienced the crash (if he survived). What kind of person he is (was). But — that is all completely irrelevant. What’s relevant? The structural stability of the bridge. That’s the underlying risk that has been lurking and could lurk in other bridges. That is the lesson to be learned from this event.

The car doesn’t matter at all. Any car could have caused the bridge to collapse. It could have been a strong wind or a dog walking over the bridge. So, why does the media cover the car? Because it’s flashy, it’s dramatic, it’s a person (non-abstract), and it’s news that’s cheap to produce.

As a result of news, we walk around with the completely wrong risk map in our heads.

Terrorism is overrated. Chronic stress is underrated.
The collapse of Lehman Brothers is overrated. Fiscal irresponsibility is underrated.
Astronauts are overrated. Nurses are underrated.
Britney Spears is overrated. IPCC reports are underrated.
Airplane crashes are overrated. Resistance to antibiotics is underrated.

We are not rational enough to be exposed to the news-mongering press. It is a very dangerous thing, because the probabilistic mapping we get from consuming news is entirely different from the actual risks that we face. Watching an airplane crash on television is going to change your attitude toward that risk regardless of its real probability, no matter your intellectual sophistication. If you think you can compensate for this bias with the strength of your own inner contemplation, you are wrong. Bankers and economists — who have powerful incentives to compensate for newsborne hazards — have shown that they cannot. The only solution: cut yourself off from news consumption entirely.

No 2 — News is irrelevant

Out of the approximately 10,000 news stories you have read in the last 12 months, name one that — because you consumed it — allowed you to make a better decision about a serious matter affecting your life, your career, your business — compared to what you would have known if you hadn’t swallowed that morsel of news.

The point is: the consumption of news is irrelevant to the forces that really matter in your life. At its best, it is entertaining, but it is still irrelevant.

Assume that, against all odds, you found one piece of news that substantially increased the quality of your life — compared to how your life would have unfolded if you hadn’t read or seen it. How much trivia did your brain have to digest to get to that one relevant nugget? Even that question is a hindsight analysis. Looking forward, we can’t possibly identify the value of a piece of news before we see it, so we are forced to digest everything on the news buffet line. Is that worthwhile? Probably not.

In 1914, the news story about the assassination in Sarajevo dwarfed all other reports in terms of its global significance. But, the murder in Sarajevo was just one of several thousand stories in circulation that day. No news organization treated this historically pivotal homicide as anything more than just another politically inspired assassination.

The first Internet browser debuted in 1995. The public birth of this hugely relevant piece of software barely made it into the press despite its vast future impact.

People find it very difficult to recognize what’s relevant. It’s much easier to recognize what’s new. We are not equipped with sensory organs for relevance. Relevance doesn’t come naturally. News does. That’s why the media plays on the new. (If our minds were structured the other way round, the media would certainly play on the relevant.) The relevant versus the new is the fundamental battle of the modern man.

News floods you with a worldview that is not relevant to your life. What does relevance mean? It means: what is important to you personally. Relevance is a personal choice. Don’t take the media’s view for it. To the media, any tale that sells lots of copies is relevant – Darfur, Paris Hilton, a train crash in China, some idiotic world record (like someone who ate 78 cheeseburgers in an hour). This swindle is at the core of the news industry’s business model. It sells the relevant, but delivers the new.

Media organizations want you to believe that news offers individuals some sort of a competitive advantage. Many people fall for that. We get anxious when we’re cut off from the flow of news. We fear we’re missing something important. In reality, news consumption is a competitive disadvantage. The less news you consume the bigger the advantage you have.

Afraid you will miss “something important”? From my experience, if something really important happens, you will hear about it, even if you live in a cocoon that protects you from the news. Friends and colleagues will tell you about relevant events far more reliably than any news organization. They will fill you in with the added benefit of meta-information, since they know your priorities and you know how they think. You will learn far more about really important events and societal shifts by reading about them in specialized journals, in-depth magazines or good books and by talking to the people who know.

No 3 — News limits understanding

News has no explanatory power. News items are little bubbles popping on the surface of a deeper world.

News organizations pride themselves on correctly reporting the facts, but the facts that they prize are just epiphenomena of deeper causes. Both news organizations and news consumers mistake knowing a litany of facts for understanding the world.

It’s not “news facts” that are important, but the threads that connect them. What we really want is to understand the underlying processes, how things happen. Unfortunately, precariously few news organizations manage to explain causation because the underlying processes that govern significant social, political and environmental movements mostly are invisible. They are complex, non-linear and hard for our (and the journalists’) brains to digest. Why do news organizations go for the light stuff, the anecdotes, scandals, people-stories and pictures? The answer is simple: because they are cheap to produce.

The important stories are non-stories: slow, powerful movements that develop below the journalists’ radar but have a transforming effect.

Most people believe that having more information helps them make better decisions. News organizations support this belief. Hell, it’s in their interest. Will accumulating facts help you understand the world? Sadly, no. The relationship is actually inverted. The more “news factoids” you digest, the less of the big picture you will understand.

No evidence exists to indicate that information junkies are better decision makers. They are certainly not more successful than the average Joe. If more information leads to higher economic success, we would expect journalists to be at the top of the pyramid. That’s not the case. Quite the contrary. We don’t know what makes people successful, but amassing news tidbits is certainly not it.

Reading news to understand the world is worse than not reading anything. What’s best: cut yourself off from daily news consumption entirely. Read books and thoughtful journals instead of gulping down flashing headlines.

No 4 — News is toxic to your body

News constantly triggers the limbic system. Panicky stories spur the release of cascades of glucocordicoid (cortisol). This deregulates your immune system and inhibits the release of growth hormones. In other words, your body finds itself in a state of chronic stress. High glucocordicoid levels cause impaired digestion, lack of growth (cell, hair, bone), nervousness and susceptibility to infections. News consumers risk impairing their physical health. The other potential side effects of news include fear, aggression, tunnel-vision and desensitization.

No 5 — News massively increases cognitive errors

News feeds the mother of all cognitive errors: confirmation bias. We automatically, systematically filter out evidence that contradicts our preconceptions in favor of evidence that confirms our beliefs. In the words of Warren Buffett: “What the human being is best at doing is interpreting all new information so that their prior conclusions remain intact.” That is the confirmation bias. News consumption, especially customized news intake, exacerbates this human flaw. The result is that we walk around in a cloud of seemingly confirming data — even when our theories about the world and ourselves may be wrong. We become prone to overconfidence, take stupid risks and misjudge opportunities.

News not only feeds the confirmation bias, it exacerbates another cognitive error: the story bias. Our brains crave stories that “make sense” — even if they don’t correspond to reality. And news organizations are happy to deliver those fake stories. Instead of just reporting that the stock market declined (or increased) by 2%, TV news anchors proclaim, “The market declined by 2% because of X.” This X could be a bank profit forecast, fear about the Euro, non-farm payroll statistics, a Fed decision, a terrorist attack in Madrid, a subway strike in New York, a handshake between two presidents, anything, really.

This reminds me of high school. My history textbook specified seven reasons (not six, not eight) why the French Revolution erupted. The fact is, we don’t know why the French Revolution broke out. And especially not why it exploded specifically in 1789. And we don’t know why the stock market moves as it moves. Too many factors go into such shifts. We don’t know why a war breaks out, a technological breakthrough is achieved or why the oil price jumps. Any journalist who writes, “The market moved because of X” or “the company went bankrupt because of Y” is an idiot. Of course, X might have had a casual influence, but it’s far from established, and other influences may be much more meaningful. To a large degree, news reports consist of nothing but stories and anecdotes that end up substituting for coherent analyses. I am fed up with this cheap way of “explaining” the world. It’s inappropriate. It’s irrational. It’s forgery. And I refuse to let it contaminate my thinking.

No 6 — News inhibits thinking

Thinking requires concentration. Concentration requires uninterrupted time. News items are like free-floating radicals that interfere with clear thinking. News pieces are specifically engineered to interrupt you. They are like viruses that steal attention for their own purposes. This is not about stealing time (see reason 8). This is about the inability to think clearly because you have opened yourself up to the disruptive factoid stream.

News makes us shallow thinkers. But it’s worse than that. News severely affects memory.

There are two types of memory. Long-range memory’s capacity is nearly infinite, but working memory is limited to a minimum amount of slippery data (try repeating a 10-digit phone number after you hear it for the first time). The path from short-term to long-term memory is a choke-point in the brain, but anything you want to understand must past through it. If this passageway is disrupted, nothing passes through. Because news disrupts concentration, it actively weakens comprehension.

You don’t visit Paris for just one hour or speed through the Museum of Modern Art in two minutes. Why not? Because the brain needs spool- up time. Building up concentration takes a minimum of a 10-minute read. Given less time, your brain will process the information superficially and barely store it. News pieces are like wind hitting your cheek. Ask yourself: What are the top ten news items from a month ago (that are no longer in the news today)? If you have a hard time remembering, you are not alone. Why would you want to consume something that doesn’t add to your body of knowledge?

The online news has an even worse impact. In a 2001 study[1] two scholars in Canada showed that comprehension declines as the number of hyperlinks in a document increase. Why? Because whenever a link appears, your brain has to at least make the choice not to click, which in itself is distracting.

News consumers are suckers for irrelevancy, and online news consumers are the biggest suckers. News is an interruption system. It seizes your attention only to scramble it. Besides a lack of glucose in your blood stream, news distraction is the biggest barricade to clear thinking.

No 7 — News changes the structure of your brain

News works like a drug. As stories develop, we naturally want to know how they continue. With hundreds of arbitrary story lines in our heads, this craving is increasingly compelling and hard to ignore.

Why is news addictive? Once you get into the habit of checking the news, you are driven to check it even more often. Your attention is set on fast-breaking events, so you hunger for more data about them. This has to do with a process called “long-term potentiation” (LTP) and the reward circuits in your brain. Addicts seek more of an addictive substance to get their fix, because they need more stimulation than non-addicts to reach a satisfying reward threshold. If you set your attention on other things – like literature, science, art, history, cooking, pet grooming, whatever – you will become more focused on those things. That’s just how the brain works.

Science used to think that our brain, the dense connections formed among the 100 billion neurons inside our skulls, was largely fixed by the time we reached adulthood. Today we know that this is not the case. The human brain is highly plastic. Nerve cells routinely break old connections and form new ones. When we adapt to a new cultural phenomenon, including the consumption of news, we end up with a different brain. Adaptation to news occurs at a biological level. News reprograms us. That means our brain works differently even when we’re not consuming news. And that’s dangerous.

The more news we consume, the more we exercise the neural circuits devoted to skimming and multitasking while ignoring those used for reading deeply and thinking with profound focus. Most news consumers — even if they used to be avid book readers — have lost the ability to read and absorb lengthy articles or books. After four, five pages they get tired, their concentration vanishes, they become restless. It’s not because they got older or their schedules became more onerous. It’s because the physical structure of their brains has changed. In the words of Professor Michael Merzenich (University of California, San Francisco), a pioneer in the field of neuroplasticity: “We are training our brains to pay attention to the crap.”

Deep reading is indistinguishable from deep thinking. When you consume news, your brain structurally changes. This means that the way you think changes. Regaining the capacity for concentration and contemplation will take nothing less than a radical news-free diet.

No 8 — News is costly

News wastes time. It exacts exorbitant costs.

News taxes productivity three ways. First, count the consumption-time that news demands. That’s the time you actually waste reading, listening to or watching the news.

Second, tally up the refocusing time — or switching cost. That’s the time you waste trying to get back to what you were doing before the news interrupted you. You have to collect your thoughts. What were you about to do? Every time you disrupt your work to check the news, reorienting yourself wastes more time.

Third, news distracts us even hours after we’ve digested today’s hot items. News stories and images may pop into your mind hours, sometimes days later, constantly interrupting your train of thought. Why would you want to do that to yourself?

If you read the newspaper for 15 minutes each morning, then check the news for 15 minutes during lunch and 15 minutes before you go to bed, you’re eating substantial time. Then, add five minutes here and there when you’re at work, plus distraction and refocusing time. You will lose productive hours totaling at least half a day every week. Half a day — and for what?

On a global level, the loss in potential productivity is huge. Take the 2008 terror attacks in Mumbai, where terrorists murdered some 200 people in an act of chilling exhibitionism. Imagine that a billion people devoted, on average, one hour of their attention to the Mumbai tragedy: following the news, watching some talking head on TV, thinking about it. The number is a wild guess, but the guess is far from a wild number. India, alone, has more than a billion people. Many of them spent whole days following the drama. One billion people times one hour is one billion hours, which is more than 100,000 years. The global average life expectancy is today 66 years. So nearly 2,000 lives were swallowed by news consumption. It’s far more than the number of people murdered. In a sense, the newscasters became unwilling bedfellows of the terrorists. At least the Mumbai attacks had actual impact. Look at the hours lost when Michael Jackson died — no real content in the stories, and millions of hours wasted.

Information is no longer a scarce commodity. But attention is. Why give it away so easily? You are not that irresponsible with your money, your reputation or your health. Why give away your mind?

No 9 — News sunders the relationship between reputation and achievement

Reputation affects how people cooperate in society. In our ancestral past, a person’s reputation was directly linked to his or her achievements. You saw that your fellow tribe member killed a tiger single handedly and you spread word of his bravery. With the advent of mass-produced news, the strange concept of “fame” entered our society.

Fame is misleading because generally people become famous for reasons that have little relevance to our lives. The media grants fame to movie stars and news anchors for scant reason. News sunders the relationship between reputation and achievement. The tragedy is that pop notoriety crowds out the achievements of those who make more substantive contributions.

No 10 — News is produced by journalists

Good professional journalists take time with their stories, authenticate their facts and try to think things through. But like any profession, journalism has some incompetent, unfair practitioners who don’t have the time — or the capacity — for deep analysis. You might not be able to tell the difference between a polished professional report and a rushed, glib, paid-by-the-piece article by a writer with an ax to grind. It all looks like news.

My estimate: fewer than 10% of the news stories are original. Less than 1% are truly investigative. And only once every 50 years do journalists uncover a Watergate. Many reporters cobble together the rest of the news from other people’s reports, common knowledge, shallow thinking and whatever the journalist can find on the internet. Some reporters copy from each other or refer to old pieces, without necessarily catching up with any interim corrections. The copying and the copying of the copies multiply the flaws in the stories and their irrelevance.

No 11 — Reported facts are sometimes wrong, forecasts always

Sometimes, reported facts are simply mistaken. With reduced editorial budgets at major publications, fact checking may be an endangered step in the news process.

The New Yorker magazine is legendary for its fact checking. The story goes that when an article mentioned the Empire State Building, someone from the fact-checking department would go out and visually verify that, in fact, the building was still standing. I don’t know if the story is true, but it highlights a point. Today, the fact checker is an endangered species at most news companies (though still alive and well at The New Yorker).

Many news stories include predictions, but accurately predicting anything in a complex world is impossible. Overwhelming evidence indicates that forecasts by journalists and by experts in finance, social development, global conflicts and technology are almost always completely wrong. So, why consume that junk?

Did the newspapers predict World War I, the Great Depression, the sexual revolution, the fall of the Soviet empire, the rise of the Internet, resistance to antibiotics, the fall of Europe’s birth rate or the explosion in depression cases? Maybe, you’d find one or two correct predictions in a sea of millions of mistaken ones. Incorrect forecast are not only useless, they are harmful.

To increase the accuracy of your predictions, cut out the news and roll the dice or, if you are ready for depth, read books and knowledgeable journals to understand the invisible generators that affect our world.

No 12 — News is manipulative

Our evolutionary past has equipped us with a good bullshit detector for face-to-face interactions. We automatically use many clues to detect manipulation, clues that go beyond the verbal message and include gesture, facial expression, and signs of nervousness such as sweaty palms, blushing and body odor. Living in small bands of people, we almost always knew the background of the messenger. Information always came with a rich set of meta-data. Today, even conscientious readers find that distinguishing even-handed news stories from ones that have a private agenda is difficult and energy consuming. Why go through that?

Stories are selected or slanted to please advertisers (advertising bias) or the owners of the media (corporate bias), and each media outlet has a tendency to report what everyone else is reporting, and to avoid stories that will offend anyone (mainstream bias).

The public relations (PR) industry is as large as the news reporting industry — the best proof that journalists and news organizations can be manipulated, or at least influenced or swayed. Corporations, interest groups and other organizations would not expend such huge sums on PR if it didn’t work. If spinmeisters can manipulate journalists, who have a natural skepticism toward powerful organizations, what makes you think you can escape their trickery?

Take the Nurse Nayirah story. Nayirah was a 15- year-old Kuwaiti girl who testified to the U.S. Congress during the run up to the 1991 Gulf War. She alleged that she had witnessed the murder of infant children by Iraqi soldiers in Kuwait. Virtually every media outlet covered the story. The U.S. public was outraged, which in turn pushed Congress closer to approving the war. Her testimony, which all media outlets regarded as credible at the time, has since come to be regarded as wartime propaganda.

Journalism shapes a common picture of the world and a common set of narratives for discussing it. It sets the public agenda. Hold on: do we really want news reporters to set the public agenda? I believe that agenda setting by the media is just bad democracy.

No 13 — News makes us passive

News stories are overwhelmingly about things you cannot influence. This sets readers up to have a fatalistic outlook on the world.

Compare this with our ancestral past, where you could act upon practically every bit of news. Our evolutionary past prepared us to act on information, but the daily repetition of news about things we can’t act upon makes us passive. It saps our energy. It grinds us down until we adopt a worldview that is pessimistic, desensitized, sarcastic and fatalistic.

If the human brain encounters a barrage of ambiguous information without being able to act upon that information, it can react with passivity and a sense of victimhood. The scientific term is learned helplessness. It’s a bit of a stretch, but I would not be surprised if news consumption at least partially contributes to the widespread disease of depression. Viewed on a timeline, the spread of depression coincides almost perfectly with the growth and maturity of the mass media. Maybe it’s a coincidence, or maybe the constant onslaught of fire, famine, flood and failure adds to depression, even if these sad reports come from far away.

No 14 — News gives us the illusion of caring

Kathleen Norris (even if I don’t share most of her ideas) said it best: “We may want to believe that we are still concerned, as our eyes drift from a news anchor announcing the latest atrocity to the NBA scores and stock market quotes streaming across the bottom of the screen. But the ceaseless bombardment of image and verbiage makes us impervious to caring.”

News wraps us in a warm global feeling. We are all world citizens. We are all connected. The planet is just one global village. We sing “We Are the World” and wave the little flame of our lighters in perfect harmony with thousands of others. This gives us a glowing, fuzzy feeling that delivers the illusion of caring but doesn’t get us anywhere. This allure of anything bespeaking global brotherhood smells like a gigantic chimera. The fact is, consuming news does not make us more connected to each other. We are connected because we interact and trade.

No 15 — News kills creativity

Things we already know limit our creativity. This is one reason that mathematicians, novelists, composers and entrepreneurs often produce their most creative works at a young age. They are oblivious to much that has been tried before. Their brains enjoy a wide, uninhabited space that emboldens them to come up with and pursue novel ideas.

I don’t know a single truly creative mind who is a news junkie – not a writer, not a composer, mathematician, physician, scientist, musician, designer, architect or painter. On the other hand, I know a whole bunch of viciously uncreative minds who consume news like drugs.

The creativity-killing effect of news might also be due to something simpler we’ve discussed before: distraction. I just can’t imagine producing novel ideas with the distraction that news always delivers. If you want to come up with old solutions, read news. If you are looking for new solutions, don’t read news.

What to do instead

Go without news. Cut it out completely. Go cold turkey.

Make news as inaccessible as possible. Delete the news apps from your iPhone. Sell your TV. Cancel your newspaper subscriptions. Do not pick up newspapers and magazines that lie around in airports and train stations. Do not set your browser default to a news site. Pick a site that never changes. The more stale the better. Delete all news sites from your browser’s favorites list. Delete the news widgets from your desktop.

If you want to keep the illusion of “not missing anything important”, I suggest you glance through the summary page of the Economist once a week. Don’t spend more than five minutes on it.

Read magazines and books which explain the world — Science, Nature, The New Yorker, The Atlantic Monthly. Go for magazines that connect the dots and don’t shy away from presenting the complexities of life — or from purely entertaining you. The world is complicated, and we can do nothing about it. So, you must read longish and deep articles and books that represent its complexity. Try reading a book a week. Better two or three. History is good. Biology. Psychology. That way you’ll learn to understand the underlying mechanisms of the world. Go deep instead of broad. Enjoy material that truly interests you. Have fun reading.

The first week will be the hardest. Deciding not to check the news while you are thinking, writing or reading takes discipline. You are fighting your brain’s built-in tendency. Initially, you will feel out of touch or even socially isolated. Every day you will be tempted to check your favorite news Web site. Don’t do it. Stick to the cold-turkey plan. Go 30 days without news. After 30 days, you will have a more relaxed attitude toward the news. You will find that you have more time, more concentration and a better understanding of the world.

After a while, you will realize that despite your personal news blackout, you have not missed — and you’re not going to miss — any important facts. If some bit of information is truly important to your profession, your company, your family or your community, you will hear it in time – from your friends, your mother-in-law or whomever you talk to or see. When you are with your friends, ask them if anything important is happening in the world. The question is a great conversation starter. Most of the time, the answer will be: “not really.”

Are you afraid that living a news-free existence will make you an outcast at parties? Well, you might not know that Lindsay Lohan went to jail, but you will have more intelligent facts to share — about the cultural meaning of the food you are eating or the discovery of exosolar planets. Never be shy about discussing your news diet. People will be fascinated.

Good News

Society needs journalism — but in a different way.

Investigative journalism is relevant in any society. We need more hard-core journalists digging into meaningful stories. We need reporting that polices our society and uncovers the truth. The best example is Watergate. But important findings don’t have to arrive in the form of news. Often, reporting is not time sensitive. Long journal articles and in-depth books are fine forums for investigative journalism — and now that you’ve gone cold turkey on the news, you’ll have time to read them.

Disclaimer

Disclaimer The above statements reflect the most truthful viewpoint I can achieve at the time of this writing. I reserve the right to revise my views at any time. I might even indulge in the freedom of contradicting myself. I have done so in the past and will most certainly do so in the future. The only reason I would change my views (a switch which would undoubtedly be noticed by the “consistency police” (usually journalists with good high-school degrees) is because the new version is closer to the truth, not ever because I would gain any personal advantage.

Notes

[1] Nicholas Carr: The Web Shatters Focus, Rewires Brains, Wired, May 2010

In defense of the Old Web

Wed, 17 Aug 2022 00:00:00 +1200

The internet has reached the point where almost everything has been concertrated in just a few platforms. This is both opposed to the original idea of a decentralized and free internet, and is also used as a tool for control, since the flow of information is “managed” only by a handful of companies.

My rather romanticized proposal is that we should make an attempt return to the old ways of the internet (1990s-2000s) — when personal websites and small communities were thriving — not because of nostalgia, but because it espoused better values and promoted creativity, despite its problems (spam, malware, bad security practices, unencrypted traffic). This might very well be a pipe dream at this point, but I think it would be great to at least see the existing movement attracting more people than it already does.

I was initially working on a full article explaining my viewpoint in depth, but the following articles express them better than I could ever have:

So, how can you be part of the small web? To start off, you need:

A domain name.
Somewhere to host your website/service. I rent a Vultr VPS with the cheapest plan available, which is more than enough for my needs, but you can even do self-hosting at home if you want. If you do rent from Vultr, you can follow this guide.
To connect the domain name with the server, so that your website can be reached.
A stable and secure operating system for servers, such as OpenBSD.

A list of guides I’ve written:

To make finding other websites easier, have a links page, and consider being part of a webring.

The tools you choose to manage your website depend on personal preference and needs, but I firmly believe that because building a website is not rocket science, and because the web has been getting severely bloated you don’t need anything more than a few command line utilities, a text editor, and perhaps a static site generator. Modern web frameworks tend to cause more headaches than actually improve workflow, so I’ll refrain from recommending them. I like writing articles in Markdown, and using Hugo for static site generation and templating.

Making a character device kernel module on FreeBSD

Sun, 10 Jul 2022 00:00:00 +1200

This article assumes advanced knowledge of C and a basic understanding of the FreeBSD kernel and programming environment. It is also meant to serve as a template/reference and not a complete implementation.

Sample code can be found here.

Also mirrored on the FreeBSD Wiki.

Implementing the device

malloc declaration

Kernel modules have their own malloc types, which are defined as follows:

MALLOC_DECLARE(M_MYDEV);
MALLOC_DEFINE(M_MYDEV, "mydev", "device description");

Then, you can use malloc(9) and free(9) as:

p = malloc(sizeof(foo), M_MYDEV, M_WAITOK | M_ZERO);
free(p, M_MYDEV);

`cdevsw` structure

The device’s properties and methods are stored in a cdevsw (Character Device Switch) structure, defined in sys/conf.h. The fields we care about most of the time are the following:

struct cdevsw {
	int			d_version;
	u_int			d_flags;
	const char		*d_name;
	d_open_t		*d_open;
	d_fdopen_t		*d_fdopen;
	d_close_t		*d_close;
	d_read_t		*d_read;
	d_write_t		*d_write;
	d_ioctl_t		*d_ioctl;
	d_poll_t		*d_poll;
	d_mmap_t		*d_mmap;
	d_strategy_t		*d_strategy;
	dumper_t		*d_dump;
	d_kqfilter_t		*d_kqfilter;
	d_purge_t		*d_purge;
	d_mmap_single_t		*d_mmap_single;
	...
};

All the *_t pointers are pointers to functions meant to be implemented by the driver. Not all functions have to be implemented however, but we usually do need to implement open(), close(), read(), write() and ioctl().

Declare the functions using some handy typedefs:

static d_open_t		mydev_open;
static d_close_t	mydev_close;
static d_read_t		mydev_read;
static d_write_t	mydev_write;
static d_ioctl_t	mydev_ioctl;

Declare the cdevsw structure:

static struct cdevsw mydev_cdevsw = {
	.d_name     = "mydev",
	.d_version  = D_VERSION,
	.d_flags    = D_TRACKCLOSE,
	.d_open     = mydev_open,
	.d_close    = mydev_close,
	.d_read     = mydev_read,
	.d_write    = mydev_write,
	.d_ioctl    = mydev_ioctl,
};

The D_TRACKCLOSE flag tells the kernel to track when the device closes so that it can close normally in case something goes wrong.

open() and close()

Those two functions are mainly used for resource allocation/deallocation and environment preparation:

static int
mydev_open(struct cdev *dev, int flags, int devtype, struct thread *td)
{
	int error = 0;

	/* do stuff */

	return (error);
}

static int
mydev_close(struct cdev *dev, int flags, int devtype, struct thread *td)
{
	int error = 0;

	/* do stuff */

	return (error);
}

read() and write()

It’s good practice to keep an internal buffer. Below is a very simplified example. The buffer in this example is allocated and deallocated on module load and unload respectively:

#define BUFSIZE (1 << 16)

struct foo {
	char	buf[BUFSIZE + 1];
	size_t	len;
};

static struct foo *foo;

Data to be received or sent back is stored in uio and the copy from user to kernel memory is done through uiomove(9), defined in sys/uio.h:

static int
mydev_read(struct cdev *dev, struct uio *uio, int ioflag)
{
	size_t amnt;
	int v, error = 0;

	/*
	 * Determine how many bytes we have to read. We'll either read the
	 * remaining bytes (uio->uio_resid) or the number of bytes requested by
	 * the caller.
	 */
	v = uio->uio_offset >= foo->len + 1 ? 0 : foo->len + 1 - uio->uio_offset;
	amnt = MIN(uio->uio_resid, v);

	/* Move the bytes from foo->buf to uio. */
	if ((error = uiomove(foo->buf, amnt, uio)) != 0) {
		/* error handling */
	}

	/* do stuff */

	return (error);
}

static int
mydev_write(struct cdev *dev, struct uio *uio, int ioflag)
{
	size_t amnt;
	int error = 0;

	/* Do not allow random access. */
	if (uio->uio_offset != 0 && (uio->uio_offset != foo->len))
		return (EINVAL);

	/* We're not appending, reset length. */
	else if (uio->uio_offset == 0)
		foo->len = 0;

	amnt = MIN(uio->uio_resid, (BUFSIZE - foo->len));
	if ((error = uiomove(foo->buf + uio->uio_offset, amnt, uio)) != 0) {
		/* error handling */
	}

	foo->len = uio->uio_offset;
	foo->buf[foo->len] = '\0';

	/* do stuff */

	return (error);
}

ioctl()

To create an ioctl, you give it a name and #define it using one of the following _IO* macros defined in sys/ioccom.h:

_IO: No parameters.
_IOR: Copy out parameters. Read from device.
_IOW: Copy in paramters. Write to device.
_IOWR: Copy parameters in and out. Write to device and read the modified data back.

Each of those macros* takes 3 arguments:

An arbitrary one-byte “class” identifier.
A unique ID.
The parameter type (can be anything), which is used to calculate the parameter’s size. The macro expands the type to sizeof(type).

* _IO takes only the first 2 arguments (class and ID) since it doesn’t use parameters.

We can now define a few ioctls that take foo_t as a parameter. This is usually done in a separate header file so that programs can use the ioctls:

#include <sys/ioccom.h>

typedef struct {
	int x;
	int y;
} foo_t;

#define MYDEVIOC_READ	_IOR('a', 1, foo_t)
#define MYDEVIOC_WRITE	_IOW('a', 2, foo_t)
#define MYDEVIOC_RDWR	_IOWR('a', 3, foo_t)

mydev_ioctl() is responsible for handling the ioctls we declared:

static int
mydev_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flags,
    struct thread *td)
{
	foo_t *fp;
	int error = 0;

	switch (cmd) {
	case MYDEVIOC_READ:
		fp = (foo_t *)addr;
		/* do stuff */
		break;
	case MYDEVIOC_WRITE:
		fp = (foo_t *)addr;
		/* do stuff */
		break;
	case MYDEVIOC_RDWR:
		fp = (foo_t *)addr;
		/* do stuff */
		break;
	default:
		error = ENOTTY;
		break;
	}

	return (error);
}

Creating and destroying the device

Character devices are given a struct cdev handle upon creation, which we usually store as a global variable:

static struct cdev *mydev_cdev;

Devices are created with the make_dev() function, which is defined as:

struct cdev *
make_dev(struct cdevsw *cdevsw, int unit, uid_t uid, gid_t gid, int perms,
    const char *fmt, ...);

sys/conf.h has the definitions of all available flags.

Create the device:

mydev_cdev = make_dev(&mydev_cdevsw, 0, UID_ROOT, GID_WHEEL, 0666, "mydev");

When done, destroy the device:

destroy_dev(mydev_cdev);

Module declaration

Necessary includes:

#include <sys/types.h>
#include <sys/param.h>
#include <sys/conf.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/module.h>
#include <sys/malloc.h>
#include <sys/uio.h>

Implement the module’s event handler. This function is called at module load and unload. Since we’re dealing with a character device, it makes sense to create the device upon load and destroy it upon unload:

static int
mydev_modevent(module_t mod, int type, void *arg)
{
	int error = 0;

	switch (type) {
	case MOD_LOAD:
		mydev_cdev = make_dev(&mydev_cdevsw, 0, UID_ROOT, GID_WHEEL,
		    0666, "mydev");
		foo = malloc(sizeof(foo_t), M_MYDEV, M_WAITOK | M_ZERO);
		foo->buf[0] = '\0';
		foo->len = 0;
		break;
	case MOD_UNLOAD: /* FALLTHROUGH */
	case MOD_SHUTDOWN:
		free(foo, M_MYDEV);
		destroy_dev(mydev_cdev);
		break;
	default:
		error = EOPNOTSUPP;
		break;
	}

	return (error);
}

Lastly, declare the module. The first argument is the module’s name, the second one is a pointer to the event handler and the last one is any data we want to supply the event handler with, i.e the arg argument in mydev_modevent():

DEV_MODULE(mydev, mydev_modevent, NULL);

Makefile

KMOD=   mydev
SRCS=   mydev.c

.include <bsd.kmod.mk>

Running the module

$ make
# kldload ./mydev.ko
...
# kldunload ./mydev.ko
$ make clean cleandepend

Testing

To test the module, load it, and create a simple program that opens the device, and makes a few calls to ioctl(2), read(2) and write(2).

Social media is ruining our lives

Sat, 18 Jun 2022 00:00:00 +1200

In its infancy, the idea of social media might have had good intentions behind it. In hindsight though, social media as we know it today, seems to have caused more harm than good, for multiple (perhaps too many) reasons. The very nature of the centralization of public discourse on the internet and the mechanisms employed for reacting to content (likes, dislikes, etc), is what lead to social media becoming what it is today: a tool for manipulation.

This article is not a scientific paper, and as such, I don’t want to bore with percentages and details that you can find on more reliable sources (I do link to some of them). These are merely my thoughts, anecdotal experiences and my attempt to spread awareness about a subject I feel is genuinely harming our society.

Addictiveness and the drug-like nature of social media

Social media arguably statisfies most of the requirements to be classified as a drug. It’s addictive, it’s a coping mechanism, it’s hard to quit and it affects our mental and even physical health, especially on young people (more on that in the next section).

Social media companies are competing to keep us engaged and make their services as addictive as possible. Many people spend a large portion of their day endlessly scrolling their feeds, consuming content that is carefully curated by complex AI to match what is most likely to keep us scrolling. Scrolling your feed isn’t necessarily exciting or fun, but it’s addicitive by design. Sometimes we don’t even want to scroll our feeds, but we do it nonetheless, like a junkie who can’t stop doing drugs, because our brains love that dopamine hit we get every time we see a new post or video popping up. Social media has mastered the “art” of exploiting our human weaknesses and subconscious, so that we are glued to our screens; that’s their business model, the more time you spend on their platform and the more ads you see, the more data you give away, the bigger their profits. It’s essentially a slot machine on steroids.

Scrolling the feed.

We now know that many of the major social media companies hire individuals called Attention Engineers, who borrow principles from Las Vegas casino gambling, among other places, to try to make these products as addictive as possible. That is the desired use case of these products; is that you use it in an addictive fashion because that maximizes the profit that can be extracted from your attention and data.

And something I think we’re going to be hearing more about in the near future, is that there’s a fundamental mismatch between the way our brains are wired, and this behavior of exposing yourself to stimuli with intermittent rewards throughout all of your waking hours. It’s one thing to spend a couple of hours at a slot machine in Las Vegas, but if you bring one with you, and you pull that handle all day long, from when you wake up to when you go to bed: we’re not wired from it. It short-circuits the brain, and we’re starting to find that it has actual cognitive consequences — one of them being this sort of pervasive background hum of anxiety."

— Cal Newport: Quit social media

If you’re addicted to gambling, smoking, or anything, the best thing you can do is quit, not minimize usage. Not smoking was unheard of a few decades ago, but now that we know about the harms caused by smoking we try to get people to quit it, not live with it because it’s the norm. The same applies to social media; because everyone uses it, it doesn’t mean you should too.

Over the years I’ve noticed the following recurring patterns that indicate social media addiction:

You can’t stay for a few hours without reflexively picking up your phone to check social media, even if there’s nothing to see.
You compulsively refresh your feed every second without really knowing why.
Your hand is already in the pocket the second a notification pops up, like you’re reaching for a gun.
You pick up your phone the moment you’re bored.
Despite knowing the harms social media causes, you still spend hours on it everyday.
You pause to check notifications when you’re hanging out with someone, even when they might be talking to you.
Checking social media is the first thing you do in the morning and/or the last thing before sleep. As a parallel, my father once told me the first thing he’d do when he woke up was pick up a cigarrete and start smoking before he even got out of bed.

They checked social media right before they went to sleep, and reached for their phone as soon as they woke up in the morning (they had to—all of them used it as their alarm clock). Their phone was the last thing they saw before they went to sleep and the first thing they saw when they woke up. If they woke in the middle of the night, they often ended up looking at their phone. Some used the language of addiction. “I know I shouldn’t, but I just can’t help it,” one said about looking at her phone while in bed.

— Dr. Jean Twenge: Have Smartphones Destroyed a Generation?

Social media is so smartly engineered that it even gives you a “high” when your post is successful. That is done through likes, shares, retweets, and so on. We usually underestimate how powerful this simple mechanism is, but making a “successful” post feels like you accomplished something, because you managed to capture the public’s attention.

So we want to psychologically figure out how to manipulate you as fast as possible and then give you back that dopamine hit. We did that brilliantly at Facebook. Instagram has done it. Twitter has done it.

And because we get rewarded in the short-term signals — hearts, likes, thumbs up — and we conflate that with value and truth. And instead, what it really is, is fake, brittle popularity, that’s short-term and that leaves you even more, and admit it, vacant and empty than before you did it.

— Chamath Palihapitiya (former growth VP at Facebook).

The hours people spend every day staring at a piece of glass and plastic should be enough to convince you.

Effects on mental health

It’s a known fact that extensive use of social media can lead to depression, anxiety and feelings of isolation, inadequacy, insecurity and low self-esteem. This mostly stems from the tendency humans have to compare themselves to others. In the past, we used to compare ourselves to a much smaller pool of people, mostly our immidiate circle and at worst TV-stars, but with the rise of social media the pool has increased to include pretty much most of the world. This is not really the problem per se though, but rather, the fact that much of what you see on social media isn’t an actual reflection of real life. People will go to great lengths to show off their best moments and you now have access to everyone’s curated representations of their lives, and so, it’s not uncommon to feel inadequate when you see everyone around you living their best life, even though in reality that’s only a small portion of it. We essentially compare our normal everyday lives to others’ highlight reels.

Studies have shown that those kinds of comparisons are most prevalent among young women, who tend to feel negative about their appearance, and in some cases even starve themselves to look like their favorite influencers and models. What’s even worse is that the influencers themselves often don’t like that in real life anyway. Extensive use filters and editing is very common, and as a result, they set unrealistic and fake beauty standards. There is also correlation between increase in female depression and suicide rates and use of social media.

Boys’ depressive symptoms increased by 21 percent from 2012 to 2015, while girls’ increased by 50 percent—more than twice as much. The rise in suicide, too, is more pronounced among girls. Although the rate increased for both sexes, three times as many 12-to-14-year-old girls killed themselves in 2015 as in 2007, compared with twice as many boys. The suicide rate is still higher for boys, in part because they use more-lethal methods, but girls are beginning to close the gap.

— Dr. Jean Twenge: Have Smartphones Destroyed a Generation?

Teenagers in general seem to be the most badly affected demographic from social media use, and there’s enough research to suggest that. Depression and suicide attempts have greatly increased since the start of the 2010s, which, is no surprise that at that time, social media and smartphones started being widely adopted by the younger generations.

Smartphone ownership crossed the 50 percent threshold in late 2012 – right when teen depression and suicide began to increase. By 2015, 73 percent of teens had access to a smartphone.

Not only did smartphone use and depression increase in tandem, but time spent online was linked to mental health issues across two different data sets. We found that teens who spent five or more hours a day online were 71 percent more likely than those who spent less than an hour a day to have at least one suicide risk factor (depression, thinking about suicide, making a suicide plan or attempting suicide). Overall, suicide risk factors rose significantly after two or more hours a day of time online.

Of course, it’s possible that instead of time online causing depression, depression causes more time online. But three other studies show that is unlikely (at least, when viewed through social media use).

Two followed people over time, with both studies finding that spending more time on social media led to unhappiness, while unhappiness did not lead to more social media use. A third randomly assigned participants to give up Facebook for a week versus continuing their usual use. Those who avoided Facebook reported feeling less depressed at the end of the week.

The argument that depression might cause people to spend more time online doesn’t also explain why depression increased so suddenly after 2012. Under that scenario, more teens became depressed for an unknown reason and then started buying smartphones, which doesn’t seem too logical.

— Dr. Jean Twenge: With teen mental health deteriorating over five years, there’s a likely culprit

The economy of attention

I’m not smart enough to have coined this phrase, but I think it explains the situation we’re in really well. This UC Berkley article goes a bit more in-depth on the subject.

We’ve all heard the phrase “when the product is free, you are the product”. It usually refers to how the service is free, but our data is what makes social media companies immensely profitable. But I want to give a different spin on this phrase. The goal of a product is to sell, and since we are the product, the way to tell if our product sells, is through likes and comments. This is our currency, and as is expected, we want more of it, and so, we’ll strive to take the perfect shot, to show the best moments of our lives, and we’ll wait for the right time to post in order to maximize engagement. If the product sells, we’ll create more of it. If it doesn’t, we’ll change it, and this translates to changing our appearance, our lifestyle, our identity, in order for the product to be “valuable”.

In an “actual” economy you sell a product to make money, but in the case of the social media economy, you do it for validation and to feed your ego. Even if you don’t want to admit it, for many individuals the underlying motivation behind posting on social media is to feel important, to feel that the world notices them, to project an ideal version of themselves. This is why people upload tens or hundreds of pictures of their faces and bodies, and spend hours every day perfecting their profiles and obsessing over how many likes and followers they got or who saw their stories.

See Adam Alter (NYU professor) and Tristan Harris (Google whistleblower and former engineer).

Hijacking the social apparatus in your brain is a good way to get people to keep looking back, and one thing they’ll do for example, is they introduced a lot more “social approval indicators” into these apps. A social approval indicitator is some way that someone can indicate to you that they thought about you or were thinking about you. The original structure of social media didn’t have a lot of this, but when they added things like the like button, there’s a reason for that, because now the like button meant that’s a lot more social approval indicators, and they added more and more of these things.

Tens of millions of dollars were invested to figure out how to do the facial recognition required to do auto-tagging on photos. Why did they spend so much money to solve that really hard computer science vision problem, is because it was another stream of social approval indicators. They’re always looking for ways that people can easily indicate that they are thinking about you, because human psychology says, if clicking on this app might reveal new social approval indicators, it’s almost impossibly irresistible not to. If I click on this app and see an indication that someone was thinking about me, that’s very hard to resist. And once they added those social approval indicators, usage minutes of the apps skyrocketed, because now, instead of it being something maybe you signed on to once a day to see what was going on, you had a constant reason to keep checking.

And the you add on to that “intermittent reinforcement”. Sometimes when you click there is nothing and sometimes there is; now you’re becoming almost impossible to avoid. Intermittent reinforcement is something that Las Vegas casino gambling has taken a lot of advantage of in their design of their games like slot machines.

So you put those type of things together, which are all engineered; this didn’t exist in the original social media, it’s not necessary for a social media experience to be what it is. All of that makes clicking on these apps really difficult to avoid.

— Cal Newport

Social media is not a substitute for real-life interaction

What makes real-life interaction meaningful is that it requires sacrifice, whereas a message or a like on social media doesn’t; it’s cheap. Taking the time to go outside and meet someone, reading each other’s body language and showing actual emotions (instead of emoji reactions) is something that social media simply cannot replace. The human brain is not wired to perceive likes and chat discussions as meaningful interaction.

A while ago I’ve had an interesting conversation about musicians (and artists in general), and how one can show support for their art. Imagine the following two cases; 1) you upload your music online, and lots of people like and comment on it, 2) you organize a concert where only a few people who really enjoy your music come, but make the effort to pay and spend their time to actually come and see you play. Which of the two cases you think would make a musician feel appreciated?

Spending more time on social media than in real-life not only causes a decline in social skills and an increase in “social anxiety” cases, but can also lead to depression and feelings of isolation and loneliness.

What a lovely meeting.

Future generations and the ability to focus

Do we really want a generation raised by TikTok and Instagram influencers? A future generation filled with mental health issues, one that is unable to have normal and healthy social lives, that is brainwashed and isolated? All that so that we make a bunch of tech companies profitable?

Our ability to focus and attention span has plummeted, because our attention is fragmented by the stream of notifications and messages we get. We’re so used to wasting hours on social media every day that we have stopped being conscious of how we spend our time. Doing important work is a struggle when you have to check your phone every few minutes, and that’s an issue even for grown-up individuals, imagine what the generations who grow up with social media from day one are going to be like.

Because social media provides constant stimuli and keeps you entertained all the time, we’ve become averse to boredom. Being bored is good, it means you have time to sit with your own thoughts and ponder. It’s a sign that you need to get a hobby and do something productive, and we lose those moments of peace and clarity when we fill our free time with noise. And I don’t believe it’s right to blame the users for this — social media apps are the result of billions of dollars worth of attention engineering.

For those reasons, and to not repeat the damage that’s been done to the current generations, it’s essential that we control our children’s tech usage in order to prevent them from becoming virtual junkies.

In the very first paragraph I mentioned how social media, in the beginning, might have actually had genuinely good intentions. In fact, I believe that, but as time went on, tech companies realized that they’re in a position where they can use their platforms to “program” users and leverage this to promote their own political agendas and twist reality to their own advantage. Here are a few ways with which this is achieved:

Self-regulation through likes and dislikes, content moderation, and Terms of Service. As I’ve explained here, there’s an incentive to being compliant and changing in order to be accepted. That, however also expands to beliefs and opinions, because the same mechanism can incentivize you to be a “good boy” and believe and say the right things, because that’s what will get you the best reactions, or even keep you on the platform. Reddit’s upvote/downvote system is a great example of this mechanism in action.
Verified accounts and expert-based consensus, which is pretty much what I discussed in my article about the Gell-Mann Amnesia effect. An MIT study shows fake news spreads faster than the truth.
Data collection. Just as data is used to show you the right ads in order to maximize profits, it can also be used to train AI to promote and recommend the content and narratives that the company thinks is “correct” and will push their ideological ambitions.

Tech giants, and especially social media companies, have proven countless times how they do have political motivations behind their policies, but I’m going to let the reader look for evidence to this claim themselves this time (spoiler alert: it’s endless). Considering their political nature and the fact that they are so big they now control the virtual public square, those platforms have switched from free speech to allowing only the narratives that benefit them, hence the various methods used for dealing with dissidents (e.g shadow-banning, demonetizing, bans for arbitrary ToS violations, etc).

The smart way to keep people passive and obedient is to strictly limit the spectrum of acceptable opinion, but allow very lively debate within that spectrum.

— Noam Chomsky

But propaganda isn’t merely only spread by bad actors, useful idiots, and politically-driven tech companies. Social media also provides governments (yes, even Western ones) with the most effective way to spread propaganda, something that people like Joseph Göbbels and Joseph Stalin (probably has to do with the first name) could only dream of in their time. Governments can now just pay influencers to spread propaganda for them, and most people will not even realize it. If you think I’m making things up, I’ll let you do the research yourself for this claim as well.

Here are a few quotes from an expert in the field that should ring an alarm:

This is the secret of propaganda: Those who are to be persuaded by it should be completely immersed in the ideas of the propaganda, without ever noticing that they are being immersed in it.

Propaganda works best when those who are being manipulated are confident they are acting on their own free will.

— Joseph Göbbels

The solution

The ideal solution is to simply quit social media altogether and seek alternative forms of online and interaction. Apart from all the unecessary harm it has caused, modern social media goes against the very notion of the decentralized (i.e normal) internet, and the online world did, does, and will function perfectly fine — better even — without social media.

However, I understand that we’ve been so conditioned to accept social media as a necessary part of our lives, that not everyone is ready to make the decision and quit it. In this case, it’s best to see social media as a purely logistical tool, which should only used to complement and improve our real life interactions, rather than replace them. This I find is rather hard to implement — especially for younger people who have been using social media all their lives — and be consistent with, without going back to the old habits. Social media is meant to addictive, it’s not just a matter of willpower.

A few steps you can take to start limiting social media usage:

Delete all social media from your smartphone and only log in manually (i.e do not save passwords) from a computer.
Keep only the pages and groups that are vital to your life/career and delete everything else. Log in every few days to stay up to date and log out without spending more time than is needed.
Turn off notifications.
Do not interact through likes and comments.
Do not make posts.
Make a phone call whenever you want to talk to a friend, instead of messaging them.
Set a timer.

And remember; not using social media isn’t “weird” or “anti-social”, as you will hear some people say. Being mindful of the technologies you choose to use, having control over your time and attention, not wanting to be a passive consumer and be used as input for some mega-corporation’s AI, and seeking meaningful and real socialization is, in fact, pretty healthy.

RSS: Advantages and usage

Fri, 27 May 2022 00:00:00 +1200

RSS (Really Simple Syndication) is a standardized protocol for creating and sharing web feeds. An RSS feed is an XML file consisting of entries, each of them usually corresponding to an article. Programs called “RSS aggregators”, parse these files and provide a nice display where you can nagivate through each entry as if it were a news feed. This is a very convenient way to “follow” websites because all you have to do is grab their RSS URL, add it to your aggregator, and read the articles once it parses the feed.

On the website owner’s end, a new entry needs to be added whenever a new article is published. The entry usually includes a short summary of the article, or as is the case for my website, the whole article, so that you can read it all through your RSS reader.

Why bother

RSS is an open protocol, it’s decentralized, and very simple both in terms of parsing and maintaining. Because RSS is such a simple protocol, it can adapt to everyone’s workflow. There are RSS readers for Android, Windows, UNIX, web browsers, email clients, etc.

Apart from the technical advantages RSS provides, it’s also a great way to have a personal, uncensored feed, following only the websites you want — even YouTube channels and Twitter accounts — without ads and additional noise and distractions.

I personally use sfeed as an RSS reader, because I like the extensibility it offers. I’ve written a small patch for sfeed_curses(1), so that you can bookmark feed entry URLs to a predefined file. I use this mostly to queue videos and podcasts and then stream them through mpv using a very simple script I created, which, all it does is read the “queue” file and pipe the URLs to mpv.

How to create and maintain an RSS feed

Below is a very basic RSS feed. Inside the <channel> tags is the whole feed, and inside <item> is each individual entry. The rest of the tags are pretty self-explanatory, if not, feel free to read the specification. The article/summary is placed inside <description> — that can be in plain text or encoded HTML:

<?xml version="1.0" encoding="UTF-8" ?>
<rss version="2.0">
<channel>

<title>Example Org</title>
<description>Example Org's RSS feed</description>
<link>http://www.example.org/rss.xml</link>

<item>
<title>Example entry</title>
<link>http://www.example.org/blog/post.html</link>
<pubDate>Sun, 06 Sep 2009 16:20:00 +0000</pubDate>
<description>
Here is some text containing an interesting description.
</description>
</item>

</channel>
</rss>

To create a new entry, you can either handwrite it in the XML file yourself, make a script or small program to do it automatically, or use some existing tool. I prefer to use my own script, since it’s a dead simple thing to do.

To share the feed, simply add the URL to your website and tell people to subscribe to it. For example, my website’s RSS feed can be obtained from https://margiolis.net/w/rss.xml.

Even though they purposefully make it hard to find, so that you can stay on their platform, YouTube, Twitter, Reddit, and other services, offer RSS feeds, and even if they don’t, there are ways you can generate one.

YouTube

Go to the channel’s home page, right-click and click on “Page source” and search for channelId" content. Copy the hash inside content="" and append it to the following URL (replace hash):

https://www.youtube.com/feeds/videos.xml?channel_id=hash

GitHub

You can get an RSS feed for each new commit that happens in a given branch. Replace username, repo and branch with the correct values:

https://github.com/username/repo/commits/branch.atom

Twitter

Twitter does not actually offer RSS feeds anymore, but there is a proxy site for Twitter called nitter that does. Replace username with the account’s username you want to follow:

https://nitter.net/username/rss

Each subreddit has an RSS feed under this URL (replace subreddit):

https://www.reddit.com/r/subreddit.rss

Facebook and others

There’s a nice program called RSS-Bridge that can generate RSS feeds for websites which don’t have one. RSS-Bridge is installed and run on your server, but there are public instances you can use.

Share ZFS datasets with NFS

Sat, 21 May 2022 00:00:00 +1200

Thanks to Mark Johnston <markj@FreeBSD.org> for recommending this configuration. The article is also mirrored on the FreeBSD Wiki.

Host

Add the following lines to /etc/rc.conf:

nfs_server_enable="YES"
mountd_enable="YES"
mountd_flags="-n"
rpc_lockd_enable="YES"
rpc_statd_enable="YES"
rpcbind_enable="YES"

For some reason the NFS server needs to be restarted the first time after boot. A simple way to do this automatically is:

# echo "service nfsd restart" >> /etc/rc.local

Set the sharenfs property to the dataset you want to share. Replace the IPs and pool/dataset* with your desired values. ZFS properties are documented in zfsprops(8).

We’re going to share 2 datasets, one with read-write and one with read-only access:

# chmod -R 777 /pool/dataset_rw
# zfs set sharenfs='-network=192.168.1.0/24,-alldirs' pool/dataset_rw
# zfs set sharenfs='ro=192.168.1.0/24,-alldirs' pool/dataset_ro

Start the NFS server:

# service nfsd start
# service mountd reload

Guest

Acquire the host’s IP address using ifconfig(8) on it first. We’ll assume it’s 192.168.1.5.

Mount the filesystems. /pool/dataset* corresponds to the actual mount point of the dataset in the host:

# mkdir -p /mnt/dataset_rw /mnt/dataset_ro
# mount -t nfs -o rw 192.168.1.5:/pool/dataset_rw /mnt/dataset_rw
# mount -t nfs -o ro 192.168.1.5:/pool/dataset_ro /mnt/dataset_ro

When done, unmount:

# umount /mnt/dataset_rw /mnt/dataset_ro

In case you want the filesystems to be mounted on boot, add the following lines to /etc/fstab:

192.168.1.5:/dataset_rw   /mnt/dataset_rw	nfs     rw      0       0
192.168.1.5:/dataset_ro   /mnt/dataset_ro	nfs     ro      0       0

Process queuing using lock files

Wed, 18 May 2022 00:00:00 +1200

Locking will be done using the fcntl(2) system call. I’m aware of lockf(3) and flock(2), but both of them normally use fcntl(2) under the hood, and they are not as portable. More information on file locking.

For a real use-case, I’ve written a notification program which uses the same mechanism, so that notifications can be queued without having to run a daemon, such as D-Bus, in the background.

First create the lock file with write permissions. O_CREAT is used to create the file in case it doesn’t exist already:

#include <err.h>
#include <fcntl.h>
...
char *lockfile = "/tmp/foo.lock";
int fd;

if ((fd = open(lockfile, O_CREAT | O_WRONLY, 0600)) < 0)
	err(1, "open(%s)", lockfile);

Locking commands operate on the flock structure. Before a call to fcntl(2) is made, we need to write the following fields:

struct flock {
	off_t	l_start;	/* starting offset */
	off_t	l_len;		/* len = 0 means until end of file */
	short	l_type;		/* lock type: read/write, etc. */
	short	l_whence;	/* type of l_start */
	...
};

The starting offset, l_len, can be anything, but 0 is what makes the most sense. We’ll set l_len to 0 as well, since we want each process to lock the entire file. The lock type, l_type, needs to be an exclusive lock (F_WRLCK), that is, a lock that prevents any other process from setting a lock on that area before it’s released. l_whence will be set to SEET_SET to indicate that the relative offset l_start will be measured from the beginning of the file:

struct flock fl;

fl.l_len = 0;
fl.l_start = 0;
fl.l_type = F_WRLCK;
fl.l_whence = SEEK_SET;

The F_SETLKW command will make the calling process wait until the lock request can be satisfied. There’s also F_SETLK, but it returns immidiately if the lock is already acquired, which is not very useful for queuing processes:

if (fcntl(fd, F_SETLKW, &fl) < 0)
	err(1, "fcntl(F_SETLKW)");

When we get past the call to fcntl(2), it means that we have acquired the lock until a call to close(2) is made. Here is where we’ll put the part of the code we want to queue, in this case a simple printf followed by a 3-second sleep to make sure queuing really works:

printf("hello from %d\n", getpid());
sleep(3);

When done, release the lock:

close(fd);

To test the code, open two terminals and run the program on both of them. You’ll see the process that was run last will not execute the code after fcntl(2) until the first one has finished.

FreeBSD VNET Jails

Sat, 30 Apr 2022 00:00:00 +1200

This article is also mirrored on the FreeBSD Wiki.

Configuration

The VNET is set up using an if_epair(4) interface bridged with the actual network interface, in my case re0. Just like if_tap(4) interfaces, epairs can be used by one jail at a time, so if you need to run more than one jail at the same time, you have to make more epairs.

If you’re using tap interfaces for bhyve VMs, you can just addm them to the bridge.

Add the following lines to /etc/rc.conf:

if_bridge_load="YES"
if_epair_load="YES"

cloned_interfaces="bridge0"
ifconfig_bridge0="addm re0 up"

Apply changes:

# /etc/netstart

The jail needs to inherit /dev/bpf* from the host in order for networking to work at all. Make a new /etc/devfs.rules ruleset:

[devfsrules_jails=5]
add include $devfsrules_hide_all
add include $devfsrules_unhide_basic
add include $devfsrules_unhide_login
add path 'bpf*' unhide

Restart devfs(8):

# service devfs restart

In /etc/jail.conf, we’ll name the jail foo and give it the other end of the epair we’ll create as its network interface. Its IP address will be acquired using DHCP. The reason I’m manually calling dhclient(8) is because adding ifconfig_epair0b="DHCP" in the jail’s /etc/rc.conf doesn’t work. Options are detailed in jail.conf(5):

path = "/usr/local/jail/$name";
host.hostname="$name";

exec.clean;
exec.start = "/bin/sh /etc/rc";
exec.stop = "/bin/sh /etc/rc.shutdown";
allow.mount;
allow.raw_sockets = 1;
mount.devfs;
devfs_ruleset="5";
vnet;
sysvmsg=new;
sysvsem=new;
sysvshm=new;

foo {
	vnet.interface = "epair0b";
	exec.start += "dhclient epair0b";
}

Installation

# mkdir -p /usr/local/jail/foo
# bsdinstall jail /usr/local/jail/foo
...
# ifconfig epair0 create
# ifconfig bridge0 addm epair0a
# ifconfig epair0a up
# service jail onestart foo

Test to see if the jail has networking:

# jexec foo ping google.com

On jail shutdown, destroy the epair:

# service jail onestop foo
# ifconfig epair0a destroy

Delete jail

Deleting jails isn’t as straight forward, so I’m leaving this here as well:

# service jail onestop foo
# chflags -R noschg /usr/local/jail/foo
# rm -rf /usr/local/jail/foo

Learning languages effectively

Thu, 07 Apr 2022 00:00:00 +1200

This article touches on a handful of important topics that are vital to learning a foreign language. Learning a new language is complicated, overwhelming at times, but highly interesting and rewarding if done properly.

I’ll refrain from going into specific methods, as if language learning can be explained in a simple recipe-like form. I think everyone learns differently, but the points I discuss in this article should be universal for everyone. It’s up to you to find the particular method that works best for you.

Special thanks to Eiliv and Randel for helping me improve this article.

Don’t learn too many languages at the same time

I’ve fallen victim of this in the past as well. There are so many cool languages out there to learn, all with their own story, culture, and interesting features and sounds. Even though this rabbithole seems fun at first, I’ve come to realize that you don’t actually learn anything this way. You only gain superficial knowledge of each language and essentially become a real-life example of a “jack of all trades, master of none”.

There’s no official limit for how many languages a person can learn at the same time, as this is purely dependent on one’s abilities and time available, but if you want to master something, you have to put in the hours, and mastering 10 languages at the same time just isn’t feasible. Instead, as a rule of thumb, find one or two languages that really interest you and focus on them. I’m sure if you’re like me, this does sound very restricting, but at the end of the day, I’d rather speak 2 languages great than 10 languages terribly.

If you do decide to learn multiple languages, make sure you have some “maintenance” time for the languages you already speak so that you don’t forget them.

Learn about the language first

Before even jumping into learning the language, make sure you know some stuff about it. Which family does it belong to? Who speaks it? Is it related to a language you already know? What about its history? See what the language looks like. Read a bit about its grammar and vocabulary. This is all useful information that can help you decide if you really are interested in learning that language, and can also give you a general idea of what you’re getting into, especially if you already have some experience with languages. All this can usually be found in the language’s Wikipedia article, but further research is never bad. Gather material which you can reference early on. This includes textbooks, podcasts, articles. Don’t get too caught up with this though, just find something to start with.

Proper pronunciation is key

Having a solid understanding of the grammar and vocabulary of the language is obviously very important, but it’s of no use when you cannot actually be understood due to bad pronunciation. Proper pronunciation makes you more pleasant to listen to, and you’re better understood (or understood at all, depending on the language). Of course, you probably won’t manage to get a 100% native accent, but you should try to, even if it’s technically not an attainable goal. A subtle foreign accent is fine as long as communication is not impeded.

To give an example of how wrong pronunciation can be a problem; English is taught in Greece from a very young age, but for some reason, (Greek speaking) teachers tend to not bother with pronunciation at all, hence why Greeks might speak good English on average, but are very hard to understand. A classic issue are the words “sit”, “seat”, “shit”, “sheet”. A Greek will most likely pronounce all 4 of them as /sit/, simply because Greek doesn’t have long vowels or the [ɪ] and [ʃ] sounds.

Learn the International Phonetic Alphabet (IPA) first. Get a pronunciation chart (like this one) for your target language and say each individual sound out loud and try to get it as right as possible. Doing this from the very beginning will make you form good speaking habits. Watch/listen to people speaking the language and try to analyze and mimic their speech. Keep in mind that correct sentence-level pronunciation (i.e having a natural flow when pronouncing whole sentences) is different from pronouncing standalone words correctly.

Each language has regional accents, so make sure you don’t mix accents together. If you’re not going for a specific dialect or accent, a good rule of thumb is to find material and speak the language in what would be considered the most stereotypical or “standard” accent.

Start speaking early on / challenge yourself

A big mistake learners make is that they abstain from speaking early on, because they are afraid they don’t speak the language well enough to have actual conversations. This is very counter-productive; for one, practice makes perfect — if you don’t speak, you’ll not learn to speak. Second, speaking and reading/writing are different, independent skills.

Speaking introduces new variables, namely, anxiety and pressure, which are legitimate barriers to speaking well. You might be able to read and write a language perfectly, heck, even better than a native, but sound like an A1 beginner when speaking to a real person, which is hardly an exaggeration. The reasons are simple:

Speaking occurs in real time. It doesn’t give you the luxury to revise and carefully think a sentence through, unlike writing. Words have to follow thought instantaneously, and that’s a skill that has to be developed, regardless of how good your reading/writing skills are.
The stress factor and fear of sounding silly hinders your ability to express your thoughts properly. That’s especially true for introverted people.
You haven’t practiced speaking enough, so producing sounds does not come out naturally and your speech has no flow.
As I said, speaking is a separate skill. To give an analogy, you might know the engineering behind building a house, but actually using tools and your hands to build it is a whole different skill, which isn’t learned by just having a theoretical background in construction.

A nice way to go about using the language, is by joining Discord language servers [1] or some other language exchange platform. Especially with popular languages, those servers are very active, with lots of native speakers in them, so there’s no excuse not to start speaking, or at least writing, from the very first day. Language learning/exchange patforms are fine too.

In essence, get out of your comfort zone, ask questions, make mistakes, expose yourself, sound stupid and get laughed at. There’s no way around it. That’s all part of the learning process.

Learn by application, not memorization

This can be said for pretty much everything when it comes to learning, and I could dedicate a whole article to how much I dislike memorization. Since I’m a programmer, consider the following quote:

The only way to learn a new programming language is by writing programs in it.

— Dennis Ritchie

We tend to remember the things we need or have been useful in the past. Make sure you don’t try to squeeze in as much vocabulary, grammar [2] and all sorts of irrelevant stuff into your head at once when you don’t really need it, especially if you’re starting out. Truth is, if you don’t put what you learn into practice, you don’t really learn it. Always have real-world conversations as a goal — when you learn something, use it in a conversation and get feedback from native speakers. Write anything, from a diary to an essay.

Media consumption: a double-edged sword

Being immersed in a language means you’ll inevitably have to consume media, be it movies, podcasts, music. This is a very good way to both see the language in action, and develop an ear for it. However, just passively consuming media won’t get you far. If you don’t put in the hours to actively hone your skills, consuming media will only be an excuse for you to be lazy. Immersion is very beneficial when combined with active learning. [3]

The proper way to combine media consumption with actual learning is to note down the things you don’t understand and study them afterwards. The big advantage of doing this is that you study in an audiovisual way, meaning you associate language with pictures. Our brains are great at pattern recognition, so being able to associate a word with a picture/gesture, creates longer-lasting and intuitive knowledge.

When watching movies in a language you’re learning, ALWAYS use subtitles in that language!

Read books

Reading has lots of benefits as well. The thing with reading is that it makes you focus solely on the language, which in turn lets you think and analyze more carefully, at a slower pace. Reading books is an ideal source of sophisticated vocabulary and more complex grammatical structures, that can make a big difference when used properly in speech. Confining yourself to the most basic and colloquial use of the language is still good if you only care about having simple conversations. Languages are highly complex and there are things that cannot be expressed with just basic vocabulary and grammar.

Textbooks on the other hand, should be used only as reference, in my opinion.

Record yourself

I know, we all cringe listening to our voices, but let me explain. When speaking a new language, one tends to pay more attention to what he wants to say than his accent — this means that, inevitably, you’ll make lots of minor mistakes that go unnoticed when speaking. Recording your voice and listening to it afterwards lets you focus only on your accent and the small details that could improve it.

Think in your target language

Part of internalizing a language is thinking in it. Start having inner monologues and dialogues in the language you’re learning, name everything around you. You get the point.

Avoid word-for-word translations

Word-for-word translating means that you learn a sentence by translating directly from your native language. For example:

Greek: Πάω να κάνω μπάνιο (lit. “I’m going to do bath”).
English: I’m going to take a shower.

Think how absurd it would’ve sounded if instead of saying “I’m going to take a shower”, I had translated from Greek and said “I’m going to do bath”. All languages are different. They have their own rules, patterns, lexical and grammatical structures. This means that, when you learn a language, you have to learn the idioms and phrases that are used in that particular language, not try and translate words. Idioms are a great way to improve fluency and get a cultural insight behind the lingusitic differences that make a language unique.

The SRS (Spaced Repetition System) fallacy

I’m aware of the research being done on SRS, as well as its benefits. What I want to argue, however, is that languages are best learned in context and SRS alone won’t provide that. It can be a useful tool if used correctly, but relying on it will give you the impression of learning, when in reality you’ll be grinding your way through vocabulary and grammar, without any meaningful context.

Learning a language isn’t simply a matter of filling sentences on Duolingo or mindlessly memorizing your Anki cards. Those platforms (or better yet, games) should be used to complement your knowledge or to spend your time productively in the toilet, not as your primary source of learning. SRS is not a magic potion that can teach you what people spend years to learn, this just a get-rich-quick scheme. Languages are more than a flashcard game.

Again, there is merit to Spaced Repetition, but use it as a complementary tool only.

Travel if possible

If travelling is a possibility, make sure to plan a trip and practice the language there once you have a solid foundation. I would go as far as to say that you should put yourself in a situation where you have no other option but to speak the language. This is probably the best practice possible — you get real-world immersion, you speak the language in real life with locals, and, as a bonus, you’ll have a great time.

And most importantly…

Have fun learning and be consistent!

Everything I rambled about in this article is all fine, but it’s totally useless if you are not consistent with your learning. Languages, like any other skill, take patience, practice and consistent efforts in order to master. Instead of studying for 7 hours once a week, study 20, 30 minutes to, ideally, 1 hour each day. The brain needs continuous stimulation in order to really learn something, so practicing once a week, even though you might practice for 7 hours straight, is less effective.

The amount of time you dedicate to learning will determine how fast you’ll learn, but consistency will determine whether or not you WILL learn at all.

Notes

Discord is not one of the best platforms I can think of, but unfortunately it’s where many language learning communities are, so at least take advantage of this. There’s a list of language servers where you can ask questions, speak and write the language.
A nice chance to look up grammar is when analyzing phrases you already know, but don’t quite get their structure. It’s important to always understand the grammar behind a language, because it’ll both make recognizing patterns easier, but also save you lots of headaches.
A good example of this is people who grew up in billingual families, but never learned to speak their second language. They might be able to understand the language perfectly, but are unable to speak. That’s because they never actively practiced learning the language, so they ended up only knowing how to recognize phrases and words they’ve been hearing over and over.

nfy(1)

Sat, 02 Apr 2022 00:00:00 +1200

A minimal and daemonless notification program for X.

Source code | Download 0.2 | Man page

Features

Very lightweight. ~250 lines of C.
Probably no dependencies, apart from the pre-installed X11 ones. Xlib, libXft and libXrandr.
Multiple notifications are queued using a lock file. This avoids the trouble of having a daemon (e.g D-Bus) constantly running in the background.
Non-blocking behavior, so that it can be used inside scripts easily.
Configuration is done by editing config.h and recompiling the source code, in a similar fashion to suckless utilities. No knowledge of C is required to edit the file. Compilation takes around 1 second.
Clicking on the notification window will make it disappear.

nfy works by piping text into it. Text cannot be passed as argument:

$ echo 'hello world' | nfy
$ nfy < foo.txt

If stdin is empty, it exits with an error:

$ nfy
nfy: stdin is empty

Install

First make sure all settings in config.mk are set according to your system’s configuration, then:

# make install clean

Notes

If you want to use nfy(1) with cron(8), make sure to export the X Display variable inside the script running nfy(1):

export DISPLAY=":0.0"

Alternatively, export the variable in the crontab file directly.

Send feedback and bugs to <christos@margiolis.net>.

Political labels considered harmful

Fri, 01 Apr 2022 00:00:00 +1200

I’m an anarcho-syndicalist, a reactionary, a classical liberal, a socialist! And the list goes on…

ideologue /ˈaɪ.di.ə.lɑɡ/: an often blindly partisan advocate or adherent of a particular ideology.

— Merriam-Webster dictionary

My point is not to suggest that we shouldn’t discuss ideology or that ideology in and of itself is useless. My issue is the urge to attach labels, and people basing their whole identity around a set of labels, which results in more division, stifling free thought, and viewing things from an “us an them” standpoint.

Labels are restrictive, not descriptive

…because people are complex; so too, are their politics. As such, political labels tend to be more restrictive than descriptive and, ultimately, they miss a key point — people aren’t defined by politics; people define politics. Labels are no substitute for experience. Allowing them to become so has rendered possible many of our most divisive political issues — from identity politics and partisanship to fake news and echo chambers.

Too often, labels become an attempt to turn the complicated into the simple. And people and politics aren’t simple.

Individuals are incredibly diverse and often hold a wide-range of political views depending on the subject or circumstances. It’s why political labels need so many caveats and hyphens — Alt-right, Far Left (or Right), Progressive Liberal, Moderate Republican, etc. It’s also why political labels are rife for exploitation.

For many, the complexity and gravity of political issues leaves them perplexed and frustrated. Understandably, people assume labels to align with political ideologies in the hope of having their views represented; however, labels divide just as easily as they associate

— Excerpts from this article

Labels as a tool for ostracization

Oftentimes we use labels to dismiss someone’s ideas. Say for example someone has views against immigration. An open-borders person’s first reaction would be to shout racist accusations at them, and thus label them as a racist, far-right, or what have you, without really judging their points based on merit or facts, but based on emotion and bias. This is a very simple an easy way to gain moral high ground in a debate or ostracize someone. And this has always happened. Christians, muslims, nazis, communists, all attaching labels to their enemies to portray them as undesirables and worthy of contempt.

Labels are not always attached to someone based on their actual views, but on someone else’s (usually limited) perception of their views. How does this make labelling at least accurate in the first place?

Between the 1940s and 1970s, Greece, my home country, had experienced a civil war, political persecution and a CIA-backed military junta. During the civil war, there were two camps you could join: the nationalists, backed by NATO, and communists, backed by the Soviet Union. Eventually, the communists lost, but polarization was so high, that persecution of them continued during the dictatorship (1967-1974). The issue was, that one was labelled arbitrarily, and simply landing on the “wrong” side was as easy as simply listening to the wrong music or having been born in a family with leftist ancestors. Others, snitched on their neighbours, or even family members, on suspicion of political heresy. Mind you, there were persecuted people that had nothing to do with leftism or communism, but not being sympathetic to the regime meant you were automatically a communist.

The reason behind this tangent is to give an example of how misleading labelling can be, and how easy it is to use it as a tool to dehumanize someone. In times of turmoil, labels are a weapon.

Another example is the Bolshevik regime using the term kulak to target dissident peasants:

Kulak, in particular, became a term of abuse directed by party propaganda against peasants who incurred the wrath of the authorities through failure to comply with demands for the delivery of grain.

— Edward Hallet Carr in “The Russian Revolution from Lenin to Stalin, 1919-1927”

My proposal and personal approach

Whenever I get asked about my ideology, people who expect me to respond with a simplistic term such as “left” or “right”, are usually annoyed, or think I am just avoiding the question. For one, I really don’t think I 100% agree with any particular ideology, and second, I don’t want to reduce the capacity to think for myself to a political label and create all sorts of biases before I even start to express any view. I find it nearly impossible to explain my whole political worldview with just a term — and that’s not because I think I am some kind of intellectual with very unique thoughts, but because one’s politics really cannot be accurately defined with just a word.

There are ideologies which I think have more merit than others, that I’m more attracted towards and tend to agree with, but I don’t like the role-playing aspect of ideologies. It’s almost always the case that people who are keen on labelling are the most insufferable in a discussion, because their goal is not to have a healthy conversation, but to prove that their side is the right one.

So, what am I proposing, anyway? I think the single most important point I’d make is to develop critical and independent thinking. Blindly accepting or denying an idea because the ideology you’re subscribed to says so, is really no different than following a religion. Instead, my approach is to study and discuss various ideologies, extract the good things from each one of them, use my intuition and common sense, and form my own worldview.

Of course, anyone who takes a political stance does fall into some broad category, but there really is no point in obsessing over the label you go with, like it’s a football team.

Why reinvent the wheel

Fri, 25 Mar 2022 00:00:00 +1200

I’ve got a few reasons for “reinventing the wheel”, some personal and some practical:

I’m curious and want to know how things really work.
I like DIY from scratch projects.
Bottom-up learning is valuable.
There are things that are fundamentally flawed and need to be done again from scratch.
Existing tools don’t always match the criteria for your specific task and/or introduce too much complexity.
Because there’s already a way to do something, it doesn’t mean it’s the right way to do it.

Some of the greatest innovations have in fact been a reinvention of the wheel, because what already existed at the time wasn’t good enough. Imagine someone telling James Watt he shouldn’t waste his time reinventing the wheel. Improving what already exists means we have stable foundations and better tools to work with in the future. The wheel itself has been reinvented multiple times, hence we don’t use Bronze Age wheels anymore.

A good example in the software world of why sometimes reinventing the wheel is a good idea is UNIX vs Windows. UNIX was written from scratch to replace Multics which had serious flaws, so they ended up with a new and clean system, built right from the bottom-up. They reinvented the wheel and made huge innovations in the process. Windows on the other hand, is built on top of MS-DOS which even at the time was a mess, so what Microsoft is left with is an OS which up to this day is overly complicated, because of fundamental design flaws that cannot be fixed unless they do away with the whole thing and start from scratch. Instead, they are coming up with half-assed solutions and add complexity to the system with each update.

Then there’s quality and efficiency. Writing your own tools means they can be tailored to perform a specific task perfectly — something a big generalized framework or piece of software can’t do in many cases. We tend to ignore the improvements better software can bring in the long term and instead spend time fighting with not-so-great tools and also rely on the power of modern hardware to cope for our mediocre solutions (see modern web tools or the web in general).

So, am I proposing that we’d be better off writing machine code and building our own programs for everything? Absolutely not. What I AM saying though, is that instead of being allergic to reinventing the wheel, we can start to see the merits in it, without overdoing it. This approach is benefecial to our personal improvement as engineers, which means an improvement in software as a whole. Just as you learn any other skill by mastering and understanding the basics, programming has to be understood from the bottom-up, not the opposite way. There’s no point in knowing all kinds of fancy frameworks if all you see are black boxes, or cannot even implement a linked list if asked to. After all, it’s a fact that software is getting worse.

And to save myself from sounding ignorant, there are cases where reinventing the wheel is a problem, namely:

Companies rolling their own proprietary solutions for everything, and ending up creating protocols and programs, which are arguably worse, expensive, harder to maintain, and incompatible with existing software.
People who like to reinvent the wheel for the sake of just having “their own” version of something, even when there actually is good software out there that covers their needs just as well.

Knowing how things really work will enable you to trace bugs easier, write/design more performant software, and overall know what the hell you’re doing. And that can only be achieved by, sometimes, reinventing the wheel. Nothing can teach you what getting your hands dirty will.

A related article I found funny.

The Gell-Mann Amnesia Effect

Tue, 22 Mar 2022 00:00:00 +1200

Briefly stated, the Gell-Mann Amnesia effect is as follows. You open the newspaper to an article on some subject you know well. In Murray’s case, physics. In mine, show business. You read the article and see the journalist has absolutely no understanding of either the facts or the issues. Often, the article is so wrong it actually presents the story backward—reversing cause and effect. I call these the “wet streets cause rain” stories. Paper’s full of them. In any case, you read with exasperation or amusement the multiple errors in a story, and then turn the page to national or international affairs, and read as if the rest of the newspaper was somehow more accurate about Palestine than the baloney you just read. You turn the page, and forget what you know.

— Michael Crichton (1942-2008)

USA TODAY removed 23 fabricated stories from their website, and, what’s interesting is that most of these 23 articles are mundane and boring. One can only imagine how frequent this is when it comes to politically and economically-related topics.

The co-founder himself has confirmed that Wikipedia is biased.

Git on 9front

Sun, 13 Mar 2022 00:00:00 +1200

This article is also mirrored on the 9front Wiki.

Resources

User configuration

; mkdir $home/lib/git
; cat > $home/lib/git/config
[user]
	name=Your Name
	email=me@example.org
^D

Examples

Create, commit and push a repo:

; cd repo
; git/init
# add a remote in .git/config...
; git/add .
; git/commit -m 'commitmsg' foo.c
heads/front: 817a3f121083091291c45f1ddfcd1b042343efab
; git/push

Clone and push changes to a repo:

; git/clone git://git.example.org/repo
; cd repo
# make changes...
; git/commit foo.c
; git/push

Make a patch:

# make changes...
; git/commit -m 'commitmsg' foo.c
heads/front: 817a3f121083091291c45f1ddfcd1b042343efab
; git/export > patch.diff

Apply a patch:

; git/import < patch.diff
applying commitmsg

See which files have changed:

; git/diff -s
M foo.c
M bar.c

Shithub usage

First ask Ori (ori AT eigenstate DOT org) for a user.

Create and push a repository:

; rcpu -u $user -h shithub.us -c \
	newrepo -d 'description' -c 'me@example.org' reponame
; git/push -u hjgit://shithub.us/$user/reponame

Repositories live under /usr/git/$user. Each repo contains editable files in /usr/git/$user/repo/.git:

webpublish: If this file exists, then the repository is published in the public web list of repositories.
desc, description: The short description of the repository. It shows up in the repo list.
contact: Contact information for submitting patches. Shows up on the repository info page.

9front CPU server setup

Mon, 07 Mar 2022 00:00:00 +1200

The contents of /net/ndb will be useful throughout the whole process; have them visible in another window:

; ip/ipconfig
; cat /net/ndb
ip=192.168.1.152 ipmask=255.255.255.0 ipgw=192.168.1.3
	sys=cirno
	dns=192.168.1.1
	dns=192.168.1.1

Boot settings

The 9fat partition contains the kernel, bootloader and boot settings. Add the following lines to plan9.ini. Make sure the values match your own configuration:

; 9fs 9fat
; cd /n/9fat
; cat >> plan9.ini

user=glenda
cpu=192.168.1.152
auth=192.168.1.152
authdom=someauth
service=cpu
^D

user is kinda like the root user on UNIX systems, cpu and auth define the IP addresses for the CPU and auth server respectively, authdom is the domain name of our the server, and service=cpu starts the CPU listener at boot time.

9front needs to boot hands-free, so the bootargs prompt has to be skipped. To do that, change the bootargs variable (its values might be different) in plan9.ini:

bootargs=local!/dev/sdE0/fs
# change to...
noobootprompt=local!/dev/sdE0/fs -m 291 -A -a tcp!*!564

Auth server

Set up the auth server hostowner’s name and password; authid and authdom have to match the values in plan9.ini:

; auth/wrkey
bad nvram des key
bad authentication id
bad authentication domain
authid: glenda
authdom: someauth
secstore key:
password: <your_pass>

Add glenda’s password. This has to be the same as the one you typed in wrkey(8). Always run keyfs(4) before modifying keys:

; auth/keyfs
; auth/changeuser glenda
Password: <your_pass>
Confirm password: <your_pass>
assign new Inferno/POP secret? [y/n]: y
make it the same as Plan 9 password? [y/n]: y
Expiration date (YYYYMMDD or never)[never]:
Post id:
User's full name: 
Department #:
User's email address:
user glenda installed for Plan 9

; auth/enable glenda

Network database

Add the following lines to /lib/ndb/local (pay close attention to detail, especially ip=):

; cat >> /lib/ndb/local

authdom=someauth auth=192.168.1.152

ipnet=iphome ip=192.168.1.0 ipmask=255.255.255.0
	ipgw=192.168.1.3
	auth=192.168.1.152
	authdom=someauth
	fs=192.168.1.152
	cpu=192.168.1.152
	dns=192.168.1.1
^D

ipnet can be anything.

Sync the changes and reboot the system:

; echo sync >> /srv/hjfs.cmd
; fshalt -r

On reboot

Enable networking:

; bind -a '#l0' /net
; ip/ipconfig
; ip/ipconfig ether /net/ether0

Drawterm as glenda:

$ drawterm -u glenda
cpu[cpu]: 192.168.1.152
auth[192.168.1.152]:
glenda@someauth dp9ik password: <your_pass>

Start a rio(1) instance:

cpu% rio -s -i riostart

/cfg/$sysname/cpustart contains commands that run on boot. You can put whatever you want in it — I’m going to just add the same commands I ran after we rebooted to make my life easier.

; mkdir /cfg/$sysname
; cat > /cfg/$sysname/cpustart
bind -a '#l0' /net
ip/ipconfig
ip/ipconfig ether /net/ether0
cat /net/ndb
^D

New user

Add the new user to the file server, add it to some standard groups and assign it a password:

; echo newuser christos >> /srv/hjfs.cmd
; echo newuser sys +christos >> /srv/hjfs.cmd
; echo newuser adm +christos >> /srv/hjfs.cmd
; echo newuser upas +christos >> /srv/hjfs.cmd
; echo newuser cron +christos >> /srv/hjfs.cmd
; auth/keyfs
; auth/changeuser christos
...
; auth/enable christos

Let the new user “speak for” for other users by adding the following lines to /lib/ndb/auth:

; cat >> /lib/ndb/auth
hostid=christos
	uid=!sys uid=!adm uid=*
^D

Reboot for the changes to take effect:

; fshalt -r

Drawterm as christos and run newuser(8) to set up his home directory:

$ drawterm -u christos
...
; /sys/lib/newuser

Acme editor notes

Sun, 06 Mar 2022 00:00:00 +1200

Resources

The Acme User Interface for Programmers
A Tour of the Acme Editor - Watch this if you’re completely new.
Plan9 Acme Intro - Part 1
The Tao of Acme
Extensibility in the Acme text editor

Mouse

Acme needs a 3-button mouse to work properly. All buttons can be used to select text, but their function is different upon release. The left button is used for just selecting text. The middle button is used for executing text. The right button is for searching text and loading files or directories. Text doesn’t have to first be selected when using button 2 and 3 (middle and right) if the selection is only one word.

Acme also makes use of mouse chording (e.g pressing more than one button).

Button 1-2	Cut.
Button 1-3	Paste.
Select text + Button 2-1	Execute with selection as argument.

Move around

`:2`	Go to 2nd line.
`:0`	Go to beginning of file.
`:$`	Go to end of file.
`CTRL-A`	Go to beginning of line.
`CTRL-E`	Go to end of line.
`CTRL-F`	Filepath autocompletion.
`Edit =`	Find current line number.

Search and select

`:,` `Edit ,`	Select all lines.
`:1,5` `Edit 1,5`	Select lines 1 to 5.
`:/regexp/`	Select lines matching regexp.
`:/regexp1/,/regexp2/`	Select lines between regexp1 and regexp2.
`Edit +/foo` `:/foo` `:foo` Right click on word.	Forward search.
`Edit -/foo` `:-/foo` `:-foo`	Backward search.

Edit text

`CTRL-U`	Delete from cursor to beginning of line.
`CTRL-W`	Delete before cursor.
`CTRL-H`	Delete character before cursor.
`Edit , d`	Clear window.
`Edit , s/foo/bar/g` `Edit , \| sed 's/foo/bar/g'`	Global replace.
`Edit s/foo/bar/g`	Replace in selection.
`Edit 2 d`	Delete 2nd line.
`Edit 2 c/foo`	Change 2nd line.
`Edit 2 a/foo`	Append after 2nd line.
`Edit 2 i/foo`	Insert before 2nd line.

Work with external commands

`cmd`	Run cmd with the file as argument.
`\|cmd`	Pipe selection through cmd and also apply changes.
`>cmd`	Send selection to cmd and see result in a temporary window.
`<cmd`	Paste output of cmd in current window (no selection required).

Any command can be used, these are just a few examples.

`Edit , < echo foo`	Replace window body with some text (works with any command).
`echo foo \| 9p write acme/$winid/body`	Append to end of current window body.
`Edit , > wc -l`	Count lines.
`Edit , \| sort`	Sort lines.
`Edit ,x/regexp/ < date`	Replace regexp with the output of date(1).
Select text + `\| sed '' > foo.txt`	Cut to foo.txt.
Select text + `> sed '' > foo.txt`	Copy to foo.txt.

Files

As mentioned earlier, files are opened using the right mouse click.

`foo.c`	Open file.
`foo.c:3`	Open file to line 3.
`foo.c:3:9`	Open file to line 3 column 9.
`foo.c:/^func`	Open file to the line starting with "func".
`foo.c:/bar/,/baz/`	Open file with a selection from "bar" to "baz".

Useful Acme commands

`win`	Spawn shell as a window.
`web URL`	Open URL in browser.
`Dump`	Save current state.
`Load`	Load dump.
`Tab 8`	Set tab width to 8.

Variables

`$%` `$samfile`	Current file name.
`$winid`	Current window.

FreeBSD sound mixer improvements

Fri, 25 Feb 2022 00:00:00 +1200

This project was part of Google Summer of Code 2021, but development is still active. The development report can be found on the FreeBSD Wiki. The reason behind this project is that the FreeBSD’s OSS mixer capabilities were really basic and outdated — even un/muting didn’t exist and one had to write custom scripts for such a basic task. Setting default audio devices had to be done by tweaking sysctls and programs needing to use the mixer required DIY implementations as there was no mixer library available. The project was merged to upstream on FreeBSD 14.0.

Kernel patches

Un/muting (commit)

I decided that un/muting is better to be implemented in sound(4) in order to avoid having to write daemons or use files. The way this works is by implementing the SOUND_MIXER_READ_MUTE and SOUND_MIXER_WRITE_MUTE ioctls, which did exist in older OSS implementations, but were considered obselete. One thing to note is that the functionality isn’t the same as their old one. Older OSS versions had those 2 ioctls take/return an integer with a value of 0 or 1, which indicated whether the whole mixer is muted or not. My implementation takes/returns a bitmask that tells which devices are muted. This allows us to mute and unmute only the devices we want, instead of the whole mixer. If you’re familiar with the OSS API, this bitmask works the same way as DEVMASK, RECMASK and RECSRC.

Playback/recording mode information (commit)

Here I implemented a sysctl (dev.pcm.<N>.mode) which gives information about a device’s playback/recording mode. The rationale for this control is to include /dev/sndstat’s mixer information in the output of the new mixer(8). The sysctl can return the following values (NOTE: these values are OR’ed together if more than one mode is supported):

Value	Meaning
0x01	Mixer
0x02	Playback device
0x04	Recording device

Userland

mixer(3) implementation (commit)

mixer(3) provides a simple interface for working with the OSS mixer. The man page explains how the library works, including some examples, so there’s no need to repeat myself. You can see the library in action in the source code for mixer(8).

The basic structure of a program looks like this (link with -lmixer):

#include <err.h>
#include <mixer.h>

int
main(int argc, char *argv[])
{
	struct mixer *m;
	const char *name = "/dev/mixer0";

	if ((m = mixer_open(name)) == NULL)
		err(1, "mixer_open(%s)", name);

	/* do stuff */

	mixer_close(m);
	
	return (0);
}

mixer(8) rewrite (commit)

This implementation is a complete rewrite of the old mixer(8) utility. It now uses mixer(3) as a backend and implements all the new features the library provides. It’s got more command line options and works with a control-oriented interface inspired by OpenBSD’s mixerctl(8). Again, everything is detailed in the man page.

Old mixer(8) output:

$ mixer.old

Mixer vol      is currently set to  85:85
Mixer pcm      is currently set to 100:100
Mixer speaker  is currently set to  74:74
Mixer line     is currently set to   1:1
Mixer mic      is currently set to  67:67
Mixer mix      is currently set to  74:74
Mixer rec      is currently set to  37:37
Mixer igain    is currently set to   0:0
Mixer ogain    is currently set to 100:100
Mixer monitor  is currently set to  67:67
Recording source: mic

New mixer(8) output:

$ mixer

pcm0:mixer: <Realtek ALC662 rev3 (Analog 2.0+HP/2.0)> on hdaa0 kld snd_hda (play/rec) (default)
    vol       = 0.85:0.85     pbk
    pcm       = 1.00:1.00     pbk
    speaker   = 0.74:0.74     rec
    line      = 0.01:0.01     rec
    mic       = 0.67:0.67     rec src
    mix       = 0.74:0.74     rec
    rec       = 0.37:0.37     pbk
    igain     = 0.00:0.00     pbk
    ogain     = 1.00:1.00     pbk
    monitor   = 0.67:0.67     rec

Code and manuals

Thermometer using PIC16F877A and BME280

Mon, 14 Feb 2022 00:00:00 +1200

This embedded system measures temperature and humidity and outputs the data on an LCD. The BME280 sensor can also do pressure but I didn’t implement it because the MCU had no more space available. The whole project can be found here; I’ve also included datasheets for the MCU, sensor and LCD.

Development was done on FreeBSD using the workflow I describe here. If you’re using Microchip’s own tools, you’ll have to make some small changes to the code, but nothing too extreme.

The source code.

Components

Microchip PIC16F877A-I/P microcontroller.
Adafruit BME280 temperature, humidity and pressure sensor.
16x2 LCD.
1x 16MHz crystal oscillator.
2x 10kΩ resistor.
2x 300Ω resistor.
1x 10kΩ potentiometer.
2x 22pF ceramic capacitor.
2x LED.
2x push-button.
Breadboard and wires.
3x AAA batteries (4.5V total) or a 9V battery with a 5V voltage divider.

Safe temperature range

Component	Operating temperature
PIC16F877A	-40°C - 85°C
BME280	-40°C - 85°C
LCD	-20°C - 70°C

So, it’s best for the system to operate in the -20°C to 70°C range.

Schematic

You can also get the PDF version.

PIC microcontroller development on FreeBSD

Sun, 23 Jan 2022 00:00:00 +1200

Tested on FreeBSD 13.0. This article has also been mirrored on the FreeBSD Wiki.

Prerequisites

sdcc is a C compiler for microprocessors. It says that PIC microprocessors are unmaintained, but I’ve found it to be pretty reliable so far (take this with a grain of salt, I’m no expert). The port can be found under:

lang/sdcc

Page 75 of the sdcc user manual lists the supported PIC devices. Header files can be found under /usr/local/share/sdcc.

For programming the MCU, I’ve found pk2cmd to work alright with PICKit2 (or Chinese clones), but there’s no port for FreeBSD anymore. The Makefile won’t install files properly, so we have some extra work to do afterwards:

$ git clone https://github.com/psmay/pk2cmd.git
$ cd pk2cmd/pk2cmd
# gmake freebsd install clean
# mv /usr/share/pk2/PK2DeviceFile.dat /usr/local/bin
# rm -rf /usr/share/pk2

Supported devices for pk2cmd are listed here.

Detecting and programming the MCU

Avoid using just the -P option to auto-detect the MCU, as the VPP the PICKit2 applies to the chip trying to detect it can damage the MCU. Instead, use the chip number beforehand as shown below. Also, use the -C option to check if the chip is blank.

If any of the following pk2cmd commands fail, make sure everything really is wired properly:

$ pk2cmd -P PIC16F877A -C
Device is blank

Operation Succeeded

Compile your source code. The target executable is the .hex file sdcc will output. Replace pic14 and 16f877a with the appropriate names for your device:

$ sdcc --use-non-free -mpic14 -p16f877a main.c

Erase the PIC (if it wasn’t already blank) and flash the new code. Again, use the appropriate names:

$ pk2cmd -P PIC16F877A -E
$ pk2cmd -P PIC16F877A -X -M -F main.hex

If all went well, you should get an output similar to this:

PICkit 2 Program Report
23-1-2022, 21:01:29
Device Type: PIC16F877A

Program Succeeded.

Operation Succeeded

Email-driven Git workflow

Sun, 16 Jan 2022 00:00:00 +1200

Basic Git configuration (in case you haven’t already done that):

$ git config --global user.email you@example.org
$ git config --global user.name "Your Name"

Git email configuration:

$ git config --global sendemail.smtpserver your_mail_server
$ git config --global sendemail.smtpuser you@example.org
$ git config --global sendemail.smtpserverport your_smtp_port
$ git config --global sendemail.smtpencryption your_encryption_type

Examples

Apply a patch (or simply make a commit) and send it to a mailing list:

$ git am < some_patch
$ git send-email --to=list@example.org HEAD^

Fix last commit and send it:

$ git commit -a --amend
$ git send-email --annotate -v2 HEAD^

Send 3 last commits (see Revision Selection for more info on the notation):

$ git send-email HEAD~3

Send the last commit to list@example.org and make the subject look like “[reponame][PATCH] commitmsg”. This is useful for sending patches to mailing lists or programmers with multiple projects:

$ git send-email --subject-prefix="${PWD##*/}][PATCH" \
	--to=list@example.org -1

git-send-email(1) manual page. Simple as that. None of that fork & pull request crap.

How to jump start your car

Wed, 12 Jan 2022 00:00:00 +1200

There are tons of articles and videos out there already, but all of them are too long.

Requirements: jumper cables and a live car. Order matters.

Turn off the live car’s engine and remove the key. Make sure the emergency brake is on and the transmission in neutral. Also make sure that your cables are always apart and away from your body.
Dead car: connect the positive (red) end of the cable to the battery’s positive terminal. The terminals are distinguished from their colors (red for positive and black for negative) and/or their sign (+ for positive, - for negative).
Live car: connect the other positive end of the cable to the battery’s positive terminal
Live car: connect the negative (black) end of the cable to the battery’s negative terminal.
Dead car: connect the other negative end of the cable to a ground, for example a bolt on your hood.
Keep the cables away from hot components, such as the radiator or the engine.
Start the live car and slightly rev up the engine every now and then. Do this for a few minutes.
Dead (now alive) car: disconnect the ground.
Live car: disconnect the negative terminal.
Live car: disconnect the positive terminal.
Dead car: disconnect the positive terminal.

DO NOT confuse the terminals or you will destroy your car’s computer system.

C coding style

Sat, 01 Jan 2022 00:00:00 +1200

First of all, I wanna wish all 0 readers of this blog a happy new year! There’s no reason to write a whole article repeating what better articles have already covered, so here’s a list with proper C coding style guides:

9front using bhyve(8) on FreeBSD

Tue, 23 Nov 2021 00:00:00 +1200

This article is also mirrored on the FreeBSD Wiki. and 9front Wiki.

Required ports:

sysutils/bhyve-firmware
sysutils/uefi-edk2-bhyve
sysutils/uefi-edk2-bhyve-csm
net/tigervnc-viewer

Add the following lines to /etc/rc.conf. Replace re0 with your own network interface. It’s good practice to assign each VM a unique tap interface in case you need to run multiple VMs at the same time. For simplicity’s sake, this setup uses only one tap:

if_bridge_load="YES"
if_tap_load="YES"
cloned_interfaces="bridge0 tap0"
ifconfig_bridge0="DHCP addm re0 addm tap0"
ifconfig_bridge0_alias0="inet 10.0.0.1/24"

Reboot your machine and then grab a 9front ISO.

Make a directory where you’ll store everything 9front-related. I usually keep all my bhyve(8) VMs under a ZFS dataset:

$ cd /path/to/vms/
$ mkdir 9front
$ mv /path/to/9front_iso 9front.iso

Create an empty file to be used as the VM’s hard drive. 10G will be more than enough:

$ truncate -s 10G disk.img

Make a startup script. Feel free to tweak the variable values to match your own setup. Obviously, when you’re done installing 9front from the ISO, you’ll be running the script without the -s 3,... line:

$ cat 9front_start

#!/bin/sh

name="9front"
cpu="2"
mem="2G"
iso="9front.iso"
disk="disk.img"
tap="tap0"

ifconfig ${tap} up

bhyve -c ${cpu} -m ${mem} -wH \
	-s 0,hostbridge \
	-s 3,ahci-cd,${iso} \
	-s 4,ahci-hd,${disk} \
	-s 5,virtio-net,${tap} \
	-s 29,fbuf,tcp=0.0.0.0:5900,w=800,h=600,wait \
	-s 30,xhci,tablet \
	-s 31,lpc \
	-l bootrom,/usr/local/share/uefi-firmware/BHYVE_UEFI.fd \
	${name}

Make a shutdown script in order for bhyve(8) to shutdown properly:

$ cat 9front_stop

#!/bin/sh

name="9front"
tap="tap0"

ifconfig ${tap} down
bhyvectl --force-poweroff --vm=${name}
bhyvectl --destroy --vm=${name}

Make the scripts executable and start the VM:

$ chmod +x 9front_start 9front_stop
# ./9front_start; ./9front_stop

Run vncviewer(1) to connect to the VNC display:

$ vncviewer 0.0.0.0

When prompted for the monitor type during boot, choose xga.

Git Web frontend with stagit(1)

Fri, 05 Nov 2021 00:00:00 +1200

stagit(1) reads Git repositories and generates static pages for them with a predefined CSS stylesheet (I said stylesheet twice!), a website logo and a favicon.

Required:

Install stagit(1):

$ git clone git://git.codemadness.org/stagit
$ cd stagit
# doas make install clean

I like to have everything stagit(1)-related inside /var/www/htdocs/git.example.org along with the actual repositories, but you can choose any other directory.

Store the stylesheet, logo and favicon inside. You’ll find the stylesheet inside the stagit(1) repository you cloned earlier; it’s called style.css. For the logo and favicon, just make your own, but make sure they are in PNG format and have the same names as below.

# cp logo.png favicon.png style.css /var/www/htdocs/git.example.org

You can edit the stylesheet to your likings, but if you’re afraid that you’ll mess things up, play around with the colors only.

Here I created a repository named repo in /var/www/htdocs/git.example.org/repo.git. I will now make a directory to store the files that stagit(1) will produce. I like to give it the same name as the repository but without the .git extension:

# mkdir /var/www/htdocs/git.example.org/repo

Create symlinks for the stylesheet, logo and favicon inside the directory you just created:

$ cd /var/www/htdocs/git.example.org/repo
# ln -s ../style.css ../logo.png ../favicon.png .

Run stagit(1) and generate the static page for your repository. This has to be done inside the directory you just created since stagit(1) stores the files in the working directory. Make sure that you give it the .git directory (i.e the actual repository):

# stagit ../repo.git

Go to the top-level Git directory and generate an index.html file which is your Git server’s homepage where all repositories will be listed. Again, you give it the actual repositories:

$ cd /var/www/htdocs/git.example.org
# stagit-index repo.git > index.html

I’ve made a simple script to automate the generation process:

#!/bin/sh

cd /var/www/htdocs/git.example.org
for dir in $(ls | grep "git"); do
	cd ${dir%.*} && stagit ../${dir} && cd .. && echo "updating ${dir}: ok"
done
stagit-index $(ls | grep "git") > index.html && echo "creating index.html. ok"

Fire up a browser and go to git.example.org and you should see everything. Success!

OpenBSD Git server setup

Wed, 10 Feb 2021 00:00:00 +1200

Git subdomain

It’s good to have your Git server under a subdomain, so that it looks like git.example.org. To do that, add a new CNAME record for the subdomain on your registrar. If you’re on Epik, don’t forget the trailing period after the domain name.

Host: git | Points to: example.org.

Setting up the Git server

Install git:

# pkg_add git

First create a git user and give it a password. If you don’t want the same hosts that exist in your current user’s authorized_keys to have access to the Git server, then add their keys manually in the git user’s .ssh/authorized_keys file. In my case, it’s just me who has access to the server, so I will not edit anything:

# adduser git
...
# cp -r $HOME/.ssh /home/git/
# chown -R git:git /home/git/.ssh

Try sshing to the server as git from your local computer just to test if it works:

$ ssh git@example.org

If it worked, exit the session.

Set up a Git directory where all repositories will be stored at and cd into it:

# mkdir /var/www/htdocs/git.example.org
# chown -R git:git /var/www/htdocs/git.example.org
# cd /var/www/htdocs/git.example.org

Say I want to create a repository named repo. The structure your repositories should have is name.git, so in this case it’ll be repo.git. Create a bare repository inside it:

# mkdir repo.git
# git init --bare repo.git

Replace each text inside double quotes with what you want it to be:

# echo "John Doe" > repo.git/.git/owner
# echo "This is a repo" > repo.git/.git/description
# echo "git://git.example.org/repo.git" > repo.git/.git/url

To be able to interact with the Git server, the repository’s owner needs to be the git user you created earlier:

# chown -R git:git repo.git

Since sometimes the Git server by default might not be listening on port 9418 (the default Git port), which means that you’ll not be able to clone repositories from the Git server, you have to set up the daemon yourself using a massive git command. You can (in fact, you should) also use Git over HTTPS or SSH, but for now I’ll be using the default Git protocol for cloning and SSH for pushing.

# git daemon \
	--base-path=/var/www/htdocs/git.example.org/ \
	--export-all \
	--enable=receive-pack \
	--reuseaddr \
	--informative-errors \
	--verbose \
	--detach

Pushing changes to the server

On your local machine, make a repository for repo (the repository you created earlier) and add a few files so that you have something to commit and push to the server:

$ mkdir repo && cd repo
$ touch foo bar
$ git init
$ git add .
$ git commit -m "initial commit"

In order to be able to push you have to edit .git/config. If you’ve used GitHub before, you might have noticed that when you want to push, you push to origin; for this server I’ll use home, but you can use whatever else you want, it doesn’t really matter.

Append the following block to your repository’s .git/config and of course replace the domain and repository names with your own ones:

[remote "home"]
	url = git@git.example.org:/var/www/htdocs/git.example.org/repo.git
	fetch = +refs/heads/*:refs/remotes/home/*

Push to the Git server:

$ git push home master

Try also cloning the repository to make sure that everything works:

$ git clone git://git.example.org/repo.git

If that step was successful too, great, you now have a working Git server. :-)

Create a Web frontend with stagit(1).

OpenBSD Web server setup

Tue, 09 Feb 2021 00:00:00 +1200

HTTPS

acme-client(1) lets us have HTTPS.

Create the certificate directories:

# mkdir -p -m 700 /etc/ssl/private
# mkdir -p -m 755 /var/www/acme

Edit /etc/acme-client.conf. Replace example.org with your domain.

authority letsencrypt {
	api url "https://acme-v02.api.letsencrypt.org/directory"
	account key "/etc/ssl/private/letsencrypt.key"
}

domain example.org {
	domain key "/etc/ssl/private/example.org.key"
	domain certificate "/etc/ssl/example.org.crt"
	domain full chain certificate "/etc/ssl/example.org.pem"
	sign with letsencrypt
}

httpd(8)

OpenBSD already ships with a web server: httpd. You need to specify the following things:

The domain name.
Which port/s the server will listen to.
Where the website’s root directory is.

Create the website’s root directory. It should normally reside under /var/www/htdocs.

# mkdir -p /var/www/htdocs/example.org

The following configuration will suffice for now. With it you have HTTP and HTTPS for your website and it redirects HTTP to HTTPS automatically. If you want to learn more or see what other options and settings are available, read httpd.conf(5)’s man page. Inside /etc/httpd.conf we’ll write the following:

server "example.org" {
	listen on * port 80
	root "/htdocs/example.org"
	location "/.well-known/acme-challenge/*" {
		root "/acme"
		request strip 2
	}
	block return 301 "https://example.org$REQUEST_URI"
}

server "example.org" {
	listen on * tls port 443
	root "/htdocs/example.org"
	tls {
		certificate "/etc/ssl/example.org.pem"
		key "/etc/ssl/private/example.org.key"
	}
	location "/.well-known/acme-challenge/*" {
		root "/acme"
		request strip 2
	}
}

Generate the TLS certificates:

# acme-client -v example.org

Test to see if the configuration is correct:

# httpd -n

(Re)start the web server:

# rcctl restart httpd

Certificate renewal

TLS certificates expire after a few months so new certificates need to be generated when they expire. In order to avoid having to remember this and having to manually generate them, a cronjob will do it automatically:

# crontab -e

Append the following line:

0 0 * * * acme-client -v example.org && rcctl reload httpd

Use cases for goto

Tue, 19 Jan 2021 00:00:00 +1200

This article is a response to all my university professors who, for some reason, think goto is useless and should be avoided at all costs.

Some use cases

The most important use case there is for goto is by far error handling when there are more than 1 points of failure. In this case, you might want to cleanup some resources while also skipping part of the code that should not be executed, without having to deal with flags, helper functions, and other methods that would make the code ugly, slower and error prone. Try rewriting the following snippet without a goto:

int
foo(int *bar, int *baz)
{
	if (!func1())
		goto fail;
	if (!func2())
		goto fail;
	if (!func3())
		goto fail;

	return 0;

fail:
	warn("foo failed");
	if (bar != NULL)
		free(bar);
	if (baz != NULL)
		free(baz);

	return -1
}

Another use case is breaking out of deeply nested code. Let’s say you’ve got 3 for loops and there’s a special case in which you really want to break out of all the loops at once. how do you do that? There are multiple ways you can go about doing so but one way would be to set a flag and check it on every nested level.

flag = 0;

for (i = 0; i < 10; i++) {
	for (j = 0; j < 10; j++) {
		for (k = 0; k < 10; k++) {
			...
			if (flag)
				break;
		}
		if (flag)
			break;
	}
	if (flag)
		break;
}

Another ugly hack you can use is something another colleague from university showed me, and something I would never use; when the flag is set, manually max out all the loop counters.

A pretty straight-forward solution would also be to put the loop into a function and use a return statement to break out of all the loops. That’s actually a good solution, and I’m aware of it, but I want to provide another solution, which is also quite faster than using a function since it avoids that additional function call.

An alternative, and in my opinion, better way of solving this problem would be by using a (don’t say it, don’t say it) goto:

flag = 0;

for (i = 0; i < 10; i++) {
	for (j = 0; j < 10; j++) {
		for (k = 0; k < 10; k++) {
			...
			if (flag)
				goto end;
		}
	}
}
end:
...

Who cares, anyway?

In the first use case, the code is much more readable and you avoid code duplication. In the second use case the goto solution actually does improve performance. The reason why is simple; we check for flag on every single loop, which means, that in case flag is never set, we’ll have done 10 * 10 * 10 = 1000 checks just to see if flag is set. And that’s just with 3 for loops going from 0 to 10 each; think how easily this can scale up if you just increase the iterations. The goto solution does only one check in the third loop, which means that, in the above scenario, where flag never gets set, we’ll have done only 10 checks - that’s 100 times faster than the other solution.

Using a function is almost just as fast as using a goto without a function, but not having to call a function is generally faster. Both solutions are great and totally valid, I just want to show an alternative one.

Final note

goto does have its place but it should be used carefuly; if you overuse it, your code will either become incomprehensible, or flat out broken. The use cases I showcased in this post are very common and sometimes the code can be vastly improved with just a simple goto if used correctly.

Again, thanks to both my colleagues who helped me improve this article with their recommendations.

Sync files with rsync(1)

Sun, 22 Nov 2020 00:00:00 +1200

Connecting local machines

In order to connect two machines on the same network, they both need to know each other’s network IP address. To get your network IP address execute the following command on each of the local machines you want to connect:

$ ifconfig

In your running network interface’s section, ifconfig will output a line that looks like this:

inet 192.168.x.y

This is your network IP address which the other machine needs to know. Suppose you want to connect two local machines at home; we’ll call the first one host1 and the other host2. the ip address for host1 is 192.168.1.7 and for host2 it’s 192.168.1.8. add the following line on host1’s /etc/hosts so that it knows who host2 is. do the same for host2.

192.168.1.8 host2

After completing this step ping each other using both the IP and the hostname to make sure everything works:

$ ping 192.168.1.8 

ping 192.168.1.8 (192.168.1.8): 56 data bytes
64 bytes from 192.168.1.8: icmp_seq=0 ttl=64 time=36.931 ms
...

$ ping host2

ping host2 (192.168.1.8): 56 data bytes
64 bytes from 192.168.1.8: icmp_seq=0 ttl=64 time=74.056 ms
...

If you don’t already have an ssh key pair, generate one:

$ ssh-keygen

Copy the ssh public key over to the other machine:

$ eval $(ssh-agent -s)
$ ssh-add
$ ssh-copy-id user@host2

Repeat the same process for host2. to verify that the key was indeed copied over, look at ~/.ssh/authorized_keys.

Using rsync

You can think of rsync as cp with superpowers; in fact, you could even alias cp to rsync.

To just copy a file on your machine you can do exactly the same thing you would do with cp:

$ rsync foo bar/

Suppose we want to send that file to host2 (read the previous section):

$ rsync foo host2:

By default, rsync assumes that the target user has the same name as yours. In case it’s different, you need to specify it:

$ rsync foo user@host2:

The file will be copied in the other machine’s home directory, if no other directory is specified. To send it to a specific path:

$ rsync foo user@host2:foo/

rsync has a lot of options, but some of the most common ones, and the ones I use most of the time are the following:

-r: Copy directories recursively.
-u: Update only the files that have changed (incremental copy).
-v: Increase verbosity.
-a: Preserve permissions and metadata. does not preserve hard links.
-p: In case something goes wrong and the sync breaks, continue the sync from where it stopped.
--delete-after: Delete the old files after the transfer.

Note: when you want to transfer a directory, you must add a / after its name (e.g foo/), otherwise rsync will skip it.

Sample usage

Suppose I want to update a website that is hosted on a remote server. I can make changes locally and just sync it with the server whenever I want using rsync. Let’s say the remote directory is located at /var/www/website:

$ rsync -purv --delete-after website/ user@server:/var/www/website

You can automate this process using a simple shell script. In this case though, you have to pass the absolute paths of the directories so that you can run the script from everywhere:

#!/bin/sh

src="/foo/bar/website/"
dst="user@server:/var/www/website"
rsync -purv --delete-after ${src} ${dst}

Arduino on FreeBSD

Wed, 28 Oct 2020 00:00:00 +1200

This article demonstrates how to develop for Arduino boards using only basic command line utilities, without having to use the Arduino IDE. The article has also been published on the FreeBSD Wiki.

Tested on FreeBSD 12.2 and above.

Prerequisites

Required ports:

devel/arduino-core
devel/arduino-bsd-mk
devel/avr-gcc
devel/avr-libc
devel/avrdude
comms/uarduno

With all the software installed, add the following line to /boot/loader.conf in case you want the Arduino kernel module to load automatically on boot. If you want to manually load the module whenever you need it, skip this step:

uarduno_load="YES"

Load the kernel module:

# kldload uarduno

Check your ~/.arduino/preferences.txt and see if the following lines exist (source):

serial.port=/dev/cuaU0
launcher=/usr/local/bin/firefox

Add your user to the dialer group:

# pw group mod dialer -m $USER

Connecting the board

Standard Arduino boards connect as /dev/cuaU0 and/or /dev/ttyU0 on FreeBSD. In case these serial ports don’t show up in /dev, you might need to press your board’s reset button. After you’ve plugged your board into a USB port, you should get the following output from dmesg. Although the output may vary, the important thing is that your board is connected and detected.

ugen1.5: <Arduino (www.arduino.cc) product 0x0043> at usbus1
uarduno0: <Arduino (www.arduino.cc) product 0x0043, class 2/0, rev 1.10/0.01, addr 5> on usbus1

If dmesg returned information about your board, you should also see cuaU0 and/or ttyU0 in /dev. In case your board is still not detected — considering it’s not a fake one, try using a different USB cable or reset it again and make sure you’ve followed the setup steps correctly.

The Makefile

The only thing you’re going to need in order to get started is just a Makefile that’ll be used to compile and upload your Arduino programs. Make a new directory for your Arduino project and a Makefile with the following lines:

ARDUINO_DIR= 	/usr/local/arduino
ARDUINO_MK_DIR= /usr/local/arduino-bsd-mk
#ARDUINO_LIBS=	
AVRDUDE_PORT=	your_board_port
ARDUINO_BOARD= 	your_board_name
SRCS=		your_source_files
TARGET=		your_program_name

include /usr/local/arduino-bsd-mk/bsd.arduino.mk

In my case my board is an Arduino Uno, so I’d have to set ARDUINO_BOARD to uno. You can see which other board types are available in /usr/local/arduino/hardware/arduino/avr/boards.txt. If you want to install new libraries, copy them over to /usr/local/arduino/hardware/arduino/avr/libraries/.

Avoid having source files named main.

Building and uploading a program

Write some Arduino code, and when you’re ready to compile and upload, run the following command:

# make install flash clean cleandepend

If all went well you should see the board executing the new code. If it doesn’t, try to see what errors the Makefile produced.

Monitoring

The Arduino IDE provides a serial monitor feature, but FreeBSD has a builtin monitoring utility which can be accessed directly from the terminal. Run this whenever you want to monitor your board and exit with ~! (use the appropriate port):

$ cu -l /dev/cuaU0

Using board types other than the Uno

As it’s mentioned above, we’re using the uarduno kernel module. Even though the module’s description is “FreeBSD Kernel Driver for the Arduino Uno USB interface”, you can, in fact, use different board types other than the Uno. According to uarduno’s website, you can modify /usr/ports/comms/uarduno/files/ids.txt to include more board types; the two fields are Vendor ID and Product ID. Read the comments inside the file for more information.

{ 0x2341, 0x0001 },  // Arduino UNO, vendor 2341H, product 0001H
{ 0x2341, 0x0042 },  // Arduino MEGA (rev 3), vendor 2341H, product 0042H
{ 0x2341, 0x0043 },  // Arduino UNO (rev 3), vendor 2341H, product 0043H
{ 0x2341, 0x0010 },  // Arduino MEGA 2560 R3, vendor 2341H, product 0010H 
{ 0x2341, 0x8037 },  // Arduino Micro

When you’re done, clean and re-build the port.

Known issues and their fixes

Even though you might have plugged your board to your machine, you might notice that there is no device appearing in /dev. Although there is no definite answer as to why this is happening, make sure that the USB cable is connected properly; on some boards, you have to hear a click sound.

When trying to use a new library, you might notice that your code doesn’t compile. A common issue is that you haven’t stored the library in the correct path. As mentioned, libraries are stored in /usr/local/arduino/hardware/arduino/avr/libraries/, so you have to move it there.

Simple Brainfuck interpreter in C

Wed, 02 Sep 2020 00:00:00 +1200

How Brainfuck works

There are only 8 symbols supported in Brainfuck:

Symbol	Function
>	Increase position of pointer
<	Decrease position of pointer
+	Increase value of pointer
-	Decrease value of pointer
[	Beginning of loop
]	End of loop
.	Output ASCII code of pointer
,	Read a character and stores its ASCII value in pointer

It’s best to imagine Brainfuck programs as arrays of integers, which the pointer can manipulate. Let’s say this is our initial state:

{ 0, 0, 0, 0, 0, 0 }

We can assign values to each position in the array by moving the pointer around. Using the + and - symbols, we can increment or decrement by 1 each time. If we wanted to move the pointer two times to the right and increment the value there by 3, we would have a program that looks like this:

>>+++

The updated version of the array:

{ 0, 0, 3, 0, 0, 0 }

Following the same logic, we can assign specific values to each cell and make an actual program. If we wanted to print the letter “B” on the screen, which corresponds to the ASCII value 66, we could write the following program:

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.

In order to avoid writing things like this we can use loops. The loop is executed as long as the value inside it is not 0. Essentially, it’s going to do the multiplication 10 x 6 = 66 and then print the value:

+++++ +++++		# add 10 to cell #0
[			# beginning of loop
	> +++ +++	# add 6 to cell #1
	< -		# subtract 1 from cell #0
]			# end of loop
			# value at cell 1 is now 66 (10 x 6 = 66)
> .			# go to cell 1 and print its value

Or, for compactness:

+++++++++++[>++++++<-]>.

You can learn more about how Brainfuck works here.

Building the interpreter

We’ll first read the Brainfuck source from stdin into a static size buffer. 50.000 bytes should be large enough to store any Brainfuck program, since I doubt anyone is mad enough to write actual programs in it:

#define BUFSIZE 50000
.
.
.
size_t len = 0;
char buf[BUFSIZE];

while (read(STDIN_FILENO, &buf[len], 1) > 0)
	len++;
buf[len] = '\0';

We’ll declare the rest of the needed variables:

int closed;		/* number of active loops */
int opened;		/* number of inactive loops */
int pos = 0;		/* position in the program */
unsigned short *pc;	/* program counter */
char *src;		/* source code */

One of the reasons we have a len variable is to allocate just enough memory for src. We’ll also empty the buffer because we now want to use it to store the values the Brainfuck program will produce:

if ((src = malloc(len)) == NULL) {
	perror("malloc");
	exit(1);
}
strcpy(src, buf);
memset(buf, 0, len);

We can now parse the source code symbol by symbol. pc will act as the “pointer”, moving back and forth in the array. Each symbol will have its own case inside the following switch statement:

for (pc = (unsigned short *)buf, pos = 0; pos < len; pos++) {
	switch (src[pos]) {
		...
	}
}

For the < and > symbols we simply move the pointer:

case '>':
	pc++;
	break;
case '<':
	pc--;
	break;

The + and - symbols in/decrement the value of the cell the pointer is currently at:

case '+':
	(*pc)++;
	break;
case '-':
	(*pc)--;
	break;

To implement the . and , symbols we’ll use the standard library’s putchar() and getchar() functions:

case '.':
	putchar(*pc);
	break;
case ',':
	*pc = getchar();
	break;

Now comes the last, but harder part, which is to implement loops. The logic behind my implementation is that instead of keeping track of every bracket to know where a loop starts and ends, the program keeps going through the source code and, using a counter, we know that a loop starts or ends when that counter is 0 and and an opposite bracket has been found. Also, in each iteration the pos variable changes accordingly so that we can imitate the looping behavior of Brainfuck.

These are the steps the program follows for each of the two symbols:

Beginning of loop: `[`

If the pointer’s value is 0, we have a new loop.
Count how many (if any) nested loops we encounter.
If we encouter a [, increment the opened variable.
If we encouter a ], decrement the opened variable.
Keep counting until there are no new active loops (i.e opened is 0).

case '[':
if (!(*pc)) {
	for (opened = 0; pos++; pos < len; pos++) {
		if (src[pos] == ']' && !opened)
			break;
		else if (src[pos] == '[')
			opened++;
		else if (src[pos] == ']')
			opened--;
	}
}
break;

End of loop: `]`

If the pointer’s value is is not 0, we have an active loop.
Start going back and count how many (if any) nested loops there are.
If we encouter a ], increment the closed variable.
If we encouter a [, decrement the closed variable.
Keep counting until there are no active loops (i.e closed is 0).

case ']':
if ((*pc)) {
	for (closed = 0; pos--; pos >= 0; pos--) {
		if (src[pos] == '[' && !closed)
			break;
		else if (src[pos] == ']')
			closed++;
		else if (src[pos] == '[')
			closed--;
	}
}
break;

Putting it all together

Below is the full program. You can also find this program here

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#define BUFSIZE 50000

int
main(int argc, char *argv[])
{
	size_t len = 0;
	int closed, opened, pos = 0;
	unsigned short *pc;
	char buf[BUFSIZE], *src;

	while (read(STDIN_FILENO, &buf[len], 1) > 0)
		len++;
	buf[len] = '\0';

	if ((src = malloc(len)) == NULL) {
		perror("malloc");
		exit(1);
	}
	strcpy(src, buf);
	memset(buf, 0, len);

	for (pc = (unsigned short *)buf; pos < len; pos++) {
		switch (src[pos]) {
		case '>':
			pc++;
			break;
		case '<':
			pc--;
			break;
		case '+':
			(*pc)++;
			break;
		case '-':
			(*pc)--;
			break;
		case '.':
			putchar(*pc);
			break;
		case ',':
			*pc = getchar();
			break;
		case '[':
			if (!(*pc)) {
				for (opened = 0, pos++; pos < len; pos++) {
					if (src[pos] == ']' && !opened)
						break;
					else if (src[pos] == '[')
						opened++;
					else if (src[pos] == ']')
						opened--;
				}
			}
			break;
		case ']':
			if (*pc) {
				for (closed = 0, pos--; pos >= 0; pos--) {
					if (src[pos] == '[' && !closed)
						break;
					else if (src[pos] == ']')
						closed++;
					else if (src[pos] == '[')
						closed--;
				}
			}
			break;
		}
	}
	free(src);

	return (0);
}

Christos Margiolis: Writings

PostgreSQL 15 and pgAdmin4 on FreeBSD

PostgreSQL

pgAdmin4

Upgrading pgAdmin4

Inline function tracing with the kinst DTrace provider

Table of Contents

Quick background

Usage

Inline function tracing

How it works

Syntactic transformations

Heuristic for calculating the entry and return offsets

Using DWARF to find call sites of inline functions

Table of contents

What is DWARF?

Inline functions in DWARF

Calculating call boundaries

The DIE has DW_AT_low_pc and DW_AT_high_pc

The DIE has DW_AT_ranges

Finding the caller function

inlinecall(1)

Nested inline functions

Rolf Dobelli: Avoid the News

Related reading

Table of contents

Prologue

News is to the mind what sugar is to the body

No 1 — News misleads us systematically

No 2 — News is irrelevant

No 3 — News limits understanding

No 4 — News is toxic to your body

No 5 — News massively increases cognitive errors

No 6 — News inhibits thinking

No 7 — News changes the structure of your brain

No 8 — News is costly

No 9 — News sunders the relationship between reputation and achievement

No 10 — News is produced by journalists

No 11 — Reported facts are sometimes wrong, forecasts always

No 12 — News is manipulative

No 13 — News makes us passive

No 14 — News gives us the illusion of caring

No 15 — News kills creativity

What to do instead

Good News

Disclaimer

Notes

In defense of the Old Web

Making a character device kernel module on FreeBSD

Table of contents

Implementing the device

malloc declaration

cdevsw structure

open() and close()

read() and write()

ioctl()

Creating and destroying the device

Module declaration

Makefile

Running the module

Testing

Social media is ruining our lives

Table of contents

Addictiveness and the drug-like nature of social media

Effects on mental health

The economy of attention

Social approval indicators

Social media is not a substitute for real-life interaction

Future generations and the ability to focus

Social control and propaganda

The solution

RSS: Advantages and usage

Why bother

How to create and maintain an RSS feed

RSS for YouTube and social media

YouTube

GitHub

Twitter

Reddit

Facebook and others

Heuristic for calculating the `entry` and `return` offsets

The DIE has `DW_AT_low_pc` and `DW_AT_high_pc`

The DIE has `DW_AT_ranges`

`cdevsw` structure