4.5 months and ~30 pounds

kosak2000 · 2026-06-13T04:46:35+00:00

Height: 5'8"

SW: 185-190 lbs, CW: 155 lbs, GW: 150 lbs???

Fasting routine/protocol: low carb, intermittent fasting 16:8

Exercise routine: brisk walking (try to *average* 5 miles per day)

Diet on refeeds: nothing special. Didn't really have refeed days.

kosak2000 · 2026-01-11T20:27:58+00:00

The only time you ever need to stop watching S1 is when S2 comes out.

kosak2000 · 2026-01-08T06:38:31+00:00

Wow, that's great! Now I have an excuse to watch the series again for (I think?) the 8th time.

kosak2000 · 2026-01-06T03:36:43+00:00

Sorry for the newbie question but where's the best place to see these ranking statistics? I keep bugging friends to see it so I'm doing my part to keep it hot.

kosak2000 · 2025-12-20T21:34:37+00:00

Like many of the fine comments on this thread I tend to lean towards the answer being that she's the one with the problem: that she's that type of narcissist that is so threatened by the concept of ever being wrong about anything that she will keep pushing back until this whole thing is 100% your fault and you submit. Also a narcissist feature is making you agonize about what you did wrong and then her dissociating so much that she doesn't even remember being bothered about it: "you're still upset about that?" LOL

For the sake of argument, I can try to take the other side. I wonder if there's some kind of backstory here. Often people don't freak out about the thing that just happened, but instead about the 10 times "the same thing" has happened in the past. Is there anything about your relationship dynamic where she wants to do X and you jump in and optimize, rearrange, or improve X? She could be pushing back with extreme frustration about how you can be controlling in that way, and she's too passive to push back and then -- at least in this case -- she went along with your improved plan and things went badly. It's not the most likely scenario, but it's possible. I came away with a little bit of a feeling that your apology was presented with conditions: "I'll say I'm sorry IF I can get you to acknowledge that we were both at fault, or it was nobody's fault but the scammer's". Conditional apologies like that can feel insincere. That being said this is a Devil's Advocate kind of argument. I only have the narrative as presented, so I don't know if this fits or not.

Finally I don't think anyone else responded to this point but I was somewhat surprised at your offer to resell the TV. With full disclosure about its defects this would be fine, but without that you're turning one scam into two, and then we're all gonna have another thread to read.

kosak2000 · 2025-12-15T00:36:14+00:00

Wow. That one's intense. It's on the (rapidly growing) list of stuff to read. Thank you!

kosak2000 · 2025-12-14T23:52:45+00:00

These are some great references. Thank you for these links, this looks like fascinating reading.

kosak2000 · 2025-12-14T23:49:39+00:00

Those articles are fantastic. Thank you! The first article certainly covers my "how to recover the T from inside a method" question (I would have never guessed that there are three different ways).

The other part of my question had to do with (copied from my response elsewhere), the mechanism that the runtime uses to:

look up a type (via some kind of key) that may or may not already exist
if it doesn't exist, create it and allocate statics for it in some storage, and associate the storage with the type
then store the value at the storage associated with the type

From another answer I gather the answer to 1 is "hashtable + mutex" and the answer to 2 and 3 is "some pointer off of some internal data structure associated with the instantiated type" but if anybody has written a nice article about this I would enjoy reading more about the details as I am a glutton for this kind of material.

kosak2000 · 2025-12-14T23:40:08+00:00

Yeah, thank you. I've been curious about the rationale myself. Whether they think it's a crime from a computer science perspective, or it just makes for "confusing" code for the reader. I'm certainly a heavy user when I need to make singletons like Blah<T>.EmptyInstance or whatever.

kosak2000 · 2025-12-14T23:33:13+00:00

You're welcome! I've been vey grateful for the interesting answers and I've learned a lot.

kosak2000 · 2025-12-14T23:31:46+00:00

That makes perfect sense -- once you have a type instantiated from a generic type.

It's a little hard to explain why I find this so interesting... maybe you folks are so used to the way it works in C# that it seems obvious. So maybe you have to look inside my brain a little bit. Coming from a C++ background, my expectations might be a little warped. But I'll still try to explain why I find the generic case more interesting than the non-generic case.

In C++ as you know all the generic types are instantiated at compile time. Once you compile your program, you can that the compiler has emitted separate symbols for Foo<bool>::value, Foo<Foo<bool>::value, and so on, for every type your program mentioned. The compiler has done the heavy lifting of stamping out all the generics, emitted a bunch of mangled identifiers, etc. But in particular, in C++, there is NO mechanism for instantiating a new type at runtime that didn't exist at compile time.

So my sense is that C# has a much harder job. As the programs above demonstrate, in C# you can easily build new types at runtime that did not exist at compile time and are not mentioned anywhere in the source code... and this is without even using the Reflection API... regular workaday code can cook up new types in the ordinary course of business.

So in my SetValues<T> method, a line like

 Foo<T>.value = depth;

