@rolle @exerra @donovanh

Few things I like in IRC over Matrix, or any other protocol in professional setting:

1. Does not try to blend #security and #decentralization. By not having security at all is one way to implement a sound security model. This allows to design security properties both by means of infrastructure security, i.e. outside the protocol, and also by tunneling, i.e. inside the protocol (classic example is off-the record messaging). This keep the core protocol compact and sound, and easy to verify for correctness, which is by itself a strong security property.
2. Has both decentralized and client/server based topology since 1988(!). It is a network of servers, which together form an IRC network.
3. Protocol messages are both rigidly structured AND still human-readable (unlike JSON), and have a clean specification (RFC 1459).
4. Features not in the protocol itself can be implemented efficiently with bots, given the ease parsing and producing IRC protocol messages.
5. IRC network heals fast from failures and has high #availability properties, given the clean and rigid definition of what it does and what it does not do.

#IRC #infosec

@rolle @exerra @donovanh

Few things I like in IRC over Matrix, or any other protocol in professional setting:

1. Does not try to blend #security and #decentralization. By not having security at all is one way to implement a sound security model. This allows to design security properties both by means of infrastructure security, i.e. outside the protocol, and also by tunneling, i.e. inside the protocol (classic example is off-the record messaging). This keep the core protocol compact and sound, and easy to verify for correctness, which is by itself a strong security property.
2. Has both decentralized and client/server based topology since 1988(!). It is a network of servers, which together form an IRC network.
3. Protocol messages are both rigidly structured AND still human-readable (unlike JSON), and have a clean specification (RFC 1459).
4. Features not in the protocol itself can be implemented efficiently with bots, given the ease parsing and producing IRC protocol messages.
5. IRC network heals fast from failures and has high #availability properties, given the clean and rigid definition of what it does and what it does not do.

#IRC #infosec

@rolle @donovanh My main tool for informing about new kernel features is mastodon, and IRC for syncing up in dev (OFTC). I use IRCCloud for convenience and first class per-network bouncer (~60€ annually). They are my main tools for communicating in professional life in addition to plain text email. BTW I dislike Matrix 🥲 Nothing ever works when Ive tried it. The product I sell is being a hacker and TikTok and Instagram do not reach my potential ”customer base”.

1. Stack Overflow answer: “My friend/AI told me that…”
2. Man page answer: “ You need to do this because…”

#stackoverflow

Also, 9/10: 20 minutes of a man page > 60 minutes of Stack Overflow vomit. #stackoverflow

note to myself: when #zsh completions are not working as expected in any OS, 9/10 times it is missing -u flag for compinit ;-) Had forgotten this.

From zshcompsys man page:

To avoid these tests and make all files found be used without asking, use the option -u, and to make compinit silently ignore all insecure files and directories use the option -i. This security check is skipped entirely when the -C option is given.

@raven667 essentially most audio plugins call a limited subset on Win32, meaning that it would be possible to make API shim for that subset.

nothing to do with packaging

This would be great for #audio #plugins, as they don't need an enormous subset of Win32 API.

This could be realized in practical manner for instance in a future version of #CLAP, which could have up-calls whose API signatures would be along the lines with stuff commonly used for from Win32 API. I.e. basic graphics context stuff, file picker etc. Most of the plugins neither sample nor produce audio. They are just plain data processors with a fancy GUI.

A plugin using only those API's would be universal to all operating systems.

And since PE/COFF is widely know format and used across the operating systems for EFI support, DLL would be perfect format for the binary. That way one could have plugin binary that is cross-operating system compatible. I.e. host would implement the API and provide PE/COFF loader to initialize the plugin.

In addition to PE/COFF there should probably be target for wasm, which would enable plugin ecosystem for web daw's.a

https://www.youtube.com/watch?v=H5v0CK249rI

#MusicProduction

Great I get in my “hello bpf” truncated stacks delivered through a ringbuf:

❯ sudo build/hello-ebpf
[0]: 0xffffa5c74e6e9498
[1]: 0x0000000000000000
[2]: 0x0000000000000000
[3]: 0x0000000000000000
[4]: 0x0000000000000000
[5]: 0x0000000000000000
[6]: 0x0000000000000000
[7]: 0x0000000000000000

It looks like this because I temporarily hooked kprobe to a syscall. Next I change the hook to tpm_transmit.

I do all post-processing from this at the host.

#linux #kernel #bpf #profiler

#iLok comes much more nicer to use once you discover by accident that there is a command-line tool installed to /usr/local/bin

iloktool - 5.9.0 (b5097,  edaa5278, Release, 64 bit, built Oct 25 2023)
Copyright 2023, PACE Anti-Piracy, Inc., All rights reserved. CONFIDENTIAL.

Usage: iloktool <operation> <options>

<operation> is one of the following:
help            Prints this help message.
auths           Show all of the authorizations (licenses) available to your computer.
cloud --open    Open an iLok cloud session. Requires --account & --password for the iLok account.
cloud --close   Close all iLok cloud sessions or with --account & --password close a single session.
cloud --status  Returns the cloud status: "Open" or "Closed".
list            List iLok devices attached to this machine.

