Another thing you might want to consider is the repairability. If you want to swap the battery years down the line, this can become a really important metric as well. iFixit is your friend here: you can just look up a device and check what the repairability score is.

Thanks for the info, I changed it.

is the GCam app noticeably better than a stock camera app? What sorts of things would it do better?

As I mentioned in my first comment: “Sometimes, the picture quality is decent, but often times it’s lacking” when it comes to the ROM camera app. How well a camera does, depends on the app (which is supplied by the ROM) and the driver (usually supplied by the manufacturer). The quality can, therefore, vary from device to device. A few years ago I would’ve definitely said that GCam is a step above ROM camera apps, but in more and more cases, those have become almost comparable in quality. One aspect where GCam still actually makes a difference is long exposure modes (low light and night photography) as well as offering special modes like panorama or photo-sphere.

The last I checked, the Pixels had excellent sensors but had some camera software issues that I believe were eventually resolved. I’m hoping that isn’t an issue if I’m just using a basic OS.

From my experience, older oneplus devices (e.g. oneplus 7/oneplus 7 pro) and pixel devices (pixel 5 and upwards) have excellent community support, so you should be golden.

For me, the key aspects for selecting the right hardware are the camera and the comunity support. All the other capabillities you listed are available on any phone that has a relatively recent ROM available.

Let’s start with the camera quality: If you want to use your phone without GSF or microG, you could use the camera app that comes with the ROM you flashed. Sometimes, the picture quallity is decent, but often times its lacking. Instead, I would recommend using a modded GCam App together with fake GSF. This way, you can use googles powerful camera app without sacrificing your privacy. So when I’m looking for hardware, I always check, if there is a modded GCam version available.

Aside from that, I would check if there are recent stable versions of the ROM I want, available for the hardware. The last thing I would check is, how active and how big the modding community for that device is. If you can’t find a lot of support on XDA, it’s probably not the best hardware choice to begin with.

When it comes to software, there are a lot of privacy-friendly replacements to choose from, but here is my setup:

• Syncing Contacts and Todos: selfhosted baikal + DavX5 + Simple Contacts + Tasks
• Syncing Photos: selfhosted NextCloud AIO + nextcloud app
• Syncing Notes: selfhosted webdav + Joplin
• Find My Phone functionality: FindMyDevice
• Maps: OrganicMaps
• Speach to text: FUTO Voice
• Synced Music: Selfhosted JellyFin + FinAmp
• browser bookmark sync: selfhosted webdav + floccus

EDIT: GCam and FUTO are not Open Source, but they are free and don’t collect or require any user data

As a lemmy client, I would add Eternity (APGL-3.0).

For latex documents I would highly recommend Overleaf (APGL-3.0). You can selfhost it on an old PC or raspberry pi and have crossplatform access on all your devices

A better alternative to F-Droid would be Neo Store (GPL-3.0) which has a more modern design and is less broken in general.

For apps that are only available as github releases (e.g. hypeBard) I would recommend obtainium (GPL-3.0) which automates the update process.

My personal preference for calculator apps is NCalcLibre (GPL-3.0) which has a slightly different set of features than your suggestion but has a more structured UI imo.

Text Tools Pro (Apache-2.0) is another awesome tool that can improve your typing experience dramatically.

If you have a degoogled device you might want to install FMD (GPL-3.0) in case you lose it.

For rooted devices, I would also add BCR (GPL-3.0) + BCR-GUI (GPL-3.0) to keep a record of important calls.

Another app that is especially useful on rooted devices is AdAway (GPL-3.0) which is a system-wide ad blocker that doesn’t require any resources.

Maybe not exactly what you are looking for, but you could use a website archiving solution to store one of those online man-page collections. I know it sounds like overkill, but it’s actually easy to setup and can be used for all kinds of other things as well. For instance, I have a local docker container running SOSSE for C++ and Python references and for all kind of libraries and APIs I use for software development. This way I have everything I need on my laptop and can work anywhere, even if there is no network connection.

Anki is absolutely awesome. Since there is a large amount of community made decks, I found one that was specifically made for the book I used for learning Japanese. In addition to that, I also found a free Japanese-English dictionary app that had the option to add words as flashcards to a specified Anki deck. Even though it doesn’t have the most modern looking or intuitive UI, Anki is my main tool for learning Japanese because there are so many useful integrations and a large community behind it, and it is completely free.

I’m glad you liked the idea of the world building twist, and I think I agree with everything else you said as well. Thanks for the feedback!

This sounds a bit like hamster simulator, which we used in high school in our “programming” class, the site is in German, but you might the idea. But I can absolutely see how you can make this more compelling.