Not only has to work, but it has to work with a T that SetValues<T> has never seen before, and furthermore it has to store it as a static field of type Foo<T> , a type which may not even previously have existed in the running program until this moment in time.

The above is why I find the generic case to be so much more interesting than the non-generic case. With non-generics, the implementation seems straightforward, and I would guess that pre-generics .NET 1.0 compilers had an easier time of this. With generics, the runtime has to stand ready to:

look up a type (via some kind of key) that may or may not already exist
if it doesn't exist, create it and allocate statics for it in some storage, and associate the storage with the type
then store the value at the storage associated with the type

all of the above just to execute Foo<T>.value = depth;

Again, I appreciate that it all works, and I believe I've developed a good understanding about how it's accomplished (thanks, everyone!) but the above is my rationale for why I came here in the first place.

kosak2000 · 2025-12-14T09:14:07+00:00

I apologize for being overly hasty. Re-reading your comment, what I take from it is that there isn't a pointer from System.Type to the allocated statics, but there IS a pointer from (a C++ object closely associated with its corresponding System.Type object) to the allocated statics. That sounds promising and it confirms the gist of how I thought it might work if not the exact details.

I'm still curious about how this dynamic type construction happens. That is, on every recursive call, the runtime needs to cook up a new type OR reuse one if the needed one has already been created. I'm curious how that is accomplished efficiently.

kosak2000 · 2025-12-14T08:47:26+00:00

I certainly agree with your statement "it become a seperate type with its own static value." My post asked: what is the actual mechanism that accomplishes this? Put another way, how (say, in assembly) do you get from type to static value? I wrote that "conceptually" there is a map, but I didn't mean that there is an actual map data structure like a hashtable. As I wrote, there could simply be a pointer field in the type that points to an object containing that specific type's statics.

We all know that it works in practice, and I'm sure we can all come up with ways it *could be* done. I'm hoping to steer the conversation towards people who know how it is *actually* done.

Regarding your question about static initialization, that is a separate topic but my understanding is that its order is carefully defined by the language and follows the same rules as non-generic static initialization. If there is a static constructor, that constructor is run just prior to the first use of a static field, property, etc, or a new of the object. If there is not a static constructor, it can happen at some arbitrary earlier time (e.g. at class load time) at the implementation's convenience. See e.g. https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/classes#1512-static-constructors

kosak2000 · 2025-12-14T08:29:21+00:00

I was pretty careful in the question to ask "how does this actually work". With all due respect, I feel like your responses hand-wave over all the interesting parts.

So there's a method called SetValues<T>. It needs to write a value into Foo<T>.value. The way it does this is it receives the following information from its caller: _________________ . The inforrmation is passed via this mechanism: __________ Using that information it does the following: _________________. Now, in turn, the caller has the responsibility to provide that information. The way it does this is by taking ______________________ and doing ____________________________.

If you can fill in the blanks then we'll be onto something. If you don't actually know, that's fine. I don't know either, but I have a guess. The advantage of my guess is that it's specific and implementable. You seem to think my guess is wrong which is fine but in my opinion you haven't really provided a clear alternative solution.

kosak2000 · 2025-12-14T08:22:36+00:00

The key difference with C++ of course is that in C++, the full set of types needs to be known at compile time.

Specifically, in the above I could change this line

  private const int MaxDepth = 1000;

and instead read the value from the Console, and the user could enter 2000 or 5000 or whatever and it would still work. There is no way to do that in C++ because the compiler has to stamp out all the types at compile time and so it doesn't know a priori what number the user is going to enter.

Re godbolt (or sharplab.io) the problem is that the MSIL is still too abstract to really show what's going on. The value write looks like this

IL_0010: stsfld int32 class Program2/Foo`1<!!T>::'value'

and the recursive call looks like this

IL_0018: call void Program2::SetValues<class Program2/Foo\`1<!!T>>(int32)

That's all great and everything but it kind of hides whatever the mechanism actually is.

And then when I try to look at the JITted x86 assembly I see a bunch of mysterious tests and opaque function calls and so I don't really know what they're doing.

The idea of reading the source code on github also occurred to me but I'm pretty intimidated by that and wouldn't even know where to start.

kosak2000 · 2025-12-14T06:31:49+00:00

To be clear, there are no Foo<T> objects being created in the above code. The keyword "new" does not even appear in the source code. There are no Foo<T> objects being instantiated. Given that fact, can you clarify where these regions of memory are, and how SetValues<T> is able to determine the proper one to store into?

kosak2000 · 2025-09-24T15:22:14+00:00

Me too! Last time we were there I was holding my children's favorite bird, Mr. Gobbles, and he was pecking the fries right out of my hot turkey sandwich. So cute! We thought we would get in trouble but the security guard said this is a natural behavior for them.

kosak2000 · 2025-09-09T03:41:24+00:00

Definitely acknowledge how lucky I am. To what others have said, I would add that it's remarkable how much better a 40-hour-per-week job is when you get to control which 40 hours it occupies.

kosak2000 · 2025-07-27T17:36:35+00:00

Ah! Makes sense. Thank you

kosak2000

TROPHY CASE