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.
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
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
Got you :) I advise you to work on it and get over it - it's far more satisfying to mostly (not always) write about things others are interested in; people find value in your work and you have more impact at the same time; it's an overall win-win.
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?
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).
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.
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?
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:
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.
I apologize for being imprecise. We're aware it's more than just ADL or constexpr, but we had insufficient time to address it at this meeting. It's definitely on our radar, we flagged it as a high priority item.
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.
Do you consider this a C++ language bug that you happen to be able to exploit? Or a necessary result of being able to combine several correctly behaving features?
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.
I kind of hope they don't fix it. I could see this being as useful as the Boost Pre-processor Library. In fact I already know of a place where it would be useful. The Template Unit Test library requires (did require?) you to manually number your tests in sequence as template arguments. This const_expr counter could be used to not need to assign the numbers by hand.
> "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! :-)
This article dives into why that is, and the hidden costs of adding something as simple as /rss.xml to your blog.