reificator

You got 'em. Google rarely reveals why they killed someone's account.

So we can't prove it was due to email content. For all we know it could just be a dude named Richard who throws darts at a board full of usernames all day.

In fairness to those learning through YouTube or other modern sources: I learned from books and after finishing the exercises in the books I also had no idea what a "super simple project" was, or at least what one step up from the book was.

Ultimately I learned by starting projects that were too large, hitting a roadblock, and stepping back to learn about that thing. Then starting another project and repeating.

This process took years and years before I was reasonably confident in estimating the size of a project. And to be honest even now, nearly 25 years after writing my first tiny cli trivia game, I still get it wrong sometimes, especially in a new domain.

At the end of the day estimation is hard even for veterans of the software industry.

If he gets hurt in these videos he'll accrue some medical bills.

If some number of kids watch his videos and get hurt mimicking them, he'll accrue a bunch of lawsuits to cover their medical bills.

Putting the disclaimer implies nothing but a well-founded fear of frivolous lawsuits.

So the actual volume playing is effectively:

Hardware volume x Windows master volume x Windows app volume x In-app volume

No one wants or needs that level of control.

I don't have a separate hardware volume relative to the Windows master volume, but otherwise I want and need that level of control.

- Windows Master Volume: I turn the knob on my headset or keyboard and things get quieter or louder. This is the thing I adjust most frequently.

- Windows App Volume: I turn games down, usually to 10-20% or so. Then I turn everything but comms (discord, zoom, etc) down to 80%. This ensures that I hear live communication over all else, and that my games aren't drowning out whatever I'm watching in the background.

- In-App Volume: Here I adjust balance in games. Music unfortunately gets set to 0 because I'm rarely just playing a game these days. Voice lines get set higher than sound effects until I'm sure I can distinguish them clearly.

Namespaces do not solve the issue but they do mitigate a specific vector, while also removing a perceived need to preregister crates.

There’s no downside beyond “it requires development time and maintenance” like any other feature.

It looks like this works well from mobile until you try to edit and the keyboard covers the code.

Sliding the animation off screen to make room if a soft keyboard is detected might allow this to be used on phones.

It's quite a high bar apparently, and a lot of people out there don't manage it.

It's not a high bar. There's just a surprising number of people that are really good at playing limbo.

1. Apologies, the posts you replied to were shitting on me so I misinterpreted your comment as agreeing with them. ("you must be fun ~~at parties~~ in taxis" is a common dismissal + insult online)

2. Yeah... You're not wrong.

No I'm just sad that treating someone like a human being is considered a positive and not... you know... the absolute bare minimum someone could do.

Wait I'm an asshole? For being upset that treating taxi drivers "as a human being" is considered a positive interaction instead of the absolute bare minimum of a respectful member of society?

My previous comment, perhaps.

My original point, however, was to highlight the fact that "They treated me like a human being" was given as the example of a positive interaction.

Which is absolutely absurd. And I don't think I'm taking that too literally.

So our range is somewhere around:

- They were OK

- They treated me like a human being

- They were rude

There's no room for "We had an interesting conversation" or "They gave me some good advice" or "I think I made a new friend"? Not even "They seemed like a good person"?

The maximum is "They treated me like a human being" which is somehow above "They were OK"?

a positive "they treated me like a human being" or a negative "no, they were rude"

That's the whole range eh?

If you do make it public and add it to a resume

I didn’t say anything about adding a link to a resume. This thread has hints of people thinking “I’ll just look up their GitHub if they don’t include it” and other threads make that explicit.

You dismissed that because a one sentence readme isn't needed on a public side project.

I don’t think that’s what I said. I was saying that tracking all the things one might be judged for is unreasonable, not that having a readme is unreasonable.

https://news.ycombinator.com/newsguidelines.html

Please respond to the strongest plausible interpretation of what someone says, not a weaker one that's easier to criticize. Assume good faith.

And what if I’m not tracking that in such detail or even thinking about viewing it like that because it’s a side project?

My repos are hidden specifically because I do them for fun. I’d make them public if tinkering were an understood thing but its not.

If you give me six lines written by the hand of the most honest of men, I will find something in them which will hang him.

Better to have a clear separation between work and play.

This is clearly not true given the number of banks with no physical branches.

I did not order the list of effects by importance or impact, I ordered them by what came to mind while I was typing.

I touched on low to the ground aggro decks in the very next paragraph, and I agree that's probably the biggest issue.

However aggro decks becoming more powerful does not mean control decks cannot also become more powerful. Decks aren't a one dimensional plot of aggro to control with midrange in the middle. (though to be fair I did say "on the other end of the spectrum" in my initial post)

