Alternatively, use your shell however you want. And which isn’t POSIX so I wouldn’t use that in a shell script you intend to share.

I don’t really find it infuriating and I don’t think that makes me part of a problem. Self diagnosis can sometimes trivialize the people actually suffering from the problem, and there van be real harm there. So I definitely agree with you to some extent. But some people are so hungry for community that self diagnosing some problem like ADHD makes them part of something else. That’s sad to me, but not infuriating.

I do understand that mislabeling normal things as a mental health issue can be problematic. I wish you didn’t assume I thought otherwise from our small exchange. My point of responding was that I find it really annoying when people say “well everyone does or feels X so there’s nothing wrong with you”. I think that also does a lot of damage to people.

I’d say that the person on display in the comic doesn’t seem to be showing “normal” or “healthy” procrastination to me, but there is room for disagreement I guess.

Wow, people are so extreme on the Internet. One comment saying maybe take a step back and we’re already at “fucking stupid”.

This comic is relevant to general human experience and ADHD, both are true and valid. The comic didn’t tell people to self diagnose and no one here has told anyone to self diagnose.

Normal people feel sad. Feeling sad consistently and having it harm your life and not knowing how to fix it is called depression. People with these problems aren’t aliens showing weird never been seen before behaviors or emotions, but their lives are consistently disrupted by these normal things. It’s a problem of how often and how much the person can control it.

I see why it does this now. Debian does

CONFIG=/etc/samba/smb.conf
# stuff
ucf --three-way --debconf-ok /usr/share/samba/smb.conf "$CONFIG"

in the postinit inside the .deb file to create the /etc/samba/smb.conf file. They do it this way so they don’t nuke an already created file. I take back that they should be shipping an empty file, this way is better, but it also means you’ll never be able to query it without some changes to the packaging tools.

The man page should mention the path though that’s a bit lame.

This is a good argument for shipping an empty config file.

Your point stands, but this also isn’t completely unintuitive. There is pattern there: you installed samba and the config is in /etc/samba/. System level installs will almost always install their config in /etc/ and the sub directory will typically match the name somewhat.

There is likely a general thought that if you’re going to administer a samba server, you’ll also be comfortable with conventions and man pages. Although, funnily enough, in the particular case of samba, man smb.conf doesn’t show the path lol

It’s funny because it seems like it’s all just familiarity with conventions on both platforms. I’ve used Linux for around 15 years and I’m completely lost trying to find anything on a Windows computer.

Yikes. Not sure why I expected anything else.

You typically won’t have permission to write them with ADB.

For user specific files a lot of modern programs try to adhere to https://specifications.freedesktop.org/basedir-spec/latest/. You should set those environmental variables and check there first.

For system level… it’s definitely more complicated. I check /etc first and then then /usr dirs. If you’re using your system package manager there is generally a way to query it for that information, but it’s typically CLI based.

Or just use our lord and savior NixOS and configure everything in a single directory

Why so hostile and the name calling…? They’re saying it’s a lot of work for oftentimes a single person to do. That’s just the truth.

There is a lot of entitlement around free software. People expecting free things, often written in someone’s spare time, to be really polished just don’t understand I guess. On top of that, good documentation is hard to write and sometimes it’s a completely different skill than writing the software itself.

Sounds fun. Maybe I’m missing something but I wouldn’t expect a local restaurant to have rolled their own takeout backend. Are you actually seeing places that do? The branding might be subtle, but I’d be really surprised if they weren’t using a canned service.

Yea, it sounds pretty nice actually. I’m considering doing that as well. Makes it obvious when you’re running in a root shell too which is nice. I’d probably still keep sudo around though.

With a programmable keyboard it can just be one button too!

Oops

Another potential option here is https://www.kernel.org/doc/html/latest/networking/ip-sysctl.html

ip_unprivileged_port_start - INTEGER

    This is a per-namespace sysctl. It defines the first unprivileged port in the network namespace. Privileged ports require root or CAP_NET_BIND_SERVICE in order to bind to them. To disable all privileged ports, set this to 0. They must not overlap with the ip_local_port_range.

    Default: 1024

This is also per namespace so you could use it in combination with network namespaces if you really wanted to keep privileged ports.

It is a fantastic way to make sure things work across a team. We use Linux (bunch of different distro) and macOS at my company and once I started packaging things with nix environment related issues mostly went away. It’s not perfect and it’s not necessarily easy to learn nix, but I prefer it to sharing docker containers or other alternatives.

Sorry I didn’t mean to imply they don’t use shared libs, they definitely do, but they have to integrate them into the larger system still and put consistent interfaces over them.

I suppose we need to make definitions clearer.

The definition of “a memory safe programming language” is not in debate at all in the programming community. I have no idea why you’re trying to change it.

I’d argue those weren’t the best developers then

This is incredibly arrogant, and, tbh, ignorant.

You missed the point of the examples: those aren’t necessarily “easy mistakes” to make and of course a UAF is easy to spot in a 4 line program, the point is that there is no language construct in place to protect from these trivial memory safety issues. With respect to the “obviousness” of the std::string mistake, if you instead consider an opaque interface that requires a const char* as an input, you have no idea if it is going to try to reference of that pointer or not past the lifetime of the std::string. If you can’t see past the simplicity of an example to the bigger picture that’s not on me.

I disagree with the blanket statement “C++ isn’t memory safe”. C++ provides the tools for writing memory-safe code, but it does not enforce it by default.

This is such a weird take. C++ isn’t memory safe. The blanket statement is… true. You say as much in the second sentence.

With C++, you retain full control over memory management and can choose the best tool for the job. You’re not boxed into a strict ownership model that may force refactoring or add extra layers of abstraction.

You have full control in Rust too, at least to the same extent as C++. Rust isn’t memory safe either. Rust is just the opposite of C++ in the approach to safety: you opt in to being unsafe with the unsafe construct instead of being unsafe by default. They’re just different paradigms. I’d actually argue that you don’t have full control in either language unless you opt in to it, modern C++ tries very hard to abstract away memory management. You can write an entire program without a single new or malloc, which is pretty great.

Sure, mistakes can happen, but with proper practices and modern C++ features you can achieve a level of safety that meets most needs without sacrificing the expressiveness and efficiency you might require in complex systems.

This is just simply not true and is consistently proven incorrect every time an aspect of C++'s memory unsafety is exploited. I work in security and I still, in 2025, exploit memory corruption. The best developers money can buy still make mistakes with C and C++.

Besides that: which conventions do you mean?

The way you have to interact with smart pointers for example:

#include <memory>

int main(int argc, char** argv)
{
    std::unique_ptr<int> a = std::make_unique<int>(1);
    std::unique_ptr<int> b(a.get());
}

Double free, but compiles without warning. It’s convention to not use unique_pointer’s constructor, not enforced.

#include <iostream>
#include <string>

int main(int argc, char** argv)
{
    const char* c;
    {
        std::string a("HelloThisIsAHeapString");
        c = a.c_str();
    }
    std::cout << c << std::endl;
}

Use after free. No compiler error or warning, it’s convention to not maintain references to C++ string data, not enforced.

That’s all fine, whatever, but these are conventions. We’ve shot ourselves in the foot a million times and come up with our own guard rails, but the developer needs to know all of them to not make the mistake.