For me it’s even more about the mental model than tooling, but yeah, it’s good to have separate IDEs here 😉

It must have changed recently so that now you need to log in. But yeah, any app that can do a similar thing would do the job here 🙂

happy to hear that 😀

You may need to restart the vscode

I have no specific advice regarding Terraform, I guess you need to do some trial and errors yourself.

Hi @Dawid Sibiński

While I am working with Terraform script in VS Code, when I Hover on any Terraform script filed it should show me that particular data type of the field, but it is loading infinitely, can you please me on this issue

thanks for sharing!

good to know, thanks for sharing!

No worries! 😌

Hi, unfortunately, I’m not planning any updates here soon. I am sure you’ll find all info in the docs or on StackOverflow 🙂

wow, thanks for sharing that Pat! May be helpful to many people out there 🙂

Ultimately I moved my scratch .js and .json files into a hidden folder (this is linux so I just put a . in front of the foldername), closed VSCode, killed the pids of the hung processes one more time, and then restarted VSCode.

take it easy, man 🙂 This is just a metaphor, I even put it in double quotation (“superset”). This is only to illustrate a concept, you don’t have to take everything literally 🙂

Enjoy! 🙂

Weirdly enough my older phone work just fine connected to wifi while playing on bluetooth headphone all the time before. It just doesn’t make sense but it is what it is haha. Also thanks for the explanation!

You’re welcome!

Hi Dmytro, thanks for your comment.
Extremism is always bad 🙂 I don’t recommend wrapping every library. I wouldn’t even think about abstracting stuff like mobx or react-hook-form. This would lead to – as you mentioned – having hundreds of wrappers with probably more logic inside the wrappers themselves than the actual library provides.

Referring to your first remark – if the wrappers are implemented incorrectly, i.e. having a lot of logic inside them instead of only exposing the 3rd party code with minimum amount of own code, then I’d agree it is a nightmare debugging this. However, to me, a wrapper should be minimalistic in a way that no documentation is needed for it. It only acts as a proxy to the external code. I create wrappers only for stuff that can be exposed via simple API, without much additional logic inside.

Regarding the second point – I had pretty different experiences here 😉 I saw external libraries used so extensively in the code that no one would even think about replacing them. And that’s often problematic.
If you need to change your wrapper’s API because of the changes in the wrapped library, then you either didn’t think abstract enough when creating the wrapper or you shouldn’t have created it in the first place (see my previous remarks about what not to wrap).

Wrappers’ role is not only to hide the 3rd party implementation details. They let you think first, use later. First: think which features of a library you might need, try to abstract them (in a form of contract). Later: use the contract’s implementation(s) in your code.

This works in only one particular case – if you are ready to support and spend time on documentation for your wrapper. Elsewhere, it will cost you (mostly new developers in a team) a lot of headaches.

De nada! 😉

happy to hear that, Adri! 🙂

That sucks 😐

no worries, glad it helped!

I’m happy to hear that! 😉

I’m happy to hear that! 🙂

you’re welcome!

hey, I’m not an expert here, just published my way to diagnose and fix the issue 🙂 Try with different WiFi channels and see if that helps.

Glad you liked it!

Thank you Rayan 🙂

Hey Crizzyeyes,
thanks for your insights.

“What makes a person suited or unsuited for the diet?”
I think it’s mostly the environment in which a person operates. There are thousands of people who are simply interested in politics, news in general and they enjoy reading multiple news websites even to get various points of view. I don’t, so I don’t spend time on it. Everyone would probably have different “diet” depending on situation and point of view. I guess everyone is suited for such low-information diet, but defined differently and with different rules (everyone probably could spend his/her time more efficiently).

Regarding Twitter – maybe it will (or is already) becoming “poisoned”, but what I meant is that following hashtags on Twitter you can quickly see a lot of opinions (tweets have characters limit) so you can much quicker get a lot of different points of view. So even if some tweets are paid by TV/newspapers, you’re able to quicker filter it out and form your own opinion on a particular topic.

Hey Oleg,
thanks for sharing this criteria, it’s also a good approach 🙂

I use a slightly different criteria – whether value I get (valuable for me) from following this person is greater than amount of irrelevant (for me of course) stuff produced by the same person.

This strategy doesn’t work if everyone were to follow your “low information diet” strategy, because no one would be reading the news. So clearly there is a need for an “outsider person” who does not follow this diet for this diet to work in the first place, which I find interesting. What makes a person suited or unsuited for the diet?

“What’s more, Twitter provides more realistic information, in most cases published by people who are on-site when something happens, so it’s not poisoned or already influenced by public media.”

I wouldn’t count on this. I think it’s a mistake to assume that this will continue to happen as-is. There is a lot of incentive for the “public media” to push back against this, and they have, in some ways. Eventually you may find yourself coming to trust a Twitter account, only to later find out that they were actually being paid off by the BBC for years, just for example.

Right, such statement could be much more accurate in 2011 🙂

Right, such statement could be much more accurate in 2011 🙂

Thanks guys.
@adamfurmanek:disqus indeed, I should rather use 85,000 bytes terminology. Sometimes forgetting we’re on Windows and with Microsoft, so using 1KB I should assume 1024 bytes 😉