Deutsch wäre jetzt kein Problem für mich und ich glaube, ich erinnere mich sogar daran, das auch mal im IT Unterricht gehabt zu haben. Leider war die Lehrerin damals 'ne Katastrophe und ich hab’ das meiste von damals wohl schon ausgeblendet 😅

Building something in-game and extending the world with coding is an interesting perspective. I haven’t thought about it this way before. Instead, I always thought about solving programming tasks and, therefore, solving some issue in-game. I’d have to think about this more and see if I could incorporate that idea. Thanks for the suggestion!

Nextcloud AIO is just a link (just the local IP+port) to the maintenance interface of my NC installation. The officially supported docker image of Nextcloud (link here) has a built-in maintenance interface which allows you to update the installation and all dependencies.

Because Nextcloud is more complicated to maintain (especially when you have a lot of apps installed), I have split all that functionality across multiple smaller services. Baikal, WebDAV, Vaultwarden and Freshrss are technically not needed if I use Nextcloud apps, but all of those services are easily configurable as docker containers and if one of them fails, none of the others are affected. If I use Nextcloud for everything and treat it as a monolithic service, I would lose all functionality if the service fails. Because of that, I only use Nextcloud’s core functionality, which is syncing files across devices and automatically uploading all the pictures I take with my phone. For everything else, I have a dedicated service that is easier to set up and maintain.

I second this but would recommend n8n instead, since you can self-host it and you’re not dependent on another online service.

I’ve heard that a lot of people have trouble with updating and maintaining nextcloud but I personally never had those issues and my instance is running for over 5 years now. I would agree with other people here, that something like docker makes everything easier if you want to selfhost. I personally followed this guide with a custom dockerfile that looks something like this. Once you have a functional docker image and a docker-compose file, updating your instance is as easy as typing:

docker compose stop
docker compose rm -f
docker compose build --pull
docker compose up -d

If you chose to go down that route as well, you might want to change the config files in your docker image since some of the values might not suit your instance. I, for example, have added the following for the PHP config:

RUN sed -i "s/\(opcache\.interned_strings_buffer*=*\).*/\148/" /usr/local/etc/php/conf.d/opcache-recommended.ini
RUN sed -i "s/\(opcache\.memory_consumption*=*\).*/\1256/" /usr/local/etc/php/conf.d/opcache-recommended.ini

There are a many approaches to implementing OOP in C. Since C doesn’t give you any language constructs to implement this out of the box, it’s up to you to do it in a consistent and understandable manner. Since there is no definite way to do it, let me just give you an example of how I would translate a Python file, and you can decide how you implement it from there:

--------------
class Parent:
    def __init__(self, param1: str, param2: int):
        self.__param1 = param1
        self.__param2 = param2
    def __private_method(self):
        print("private method")
    def public_method(self):
        print("public method")
    @staticmethod
    def static_method():
        print("static method")
    @property
    def param1(self):
        return self.__param1

class Child(Parent):
    def __init__(self):
        super().__init__("param1", 2)
--------------

I would split the C code for this into header and source files:

(header.h)

--------------
#pragma once

/// Parent Class ///
typedef struct Parent_obj {
    char* param1
    unsigned int param1_len
    int param2
} Parent_obj_t;
void Parent_init(Parent_obj_t* self, char* param1, unsigned int param1_len, int param2);
void Parent_public_method(Parent_obj_t* self);
void Parent_static_method();
void Parent_param1(Parent_obj_t* self, char* out, unsigned int max_len); // property method with upper bound string length
void Parent_del(Parent_obj_t* self); // destruct object (similar to __del__() in python)

/// Child Class ///
typedef struct Child_obj {
    Parent_hidden_state_t* super
    char* param
    unsigned int param_len
} Child_obj_t
void Child_init(Child_obj_t* self, Parent_obj_t* super);
void Child_del(Child_obj_t* self);
--------------

(source.c)

--------------
#include "header.h"

/// Parent Class ///
// private methods
void Parent_private_method(Parent_obj){...}
// public methods
void Parent_init(Parent_obj_t* self, char* param1, unsigned int param1_len, int param2){...}
void Parent_public_method(Parent_obj_t* self){...}
void Parent_static_method(){...}
void Parent_param1(Parent_obj_t* self, char* out, unsigned int max_len){...}
void Parent_del(Parent_obj_t* self){...}

/// Child Class ///
// public methods
void Child_init(Child_obj_t* self, Parent_obj_t* super){...}
void Child_del(Child_obj_t* self){...}
--------------

Modules and namespaces can be modeled using folders and prefixing your structs and functions.

deleted by creator