• 5 Posts
  • 19 Comments
Joined 5 months ago
cake
Cake day: February 10th, 2024

help-circle




  • Their download page doesn’t make this clear: Molly is not on F-Droid.

    Instead, the Molly project hosts an F-Droid-compatible repository, which you can configure your F-Droid client to use in addition to / instead of the F-Droid repository. If you do this, the downloaded software will come directly from the Molly developers, not from F-Droid.

    Some people avoid this because it loses a layer of oversight. Others prefer it because it avoids a potential attack vector. You’ll have to decide for yourself whether it’s something you want to do.





  • I’ve been thinking of OSS and source available as interchangeable.

    Nope; they are distinct terms. Source-available is just a general way of saying that the source code can be (legally) acquired. It doesn’t meet the standards of open-source software (OSS) or Free Software, both of which guarantee certain rights and freedoms, such as permission to make and redistribute changes to the source code.

    https://opensource.org/osd

    https://www.gnu.org/philosophy/free-sw.en.html#fs-definition

    It’s understandable that it might be confusing, though, since some people use the terms casually without understanding that they have specific meanings, and since both phrases use English words that could be interpreted to mean something else. (For example, “free software” doesn’t mean software whose price is zero, and “open-source software” doesn’t mean software whose source code is published in the open.)

    Edit to add: Like many English words, the context in which they are used affects their meaning. The field of software is such a context.

    But now it kind of seems to me that free software is interchangeable with open source software. Is it just a matter of branding?

    The two overlap, but are not exactly the same. The umbrella term FOSS evolved to encompass both, because there is so much overlap between them that having such a term is often useful.





  • I was replying to this exchange:

    Could mean FOSS but they keep the trademark.

    Sure, but that’s unlikely, given the wording. “Owner of the software” is fairly clear

    The article’s text said, “Winamp will remain the owner of the software”. That does not, in fact, preclude giving it a FOSS license, nor does retaining a related trademark. GP was correct. They can make it FOSS and keep the trademark and copyright. I don’t see any reason to think it unlikely.

    The creator doesn’t “surrender” their copyright, but someone can fork it and then have ownership of their version

    Forking someone’s copyrighted work does not change ownership of the rights in any jurisdiction that I know of. If you meant “ownership” in a difference sense, like maybe control over a derivative project’s direction, then I think choosing a different word would have made your meaning more clear.









  • Supporting SQLite as an option for people with modest needs is not a bad idea. As long as you keep your SQL simple and avoid vendor-specific extensions, adding support for it at any point shouldn’t be difficult.

    Providing a Docker config is fine, but I would never lean on it as a substitute for conservative dependency choices and good build scripts. Many people don’t use it and never will. If you instead design your software to be easily built/installed/packaged natively for any distro, then it will reach more users, and as a side effect, will also be easy to package for just about any container system (Docker, Kubernetes, LXC, etc.)


  • One thing that goes a long way toward making self-hosting easy is to minimise dependencies.

    In order of preference (best to worst):

    • Your language’s standard library.
    • Those that are installed by default on most linux distros.
    • Those that are available in the main package repos of most distros.
    • Those that come from a community package archive. (AUR, PyPI, etc.)

    Mind the version numbers, too; try not to depend on library features that aren’t widely packaged/deployed yet.

    Bonus points for supporting multiple OS, like the various BSD flavours.

    Being conservative with dependencies makes it more likely that someone will be willing to install, package, or administer your software. It also helps limit the attack surface, potentially avoiding exploits in the future.