Thanks Konrad.
Hmm, you’re probably right, it was not very clear for me. I’ve just verified in ‘Under the Hood of .NET Memory Management” which says “In fact, for performance reasons, .NET preferentially allocates large objects at the end of
the heap”. That’s probably because it’s quite on old book (2011), while LOH handling was optimized a lot in .NET 4.5.

However on the schemas presented on https://docs.microsoft.com/en-us/dotnet/standard/garbage-collection/large-object-heap it seems as you said, so:
1. Try to allocate in the free memory blocks
2. If no free memory chunks large enough found – try to allocate at the end of the heap (and request more segments from the OS if necessary)
3. If point 2. didn’t work – perform a full GC hoping that some more objects get reclaimed.

“garbage collector prefers to allocate new large objects at the end of the heap”

This is generally quite misleading – in fact GC always prefers to make use of fragmentation first.

Btw such arrays of doubles are allocated in LOH only in case of 32-bit framework, which is a small detail probably worth calling out.

> not 10626 elements as could be expected
Just nitpicking 🙂 I think it should be 10624, this gives 10624 * 8 doubles + 4 for sync block + 4 for type handle + 4 for size = 85004.

You’re right, it’s included in the Quick Actions 😉 Thanks, didn’t know this one!

Code snippet is provided probably in the newest VS, I discovered it after I read your post 😀
https://uploads.disquscdn.com/images/4291fb8a8c917ae048fd65877302645419ec403ef5c45434d1e2491a30e1f70b.png

Hey Matteo,
I guess you’re getting this “tree” too literally here. In fact, it’s more like a graph. Don’t treat it as a proper binary tree or something like that. It’s just a “network of references”, while each reference allocated on the stack is a separate GC root.

Thanks for clarifications Konrad 😉
Hope it’s clearer now for Jim and everyone else interested.

`GC.SuppressFinalize` is designed to be called from user threads so its overhead needs to be as low as possible. Thus, the only thing it does is what documentation says – it sets single bit in an object header (look for `BIT_SBLK_FINALIZER_RUN` in CoreCLR if you are really interested). Any manipulation on finalization/fReachable queues would require synchronization between threads, the overhead of which we want to avoid.

This bit is then checked by the finalization thread but only for objects in finalization queue that just become unreachable – if set, it simply removes the object from the finalization queue instead of promoting it to fReachable queue.

The only way to call `GC.SuppressFinalize` on an object in fReachable queue is from its `Finalize` method which is obviously too late (finalization is just happenning). Bit would be set but it doesn’t matter as there is nothing that would interpret it afterwards.

Hey Jim,
good point.
Microsoft docs says: “This method sets a bit in the object header of obj, which the runtime checks when calling finalizers”

However if you think about it, in my implementation GC.SuppressFinalize(this) can be called either directly from code (when the object is still referenced by something, meaning the reference is present on the finalization queue) or by the “finalization thread”, when the reference will be already moved to fReachable queue. So I guess in fact it removes it either from the finalization queue or from fReachable queue, depending when the method is called.

On the other hand I don’t find any more details on a bit flag mentioned in Microsoft docs. The “GC cycle” is passed anyway – as I wrote “finalizable objects stay uncollected for at least 1 more GC round than “normal” objects”.

Anyway, the goal of calling GC.SuppressFinalize is to prevent your object to be finalized twice.

Is the object reference removed from the fReachable queue or the finalization queue, or both? Removing it from the fReachable queue doesn’t seem all that helpful, as the first opportunity to be GCed has already passed.

Hey Wojtek,
thanks for your comment! 🙂
As you know, Dispose is just a pattern and there may be multiple implementations, each one probably better for different use cases (it depends for example is your class is sealed or not). However, I’ve added the link you mentioned into the post so everyone can take a look on this implementation. I guess Microsoft contributors are worth trusting 😉 Thanks for pointing it out!

Can you also direct us to the VS snippet? What’s the name of it and how to use it?

My pleasure! I look forward to the review of the book 😉

Thank you for your valuable comment Konrad 🙂
I modified the article a bit in these misleading places according to your remarks.
Looking forward to your book assuming you dig into these details that deeply 😉

Cheers!
Dawid

“after the full GC cycle generation 0 and generation 1 become empty”

Nope. During full GC objects from gen0 are promoted to gen1 so it does not have to be empty.

“normally using static data should be avoided as much as possible and reasonable”

Long living objects in gen2 (like statics) are not a problem by itself. Just by the fact that they are there does not mean full GCs will be triggered. The main problem are objects that are living just long enough to be promoted to gen2 (possibly triggering full GC) and die there soon (putting the work on the GC)

“card table stores this information per “bit”, which represents 128 bytes of managed memory”

128 bytes in 32-bit, 256 bytes in 64-bit. And due to write barrier optimization, no single bit is manipulated but the entire byte. So, in fact making such older-to-younger reference marks 2048 bytes as potential roots region.

Hey Jelena,
I’m glad you find them useful 😉 Sure, thanks for noticing that topic, I’ll try to mention it in one of the coming posts on garbage collection.

Take care,
Dawid.

You’re welcome!