When I say higher mana value cards are more playable, I mean in the sense that they can be cast "on curve" much more often, because if you want to cast a 7 drop on turn 7 without ramp you can choose do so, while with a normal deck you might expect to hit 7 mana between turns 8 and 11. (Not a hard calc, just a gut check)

If you have to answer your opponents' threats 1-1 early you can refill with answers, and if you get ahead with 2-1s or 3-1s you can keep drawing land to play your expensive threat on curve.

I personally suspect that aggro would completely dominate a separate land deck meta if pushed hard enough.

Agreed, I probably should have listed it first.

Even in the short term, look at when Arena ran their Treasure events where each upkeep that player would get a treasure token. By the end of the first day the event was dominated by “mono red” decks with 13 land and free splashes.

It’s good for teaching younger players who still have temper problems, but there’s only so much of the game you can experience this way. And don’t expect to get to advanced or expert strategies without the game balance falling apart.

One knock on effect I’d predict is higher mana value cards would be substantially more playable. I expect a deck of walls + counterspells + removal + big finishers like the Eldrazi or even just Baneslayer Angel to be much more effective than it is now.

On the other end of the spectrum super low to the ground aggro strategies also get a huge bonus by simply never having to draw a land again.

Probably Storm (play a bunch of cheap spells, typically with a discount or with effects that give you mana when you cast a spell) gets a huge boost as well as they can ensure they never fizzle out. Once the engine is going they’ll always win unless they get countered.

What lose out here are all the decks in the middle. The midrange, “fair” decks that are just trying to curve out with the best play each turn.

And all that’s not counting the rules headache with cards like Oracle of Mul-Daya, Fact or Fiction, Treasure Hunt, or Dark Confidant. Which pile does my Maze of Ith go in? Cultivate? Sol Ring? Faceless Haven?

With that said it’s also my personal opinion that variance just makes the game more enjoyable and widens the group of players you can compete against, as long as you have the emotional capacity to not take losses personally.

Their schedules are clearly flexible because they’re already changing them twice a year under the current system.

They already change schedules though, we just launder it through the time “change” despite clear evidence of costs in both productivity and literal human life.

Changing your working hours means a talk with your boss and maybe HR. If we didn’t have DST maybe it would be a box you check when you get hired.

We spend so much on engineering systems that handle DST changes, there’s an increase in sleep deprived auto accidents, people die from heart attacks… All to avoid individuals asking for different hours at work?

Sorry, “changing” time twice a year is not a reasonable substitute for scheduling work appropriately depending on the season.

Native English speaker, would give the same rough definitions for each phrase if asked[0], but for whatever reason I read the GP and didn't think it was out of place at all. Immediately got the intended meaning. Even after having it pointed out it seems fine to me, in fact I can't really see the "control" meaning even though I know it should be there.

[0]: Though I'd use "pulling the strings" and "pulling at threads".

You're pushing a rock up hill--many markdown renderers natively support mermaid, plantUML, etc. using fenced code blocks.

And yet Github's markdown support carries much more weight. Raising concerns at this point is a perfectly reasonable thing to do.

I think you're caught up on exactly the opposite of the complaint here. People aren't requesting JS execution, they have the various "notebook" solutions for that.

People are saying that triple backtick fenced code blocks are used to preserve whitespace and fixed width, usually with syntax highlighting as a bonus. That's the expected behavior.

However with the described mermaid support, it's taking a fenced code block with a mermaid tag and transforming it into a graph.

When inspecting the text content of a markdown file, there's no difference between a `javascript` tagged code block, a `haskell` tagged one, and a `mermaid` tagged one. But now when rendering, the mermaid one is special cased.

This is undesirable for multiple reasons, the most obvious being that it's now harder to write a README that displays mermaid syntax.

A good starting point would be either different syntax or a different tagging convention. For instance I think I saw `!mermaid` suggested, where the `!` would mean that the code should be interpreted instead of rendered as code.

I don't have a horse in the race of what this looks like, only that there should be a distinction between rendered and interpreted code blocks.

Which is the exact inconsistency under scrutiny here.

Compile time would be pretty sweet. I've never looked into it so I don't know for sure.

Don't get too caught up in the hype, it never ends well no matter what the architecture. But it's certainly useful and fun to play with.

Dungeon Siege[0] shipped in 2002. Unity began their ECS journey by sniping talent from Insomniac. ECS is not an unproven concept in someone's head.

