The aspect that makes an image taken from a camera valued is that it is a represention of the real world.
The aspect that makes digitally created images valued is that is is a deliberate representation of an image in the artist’s mind.
Both of these are therefore valued because there is an element that makes it - in some sense - real.
Automatically generated images do not share this element. These images are not representations of the real world, nor are they a deliberate representation of an image in the artist’s mind. Generated images are loosely based on patterns from such representations - this is not sufficient.
Of course, these are not clear boundaries. And the appeal of automatically generated images cannot be ignored. It is an accelerant - imitating at a moments notice that which previously took much time and resources. It provides to the masses an ability they previously couldn’t achieve. However, these imitations mock that which we value in an image. If there are no clear boundaries, we must at least define some scale or varying degree.
Images taken from a camera require some signal processing and filtering to convert readings from a sensor to a digital image. This can be considered a minimum necessity. However, further modifications are done using software to change how the image appears - this is not particularly desirable (unless it is deliberate and explicit). Worse, some modern cameras use automatic generation to enchance the image!
Digital images are created using software. The artist has an image in mind, and the software is simply a medium through which it is expressed. Parts of this process can be delegated to automatic generation and classified by the control exerted:
How different is the result from the image that the artist had in mind?
The problem is that all these delegation types may eventually produce a comparable result. It is the artists responsibility to be deliberate and transparent, and it is the patrons responsibility to demand it.
What if the artist does not have a particular image in mind? It may be vague; it is not inconceivable that the process of creation influences and directs the final form. For such creations, the influence may be subject to the same scrutiny as the creation. Is the influence a true representation of the real world, or a deliberate representation of an artist?
Ultimately, this is a preference. It is possible to define the boundary concretely, to draw a line seperating that which is acceptable and that which is not - but this is subject to change and scrutiny. The artist must decide.
Summary:
Too little is not good.
Too much is not good.
These extremes are not great.
You must first realize this balance. If you listen carefully, too much and too little with guide you there.
And then you will realize your potential.
]]>
This method does not require an external installation media, but only works for local accounts. If the drive is encrypted with BitLocker, it’s key will be required (this method does not reset the key).
Source: https://dev.to/jackscott7/reset-windows-1011-password-without-usb-or-reinstall-43m6
Online Microsoft accounts require internet access to login; passwords are tied to this account and cannot be reset locally.
Some sources recommend pressing F11 on startup to enter “Recovery”, but this is not reliable; some machines may use F10 or F12 instead. Use the force shutdown method above instead.
Select “Troubleshoot”
Select “Advanced options”
Select “Command Prompt”
This will open a command prompt window.
Identify the operating system partition (value for “osdevice”). This is typically “C:\”, but it may be different.
bcdedit
Create a backup of “Utilman.exe”, and then replace it with “cmd.exe”:
copy C:\Windows\System32\Utilman.exe C:\Windows\System32\Utilman.bak
copy C:\Windows\System32\cmd.exe C:\Windows\System32\Utilman.exe
If prompted to overwrite, accept by typing “Yes”.
Windows is not case sensitive. If you experience difficulty due to keyboard layout issues, special symbols (like “\”) can be copied from the terminal prompt.
The command prompt window can be closed and the system can now be rebooted.
After startup, select the “Accessibility” icon at the bottom right of the screen. This will open a command prompt window.
List the users (to verify username) and change the password:
net user
net user "UserNameHere" "NewPasswordHere"
Although the next step is not necessary, it it recommended for security. Once logged in, open a command prompt and restore the Accessibility utility:
copy C:\Windows\System32\Utilman.bak C:\Windows\System32\Utilman.exe
If this returns access denied errors like above (even with admin privileges), boot back into recovery mode to restore.
]]>
No knowledge about the internal workings of the black box is expected. It may not be known, or you may not know it. The system is only known in terms of inputs and associated outputs.
All inputs are not the same. Some inputs control what the system does.
Other inputs control what the system operates on.
The output can be used to drive inputs - this is feedback.
To know the black box is to know the relation between it’s inputs and outputs; to contruct a model of how it might work.
A model may reveal the internal workings of the black box.
Does the black box make you uncomfortable? Does it leave you with the feeling that your knowledge is superficial or incomplete? Do you perhaps seek to know everything? If so, there is one more thing you should know.
All systems have black boxes. Complete knowledge of any system is not possible. Uncovering how a system works - and constructing more models - reveals more black boxes.
Some elements were inspired by https://en.wikipedia.org/wiki/Black_box.
]]>
Over billions of years, that simplicity becomes slightly more complex.
Complexity is accelerated by dependency.
That complexity can only persist because it gives enough time for the environment to support it - for it’s dependencies to persist. This is a delicate balance.
All complexities are not the same. The Earth has evolved to deal with much of it. However, some complexities - the ones we create - are very difficult to undo.
When that complexity far exceeds what the environment is capable of handling, it makes me sad.
Because that means one of two things:
This may not be inherently bad, but the future of life then becomes an uncertainty.
]]>
A terminal emulator provides an interface to the system using text commands. A core set of utilites are provided by default, and more can be installed and upgraded with pkg - the Termux package manager 2.
Refer to the official documentation to learn more about Termux: https://wiki.termux.dev/wiki/Main_Page.
The official source for installation is F-Droid, although builds are published on Github as well 3. Google PlayStore is not recommended. Do not mix applications between sources. Applications are installed by downloading and opening the Android Package Kit (APK) file.
To install applications from APK files, “Install from Unknown Sources” must be temporarily enabled in Settings for the file manager. For security, disable it once installation is completed.
The following applications need to be installed:
F-Droid does not need to be downloded; search for the “Download APK” link under the latest version.
termux is the main application. termux-api exposes device functionality like vibrate, clipboard, torch and fingerprint 4. termux-boot allows Termux to automatically start after device is restarted 5.
Remote acceses via Secure SHell (ssh).
Install and start sshd:
pkg install openssh
sshd
To use ssh, the hostname of the server and a username/password combination is required. Run whoami to determine the username (typically in the format u0_aXXX), and set the password with passwd.
The local IP address of the phone can be used to test the connection. The local IP address can be found under WiFi settings by expanding the currently connected network. Run ssh from a different machine on the same network:
ssh -p 8022 u0_aXXX@192.168.0.1
What follows is configuring key based authentication. While not strictly necessary, it is recommended for security. It can be configured later if required.
The password will be prompted when connecting. This is not very secure since attackers could try and guess the username/password. To increase security, switch to key-based authentication by generating a key with ssh-keygen on the machine you will be connecting to the phone from:
ssh-keygen -t rsa
Enter file in which to save the key (/home/username/.ssh/id_rsa): /home/username/.ssh/keyname
Enter passphrase for "key-filename" (empty for no passphrase):
This will create two files under /home/username/.ssh:
keyname: a passphrase protected private keykeyname.pub: a public keyThe public key’s content must be copied to the file /data/data/com.termux/files/home/.ssh/known_hosts. This can be done using USB, by copying the text to clipboard and pasting it over ssh, or by using ssh-copy-id:
ssh-copy-id -p 8022 -i /home/username/.ssh/keyname.pub u0_aXXX@192.168.0.1
The private key can now be used to connect to the phone without a password:
ssh -p 8022 -i /home/username/.ssh/keyname u0_aXXX@192.168.0.1
Once the key-based authentication has been tested, disable password authentication by editing /data/data/com.termux/files/usr/etc/ssh/sshd_config and setting PasswordAuthentication no. Restart sshd for the changes to take effect:
pkill sshd
sshd
Try connecting from a different machine without the key; this should now fail:
ssh -o PasswordAuthentication=yes \
-o PreferredAuthentications=keyboard-interactive,password \
-o PubkeyAuthentication=no \
u0_aXXX@192.168.0.1
Keep the private key at /home/username/.ssh/keyname secure - you cannot login remotely without it if “PasswordAuthentication” is disabled.
Web server to host a website.
Install httpd:
pkg install apache2
Edit /data/data/com.termux/files/usr/etc/apache2/httpd.conf:
# Set server hostname and path to executables
ServerName 127.0.0.1
ServerRoot "/data/data/com.termux/files/usr"
# Set port which server accepts connections over
Listen 8080
# Set directory from which Apache will serve files
DocumentRoot "/data/data/com.termux/files/home/folderToServe"
# Set the file to save errors to
ErrorLog "/data/data/com.termux/files/home/httpd.log"
# Handle concurrent connections with Worker Multi-Processing Module
LoadModule mpm_worker_module libexec/apache2/mod_mpm_worker.so
# Maps file extensions to content types
LoadModule mime_module libexec/apache2/mod_mime.so
# Ensures proper privilege handling on Unix systems
LoadModule unixd_module libexec/apache2/mod_unixd.so
# Set default webpage to return when client connects to the server
LoadModule dir_module libexec/apache2/mod_dir.so
DirectoryIndex index.html
# Prevent arbitrary file requests (lock down filesystem)
LoadModule authz_core_module libexec/apache2/mod_authz_core.so
<Directory "/">
Require all denied
</Directory>
# Allow access only from local connections (127.0.0.1)
LoadModule authz_host_module libexec/apache2/mod_authz_host.so
<Directory "/data/data/com.termux/files/home/folderToServe">
Require local
</Directory>
Replace folderToServer with the path your website is saved at. Modules are available for more functionality - refer to the Apache http server documentation: https://httpd.apache.org/docs/current/mod/.
A folder from a different machine can be copied to the phone over ssh using rsync (without the --dry-run flag):
rsync -havP --checksum --delete --dry-run \
-e 'ssh -i /home/username/.ssh/keyname'
/local/path/to/folder/in/machine \
u0_aXXX@192.168.0.1:/data/data/com.termux/files/home/folderToServe
Test to ensure the server starts without errors by running httpd. If the command doesn’t fail due to invalid configuration, errors will be logged to the file specified above by ErrorLog. The files under DocumentRoot should now be served - visit 127.0.0.1:8080 on the phone’s browser.
The proxy to the Internet.
To access a server over the internet, the server needs a public IP address. A Virtual Private Server (VPS) is a publicly accessible machine hosted by a cloud provider. Since the phone itself does not have a public IP address, it must use a reverse proxy like frp or nginx running on a VPS to be accessible on the internet. An alternative is to use the Tor network.
The Tor network is a group of volunteer-operated servers 6. It uses a special protocol for privacy and anonymity. A Tor service can be set up to make the local services accessible to the internet.
A Tor service address is different from public domains; this is the link for the Tor Project homepage:
http://2gzyxa5ihm7nsggfxnu52rck2vv4rvmdlkiu3zzui5du4xyclen53wid.onion/
It can be accessed using the Tor Browser, and will not work with browsers that do not route traffic through the Tor network.
To setup the Tor service, edit tor run config /data/data/com.termux/files/usr/etc/tor/torrc and append:
# Service for sshd
HiddenServiceDir /data/data/com.termux/files/home/.tor/ssh/
HiddenServicePort 22 127.0.0.1:8022
# Service for httpd
HiddenServiceDir /data/data/com.termux/files/home/.tor/webserver/
HiddenServicePort 80 127.0.0.1:8080
HiddenServiceDir defines where the identity files for the service must be stored. HiddenServicePort maps a virtual port to a local port. Clients will target the virtual port (22 or 80) and tor will forward this traffic to the specified local port (8022 or 8080).
Execute tor and get the hostame of the service:
tor
cat /data/data/com.termux/files/home/.tor/ssh/hostname
Use torsocks to proxy ssh connections:
torsocks ssh -p 22 -i /home/username/.ssh/keyname.pub \
u0_aXXX@abcde23456abcde23456abcde23456abcde23456abcde23456abcdef.onion
The Termux documentation recommends
proxychains-ngovertorsocksastorsocksmay not work since Android 8 7.
Use the Tor Browser to visit the website. The services hosted on Android with Termux can now be accessed from anywhere in the world with an internet connection and Tor.
Keeping the services alive.
When the phone is rebooted, the services will stop. To automatically start up, the service must be enabled and Termux must be started on boot.
Services run in the background and restart when certain conditions are triggered.
Install the service manager:
pkg install termux-services
Start the services and enable it to autostart when Termux starts.
sv up sshd
sv up httpd
sv up tor
sv-enable sshd
sv-enable httpd
sv-enable tor
The number of services supported is limited; refer to the documentation to learn more: https://wiki.termux.dev/wiki/Termux-services.
The logs for running services are stored at /data/data/com.termux/files/usr/var/log/sv/.
To ensure that the serivce works, restart the service after killing all currently running processes:
sv down httpd
pgrep httpd
pkill -f httpd
sv up httpd
cat /data/data/com.termux/files/usr/var/log/sv/httpd/current
Create the directory for boot scripts:
mkdir -p /data/data/com.termux/files/home/.termux/boot
Create a file (nvim start-services) under the boot directory:
#!/data/data/com.termux/files/usr/bin/sh
termux-wake-lock
. $PREFIX/etc/profile
termux-wake-lock stops Android from going into deep sleep - this prevents Android’s aggressive power management from suspending background processes. The second line sources /data/data/com.termux/files/usr/etc/profile - this configures the environment.
It matters because we wish to be happy. To be happy as long as we can. To never be unhappy - if at all possible. Is it possible?
That largely depends on our the measure of happiness.
Happiness could be:
What is happiness for you?
How would you measure it?
Rhythmbox-Reloaded is a C++ application that needs to play audio files. There are libraries that handle this - they simply need to be included, initialized and used. miniaudio is easy to integrate, but has file format limitations. libvlc can support almost any format, but bundling it with the application impacts size and performance. Dynamic linking addresses this issue, but creates a requirement for external dependencies. As a compromise, the application may try to use libvlc, but fall back to miniaudio.
Miniaudio is an audio playback library for C and C++; it is made up of a single source file without external dependencies.
To use the library, download the header file miniaudio.h.
To test the library by playing a file, create ma-test.cpp:
#define MINIAUDIO_IMPLEMENTATION
#include "miniaudio.h"
#include <iostream>
int main(){
// Miniaudio variables
ma_engine engine;
ma_result result;
ma_sound sound;
// Initialize engine
result = ma_engine_init(NULL, &engine);
if (result == MA_SUCCESS){
// Load file
result = ma_sound_init_from_file(&engine, "file.mp3", 0, NULL, NULL, &sound);
if (result == MA_SUCCESS){
// Start playback
ma_sound_start(&sound);
std::cout << "Playing file.\n";
// Wait until completion
while(!ma_sound_at_end(&sound)){
ma_sleep(10);
}
ma_sound_uninit(&sound);
std::cout << "Playback completed.\n";
} else {
std::cout << "Failed to load file.\n";
}
} else {
std::cout << "Failed to initialize file.\n";
}
}
Compile and run:
g++ ma-test.cpp -o ma-test.o
./ma-test.o
Ensure the header file
miniaudio.hand audio filefile.mp3are in the same folder as the above source code file.
The high level API has built in support for WAV, MP3 and FLAC - other formats require more complex configuration with the low level API. 1 If support for an extensive list of audio formats is required, libvlc may be better suited.
libvlc is a C library that is the core engine of the VLC media player. VideoLAN provides official C++ bindings (libvlcpp) that acts as a wrapper for libvlc. The bindings consist of header files; only the vlcpp folder - containing several .hpp files - is required from the repository: https://code.videolan.org/videolan/libvlcpp.
VLC and libvlc are required dependencies. Some sources of VLC may not expose libvlc as a library. Refer to the VLC installation guides for your particular system.
Once libvlc is accessible and the vlcpp folder has been copied to the current folder, the engine can be tested; create vlc-test.cpp:
#include "vlcpp/vlc.hpp"
#include <unistd.h>
int main(){
// VLC variables
VLC::Instance m_instance;
VLC::MediaPlayer m_player;
VLC::Media m_media;
// Initialize with video disabled
static const char* const vlc_args[] {"--no-video", "--vout=dummy"};
m_instance = VLC::Instance(int(sizeof(vlc_args)/sizeof(vlc_args[0])), vlc_args);
m_player = VLC::MediaPlayer(m_instance);
m_media = VLC::Media(m_instance, "file.mp3", VLC::Media::FromPath);
m_player.setMedia(m_media);
// Start playback
if (m_player) {
m_player.play();
// Wait for playback to start, then finish
while (!m_player.isPlaying()){ usleep(10); }
while (m_player.isPlaying()) { usleep(10); }
}
return 0;
}
libvlc must be linked when compiling:
g++ -lvlc vlc-test.cpp -o vlc-test.o
./vlc-test.o
If you need to package the application as an AppImage, you must exclude libvlc when building. VLC initialization unexpectedly fails with partial vlc installations (missing some plugins) and including the full installation would be quite inefficient - it is better to dynamically link.
It would be beneficial if the application could retain some functionality even if libvlc is unavailable. When using libvlc by #include <vlcpp/vlc.hpp>, the application does not start without libvlc.
Using preprocessor directives only works for compilation. The developer machine can be required to have vlc installed, but this doesn’t solve the runtime issue.
Another option is to load the library at runtime using dlopen or LoadLibrary, but since libvlcpp is being used as a binding, this doesn’t seem easily possible.
Currently, fallback is not supported. Two build version may be offered - one using miniaudio and the other libvlc. An integrated version would be prefered.
The requirement is to implement a new database design for managing a variety of digital assets. Each asset has an associated identifier (hash) and metadata. The hash is calculated using a tool like sha512sum or phash. Metadata is extracted in JSON format using tools like ffprobe or exiftool. Ideally, only specific required metadata fields will be stored in the database, but that makes future changes more complex and requires making certain assumptions about the type of digital asset. To make the database as general purpose as possible, the database management system (DBMS) needs to support JSON documents.
PostgreSQL is an open source relational database that supports JSON types. To better understand the configuration of this database, it is beneficial to briefly cover some terminology and hierarchies.
PostgreSQL uses a client-server model. The server accepts client connections at a specified port (5432 by default) and stores data at a specified location (typically /usr/local/pgsql/data or /var/lib/postgresql/data). The server can manage any number of databases stored in this data directory; this forms a single database cluster. The database itself consists of schemas; schemas act as a namespace for organizing database objects like tables and functions (SQL queries).
PostgreSQL uses roles and privileges for access control. Roles are created and assigned permissions to perform specific actions:
create role role_name password 'role_password';
grant usage on schema schema_name to role_name; # allows accessing objects under specified schema
grant INSERT on schema.table to role_name; # allows action on specified object
The specified action can be ALL, or INSERT, SELECT, UPDATE, DELETE and so on.
Docker is used to deploy the services. Three services are used:
db: the PostgreSQL server and database clusteradminer: webpage that allows running SQL commandsapi: PostgREST web server that exposes a REST API
psql is a terminal based client interface for the PostgreSQL server. pgAdmin and phpMyAdmin are graphical interfaces similar to adminer; GUIs make running SQL commands easier by eliminating the need for terminal access. Adminer can be used to create schemas, perform CRUD operations on tables, create roles, assign permissions and execute other SQL commands.
The api is used to enable clients to perform actions without specialized tools for connecting to the database; only the ability to send HTTP requests is required.
Create docker-compose.yml:
services:
db:
image: postgres:18.2
restart: always
environment:
POSTGRES_USER: ${ADMIN_USERNAME}
POSTGRES_PASSWORD: ${ADMIN_PASSWORD}
POSTGRES_DB: ${DATABASE_NAME}
volumes:
- pgdata:/var/lib/postgresql
adminer:
image: adminer:5.4.2
restart: always
ports:
- 8080:8080
depends_on:
- db
api:
image: postgrest/postgrest:v14.5
ports:
- 3000:3000
environment:
PGRST_SERVER_HOST: 0.0.0.0
PGRST_DB_URI: postgres://${AUTH_ROLE_USERNAME}:${AUTH_ROLE_PASSWORD}@db:5432/${DATABASE_NAME}
PGRST_OPENAPI_SERVER_PROXY_URI: http://127.0.0.1:3000
PGRST_JWT_SECRET: ${JWT_SECRET}
depends_on:
- db
volumes:
pgdata:
Define the variables in .env:
ADMIN_USERNAME=
ADMIN_PASSWORD=
DATABASE_NAME=
DATABASE_SCHEMAS=
AUTH_ROLE_USERNAME=
AUTH_ROLE_PASSWORD=
JWT_SECRET=
Use
echo $(< /dev/urandom tr -dc A-Za-z0-9 | head -c32)to generate secure alphanumeric passwords; change length (to-c64,c128, …) as required. The JWT secret must be 32 characters.
Start the services with docker compose up -d.
Two roles are used to separate authentication (verifying identity) from authorization (verifying permissions). Clients connect to the authenticator role by providing the correct password, but this role does not have any permissions. The client can then switch to another role (SET ROLE role_name) which has the required permissions.
The following can be executed using a client interface (like psql or Adminer):
create role role_name nologin;
create role authenticator noinherit login password 'example_authenticator_password';
grant role_name to authenticator;
create schema schema_name;
grant usage on schema schema_name to role_name;
grant all on schema_name.table_name to role_name;
The nologin rolename and authenticator rolename and password should match that defined in
.env.
nologin disables connecting directly as the specified rolenoinherit prevents default permissions from being automatically assignedThe containers need to be restarted for postgrest to start without errors:
docker compose down
docker compose up -d
Check for keywords error or fatal in the logs (docker compose logs).
The following steps are from the PostgREST documentation 1.
Use the JWT secret defined in .env. Create a signed token using bash and openssl, replacing role_name with the nologin role:
#!/bin/bash
set -e
JWT_SECRET='test_secret_that_is_at_least_32_characters_long'
_base64 () { openssl base64 -e -A | tr '+/' '-_' | tr -d '='; }
header=$(echo -n '{"alg":"HS256","typ":"JWT"}' | _base64)
payload=$(echo -n "{\"role\":\"role_name\"}" | _base64)
signature=$(echo -n "$header.$payload" | openssl dgst -sha256 -hmac "$JWT_SECRET" -binary | _base64)
echo -n "$header.$payload.$signature"
Run this script (./script_name.sh) to create the token.
Set your token value (this needs to be repeated when a new shell is opened):
read TOKEN
To retrieve records:
curl https://domain_name.org/table_name -X GET \
-H "Authorization: Bearer $TOKEN" \
-H "Accept-Profile: schema_name"
Note, the schema must be created manually (using Adminer) and defined in the environment (
DATABASE_SCHEMAS) with the containers restarted after updates for the schema to be accessible. 2
To insert new data:
curl https://domain_name.org/table_name -X POST \
-H "Authorization: Bearer $TOKEN" \
-H "Content-Type: application/json" \
-d "{"column1": "value", "column2": {key1: value1, key2: value2}, "column3": 3 }"
There are two different ways of approaching troubleshooting - by starting with something that doesn’t work and removing/modifying components until does, or by starting with something that does work and adding components until it doesn’t. The second approach is easier when there are many things that could go wrong.
A common error that may be faced is that the binding port is already used. The syntax for port binding is - host_port:container_port. The host post may need to be changed if there is a conflict.
When modifying the docker-compose.yml, if you mount the pgdata volume to /var/lib/postgresql/data and try to access the API, it will state that the JWT secret is not set. If you have a look at logs of the PostgreSQL service, you will notice that it is actually not running - the error references a pull request which requires that the volume be mounted at /var/lib/postgresql instead for PostgreSQL v18+ 3. Determining this true cause by troubleshooting the API would have been tedious and time consuming.
The PostgREST REST API requires cache invalidation; if faced with errors of the format Could not find xxx in the schema cache and after verification that xxx indeed exists in the specified schema, simply stop and start the service to update cache.
Note, one PostgREST instance can only connect to one database instance. If API access is required for multiple databases in the same database cluster, each database requires a PostgREST instance 4. Depending on your requirements, using multiple schemas may be a better option.
]]>The first step is to get an executable for the developer machine. This is quite simple - it can be done in the Qt Creator IDE or using the terminal with qmake and make. qmake generates a Makefile based on the contents of a project file.
The specifics of the project file aren’t important; this file is created automatically by QtCreator and defines a few configurations (compiler versions and required Qt modules) as well as files to include and compile. Here is a minimal example of a project file Application.pro:
QT += core gui
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
CONFIG += c++17
SOURCES += \
application-src/main.cpp \
application-src/mainwindow.cpp
HEADERS += \
application-headers/mainwindow.h
FORMS += \
application-forms/mainwindow.ui
INCLUDEPATH += application-headers/
INCLUDEPATH += application-src/
RESOURCES += \
application-styling/application-styling.qrc
qmake reads this file and generates a Makefile:
#############################################################################
# Generated by qmake (3.1) (Qt 6.2.4)
#############################################################################
####### Compiler, tools and options
CC = gcc
CXX = g++
MKDIR = mkdir -p
COPY = cp -f
####### Output directory
OBJECTS_DIR = ./
####### Files
SOURCES = ../application-src/main.cpp \
../application-src/mainwindow.cpp
OBJECTS = main.o \
mainwindow.o
DIST = /usr/lib/x86_64-linux-gnu/qt6/mkspecs/features/spec_pre.prf \
/usr/lib/x86_64-linux-gnu/qt6/mkspecs/common/unix.conf \
/usr/lib/x86_64-linux-gnu/qt6/mkspecs/common/linux.conf \
../application-src/main.cpp \
../application-src/mainwindow.cpp
####### Build rules
Application: ui_mainwindow.h $(OBJECTS)
$(LINK) $(LFLAGS) -o $(TARGET) $(OBJECTS) $(OBJCOMP) $(LIBS)
####### Sub-libraries
mocclean: compiler_moc_header_clean compiler_moc_objc_header_clean compiler_moc_source_clean
####### Compile
main.o: ../application-src/main.cpp ../application-headers/mainwindow.h
$(CXX) -c $(CXXFLAGS) $(INCPATH) -o main.o ../application-src/main.cpp
####### Install
install_target: first FORCE
@test -d $(INSTALL_ROOT)/opt/Application/bin || mkdir -p $(INSTALL_ROOT)/opt/Application/bin
$(QINSTALL_PROGRAM) $(QMAKE_TARGET) $(INSTALL_ROOT)/opt/Application/bin/$(QMAKE_TARGET)
-$(STRIP) $(INSTALL_ROOT)/opt/Application/bin/$(QMAKE_TARGET)
Running make uses the GNU Compiler Collection to generate an elf binary that can be executed.
A critical limitation of the executable generated above is that it depends on certain libraries in a way that makes it distribution dependent.
The most likely way this issue would be discovered is by running the application on different distributions - typically a given with even with a small user base. However, for this particular project, the issue was intrestingly identified in the CI/CD pipeline.
You may wish to automate the building and publishing of the application when the source code is pushed to remote git repository. Git hosting services often include an “Actions” feature that can use docker to achieve this. A minimal image that is often chosen is Alpine Linux. Required packages are installed with the Alpine package manager apk and the process for building the application outlined above is followed.
To test the generated binary, run it on the development machine. In this case, it happens to be Arch Linux - an operating system that is organised differently to Alpine Linux. Running the binary results in an error: Error: file not found.
To understand the cause of this error, a better understanding is required of how Make and the GNU compiler works.
The compiler’s actions can be divided into 4 stages handled by different components.
| Component | Purpose |
|---|---|
| Preprocessor | expand or resolve lines starting with the directive (’#') |
| Compiler | translates source code to assembly code |
| Assembler | translates assembly code to object code |
| Linker | combines multiple object files and links external libraries |
Examining the output of each stage gives a better insight into the process.
The component of importance here is the linker.
Dynamic link object files are identified by the .so for “shared object” extension on Linux and .dll for “dynamically linked library” on Windows.
When linking, the symbols of the object file is added instead of the entire file itself.
The following command lists all the symbols in the libcurl library:
objdump -T /usr/lib/libcurl.so
During runtime, missing symbols are resolved by the system. This makes the application more resource efficient and means changes to shared objects can be easily propagated. The comes at the cost of comptatibility since more assumptions are made about the system - such as having the shared object in an accessible path.
All object files are stored directly in the resulting executable. Statically linked libraries are identified by an .a for “archive” extension.
Static linking results in better compatibility since it minimizes external dependencies. However, is increases resource consumption and makes it more difficult to update.
Static linking Qt is not trivial. The official installation only includes dynamic libraries and static linking may potentially face licensing restrictions. Static linking requires building Qt from source and additional configuration.
AppImages takes a different approach. The executable binary is generated using the same process outlined before, but this is then packaged with most required files to run with minimal external dependencies.
It should be noted that AppImages do still have some dependencies, but these are likely fulfilled by default by your distribution. There are some exceptions; Filesystem in Userspace (FUSE), which allows non-root users to mount filesystems and is required for the AppImage to work, is not bundled with older AppImages and may need to be installed explicitly.
If this is your first time packaging an application with AppImage, getting it to work may take time. After much trial and error, it seems that packaging with AppImage has two requirements: a compliant AppDir and a specific version of glibc.
Creating the AppDir is quite simple and can be done manually; this is how it is organized:
.
└── AppDir
└── usr
├── bin
│ └── app-name.elf
└── share
├── applications
│  └── app-name.desktop
└── icons
└── hicolor
└── 256x256
└── apps
└── app-name.svg
app-name.svg is an image file that will be displayed as the application’s icon. app-name.elf is the binary that was generated.
app-name.desktop is a desktop entry file:
Type=Application
Exec=app-name
Name=app-name
Icon=app-name
Categories=Utility;
Note that the file extension is excluded in the entries for
ExecandIcon.
glibc is a standard C library that provides many common and important functions. The glibc contraint is a little more nuanced.
To produce binaries that are compatible with many target systems, build on the oldest still-supported build system.
linuxdeployqt - the chosen packaging tool - recommends Ubuntu and enforces this system constraint quite strictly to encourage developers to support the most platforms.
The initial attempt on Alpine Linux failed because the glibc version was too new. From the documentation, it wasn’t entirely clear if “still-supported” referred to the “end of standard support” or “end of life”. Ubuntu 14.04 was the oldest system that had not reached end of life. Not only did the system have network issues (there was a bug with libcurl3 that made TLS connections unusable), but the application didn’t even compile. Sections of the source code needed to be modified because the glibc version was too old and didn’t recognise some of the newer syntax.
At this stage, the packaging tool was abandoned and alternatives were tested - this time on Arch Linux, a rolling distribution with the latest versions of all packages. After much frustration, the issue was narrowed down to the glibc version again (this was not as obvious as it is in hindsight). Arch Linux does not support rolling back to a specific version, so the correct version was manually downloaded from https://archive.archlinux.org/packages/g/glibc/ and forcefully installed. This promptly broke the system, causing a blue screen of death on shutdown (a first time on Linux). Luckily this was inside a virtual machine. Before shutdown, new terminals could not be opened, but some commands in an already open terminal worked and was used to copy some important data to a thumbdrive. The thumbdrive later failed due to an unrelated issue.
Ubuntu 22.04 - the oldest system that still had standard support - was used next. Everything went smoothly once the format for the AppDir was established and application was successfully packaged and run on different distributions.
A example of a command that might be used to create an AppImage on Ubuntu 22.04:
./linuxdeploy.AppImage -appimage \
AppDir/usr/share/applications/app-name.desktop \
-qmake=/usr/bin/qmake6 qmldir=application-styling/ \
-qmldir-importscanner=/usr/lib/qt6/libexec/qmlimportscanner
The
qmldirandimportscannerare required to include styling and image assets defined as Qt Resources.
It is intresting to see the lifespan of the software we build, and the chain of dependencies it requires.
]]>
Create and setup the virtual environment:
python3 -m virtualenv env-name
source env-name/bin/activate
pip3 install jupyter
Run Jupyter Notebook:
jupyter notebook
While it is very easy to install modules by sourcing the correct virtualenv and using pip, there are a few drawbacks to this approach. Jupyter Notebook needs to be installed for each new environment created. If used as a server, this would become quite tedious and difficult to maintain - particularly if there is a need to use multiple environemnts at once with different users.
The Jupyter Notebook installation can be centralized using the system package manager. Virtual environments are created separately.
To install Jupyter Notebook on Debian based systems, use apt:
sudo apt install python3 python3-virtualenv jupyter
jupyter notebook
This is convenient because there is only one Jupyter Notebook installation - it can be accessed on localhost:8888. Next, virtual environments must created, and modules need to be installed in different virtual environments.
Commands can be run from within a notebook. A better idea of how Jupyter Notebook works is needed to understand this. Internally, it has a component called the IPython Kernel. This is responsible for communicating with the Python interpreter on the system. The ipykernel is included by default when Jupyter Notebook is installed, but it can also be installed independently.
Shell commands are provided by the operating system. They can be run by prefixing a line with an exclaimation mark:
!ls ; cd example_dir
This spawns a subprocess that exits upon completion; it is equivalent (on Linux) to:
import subprocess
subprocess.run(["bash", "-c", "ls ; cd example_dir"])
In this case, the ls will list the files in the current directory and cd will change the directory. The change in directory will not persist since the process exists after completion.
Magic commands (prefixed with a percentage sign) are provided by the IPython kernel. State changes persist because these commands are run inside the kernel process itself (and apply to the virtual environment in which the kernel was installed):
%cd example_dir
%page my_file.txt
%pip install bs4
This prints example_dir/my_file.txt and installs BeautifulSoup (a module for HTML parsing) in the current virtual environment.
For all available magic commands, refer to the IPython documentation or run:
%lsmagic
To install a module in the current virtual environment:
%pip install module_name
It is not possible to create and use a virtual environment directly within a notebook. For example:
!python -m virtualenv myvenv
!source myvenv/bin/activate
!pip install bs4
The first two commands succeed but the third fails with an externally-managed-environment error. This is because a new subprocess is created for each command - the sourced environment is not actually activated when pip is used. This can be resolved by chaining the command:
!python -m virtualenv myvenv; source myvenv/bin/activate; pip install bs4
BeautifulSoup now installs in the myvenv virtual environment, but the notebook does not use this environment. The virtual environment that the IPython kernel is running on is different to the one created - virtual environments cannot be nested!
To make a virtual environments available to Jupyter Notebook, the ipykernel module should be installed inside the virtual environment:
python3 -m virtualenv --system-site-packages env-name
source env-name/bin/activate
pip install ipykernel
python3 -m ipykernel install --user --name=env-name --display-name "Python (env-name)"
The
--system-site-packagesflag is particularly important if you depend on globally installed modules. For example,matplotlibhas to be specially packaged for ARM platforms like Raspberry Pi and installed using the system package manager. This flag ensures that these modules can be found.
Since the Jupyter Notebook installation is global, the above commands can be easily run from the interface by creating a new terminal.
When creating a new notebook, you can select Python (env-name) to use a particular virtual environment.
To list all kernels and remove a particular kernel:
jupyter-kernelspec list
jupyter-kernelspec uninstall env-name
There is still a problem - this is running directly on the server. If something goes wrong, it might affect other services. This is also not very easily portable.
Using docker, this can be containerized!
This Dockerfile uses Alpine linux as the base image and installs python, pip, virtualenv and jupyter-notebook using the Alpine package manager apk.
The last command starts the notebook. This probably isn’t very secure - you might want to modify the flags based on your security model.
FROM alpine:3.22
RUN apk add python3 py3-pip py3-virtualenv jupyter-notebook
EXPOSE 8888
CMD ["jupyter-notebook", "--ip=0.0.0.0", "--no-browser", "--allow-root", "--NotebookApp.token='your-very-long-and-secure-passphrase'"]
Now, creating the following docker-compose.yaml file and running docker compose up will build the image and expose Jupyter Notebook on localhost:4444. To manage the virtual environments, use the terminal and follow the steps in the previous section.
services:
jupyter:
container_name: jupyter
build: .
ports:
- 4444:8888
To reproduce this cionfiguration on a different service, just the Dockerfile and docker-compose.yaml need to be copied.
Plaintext ("*.txt") is the most basic of such systems - it simply stores symbols in order as they appear without any other formatting. These files can be edited directly with any text editor.
Markup ("*.md", “*.tex”, “*.html”) languages include additional text to specify some formatting, but can still be reasonably edited with a text editor.
Richtext formats ("*.rtf", “*.docx”) store content with formatting instructions that typically require specialized software (word processors) to edit and render.
There are two broad categories of editors:
Latex typically uses code editors, and this may seem imtimidating and complicated until the initial learning curve is overcome.
If a visual editor is strongly preffered, LyX works with latex and is completely free and open source (GPL).
If the goal is to just explore latex without setting it up on your system, Overleaf is very useful. Note that some features are locked behind a subscription.
LaTeX is a typesetting system - it is a way of organizing text and images on a page using text commands, templates and composition.
This is a simple latex source file (hello.tex) to show some of the features of latex:
\documentclass{article}
\begin{document}
\chapter{Title}
\end{document}
You can use it to create a pdf:
latexmk -pdf -outdir=build hello.tex
Extensive use in the scientific community
The following is an example of a template that can be created:
.
├── build
├── chapters
│  ├── introduction.tex
│  ├── chapter1.tex
│  ├── chapter2.tex
│  ├── references.bib
│  └── title.tex
├── figures
├── main.tex
├── Makefile
└── style
└── style.tex
The entire document does not need to be contained in a single source file - it can be composed from many files.
In this structure, each chapter has it’s own tex file. Figures are kept in a dedicated directory (figures/) and the styling is defined in style.tex.
main.tex brings everything together with the \input command:
\documentclass{report}
\input{style/style.tex}
\begin{document}
\pagenumbering{roman}
\input{chapters/title}
\tableofcontents
\newpage
\pagenumbering{arabic}
\input{chapters/introduction}
\input{chapters/chapter1}
\input{chapters/chapter2}
\newpage
\bibliography{chapters/references.bib}
\end{document}
This should give an idea of how latex can be used to create a powerful and efficient system - once a document format is well defined, it can be reproduced very easily. For most formatting you wish to do, there likely already exists some template. If you are creating one from scratch, or modifying an existing template to meet your requirement, the process may feel tedious and unncessary, but this is a once-off cost that will be rewarded every time it is reused.
text editor: neovim document generator: latexmk viewer: evince
Your workflow will depend on your operating system and software preferences. While the workflow defined uses examples for Linux, the general setup should be readily applicable to any platform.
This is the core software that automates the building of latex source files to the desired output document.
latexmk supports many operarating systems (including Linux, MacOS and Windows) and, given the source files for a document, it issues the appropriate sequence of commands to generate a pdf, ps or dvi document. 1
continous watching and updates pvc
To edit the latex source files, any text editor will do.
Not much features are required, but the following makes the editing easier:
A terminal based text editor like neovim works perfectly too!
To autosave for the current file in
neovim, run commandautocmd TextChanged,TextChangedI <buffer> silent write.
Once again, any PDF viewer will work. Some viewers may not automatically update if the output file changes - these are not very nice to work with as they have to be refreshed manally each time.
Evince is the default document view on GNOME. A cool feature is that it supports dark mode (color inversion)!
]]>Make no mistake - metrics like views, clickthrough rate, watch time, retention, likes and subscribers are really fascinating. Such data points reveal a lot about the audience and the performance of production outputs. However, linking these metrics as a production feedback results in undesirable influence. Really, it comes done to what you are trying to achieve.
Maximizing these metrics could become the goal, creating an environment that encourages:
| Metric | Encourages |
|---|---|
| Views | Videos that many people will watch |
| Clickthrough Rate | Titles and thumbnails that attract people |
| Watch time | Videos that take long to watch |
| Retention | Videos that keep the attention of the people |
| Likes | Videos that people do not dislike |
| Comments | Videos that promote engagement |
| Subscribers | Videos that people want to see more of |
These are metrics of the people for the system that connects them to videos - “the algorithm”. None of these metrics are in direct control of the creator.
Metrics should be incidental.
| Metric | Encourages |
|---|---|
| Video count | Producing more videos |
| Video quality | Creating videos that improve the self-reported standard |
| Video impact | Producing videos that are valuable and benefit people |
Titles and thumbnails should be a true representation of what the video presents. The thumbnail should be a unaltered frame from the video. There is no reason why anything related to the video that is not included in the video would provide more value.
A video production may fall into one of three categories:
git is a commandline version control tool.
It tracks how content changes and makes different changes happening at once easier to manage.
It offers a few key features:
This guide uses graphs to establish a model of the git workflow. The internal workings of git are explored for a better understanding of how and why certain features work. It is not necessary to completely understand how it works internally to use git itself, but the hope is that it provides better clarity.
?
git pull
git add .
git commit
git push
Getting the executable.
Git can be installed by following the official documentation: https://git-scm.com/install/.
Installation makes the git command available by storing the binary executable in a particular folder.
PATH is a variable in operating systems that lists the folders to look for executables:
echo $PATH # Linux and MacOS
path # Windows
The exact location of the executable can be determined:
which git # On Linux and MacOS
where git # On Windows
If the folder is not in path - for example, by downloading the executable manually to a different folder - the full path to the executable must be used to run git, or that folder must be added to the path.
Running with full path:
/usr/bin/git --version
Starting tracking.
A repository is just a folder which has a .git sub folder.
A new repository can be initialized:
git init
This creates the hidden .git folder in the current directory and copies the contents of a template folder. The default template folder is /usr/share/git-core/templates 1.
The .git folder is particularly important to how git works. The git executable can be run from any directory, but it will search for the .git folder in the current tree to determine which repository it is working with.
Resuming development.
An existing repository can be copied with:
git clone https://git.example.com/example/example.git
This creates a new directory example and copies the content (along with the .git directory) to this directory. A similar effect can be achieved by manually copying the repository, or using tools like scp or rsync, but git clone does a few extra git specific things:
These actions are defined in the promotion model.
To go through each of these stages, a particular command is used.
git commit
git log --oneline
git reset --soft HEAD~1
git status
git add .
git restore --staged
git reset
git diff --cached
git config user.name "Name"
git config user.email "name@host.tld"
git commit -m "commit message"
git push origin master
git remote add origin https://git.example.com
git branch
git pull
git merge
git remote
Source code is available at https://git.kistu.dev/kistu/kistu.dev.
Powered by Hugo. Theme is WonderMod (with some modifications). The use of JavaScript is avoided as much as possible.
Illustrations are created with Excalidraw Inkscape.
Webpages are improved after publication. When a published piece is edited, the modified date is updated.
The complete history of changes are recorded because git is used for version control. Refer to the commit history in the source repository: https://git.kistu.dev/kistu/kistu.dev/commits/branch/master.
None of the content published is automatically generated. See posts under the tag automatic-generation for more information.
This website is available at:
https://kistu.dev
https://kistu.neocities.org
https://kistu.pages.dev
https://kistu.netlify.app
Available on Tor using the Tor Browser with these onion addresses:
http://ovypvbq2p4buxj3fknhuzkn3y42dzye7l4mqqk2dnolofrmpo6cszzid.onion
http://46f5l4o254ibgxniv7w644z5ljzrietotcc5jeq7qkaks4nlebfumyid.onion
-----BEGIN PGP PUBLIC KEY BLOCK-----
-----END PGP PUBLIC KEY BLOCK-----
A webpage typically consists of 3 types of files:
Content in this case refers to headings, paragraphs, buttons, links, images and so on. Styling content changes how the content is rendered; this includes typography, spacing, layout and color. JavaScript introduces interactivity - when certain conditions are met, it can change the structure and style of content.
This is a simple webpage. The HTML boilerplate was copied from the Odin Project 1. An example project from W3Schools was used for the counter 2.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Click Counter</title>
<link rel="stylesheet" href="style.css">
<script src="script.js" defer></script>
</head>
<body>
<h1>What is this?</h1>
<p>This is a simple webpage that counts the number of times a button was clicked.</p>
<h2>How does it work?</h2>
<p id="listing">
The HTML defines this text, the image above and the button below. <br>
CSS adds styling so it looks nice. <br>
JS changes the text when the button is clicked. <br>
</p>
<h1>Clicker</h1>
<button onclick="increaseCount()">Click me!</button>
<br>
<span>
<p class="count-display">This button has been pressed </p>
<p id="count">0</p>
<p class="count-display"> times.</p>
</span>
</body>
</html>
The background and text color are inverted by the DarkReader extension.
:root {
text-align: center;
background-color: #181A1B;
}
h1 {
font-family: "Brush Script MT", cursive;
color: #D38693;
margin-bottom: 3px;
}
h2 {
color: #89B482;
}
p {
color: #7DAEA3;
}
button {
font-family: "Impact", fantasy;
background-color: #D3869B;
border-color: #3C333B;
padding: 10px;
margin: 10px;
border-radius: 8px;
}
#listing {
text-align: left;
display: flex;
justify-content: center;
}
.count-display, #count {
display: inline;
}
// Declare the counter
let count = 0;
// Function to display the counter
function updateCount() {
document.getElementById("count").innerHTML = count;
}
// Function to increase the counter
function increaseCount() {
count++;
updateCount();
}
simple webpage
Client-Side vs Server-Side RectJS, Angular, PHP, Springboot
images
inlining - SingleFile
warc
For archiving purposes, one area of complexity is that the webpage is not monolithic; the webpage contains links to assets it requires. A local copy will have to acquire these assets and rewrite the links to refer to the local assets.
Scope: Static webpages and webpages with client-side JS.
resolution
]]>Learning a new writing system is difficult, particularly when there are two different mediums (physical and digital) to master. Software keyboards are somewhat better adapted for different languages becuase their symbol set can change to match the writing system. Hardware keyboards are limited in this aspect.
This application provides a medium to practise writing and learn the associated keyboard mapping.
The interface consists of 4 key areas:
Only English (US) en is supported.
The animation is expected to be the most complex element.
The main complexity for extending language support is expected to be OCR.
This has been occuring infrequenctly enough that the system is not unusable, but it would be great if it didn’t happen. This document mainly serves as an exploration into how the cause of similar issues can be identified.
sudo dmesg
coredumpctl list
coredumpctl info <pid>
backup hashing and verification
link to failure rate study
3, 2, 1 backup + hashing
ransomware - backup exfiltration - encryption timebomb - time triggered computation change
Highest threat:
Network Access:
[] - [] - []
second is required to prevent the third from occassionally going online (first is always online)
what prevents a packet replay attack? I could send the (encrypted) login packet to login somewhere else
]]>Why some things are difficult to define precisely.
The entity experiences a world of colors and forms.
It has limited means of sharing this experience with its peers.
So it uses what means it has.
sound as a representation
not limited to physical, references to abstract concepts
symbols expand reach
ground truth
change in symbols change in entities change in the world
]]>accuracy complexity
flat earth
]]>The exact workings are complex - a level of abstraction is needed to work with components. The complexity can be studied, but it would be counterproductive to do it for every component discovered. Rather, focus on components critical to your design.
Voltage and Current
foundations in chemistry
detect
do
Transistor
NAND
Computer vs microcontroller.
Public key (lock) + private key (unlock) address of mailbox (public) + mailbox key (private) asmetric encryption
two pairs required (private + public)(sender + receiver)
encryption authentication integrity
To generate a key using gpg:
gpg --gen-key
This will prompt for a name and email address, as well as a passphrase to encrypt the private key. The --armor flag is used to convert the binary format in which data is stored to base64 encoded text.
To print the public key:
gpg --armor --export name
Where name is the name provided when generating the key. This will print the public key in ascii.
To decrypt some text, provide the filename or pipe the text directly:
echo "-----BEGIN PGP MESSAGE----- ..." | gpg --decrypt
This automatically selects the correct key and prompts for the passphrase to decrypt the private key.
To encrypt some text, pipe the text directory or provide the filename:
gpg --encrypt --armor -r recepient-name filename
Where recepient-name is the user ID of the key and filename is the name of the file to encrypt.
Encryption can also be done without public/private keys:
echo "Hello" | gpg --symmetric --armor --passphrase "secret-passphrase"
Don’t use this module.
P2P long range communication
problem
iterations and improvements
hard brick soft brick why brick
]]>GPG is used for encryption and authentication. It’s use case requires easily local access, but this may expose it to a large variety of attacks. The aim is to make software replication of private keys difficult by implementing the key in hardware.
More research is required on how GPG works internally. If the algorithm can be easily synthesized on hardware, an FPGA-based approach may be ideal. The private key must be encrypted and stored securely to prevent easy exploitation with hardware access.
For establishing a hardware foundation, a Caesar shift can be implemented. It will take as input a key (shifting constant) and a string of text ([a-z][A-Z]), and output the encrypted text ([a-z][A-Z]). The key should be requested each time a new input is provided and should only be stored for the duration of the encryption process.
]]>“If you wish to make anything from scratch, you must first create the universe.”
This makes the “I” quite the misrepresentation. How much of that creation is truly your own contribution?
I cannot claim to have created anything, for my contribution compared to those before me - those who I depend on - is insignificant.
We stand “on the shoulders of giants”.
As our specializations increase, it becomes more difficult to determine the extent of that contribution.
Why do?
Why does it matter?
That “I” is a standard. And I hope that my claim to a creation is not one of possession, but one of quality. This transformation I present to you meets this standard, and you should expect nothing less.
How does bittorrent work
Is this true? reflection on need for sources in the search for truth
On Principles and Goals
Are you rational? A self fulling prohency of habits and how we polarize No individual has complete information Every few have sufficient information to make a decision
What should I do? Time scales of good and bad. I cannot do nothing, for that too is something. I have limited influence in the present. (Can I do something now?) I have enourmous influence of the future. (Butterfly effect) Accept things for as they are now - there is no other way they can be right now. to see things for as they are channel desire for change into processes for change, not anger violence is often the path of most destruction and least sustainability - use it sparingly Strive for independence by minimizing all dependencies To minimize some, you may need to fully rely on it (knowledge of the internet) Whether you will another 100 years or die this instant should make no difference to you
The nature of production (creating unbreakable things) one of two things must happen: nature must adapt, or we must find a solution
Argument analysis - a verifyable use of advanced prediction technology Why do we have language? Why do we have jargon?
Any advancement creates a greater capacity for This can be used for immediate evil, and immediate good It is up to the innovator whether they believe humanity can control and direct that capacity This may be why many choose not to write their teachings - it can make greater progress, but it can also make great division and progress in the opposite direction
designing a product manufacturing packaging delivery decomposition
learning systems the learning revision problem system to acquire is different from that to learn acquisition is a learning process product of acquisition may not capture that learning process
technology creates a greater capacity for
do you think we can survive without purpose? there is a scale - it is not absolute (black and white) it is very difficult to survive on the tipping point you have survived so far, so at least one of these must be true you continue if you are distracted from your purpose (we are distracted by novelty and new experience) you have forgotten your purpose
how many novel applications are there? looking at the fundamental principle, it is suprisingly simply there cannot be an infinite number of truly novel solutions with such a simple basis
how do virtual machines work? define precise layers of separation and sharing
how tor works regular services onion services
Logging on Linux (1765043562)
systemd
journalctl (-f flag)
“Making of: The Seed” (1762973380) how long it took blender modes Effects Noise Generate Follow Curve Animate Property
what is language a model
lorentz attractor and the butterfly effect (proposed 1774496809) monitoring on linux (proposed 1765055879) regarding node exporter + prometheus + grafana units of measure (proposed 1776487466) regarding base and relative units dryk drysa vivkea (proposed 1775666050)
1779984092 title: Pursuing further studies I do not like what it makes me do. I do not like who it forces me to become, and I feel that the opportunities it provides does not justify this cost.
1779992449 title: Sharing a digital asset Simply sharing a link is lazy. Perhaps it may be permitted in certain situations, but it should definitely not be the norm. A system of sharing - brief overview, personal statement or something to that effect, should be included.
1780077164 There are a limited number of novel applications. Think of the applications you use everyday.
]]>LCD and OLED screens cause eye strain over extended periods of usage. They are not ideal for viewing in outdoor environments (in direct sunlight), and consume a lot of power. The goal is to create an eink device that is gentle on the eyes and mind.
The device needs to support two applications:
While color eink is not a requirement, cost of implementation should be explored.
First, that depends on your perspective.
The common people do not care about the miseries or pleasures of ants - not that it is good, or bad, but it is simply inconsequential. In some perspectives, you may very well be these ants.
An action is good if it benefits you. It is great if it benefits those besides you.
An action is bad if it does not benefit you. It is terrible if you, as the receiver, would wish not to receive and if this is the case for those besides you.
These classifications - of good and bad - only apply to an period in time from a particular perpsective. Perspectives progress, as do times.
Thus, our second dimension is temporal. As actions accumulate, while each may be considered good or bad, they as a collective can also be judged.
It is important to not confuse this collective judgement of actions with an individual action, else you may be misguided into thinking good is bad and bad is good, and neither matter so.
Herein lies the importance of justification. You do not necessarily need an initial reason to do something (this is natural), but without reason that action may not stand in the perpsective of the future. You must build some framework of reason, else regret or forget.
Here arises a difficulty. To provide a reason, we must judge the benefit of an action apart from that of an instant. Such judgements require a scale to be chosen. Depending on the scale, the collective judgement may waver.
Just because you think that neither matter, does not mean it does not matter. While none may share your exact perspective, there are many who share a similar perspective.
Do no evil. is a Vagueness of these dimensions that could justify almost any action. This state is only resolved by a matter of chance that cannot be depended upon.
]]>no transparency - 24bit RGB
Lossy compression
]]>The path of knowledge is collection of explorations which reveal something greater than it’s individual elements, but only to those that wish to see it.
What follows is a collection of small, niche and rather unimportant solutions to some challenges we’ve faced. Each one may very well be irrelevant by the time it is stumbled upon again, but the hope is that it serves as a remainder of the path travelled and the patterns of thought behind it.
To reinstall KOReader on a Kindle Paperwhite 2 (PW2) with firmware version 5.12.2 that was previously jail broken and then reset (Settings > Device Options > Reset):
extensions and mrpackages to the Kindle root folderUpdate_KUALBooklet..._install.bin to mrpackages:log mrpi on the default searchbarUpdate_KUALBooklet_hotfix..._install.binUpdate_jailbreak_hotfix...install.bin to mrpackages:log mrpi on the default searchbarkoreader to the kindle rootextension/koreader to the extensions folder under kindle rootFollow the MobileRead threads very carefully (it is easy to misread instructions or do them in the wrong order). All required files can be found on the snapshots page.
If the jail break is not installed properly, KOReader will not launch.
koreader folder in at the kindle root as crash.log.could not open framebuffer error. Carefully follow the above instructions - reset to start from scratch if necessary.Kindle root refers to the folder seen when the kindle is plugged in (USB Drive Mode) - it should contain the folders documents, extensions, mrpackages and so on.
To generate a key using gpg:
gpg --gen-key
This will prompt for a name and email address, as well as a passphrase to encrypt the private key.
To print the public key:
gpg --armor --export name
Where name is the name provided when generating the key. The --armor flag is used to convert the binary format in which data is stored to base64 encoded text.
To encrypt text, pipe the text directly or provide the filename:
gpg --encrypt --armor -r recepient-name filename
Where recepient-name is the user ID or name of the key pair and filename is the name of the file to encrypt.
To decrypt text, provide the filename or pipe the text directly:
echo "-----BEGIN PGP MESSAGE----- ..." | gpg --decrypt
This automatically selects the correct key and prompts for the passphrase to decrypt the private key.
Encryption can also be done without public/private keys:
echo "Hello" | gpg --symmetric --armor --passphrase "secret-passphrase"
To see which process is using a particular port on Linux:
sudo ss -tulnp | grep :portnumber
sudo lsof -i portnumber
Use kill(graceful) or kill -9(forceful) to stop the process.
To move a qbittorrent instance, the following folders/files are sufficient:
~/.local/share/qBittorrent/BT_backup~/.config/qbit/qbitdata.conf~/.config/qbit/qbit.confForgejo runners can be setup on linux machines to use docker containers to execute jobs. These job containers may have difficulty accessing the internet due to a misconfigured DNS; it may produce errors like unable to resolve host and ping: bad address. To resolve this, add a different DNS nameserver:
echo "nameserver 8.8.8.8" > /etc/resolv.conf
To compare the output of two commands using git, process substitution can be used:
git diff <(exiftool imageA.jpg) <(exiftool imageB.jpg)
This is different from command substitution $(<command>) which executes the command and replaces with it’s output.
Process substitution <(<command>) instead creates a temporary file descriptor containing the command’s output.
Bash command chaining:
c1 && c2: execute c2 only if c1 succeeds
c1 || c2: execute c2 only if c2 fails
c1 ; c2: execute c2 after c1 (regardless of result)
c1 & c2: execute c1 and c2 in parallel; follow with wait
From reddit.
To find and replace in vim (normal mode):
:%s/oldString/newString/g
: enters command mode
% sets range to entire file
s invokes substitution command
g replacs all occurrences in each line (omit for first occurrence only)
Use gc to ask for confirmation for each occurrence.
To reset the root password for a Hetzner VM, navigate to the ‘Rescue’ tab for the server and ‘Reset Root Password’.
To repopulate the Archlinux keyring (to resolve invalid signature errors) by resetting all the keys:
sudo rm -r /etc/pacman.d/gnupg
sudo pacman-key --init
sudo pacman-key --populate
The error: failed to commit transaction (invalid or corrupted package (PGP signature)) has a few causes - in this case, trying to reinstall the archlinux without updating the repository and cancelling the partial installation (after it hanged) caused corruption.
To create an email alias that doesn’t meet the email requirements in Gitea/Forgejo, create an alias that does meet the requirements (“user1@example1.com”) in Settings > Account > Add email address.
Then, connect to the database using user gitea or forgejo:
psql -u <user>
Ensure that the alias was created and update the email address:
SELECT id, uid, email FROM email_address WHERE email = 'user1@example1.com';
UPDATE email_address SET email = 'user1' WHERE email = 'user1@example1.com';
The goal was to ensure that commits without a valid email address appeared in the heatmap of Gitea/Forgejo. However, it seems the heatmap is generated from the service actions and not git itself; not commits. An attempt was made to use commit details to generate the heatmap, but the issues that arouse were deemed too complex for the added benefit.
To delete your entire Neocities site using the neocities gem:
neocities list / | sed 's/\x1b\[[0-9;]*m//g' | tail -n +2 | grep -v '/' | while read -r f; do
echo "Deleting: $f"
neocities delete "$f"
sleep 2
done
neocities list / lists all files in root recursivelysed strips ANSI color codes (deletes fail otherwise)tail skips the first two header linesgrep filters out subdirectory filesFiltering out the subdirectory files and only deleting top level entries is necessary because neocities delete folder runs before neocities delete folder/file-in-folder.txt - the second delete fails because that folder no longer exists.
All of this is unnecesary. Just use the prune flag:
neocities push --prune public;
Makefiles can use variables from an environment file; this is particularly useful when it is tracked by git but sensitive information needs to be used.
.env
USERNAME="user1"
PASSWORD="pass1"
Makefile
-include .env
export
echo Username is $(USERNAME)
echo Password is $(PASSWORD)
To stop highlighting after a search with /search-term in vim, run :noh.
rsync can be used to both list and copy files.
List files:
rsync -havP --dry-run -e 'ssh -p 8080 -i ~/.ssh/auth-key' user@host:dir1/ .
To copy files that match a pattern:
rsync -havP --dry-run --include="PATTERN" --exclude="*" -e 'ssh -p 8080 -i ~/.ssh/auth-key' user@host:dir1/ .
This is not particularly novel - dry-run is used to see what files are available and the include and exclude flags are used to select a particular file. This pattern is quite useful because it does not rely on another process to list files and depend on a method of copying results - it is just one terminal based process.
To reboot a phone from the Termux commandline with superuser privileges:
sudo -c "reboot"
Onion sites use http, not https. If you try to use https, you will be “Unable to connect” with an NS_ERROR_CONNECTION_REFUSED error on Firefox.
Using vim to create a file in a folder that doesn’t exist results in an error when saving: E212: Can't open file for writing: no such file or directory. Use the ++p flag (from v9.0) when writing to create the parent directory:
:w ++p
Source: https://neovim.io/doc/user/editing/#%2B%2Bp
Use this pattern to operate on a list in parallel using Bash and xargs:
#!/bin/bash
process_item() {
item="$1"
}
export -f process_item
find . -maxdepth 1 -type d | xargs -P "${JOBS:-$(nproc)}" -I {} bash -c 'process_item "$@"' _ {}
find returns a list of items that match the specified filtersxargs is used to build and execute commands
-P or --max-procs=N specifies the number of processes to use-I or --replace is used to run the command once per line instead of passing everything as an input to one command{} is a placeholder that is substituted with the input value (from the pipe)${JOBS:-$(nproc)} uses $JOB variable if set; else uses the output from $(nproc)bash -c spawns a bash shell and executes the command that follows
$@ is a placeholder that expands positional arguments (just $1={} in this case)_ is an empty placeholder; sets the value of $0{} is a placeholder that is substituted with the input value (from xargs)GNU parallel supports better output handling (groups and prints on completion instead of interleaving) and progress tracking, but is not installed by default on most Unix systems.
The main section of a Hugo site is determined based on the section (folder under content) with most posts. This is quite unexpected - the output suddenly changes based on the state of these subfolders. To define sections explicitly, set mainsections=["section1", "section2"]. Posts from these sections will then be shown on the homepage. Leave it empty if none should be included.
To see what commands a package (package_name) provides on Archlinux:
pacman -Ql package_name | grep '/usr/bin/'
Use jq to create JSON strings in bash; it is particularly useful when the string contains single quotes and newlines. Special characters can usually be ignored using single quotes, but single quotes cannot be escaped.
data=$(jq -n \
--arg keyvar1 "value" \
--argjson keyvar2 '{"subkey": "value"}' \
'{"key1": $keyvar1, "key2": $keyvar2}')
To undo the last commit, but keep the changes staged:
git reset --soft HEAD~1
From unix stackexchange and askubuntu.
To mount a qcow2 disk image:
modprobe nbd max_part=8
qemu-nbd --connect=/dev/nbd0 /path/to/your/image.qcow2
lsblk /dev/nbd0
mount /dev/nbd0p1 /mount/folder
To unmount:
umount /mount/folder
qemu-nbd --disconnect /dev/nbd0
rmmod nbd
If the partition is encrypted, first decrypt the volume:
sudo cryptsetup luksOpen /dev/nbd0p1 decrypted_volume_name
sudo mount /dev/mapper/decrypted_volume_name /mount/folder
When unmounting, lock the partition:
sudo umount /mount/folder
sudo cryptsetup luksClose decrypted_volume_name
To apply a CSS style to the parent of a element, use the :has pseudo class:
.some_class:has(#some_id){
/* style for some_class*/
}
To rename all occurences of a string in a folder (across multiple files):
find . -type f -exec sed 's/old-text/next-text/g' {} + | grep new-text
To actually perform the replace, remove the pipe to grep and add the ‘-i’ flag to sed.
Navigation in certain software would be better suited with different input interfaces.
https://github.com/FaqT0tum/Orbion_3D_Space_Mouse
https://github.com/KikiHobbyRepair/SpaceRat
https://github.com/pepijndevos/spacefox
https://github.com/sb-ocr/diy-spacemouse
Now, there is some compromise. Because this invention was not invented here, some elements of the solution may not be as desired. You need to make a decision here - are these compromises acceptable? If not, your work is not done! You have a reference, but your problem is not truly solved.
One should not simply give up on an idea because something similar has been attempted. One should also not simply pursue an alternate solution without a clear direction.
]]>up to develoepers
]]>There is a wide range of applications built using Python. Python gives developers the power to perform various complex tasks. A key component of this success is modules - a collection of code that performs a specific task. Modules can be installed using pip and used with import.
pip install requests
import requests
Python is open source, so anyone can contribute. Looking at the source, the Python programming language has over 3000 contributors. Most of the development is managed by a few developers - these are the core maintainers. 20 people are responsible for almost 60% of commits.
Python modules are separate from the Python programming language itself, and these are maintained by a different set of maintainers.
The reason software is continously being updated is because of fixes and features. Fixes are required for existing features that don’t work as expected. More features may be required to solve larger problems, or support more applications.
Modules for python change.
what is python, what are modules?
why can’t they be moved?
“Choose not to be harmed, and you won’t feel harmed. Don’t feel harmed, and you haven’t been.”
“We cannot expect what cannot be delivered.”
“See things for as they are, not as they should be.”
“Pain is inevitable, suffering is optional.”
]]>“There is nothing for me do in these worlds, nor do I need or desire anything. "
Inspired by the original game, as well as Pairs by Max Gorin.
Game states must be stored on a central server. One target is minimal, self-contained dependencies.
A centered grid whose dimensions are set by input fields.
Perhaps mechanisms can be introduced for learning more about the script - pronounciation, words and so on.
]]>Popular software is typically accompanied by well-written documentation. This documentation can be easily aquired. However, it’s utility is severely restricted because searching a collection of documentation is difficult. The current solution of this problem is to rely on a search engine like Google, which resolves queries - often structured as questions without a direct link to the keywords expected in the solution. The goal of this system is to provide a modular framework for local search operations of this nature. Such a system can be extended to index and search a website crawled and saved locally, acting as a search engine.
Dash is a proprietary browser for MacOS that searches documentation sets generated primarily from various developer API docs and manuals. Zeal - inspired by Dash - is an alternative for Linux and Windows machines that uses the same docsets. Devdocs is an open source API documentation browser that fills a similar role, but does not use the same docset format.
One short coming of these existing systems is that semantic search is not supported - the indexing is limited in this regard (although this could be justified for a documentation browser). The “docset” feature meets the requirement of modular data sources very well.
Hister is a search engine that consists of a browser extension, indexer, web app and terminal interface 1. It was developed by Adam Tauber, who also developed SearX - a metasearch engine that dispatches queries to other search engines. The indexer and user interface should serve as a good reference, but the overall application goals are not the same; the crawling mechanism does not meet the required scale and the index is likely not modular. Some technical aspects are well presented at https://hister.org/posts.
More research needs to be done on the systems that are suitable for this application. Currently, a language model for query transformation and a fragmented meilisearch index for modular sources is being explored.
]]>The internet is fragile.
Each stage typically involes an extraction operation - during crawling, this is extraction of links and during scraping it is the extraction of content. Network requests are expensive, so extraction operations are better suited on local resources.
Once content has been aquired, keeping it up to date is a challenge. At scale, some sort of automation is required. Automation logic is fragile, so monitoring is critical.
For certain sources, RSS is available and may be adapted to meet the needs of the archive.
Git can be used for both initial acquisition and updates for source available websites. This is edit safe (the history of published content that is later modified is preserved).
One difficulty that needs to be considered is if builds are not included in the source - additional software may be required to build the website; for example, a particular version of Hugo may be needed to convert markdown to html (this is not ideal).
RSS can be used for updates. Initial aquisition will still require a custom crawler and scraper. This scraper can be reused for new targets identified by RSS. This is not edit safe.
For blogs where the published site is the only source and which does not contain RSS capabilites, a custom recrawler needs to be crafted. The recrawler is very suseptible to errors as a result of layout changes and should be monitored for indications of such errors. This is also not edit safe.
A asset uploaded to YouTube is re-encoded to various formats. TCP guarentees that the delivery of a particular asset is perfect - the source and destination are bitexact. However, various attributes of the asset (including metadata and description) may result in slight variances. For a given quality, it should technically be possible to extract a bitexact copy of the source, regardless of when it was acquired.
]]>Figures of Authority
]]>Ethics determines whether an action is good or bad
The young and porn; age restriction proposal Privacy vs security
technology enables something, or allows a greater capacity of without restriction, this capacity can be exploited for good and bad restrictions may not work as expected
When you clicked on this article, it is shown on your computer. This may seem trivial, but there is a whole chain of dependencies that make this possible.
client -| |- server
For any two computers to communicate, they have to be connected.
ISP connection to the internet
the larger picture
ISP hierarchy
? Even if the some part of the communication is wireless (as is the case for WiFi and LTE), a significant portion includes long, physical cables.?
Terrestrial cables Undersea cables
Satellites launched, maintained
first, lets get the not directly related to the Internet, but a critical dependency nonetheless.
This complex system depends on another largely complex system.
Electrical power generation and distribution generation overview
Technical expertise for maintainence
evolving
Firmware - routers, NIC Communication standards (DNS) Firewalls
hosting provider (ongoing cost) software updates and configuration
There are just too many sources. How many websites/webpages on the internet - Google crawled?
need for search engines
increasing dominance of autonomous search engines powered by data collection - no direct input (social media algorithsm) follow what I do, not what I say
Give back control to the end user. Minimize dependencies - become independent. Encourage freedom within reason.
There are countless valuable resources on the internet. If you find something useful and have the capacity, please archive it. There is no guarantee that it will be available in the future.
]]>The idea is that even though you may have limited means to influence the present, even a limited means can significantly influence the future.
The question is that of timescales. Accumulating power decreases the timescale of your influence - you can see vast changes happen presently.
But any power, no matter how insignificant - if fact, even just in presense - has such an influence in sufficien time.
The theory is that their is a point at which the magnitude of change becomes sufficiently large that any two influencers are comparable, and that this point can be made significantly closer “in the window of this lifetime or the next” without instantly requiring large amounts of power.
The butterfly effect
import matplotlib.pyplot as plt
import matplotlib.animation as animation
fig, ax = plt.subplots()
# ... your animation code here ...
How does this change? Perspective. You should not be discouraged from attempting to solve problems that are “out of your control” because you are powerless - there is reason why it has not been solved by those in power and you are likely to face those same issues if you are in power. Rather, you should focus on action - what can be done now, what can be done in the future and how to plan for those capabilities.
At the same time, you should realise the limits of your capability. If you try and tackle too many things at once, you spread your capability thin and require increase the timescale to resolve. Not all problems that exist need to be resolved. You must decide with ones are meaningful enough to dedicate yourself to.
]]>This is a guide that provides a gentle introduction, with snippets for more advanced features.
y - yank (copy) p - paste d - delete x - cut
Replace last 12 characters of each line
s/\(.\{12}\)$//
| char | represents |
|---|---|
% |
full document |
$ |
end of line |
^ |
start of line |
Fundementally created from the principles of chemistry and physics. While the functionality is quite simple, designs can be quite complex to achieve the required performance with limited space and power.
Firmware is software that is very closely tied to the hardware. In a wired mouse, the laser is one of the main sensors. It bounces light of the surface and the sensor registers this. The firmware is run on a microcontroller and translates this sensor reading into a format that can be sent through the transmission medium.
Drivers are software closely tied to the device and interface - it interprets commands received from the firmware and sends it to the OS for performance.
Operating System manages memory and processing. It allocates memory for applications and provides access to the CPU.
Applications
When a mouse clicks a button, a metal contact mouse. This is wired to a sensor that triggers the firmware to send a signal through the connecting interface. The operating system receives this signal, and uses the driver to determines that a click action must be performed at a specific location. The operating systems propogates this signal which the appliction consumes. The application logic and relevant data defined to be executed when the button is clicked is loaded into the memory and executed by the processor. This then updates the screen, which is sent back down the pipeline.
Dependencies |- uniquely suited as a means of creation; minimal dependencies (low barrier of entry) |- field of many domains - not just like computing, but you can be equally intrested in so many other fields - what sort of problems can you solve? |- actuators (change the world) |- sensors (collect data) - data
“What can you do that hasn’t already been done?” - Easiest and most meaningful to address challenges you face - Check if its done! You don’t want to do it all over again. It’s likely huge undertaking.
Novelty in hardware design comes mainly through integration of hardware modules. Novelty in software programming comes from application, or integration of libraries. DSP?
]]>