<options>:
  -h [ --help ]         Show these usage instructions.
  -a [ --account ] arg  This is the account login ID in the "cloud" operation.
  -c [ --close ]        This is used with the "cloud" operation to close all or
                        a single open cloud session.
  -o [ --open ]         This is used with the "cloud" operation to open a cloud
                        session.
  -p [ --password ] arg This is the account password for the "cloud" operation.
  -s [ --status ]       This is used with the "cloud" operation to get the
                        cloud status (Open or Closed).
  -t [ --type ] arg     If specified, this filters the "list" operation by the
                        specified iLok type.
  -V [ --version ]      Show the version number.
  -v [ --verbose ]      Indicate verbose output.

Examples (omit the -v at the end if you don't want verbose):

If you specify no operation, you get a non-verbose list of all local and
remote iLoks:
    iloktool

List all, just iLok1, just iLok2 and just iLok3 type devices respectively:
    iloktool list -v
    iloktool list --type 1 -v
    iloktool list --type 2 -v
    iloktool list --type 3 -v

Display all auths (licenses) available to your computer:
    iloktool auths -v

Open a cloud session, close a cloud session, close all cloud sessions or get
cloud status respectively:
    iloktool cloud --open --account your_account --password your_password -v
    iloktool cloud --close --account your_account --password your_password -v
    iloktool cloud --close -v
    iloktool cloud --status -v

Once you successfully use your account and password to open or close a cloud
session, your password will be saved in the computer's key chain, and you can
omit the password in subsequent open and close operations:
    iloktool cloud --open --account your_account -v
    iloktool cloud --close --account your_account -v

I used to hate iLok but these days I think that it would best if all #audio #plugin companies would use the only solution that has matured somewhat usable instead of inventing their own factors worse licensing schemes.

#MusicProduction #licensing

And Microsoft has been kind enough to document how to keep your existing #CMake project and use vcpkg: https://learn.microsoft.com/en-us/vcpkg/get_started/get-started?pivots=shell-cmd

#Microsoft 's #vcpkg is more like "accepting the unfortunate reality" and is actually pretty good because it can be used in most applications, despite "less perfect". Ugly but useful...

Anyone who works with #embedded toolchains knows that #build2 fixed #toolchain approach neither works for C nor C++. It has benefits, yes, but it is simply unusable in wide range of applications.

#C #cplusplus

@pchaigno Another thing I'm looking at after holidays whether eBPF ELF Profile spec could be supported by a Rust crate called Goblin.

@sjvn that’s a lower number than i would expect

@pchaigno Had a four weeks of holiday in a row first time since 2018, which leads to doing crazy things ;-)

@pchaigno I drafted a quick plan what I want to do https://social.kernel.org/notice/AkA1B7U8A1zpNR8gEa.

I've previously used bpftrace to hook into tpm_transmit and then see similar information in "raw statistics form". now i'm aiming to level up and make graph that gets updated periodically.

I quickly drafted yesterday something just to see that I'm able to make a C project with bpftool and libbpf shenanigans: https://codeberg.org/jarkko/hello-ebpf. I know it is useless cruft at this point but this was at least enough to see that given the investment in time i can make it happen ;-)

Next thing I'm planning look at is bpf ring buffers.

Life hack for github-cli gh repo clone $(printf 'squidowl/halloy%.0s ' {1..2}), i.e. clone into owner/repo directory, not just repo. #github

EDIT:

I wrote a small #bash (obviously works also for #zsh) function to make cloning easier in my environment:

gh-repo-work() {
  local url=$1
  # Strip path from URL:
  local url_path=${url#*\.*/}
  # Clone to the Github tree:
  gh repo clone $url_path "$HOME/work/github/$url_path"
}

“Demo”:

~ main*
❯ gh-repo-work m4b/goblin
Cloning into '/Users/jarkko/work/github/m4b/goblin'...
remote: Enumerating objects: 7261, done.
remote: Counting objects: 100% (1215/1215), done.
remote: Compressing objects: 100% (326/326), done.
remote: Total 7261 (delta 977), reused 922 (delta 889), pack-reused 6046
Receiving objects: 100% (7261/7261), 3.22 MiB | 4.69 MiB/s, done.
Resolving deltas: 100% (5565/5565), done.

~ main*
❯ ls -1 work/github/m4b/goblin
CHANGELOG.md
Cargo.toml
LICENSE
Makefile
README.md
assets
etc
examples
fuzz
fuzz-afl
src
tests

~ main*
❯ rm -rf work/github/m4b/goblin

~ main*
❯ gh-repo-work https://github.com/m4b/goblin
Cloning into '/Users/jarkko/work/github/m4b/goblin'...
remote: Enumerating objects: 7261, done.
remote: Counting objects: 100% (1227/1227), done.
remote: Compressing objects: 100% (337/337), done.
remote: Total 7261 (delta 988), reused 923 (delta 890), pack-reused 6034
Receiving objects: 100% (7261/7261), 3.23 MiB | 6.68 MiB/s, done.
Resolving deltas: 100% (5564/5564), done.

~ main*
❯ ls -1 work/github/m4b/goblin
CHANGELOG.md
Cargo.toml
LICENSE
Makefile
README.md
assets
etc
examples
fuzz
fuzz-afl
src
tests

The list of papers accepted at the 2nd #eBPF workshop has been published by ACM: https://dl.acm.org/doi/proceedings/10.1145/3672197#tableOfContent.