That Unity and Unreal are lacking (even after Unity's public efforts in the area) is because they are licensed en masse and retrofitting each with an ECS would be no small feat. And is that refactor worth losing revenue from obsoleted marketplace content? Or does the ECS need to interoperate perfectly with existing code from endless numbers of existing projects while still providing the benefits of a dedicated solution?

Unity and Unreal are not the only engines. In house engines are shaped by the needs of the immediate users, and not the sales pitch for hobbyists or third party studios.

[0] https://www.gamedevs.org/uploads/data-driven-game-object-sys...

That’s a very good question, because sequencing tends to be the place where implementations vary the most.

Usually there will be some way to sort systems into steps and define the order of those steps. Some require you to hardcode the order, others define constraints like “after input” or “before physics” and attempt to solve those constraints, and some let you define groups that can run together and you define the order of the groups. Explicit signaling is not typically built in, but you may be able to implement it yourself if desired.

In environments with an expressive type system, most tend to favor the constraints model. Otherwise ordering tends toward the hardcoded approach, typically implicitly in registration order.

As to managing what systems are responsible for updating a given component’s state, that tends to be left to the game developer.

Sometimes there is a concept of events and if it’s not obvious who should mutate something then systems that want to mutate will send events that later systems can consume. For instance an input system and an AI system might both send a Move(entity, direction) event that a later system validates and applies.

And because it’s cute to do so, often times those events will be implemented as components themselves, with convenience wrappers to make it feel more natural to end user developers. This can come in handy for networked games and debugging in editor. You could also use it in game, such as displaying a unit’s next planned move in a turn-based game.

asking the hard question... how does it stand up to the unpleasant cases?

It's the best tool I know of for a certain class of problem, that's all I'm claiming. Not evangelizing it as a magical cure-all for all domains, just explaining it in enough detail that it can be understood by someone outside the domain of gaming.

what about when the abstractions age and a new feature for a system needs the data from the components from another system?

the long term answer is probably a refactor, but what's the common quick fix? copying/duplicating data between component types? systems that examine other components as well as their native ones? merging systems?

I apologize if I gave the impression that things are so tightly coupled that a system owns a component or vice versa. (Though if I had to pick one, it'd be that components have associated systems)

In reality your components are just plain structs, and any systems that want access can query for entities based on any combination of components. (and good ECS impls allow for exclusion as well)

For instance I mentioned a Position component. This would be used by a movement system that checks for (Position, Velocity). It would also be used by a rendering system, which could query for (Position, Mesh) or (Position, Sprite) as appropriate. It could be used for collision by querying for (Position, Bounds).

If later you want to unload entities that are too far away from a player, you could perform two queries: (Player, Position) and (Position), filter out entities in the second query that are within n units of an entity in the first query, and then despawn what remains.

No existing data or systems need to change to allow multiple systems access to the same data. The only thing that might change is if the engine provides automatic parallelization, and you have two systems that mutate the same data, you may need to define an explicit ordering for them and they would not run simultaneously. If you don't need explicit ordering you may not even need a code change in this case.

***

In the spirit of what you're asking though, let's say you've been making a tile-based game where the player can move between discrete spaces like in chess, but you decide you'd rather have free movement like Mario. Your Position component uses integers instead of floating point values and you don't want to change your world's scaling. Here you have a few options:

0. You could just bite the bullet and change the types on the Position component to floats instead of ints, and let your type system guide you to any errors. Then you run your test suite again and make sure that everything is still behaving as expected. I'd also plan on creating several new tests based on analyzing existing uses of Position. And of course play your game again to make sure it feels right.

1. You can store the fractional position in a separate component, PositionFraction, and create/update systems as needed. Movement would need to be updated to look for (Position, PositionFraction, Velocity) and rendering would need to be updated to look for (Position, PositionFraction, Sprite). Meanwhile pathfinding could still just look for (Position, Goal).

2. You can create a second component that holds the full float value called PositionFine. Like above you update the systems that care about fine-grained positioning to use PositionFine instead of Position. Then you create a system to update Position based on PositionFine's value or vice versa, and log anytime there's a discrepancy. Once you're confident that you can drop Position, you replace every use with PositionFine. Rename afterward as desired.

If I'm changing the meaning of an existing component like this, #0 would be my strong choice, but if the game is already in production and the migration needs to go over super smoothly I'd consider #2 as well. In particular you can treat the existing logic as the source of truth, but run the new logic side-by-side and log out any variation between the two for analysis before flipping the switch and preferring the new logic.

However if the new data is purely additional and makes sense being split off from the existing data, then #1 is the solution to use. Think migrating from displaying usernames over players' heads to letting them choose a custom name. You still need the username for authentication, save games, friends lists, and the like. But a new component for the display name lets you reference that when it makes sense.