Why is it that version managers are always mentioned after the installation instructions?

As much as I want to put this on StackOverflow, I think this particular question fits better here.

I hope this doesn’t sound too petty, but this is something that has always bothered me.

I’ve always wondered why the designers/developers of programming language websites don’t just put version managers right next to the initial setup and installation instructions in their documentation instead of long after, and sometimes quite hidden in the side-notes.

Most people (I would assume at least) follow installation procedures line by line. That being the case, and the fact that you usually have to install the version managers first if you have a need for them; wouldn’t it be more logical to bring the version managers to the user’s awareness right around the same point in the documentation as the language’s installation instructions?

In fact, Ruby is the only language I’ve ever installed that started the installation section with something like:

“some language” Installation Options:

  • Stand Alone Installation Instructions
  • Virtual Machine Installation
  • Installation With A Version Manager

So, as stupid as this might sound, I’ve begun to wonder if there isn’t some reason for this. Obviously, I’m not trying to excuse anybody for not thinking of version management up front, however considering that I almost always forget about version management when coming into a new language, I’d assume that it’s at least sort of common to make that mistake.

So, is this one of those globally common bad design things? Is this even bad design or am I just being whiny? Or is there legitimate reasoning behind this, and if so – what? It seems far too common a practice for it to just be by accident. I mean, who writes up installation procedures, then adds version management instructions at the tail end and not think, “huh, maybe I should put this up at the top.” ?

Does a Buffer Overflow vulnerability always mean a code execution vulnerability?

Since Buffer Overflows always let an evil hacker to write outside the buffer and overwrite the return pointer to a shellcode the evil hacker can place, does it mean that a successful exploitation of a Stack Buffer Overflow always mean the ability to invoke a shell if done the right way? At least in theory, if you assume that DEP and ASLR is not in place.

WordPress plugins always deactivates by itself after “Database is required” loop

After updating the latest update in wordpress, this “Database is required” loop keeps going and it deactivates the plugins. I already tried the solution that the other sites/forums gave which is to have the same db_version in my version.php and wp-options. Up until now, it doesn’t work. Any available solutions?

How can I improve combat so my players don’t always use the strategy of focusing fire on one enemy at a time until it’s dead?

I’m DMing a campaign on 5e with a group of four players. We’re all experienced in RPG in general but not specifically on 5e.

Players are Level 4. Wizard, Fighter, Rogue and Druid, Circle of the Moon.

My players have come to the conclusion that, given the mechanics of the game, is much more effective to focus all the fire power on a creature at a time and avoid spreading damage. Their logic is it really doesn’t matter if a creature has 1 or 80 HP left, as longs a it has over 0, he has all capacity to do damage. In effect, creatures are binary, they are either alive and therefore have full capacity to act, or death, in which case they don’t.

Unfortunately I agree with this assessment but I feel it makes the game less fun. Not because I’m looking for super realistic combat but because it limits the combat strategy to “drop them one at a time”.

As such, they tend to not distribute their efforts or engage separately but, instead, swarm into a single enemy, concentrate all the attacks and then move to the next. This feels to me like the more effective tactic but also the least “fun” and role playing way of doing combat.

Is my players interpretation wrong or am I handling the combat in the wrong way? What am I missing?

Password management with an always password hidden [on hold]

Is there any password management application which hide permanently password for non adminstrator user, even with at autocompletion on web browser ? The idea is to keep password secure from users, they could just copy to the clipboard and paste it only on secure field. This prevent users to write or store somewhere else the password. And this application must worked with iOS, Android, Windows and MacOS.

Is it normal that the service WMI Performance Adapter always starts when launching Chrome browser? Whats the reason

Is it normal that the service WMI Performance Adapter (WmiApSrv.exe) always starts when launching Chrome browser? Whats the reason?

I have heared this service can be maliciously used to “communicate” through the internet via open ports?

When I forcefull end this process in the taskmanager, Chrome keeps running perfectly, without issues.

Could it be that this WMI process is needed because one of Chrome’s features called “Conceal local IP addresses with mDNS hostnames”?


