refp

The TLDR is that I back in 2015 published some C++ related posts that got way more traction than I originally anticipated, and given the subscriptions to the RSS-feed I felt like I could not live up to the contents people perhaps expected.

On the other hand, I have no idea what people _actually_ expected to be published, but in my head I have for what it's worth created this nightmare scenario where I post something not related to C++, and all those readers would be /pinged and disappointed.

Impressions and clicks are a confident booster, though the fear of disappointing or letting people down because they expect "better" content is something I for sure struggle with

For me it boils down to the fact that rss-feeds propagate without any knowledge or control. One left-over subscription somewhere can ping so far, whereas a manually copied link (like if someone reads an article and decide to share it) at least is an isolated event.

It is not the author of the RSS who "disturbs" sleeping agents, it is simply the one who actually forwarded the message. If that makes sense?

Solid advice for sure, and ignorance is bliss but damn does this nuddle of mine (brain) make it difficult at times; "no logs for an httpd? you cray-cray-crazy? what if something happens!?"

Perhaps I need some further self-reflection, because I fear that with no logs I would assume the worse and end up in the same boat. Though.. maybe it is time to grow up? No idea, weirdly enough this problem is one of the hardest I have ever faced

Ever since I first started blogging I have struggled with performance anxiety, and I have concluded that much of this boils down to me adding an RSS feed to my site.

This article dives into why that is, and the hidden costs of adding something as simple as /rss.xml to your blog.

I have recently switched to mozilla thunderbird, and one of the <3 moments is definitely the builtin RSS-reader (which I use extensively now that I have it easily accessible on my third monitor).

Sadly I never finished that blog series due to severe suicidal depression (ended up being hospitalized for several months), but I do have a toy implementation of that laying around somewhere.

Currently abroad for my primary profession (fashion model), but as soon as this current job is finished and I'm back home I could look for it and ping you.

Any preferred channel where I can reach you, or do you prefer me replying here?

No, but in general, issues like this boils down to grouping too many actions into the same visual category (when they are not acting upon the same entity).

As an example, I often see software where modification of the current entity is grouped together with actions that are really _making use of_ said entity.

Whenever I see "delete" next to "reply" in communicational tools a red flag is waved high. It's a disaster waiting to happen.

In the "delete" scenario the problem is often circumvented by having a confirmation dialog - but other more subtle bloopers often go overlooked.

you are correct. (DISCLAIMER: I am the author of what you are referring to)

For those who are looking to understand what is going on, I would recommend the blog series I wrote -almost- more than half a decade ago at https://b.atch.se

Compiler intrinstics havet changed a lot since then, but the wording in the standard remains quite stable in this department

Disclaimer; I did not read your post in full (on set, working atm).

Edit: time flies, it has been more than half a decade.

A detailed post that shows how to implement a stateful meta-container that is usable where a constant-expression is required, effectively making it possible to store away different states during compilation of a program. The approach enables the world of meta-template programming to closely follow the semantics of imperative programming.

This post is part of the series regarding non-constant constant-expressions in C++, previous posts are linked below:

* http://b.atch.se/posts/constexpr-counter/

* http://b.atch.se/posts/non-constant-constant-expressions/

I just submitted a request to join the reflector where I know this is being discussed; nonetheless, information will be published on http://b.atch.se as soon as I have had time to write the contents of new posts.

I have been trying _very_ hard to get in contact with the folks that are discussing this approach; just preventing ADL constexpr tricks (through "friendly definitions") isn't enough.

I am still waiting for the relevant parties to reply to my emails, but an article explaining "everything" (and the different approaches (about 3 at the current time, in addition to "friendly definitions") will be published soon.

There is a lot of wording that has to be changed in order to prevent the semantics explained.

It is part of both, the technique described is not the only way to reach a solution for the given problem (implementing a counter usable in constant-expressions).

In other words; if one sees this as a "bug" in the ISO C++ Standard, the "problem" is a lot deeper than friendly definitions (the technique used in the post).

C++ is a complex language, where many rules touch upon other, and with that it is not surprising that some rules can be bent to allow behavior which was perhaps never intended.

Future posts (probably after part 3) will address the philosophy of the "exploit", other techniques that boil down to doing the same thing, as well as proposed (ISO Standard) wording to "fix" the "problem" - if that is the path being walked.

This is the second post in the series regarding "non-constant constant-expressions in C++" - http://b.atch.se/posts/non-constant-constant-expressions/

Feedback is more than welcome!

/Filip Roséen

> "This lack of dependency must inherently mean that it will yield the same value upon each invocation having the same set of arguments"

That quote was written in a "this is what most of us used to think" sort of way, it was never intended to be read literally - though maybe I should clearify the intent.

I certainly agree with your post, and your little hack is very cute; +1! :-)