12,000 consoles … for an estimated value of more than 47.5 million euros.
Each console costs 40 grand? 
One thing I'd really like to do is learn what the default install of Mint+Cinnamon is doing, how to go over the different components, how to pick and choose what i want this thing doing. I didn't find the official documentation overly helpful, troubleshooting the install aside, so i wanted to ask here
It sounds like, as soon as you get half-comfortable, you should install Arch.
This is not a meme, your question is exactly what archlinux exists for.
Don't use the installer, follow the good old https://wiki.archlinux.org/title/Installation_guide
Good luck, don't take Arch too seriously.
I bought a second-hand xperia 5 III last week. Edit: Flashed lineageos and a magisk module to use the stock camera.
The naming scheme is confusing, the first number is the price range, where 1 is the most expensive, 5 the sweet spot, 10 the "budget" model, then the second number is the generation, I < II < III < IV < V < VI.
Recently I found out about sony xperias.
- Decent price second hand
- decent specs, snapdragon CPU
- Unlockable bootloader
- Very good camera, not bricked by unlocking the bootloader
- LineageOS support on some models
- Headphone jack
- Double SIM + eSIM
- micro SD card
- Large battery
- Easy to repair
For smartphones I think a significant driver of their ever-increasing sizes is that battery technology is lagging behind power demand. The worst thing of having a small phone these days is that the battery lasts less than a day. Big screens used to be too power hungry to be practical but LEDs are extremely efficient these days.
My prediction is that we'll return to the miniaturization craze of the 1990s whenever the next breakthrough in battery technology happens.
Huh, when I set it up zsmalloc wasn't finished and never deallocated. But it seems that today it's the right choice! Thanks.
am i right that you can create zswap block devices and mount them like with zram? (eg. mounting /var/tmp)
zswap is a "front swap", it needs a backing swap to function that's crucial to the design. It automtically goes in front of all the swaps you have enabled.
You could probably put the backing swap on a loop device on a tmpfs, but I don't know how it will handle the loopback. It's a better idea to put it on disk. It can be a slow or write-limited disk, it will not get used much. You definitely should not use zram and zswap at the same time.
excuse me the embargo has an exception for food and medicine
It's really easy you see, you just need to pass an inspection and get a written permission from the President of the US, the payment must be made in cash in US dollars before shipment and through some non-American bank, and the shipping company must go straight from a US port to a Cuban port and back with no layovers.
This is not a joke, it's what is actually written in the law.
Yes, more or less, they are closely related:
In regular swap, when you're low on memory the kernel chooses some memory pages (low priority processes and least recently used) and writes them on disk on a file or partition. When the process that owns those pages need them back, the kernel goes fetch them one at a time. Since memory pages are 4KiB the speed on this depends on the 4k random access speed of your disk.
You can have more than one swap, and the order they are used depends on their priority, or on the order they were enabled in if you didn't specify any priority.
zram is a kind of swap space that, instead of writing to disk, compresses the pages and writes them back in RAM. You set an uncompressed size for it and if the pages don't compress well (usually encrypted on already-compressed data) then it will occupy the same amount of RAM. Since you can't tell in advance what the compressed size will be and there's no mechanism to stop it from filling up, you must be conservative on the size of zram. When the zram gets full all new pages will go to the next swap in priority order. This causes a problem where there's old data you don't care about taking RAM space in zram that cannot be reclaimed, and then your workload is going to regular swap which is slow.
zswap is a layer on top of swap, the technical name is "frontswap". For it to work you need to already have a swap configured. Before memory pages are written down on the swap file, they are compressed, and if the compression ratio is good enough the pages go to RAM instead of to the swap file. You set a compressed size for the zswap (by default, 20% of your total RAM) and when this limit gets full the least recently used pages are written to disk. The compression is so fast that you barely notice a hiccup while it's happening, it feels like you magically have 50% more RAM than before.
Answering your question, zswap is configured by kernel parameters, and now that you mention it it might work to put the parameters on the kernel cmdline instead of editing sysfs, this means configuring the boot loader and adding zswap.enabled=1 zswap.compressor=lz4 zswap.zpool=z3fold to the kernel cmdline.
zswap has the same purpose than zram but a better design: it sends to disk the pages that cannot be compressed, and when it gets full it writes them back least recently used first. zram on the other hand keeps uncompressible pages around, and when it gets full all new pages go to disk and it makes the situation worse when you're low on RAM.
The size is allright, but the zswap config is crucial.
I can't figure out how to do it in guix with any certainty, perhaps you can enable it manually once to test and then research it better if you feel that it's worth it. Like this, as root:
modprobe zswap
echo z3fold > /sys/module/zswap/parameters/zpool
echo lz4 > /sys/module/zswap/parameters/compressor
echo 1 > /sys/module/zswap/parameters/enabled
sysctl vm.swappiness=100
The 1 > enabled must be written after the other two. If you don't have sysfs mounted at /sys, check with the mount command where it is.
A couple of mailing list threads that may help you do it "properly" in guix:
https://lists.gnu.org/archive/html/guix-devel/2023-02/msg00077.html https://lists.gnu.org/archive/html/guix-devel/2018-03/msg00332.html
Try this if you have low RAM, I lived with it for months when I had a broken DIMM and had to make do with 4 GB. The difference is incredible.
/etc/tmpfiles.d/zswap.conf
#Type Path Mode UID GID Age Argument
w /sys/module/zswap/parameters/zpool - - - - z3fold
w /sys/module/zswap/parameters/compressor - - - - lz4
w /sys/module/zswap/parameters/enabled - - - - 1
/etc/sysctl.d/00-swappiness.conf
vm.swappiness = 100
Depending on your workload you may increase swappiness to 200 with good results.
You need to set up some 8 GB of swap, it's mostly for accounting purposes and will barely get used so it can be anywhere. If you already have zram, disable zram, it's counter productive. Use the swapon command with no arguments to check if you have zram.
I like it because it's designed. It think it's the only DE with actual designers continuously working on it. It has few options and doesn't feel hacked together.
I doubt they worried about being condescending, lots of people fear that the official documentation will be too difficult and never read it. The logic is that the docs are arcana written by witches that know how to write programming languages, and the tutorials are written by regular girls that had to struggle to understand the language instead of the syntax just appearing on their heads.
I pretty much learned how to program from the official Python tutorial. I had been struggling for years before that; I had some notions but I couldn't put together anything really useful. The Python docs got me over the hump precisely because of what OP said: it starts from 0 and builds up until you have enough tools to write whatever project you have in mind. I imagine that having had to design and reason everything about the language actually gives the writer a great sense of how it fits together and what the logical increments are.
Since then I always go first to whatever the language designers wrote; for example K&R's The C Programming Language, the Rust book, the Postgresql manual, etc, and only once I feel that I know enough I complement it with other sources.
This approach extends to libraries as well: first I read whatever official docs there are, then I search the source code for the functionality I need to learn about, and only if that fails I look elsewhere.
It seems like a slow method but it's so reliable that it works out for me. After a while of doing this you become the reference and people come ask you questions.
Python in particular is very well documented. There are two levels, the official tutorial that glosses over stuff and presents things conceptually, and the reference that tells you exactly what is happening and what the syntax does.
That whole chapter about the data model is really useful when you try to do anything fancy with Python. It's all in one page so you can Ctrl-F all the arcane definitions.