The intended filename format is:

src: 20261019_12345678.jpg
out: 20261019_zest_12345678.jpg

That way the subsecond timestamp is preserved and the process does not lose information. (For JPG, ~every camera saves timestamps in EXIF metadata as well, but filenames are ~100x faster to parse, and they are indexed by Everything app.) The datestamp is really nice to quickly get to in a file folder by typing it out (in Windows or most Linux GUIs or terminals).

The subsecond timestamp is ugly and TMI and I have thought about trimming it down to the second. I'll have to query my ~10,000 JPEGs and see how often two photos happen in the same second. There's a certain elegance to every timestamp being the same length, so I probably don't want to trim some to the minute and others to the second.

The goal is not perfect disambiguation but creating high enough signal relative to the noise (800k files with "program" in the path is a lot of noise when I'm e.g. searching Everything).

For the photo case, I will run the rename program after the day ends. So I can take in a list of numerically sorted files (oldest to newest) and output filenames that retain that sorting (admit -> zinc). In cases where I know how many files are being renamed, I'll check if there are <156, <278, or <2500 (BIP + SLIP) and choose the wordlist accordingly.

For my situation, cycling the wordlist (zinc -> back to admit) is not a problem after the day has rolled over. It's slightly annoying if it happens in the span of 4 hours (>156 photos in the span of 4 hours). The root purpose is disambiguation. Photos not taken on the same day are very different, but in the same hour I might be in the same location.

Yeah, I’m starting to think that a tunnel at the router level with family is a preferred approach. I dread the setup time, but it sure lowers the attack surface.

"frontmatter" is what the kids call "metadata" these days...

What if I visit a website to order a burger

Make it extra beige with

Eighgzekyoote Docyument Chelle script Reut folder Phaiel manager Ehrawr code

Who are you callin' fancy, cowboy?!

I'm offended!

:P

If you do the heavy lifting with external libraries in python, you are already running C code.

I'll have missed whether you intended to add these words to the date and time stamps in the file names, or whether you intended to replace them. The former drastically increases permutations and thus lowers the risk at generating collisions, especially at subsecond intervals.

Recently I implemented an idea for this I first saw with Keybase: to generate a security key based on 9 or 10 dreary dull words. Each subsequent word increases the permutation power exponentially, meaning the initial list doesn't even have to be all that long.

How fast do camera shutters shut? How many subzero pictures do they take? Does it differ from one model to the next? And: is your storage system capable of keeping up when you have it rename every photo it receive?

I love posts like this. Congratulations on doing a thing. respect

Here are the two wordlists, sorted by filename prevalence.

beige-wordlist-156

starting
decorate
treat
merit
multiple
mandate
imply
expect
explain
quarter
ruler
prepare
category
exceed
describe
primary
finding
agency
forecast
admit
hanger
hearing
permit
dictate
equip
careful
recall
educate
identify
calcium
ordinary
evaluate
length
quantity
execute
likely
herald
reaction
enforce
closet
ancient
industry
gesture
often
champion
ambition
ranked
decision
grant
organize
duration
dominant
relate
meaning
maximum
together
blanket
fused
improve
flexible
fancy
aspect
grasp
repeat
gravity
losing
engage
depart
exclude
declare
costume
observe
frequent
increase
modify
apart
making
crunch
cubic
lift
fraction
submit
deal
fragment
leader
bolt
alto
belong
amount
bracelet
hesitate
capacity
cause
funding
trend
carbon
floral
exact
amuse
omit
mixture
beam
inherit
stay
genre
herd
involve
junior
emphasis
briefing
adorn
cowboy
purchase
dough
diminish
brave
bulb
devote
being
agree
envelope
budget
coal
fiscal
much
civil
payment
unfold
cradle
zeta
zeal
glance
obtain
carve
genuine
xeno
aluminum
chew
faint
says
midst
ceramic
buyer
usual
phrase
yield
ajar
paid
enlarge
mild
humidity
furl
zinc
depict
judicial
zest

beige-wordlist-278

program
package
profile
source
extra
include
plot
move
heat
type
install
valid
intend
cover
index
huge
main
manual
zone
language
level
object
class
network
item
group
kind
manager
hand
various
bundle
quick
plan
advance
lend
round
provide
order
axis
very
deploy
random
replace
step
volume
simple
large
kernel
review
method
expand
material
machine
fact
metric
force
element
counter
cards
render
inform
crystal
single
should
require
regular
guard
carpet
general
detect
listen
result
gather
aide
inside
depend
width
domain
extend
true
dynamic
have
flip
mixed
course
living
join
capture
ending
away
hybrid
march
firm
echo
moment
exchange
forward
perfect
piece
clock
greatest
idea
beyond
total
response
percent
credit
bucket
clay
lift
deal
together
repeat
length
cubic
bolt
alto
champion
fused
apart
observe
ancient
multiple
discuss
exact
treat
omit
beam
making
stay
fancy
herd
primary
engage
herald
category
fragment
grant
bulb
cowboy
expect
being
coal
execute
fraction
much
carbon
prepare
finding
gravity
organize
trend
inherit
genre
junior
cause
maximum
depart
duration
civil
leader
crunch
purchase
payment
quarter
mixture
submit
zeta
losing
explain
budget
exclude
zeal
aspect
flexible
obtain
brave
hanger
practice
amount
xeno
estimate
agree
equip
relate
chew
reaction
says
carve
remind
identify
ruler
evaluate
modify
funding
floral
dough
starting
describe
unfold
costume
imply
briefing
gesture
closet
ancestor
recall
decision
usual
capacity
ordinary
improve
agency
yield
phrase
amuse
belong
envelope
ajar
cradle
enforce
hearing
faint
easel
increase
paid
declare
likely
meaning
decorate
ambition
blanket
formal
steady
mild
industry
merit
emphasis
fiscal
glance
forecast
careful
often
genuine
furl
quantity
ceramic
overall
involve
permit
exceed
ranked
bracelet
zinc
endorse
enlarge
helpful
realize
buyer
zest
admit
aluminum
devote
midst
depict
indicate
dictate
frequent
mandate
grasp
dominant
calcium
diminish
educate
humidity
hesitate
adorn
judicial

You can alphabetize them at any number of sites such as https://wordcounter.net/alphabetize

I do not think I've gotten as far as pagination, but I assume you mean the frontmatter you see at the top of the pages. I have added that, as it comes with goldmark-meta. Feel free to check out the examples/ folder. :3

The sea is not nearly hot enough!

Every method just returns an empty string. Runs fast as hell. Just don't expect it to do anything.

Using static site generators made me stop worrying - it doesn't matter how bloated, lightweight, slow or fast the software is - as long as it produces static HTML that even the dumbest server can serve.

That said, does your software offer things like pagination, page metadata that can be iterated over, etc.?

Then use it poorly and it's a double negative.

The issue is that any time you add another generic layer, it involves another layer of loops for "handle everything" tasks and lookups for "handle this specific thing" tasks. A native app could set a bunch of values for properties by changing them in a single function accessing a single data structure. You might have a single function that does the same thing using frameworks, but that function is potentially going to use accessor functions to reach down each layer to set those values where they matter plus could need to do a bunch of transformations as it traverses each layer (or maybe that's done on the render side).

So then you add a bunch of caching to improve these common scenarios and balloon memory usage, which was already inflated because those layers also need memory to store their data structures.

And these things get worse as they scale, so small scale tests still look snappy and hide how much things can grind to a crawl when it needs to handle the large or normal scale. Not to mention, if you don't have a speedy version to compare to, you might just think that it makes sense for this process to take a couple minutes because it has millions of things to do (despite running on hardware that can do billions of things per second).

I'd say a bit of both. People who are fine with having a DOM worth of overhead don't give me much confidence they are selecting algorithms well, which can absolutely affect performance and efficiency regardless of what language they are written in.

Hell, even with the optimal data structures and algorithms selected, how you set them up can make a huge difference.

Like I once had essentially a data translator that, in order to be generic, used keys in a dictionary to replace the hardcoded data structure that needed to be updated any time the spec changed, even if we didn't care about the new values.

The first version used an array of dictionaries and was slow as fuck. Each line of data would get its own dictionary and just parsing the data into this scheme took a couple minutes IIRC. Since the data was guaranteed to have the same keys each line (we were worried about changes between versions, not lines), I changed it to a dictionary of arrays, where each line would have the same index across the dicts, and it brought parse time down to several seconds. Huge difference even though big O notation would have simplified to the same expression for the two methods.

But if you pick something with a worse big O expression, it gets worse on a whole other level.

Great read! Very digestible too. I learnt something today, thanks

I compared one single Qt app (QOwnNotes) with one single similar Tauri app (I don't remember the name, I was trying apps because I was looking for something extensible that wasn't Electron-based as Logseq). It was a huge difference for me, at least, more or less 100 MB, and for what I knew, it was not that badly programmed.

And for me, with only 16 GB lf RAM and an Intel Xeon v4 (12C/24T @ 2.20 GHz max) it's even more noticeable, specially because I work in multimedia (music production and sound design) and I have to use a browser and a communications app all the time because I need to research stuff and communicate with some peers and my clients (the very few times I have clients).

Every byte counts, even if you have lots of memory and a huge processor and GPU. Thinking that "1 MB is not that much" is what has led us to this crysis. We should make any and all possible optimizations to be able to ship featureful software that's not overbloated (Suckless dickheads can suck my ass).

I've also compared native Rust library (egui? don't remember exactly) with Tauri and the difference wasn't that big. What did you compare? As I said, native solutions should use less memory if you run a lot of them at the same time as they will load shared libraries only once. So I guess if you run KDE and start single Qt app it will look better than running single Qt app under Awesome WM or cosmos.

Electron is also the worst web based toolkit out there. Solutions that use system webviews instead of running whole Chrome are much lighter.

You can write slow and inefficient software in any language

Yes, but you can't write snappy fast software in any language, high level languages like python, lua and php carry alot of overhead from the get go, because of dynamic typing, heavy abstractions, and heavy garbage collectors.

I don't think you're making the kind of argument you intended to make. Those are two different programs with two different development teams behind them. The design behind them (the literal thing the article is talking about) are likely completely different from each other. Comparing the languages based on two different implementations of the same spec is a bit more than disingenuous. If you want to actually compare you need to recreate the same implementation as closely as feasible. Something like this https://youtu.be/WB7v-ezqcJM

Ive used them to help a lot in the past, but they often didnt give enough detail. Like I would know the area something was a problem, but pinpointing exactly what it was was still up to me, and would take some time. It worked but it could have been better.

Turns out there was a library you can add which adds that extra missing detail, and with that it was possible to highlight the exact issue. Wish id known about that sooner. That was on me though.

I've done tests like that too, and I can't agree with you.

Plus, GTK is a bad comparison. One of the worst native toolkits, if not the worst one along with any and all immediate mode ones.