Kobolds with a keyboard.

  • 1 Post
  • 30 Comments
Joined 3 years ago
cake
Cake day: June 5th, 2023

help-circle
  • Parents giving their children these devices, observing excessive attachment, and not cutting them off bear considerable responsibility.

    While I do agree that parents should bear the brunt of the responsibility here, you must realize that kids are resourceful and no amount of parental oversight will stop a determined kid from accessing this content. Parents aren’t in their presence 24/7, and just like a kid whose parents deny them candy can find plenty of ways to obtain it without their parents knowing, the same is true for social media use. It’s the old adage that the more you tighten your grip, the more slips through your fingers.

    liberty

    You keep using that word, but this isn’t really about personal freedoms at all. It’s about companies that saw that their product was causing harm, and actively made the decision to continue promoting that harmful product in the name of profits. Their products were specifically engineered to cause these outcomes, and you’re defending their right to do that. Do you just propose we allow companies to do whatever they want in the name of profits, no matter the cost to society? If not, where do you draw the line? How much harm do they have to knowingly cause before you think it’s too much?

    When risks are open & obvious, such as the overconsumption of certain foods & legal substances, that’s generally viewed as a matter of personal choice rather than unreasonably dangerous product defect.

    We restrict alcohol and cigarette use by underage people, too, actually, because their effects are known to be harmful, so I’m not sure what point you’re trying to make here. Nobody’s talking about making social media use illegal for adults.

    Basically, I think you’re arguing against social media restrictions for kids which is fine but that’s a completely different discussion. It’s related, but it’s not what this article is about - this article is about holding corporations responsible for bad behavior. If that isn’t what you want to discuss, why are you here?

    However, even supposing such features defectively make the system unreasonably dangerous in a reasonably foreseeable manner, that only demands that service providers provide fair warning. Once duty to warn has been met, users are reasonably aware of risks and responsibility shifts to risk-takers or parents who give children access despite reasonably knowing the risk.

    Okay, I think you’re just not understanding the situation here. Meta did research on the effects of social media. They found that it was harmful. Even after determining that, they continued to promote it as not harmful. Zuckerberg even testified that that evidence that social media was harmful didn’t exist, after they had found evidence that it was. This all came to light because of whistleblower testimony. So even if we accept your premise here, that duty to inform was not met and that’s part of what’s at issue here.








  • The actual quote that the tagline paraphrases:

    “And so Tim has gone from making games to making one game, spending all his time doing that and trying to make as much money as possible,” says Faliszek. “And I guess well, hey, Tim, Gabe’s better at that than you. I don’t know what to tell you, man, because you stopped caring about making things.”

    Other good quote:

    Faliszek says it infuriates him to see “lazy dev” complaints when companies like Epic “just cut them off at the knees, man.” He suggests looking at the documentary about Half-Life and Valve: “And how many people still work there after all those years?”

    And it turns out the salary was good. Very good. “They care so much about what they’re making that they’re still there and they’re all rewarded handsomely,” says Faliszek. "To be clear, I could retire, I worked my ass off at Valve, and I could retire today. I made more money than I’ll ever make. And the money I made is dwarfed by the people who were there longer than me or before me.

    "But Valve understood that. That’s how you get this thing where people cared, people worked hard, people stayed because they felt they were improving. What they were building on was something that they had agency over and owned. Like, even now, I’m excited when I see the Valve announcement about the VR stuff and everything, that makes me happy.






  • I wouldn’t call myself a veteran by any sense, and it’d be helpful if you posted a screenshot of your scene tree so we can see what you’re working with. A few notes:

    Generally speaking it’s recommended to keep scenes and their associated scripts in the same directory. You can subdivide your /scenes directory further, as well, to organize things, but really your structure is up to you and whatever works for you is fine.

    Consider making one “Main Menu” scene, and adding all of the sub-menus as children. Rather than adding and removing children, you can just hide / show them as needed. The increased resource usage to keep them all in the scene tree at once is extremely minimal and should have exactly zero impact. This also makes it easier to, for example, show the menu over a paused level if the user presses Escape (or whatever button you use), and it makes it easier to assign references to the sub-menus, using exported variables.

    (If you add @export before a variable declaration, the variable shows up in the Godot editor when you select the node the script is attached to, and you can assign values there. This creates dynamic references to e.g. scenes, and if you move the scene in your folder structure or the scene tree later, it will automatically be updated. With the ‘hard coded’ paths you’re using currently, you’ll need to manually go and update those references any time your file structure changes.)

    I’d use a simple state machine to manage this. A very basic implementation is to have a “states” enum with your various states (e.g. MAIN_MENU, OPTIONS, LEVEL_SELECT, etc.), and a “current_state” variable. Make a ‘change_state’ function that has 3 components:

    1. ‘Exit’ the current state. This is where you run any code that needs to happen when a state ends - for example, when you exit Options, you want to hide the Options menu node, etc.
    2. Change the state, where you actually set the state variable to the new value
    3. ‘Enter’ the new state, where you include code related to the new state starting - for example, for Options, this is where you Show the window (and maybe run an initialization function inside the options menu script, if needed).

    It’s a very compact way to keep all of the code in one place and make it very easy to add new states or functionality later. For the project as a whole, you might want to consider a more robust state machine if it warrants it.

    Edit: here’s a quick and dirty example of what a (very basic) state machine might look like for a single thing like this:

    enum States {
    	NONE,
    	MAIN_MENU,
    	OPTIONS,
    	LEVEL_SELECT
    }
    var current_state = States.MAIN_MENU
    
    func change_state(new_state:int) -> void:
    	# Exit state
    	match current_state:
    		States.MAIN_MENU:
    			main_menu.hide()
    		States.OPTIONS:
    			options.hide()
    			options.save_options_to_disk()
    		States.LEVEL_SELECT:
    			level_select.hide()
    			set_next_level(level_select.chosen_level)
    	
    	# Set state
    	current_state = new_state
    	
    	# Enter state
    	match current_state:
    		States.MAIN_MENU:
    			main_menu.show()
    		States.OPTIONS:
    			options.show()
    		States.LEVEL_SELECT:
    			level_select.show()
    

    You can use a similar state machine to handle (for example) player actions - have states for Jumping, Running, Walking, Standing, Climbing, etc., and use the state machine to both start and stop animations as needed, and to gate input (to prevent, for instance, jumping while already jumping.)

    Edit #2: Without seeing the rest of your code it’s hard to say if this applies, but just as a note: If you’re removing scenes from the scene tree, then re-instantiating them the next time you need them, you’re potentially creating a memory leak. You either want to store references to the scenes after you remove them, and just re-add them to the scene tree, or you want to free them (via queue_free()) which actually removes them entirely and frees up the memory they were using, then reinstantiate them later. (Removing children doesn’t actually remove the scene from memory.)



  • Here’s a thought experiment: imagine Instagram, but every single post is a video of paint drying. Same infinite scroll. Same autoplay. Same algorithmic recommendations. Same notification systems. Is anyone addicted? Is anyone harmed? Is anyone suing?

    Of course not. Because infinite scroll is not inherently harmful. Autoplay is not inherently harmful. Algorithmic recommendations are not inherently harmful. These features only matter because of the content they deliver. The “addictive design” does nothing without the underlying user-generated content that makes people want to keep scrolling.

    This feels like an awful argument to make. It’s not the presence of those things that make Meta and co so shit, it’s the fact that they provably understood the risks and the effects that their design was having, knew that it was harming people, and continued to do it anyway. I don’t care if we’re talking about a little forum run by a Grandma and Grandpa talking about their jam recipes; if they know that they’re causing harm and don’t change their behavior, they should be liable.