Do compilers of high programming languages always compile them directly to machine code?

As an amateur Bash/JavaScript scripter who never wrote one sentence in Assembly, I ask:

Do compilers of high programming languages always compile them directly to machine code, or are there cases when a compiler of some high programming language compiles it to assembly (and then assembler will assemble input to machine code output)?

Are these special (one production) Context-Free Grammars always unambiguous?

Consider the following (Context-Free) Grammars with only one production rule (not including the epsilon production):

  • $ S \rightarrow aSb\;|\;\epsilon$
  • $ S \rightarrow aSbS\;|\;\epsilon$
  • $ S \rightarrow aSaSb\;|\;\epsilon$
  • $ S \rightarrow aaSaaSbb\;|\;\epsilon$
  • $ S \rightarrow aSbScSdSeSf\;|\;\epsilon$
  • etc…

Grammars like these uphold 4 basic rules:

  1. The non-terminal symbol $ S$ can never appear next to itself.
    • e.g. $ [\;S \rightarrow aSSb\;|\;\epsilon\;]$ would not be allowed.
  2. The non-terminal symbol $ S$ can appear at the beginning or end of a production but not on both sides at the same time.
    • e.g. $ [\;S \rightarrow SabaS\;|\;\epsilon\;]$ would not be allowed.
    • e.g. $ [\;S \rightarrow Saba\;|\;\epsilon\;]$ or $ [\;S \rightarrow abaS\;|\;\epsilon\;]$ would be allowed.
  3. The sequence of terminal symbols that exist between each non-terminal $ S$ cannot all match.
    • e.g. $ [\;S \rightarrow aSaSa\;|\;\epsilon\;]$ , $ [\;S \rightarrow abSabSab\;|\;\epsilon\;]$ , etc. would not be allowed.
    • e.g. $ [\;S \rightarrow aSaSb\;|\;\epsilon\;]$ , $ [\;S \rightarrow abSabSaf\;|\;\epsilon\;]$ , etc. would be allowed.
  4. The sequence of terminal symbols at the beginning and end cannot match.
    (i.e. $ [\;S \rightarrow ☐_1SaS☐_2\;|\;\epsilon\;]$ s.t. $ ☐_1 \neq ☐_2$ where $ ☐_1$ and $ ☐_2$ are a sequence of terminal symbols)
    • e.g. $ [\;S \rightarrow aSbSa\;|\;\epsilon\;]$ , $ [\;S \rightarrow aaSbSaaS\;|\;\epsilon\;]$ , etc. would not be allowed.
    • e.g. $ [\;S \rightarrow aSbSb\;|\;\epsilon\;]$ , $ [\;S \rightarrow aaSbSaxS\;|\;\epsilon\;]$ , etc. would be allowed.

Are (Context-Free) Grammars, that follow these 4 rules, always unambiguous? It would seem so. I really don’t see any conceivable way that such Grammars could be ambiguous.

(Note: To show why Rule 4 is necessary consider the grammar $ S \rightarrow aSbSa\;|\;\epsilon$ with the string $ aababaababaa$ . A visual derivation can be found here.)

I’ve spent a lot of time thinking about this question and have had a hard time finding any way of either proving or disproving it. I’ve tried showing that Grammars like these are $ LL(1)$ . However, it seems only Grammars of the form $ S \rightarrow aSb\;|\;\epsilon$ are $ LL(1)$ . Grammars like $ S \rightarrow aSaSb\;|\;\epsilon$ are not $ LL(1)$ . Maybe I need to use a higher $ k$ for $ LL(k)$ ?

(This question is a follow-up/reformulation of a previous question.)

I would really appreciate any help I could get here.

Do integrity and authentication always come together?

I cannot come up with a case where there is only one of them.

When there is integrity, a random person cannot modify the message without being noticed. That is, an unauthenticated user cannot modify the message without being noticed. Therefore there is authentication.

When there is authentication, nobody except the sender can change the message after MAC or signature is added. Therefore there is integrity.

Am I missing something?