## Is it necessary to export features with a version number?

By default, modules generated with features are created with a version string in the *.info file.

I think the convention is to increase this version number when the feature changes.

In a distributed development work flow with a lot of merging, a linear version increment is not a useful model or metaphor.

Is the version number, and incrementing it, useful or necessary for anything?

I work in a project where until now almost none of the features has version number. But recently a colleague reported problems reverting the features on deployment, if they don’t have a version. Of this could be pure concidence, and caused by something other than the missing version number.

## Question about Restricting Features and LIcensing

We have a product that contains features (Let’s say feature A, B and C).

We are about to move it to production (a web application) for a certain client.

However, as per my boss, we will deploy the product to the client’s premises. The client will also have the source code.

Now, my boss wants to restrict the features for that certain client. He wants to restrict the feature A, so that only features B and C would be available to the client.

So what are our options? How can we do this technically(restricting features) and in terms of licensing?

## Can you multiclass the same class twice for different class features?

The way that 5e works, each class has a sub class that dictates a heap of class features. The question here is generally, can a character of a specific class take levels in that same class in order to gain access to the low level features of another sub-class.

The best example of this would either be the wizard or the cleric taking additional levels of wizard/cleric in order to gain access to another domain or school.

Like can a Life cleric take levels of Storm cleric or similar?

If this were allowed, what would the effects be on Maximum spell level and other class level based abilities?

## Can I use Megamagic (or other spellcasting features) on a spell that I gained from multiclassing? [duplicate]

This question already has an answer here:

• Does a sorcerer's metamagic work for non-sorcerer spells? 3 answers

As I understand it, class features only apply to spells you gained through that class. For example, I can’t use the Distant Spell metamagic on, say, Cure Wounds, if I gained Cure Wounds from being a bard. Am I correct in this?

Speaking as both a player and DM here. I wanna know what I can build around.

## Creating a lock-free memory pool using C++11 features

I have created a thread-safe and lock-free memory pool program using C++11 features. A couple of notable features:

• `g_memStack` is a stack that contains the memory unit; we can allocate memory from it.
• `g_waitingReclaims` is something like a stack that contains units waiting reclaim from the memory unit.
• `g_allocatingCounter` is a counter to specify the thread number in the `Allocate` function. It will have a value of 1 to indicate that there is no other thread waiting to allocate memory from the pool. This indicates that it is safe to reclaim memory in `g_waitingReclaims`.

I am looking for a review of both correctness and style. Specifically:

• Is there anything wrong with the memory ordering in `g_allocatingCounter.fetch_add(1, std::memory_order_relaxed` (the first line in the `Allocate` function?)?

• Is it possible that the next line (`MemUnit *unit = g_memStack.load(std::memory_order_acquire);` could be re-ordered to execute first at runtime?

• If so, how would I fix that? Could I just change the memory order to `std::memory_order_acquire`? Would that require another release operation to cooperate with it (I don’t think so, because cppreference said `std::memory_order_acquire` will prevent read and write from reordering before it)?

• Anything else?

``#include <string> #include <thread> #include <vector> #include <cstdlib> #include <atomic> #include <cassert>  struct MemUnit {     MemUnit *m_next;//next unit     void    *m_data;//memory for data };  void                    *g_buffer{nullptr}; std::atomic<MemUnit *>  g_memStack{}; std::atomic<MemUnit *>  g_waitingReclaims{}; std::atomic<uint32_t>   g_allocatingCounter{};  void InitMemPool(size_t poolSize, size_t blockSize); void UninitMemPool();  MemUnit *StepToTail(MemUnit* listHead); void Reclaim(MemUnit* listHead, MemUnit* listTail); void GiveBackToWaitings(MemUnit* listHead, MemUnit* listTail);  MemUnit *Allocate() {     g_allocatingCounter.fetch_add(1, std::memory_order_relaxed);//Warning: Something wrong with the memory order. It maybe reorder after the next line at runtime.     MemUnit *unit = g_memStack.load(std::memory_order_acquire);     while (unit != nullptr && !g_memStack.compare_exchange_weak(unit, unit->m_next, std::memory_order_acquire, std::memory_order_acquire));     if (g_allocatingCounter.load(std::memory_order_relaxed) == 1)     {         MemUnit *pendingList = g_waitingReclaims.exchange(nullptr, std::memory_order_acquire);         const bool canReclaim = g_allocatingCounter.fetch_sub(1, std::memory_order_relaxed) == 1;//this operation can not reorder before exchange operation Just because the 'memory_order_acquire'         //If 'canReclaim' is true, it's ABA problem free. Because there is nobody in 'Allocate' hold same pointer within pending list.         if (canReclaim && pendingList != nullptr)         {             canReclaim ? Reclaim(pendingList, StepToTail(pendingList)) : GiveBackToWaitings(pendingList, StepToTail(pendingList));         }         return unit;     }     g_allocatingCounter.fetch_sub(1, std::memory_order_relaxed);//this operation can not reorder before 'compare_exchange_weak' Just because the 'memory_order_acquire'     return unit; }  void FreeMemUnit(MemUnit* item) {     item->m_next = g_waitingReclaims.load(std::memory_order_relaxed);     while (!g_waitingReclaims.compare_exchange_weak(item->m_next, item, std::memory_order_release, std::memory_order_relaxed)); }  MemUnit *StepToTail(MemUnit* listHead) {     assert(listHead != nullptr);     while (listHead->m_next) listHead = listHead->m_next;     return listHead; }  void Reclaim(MemUnit* listHead, MemUnit* listTail) {     listTail->m_next = g_memStack.load(std::memory_order_relaxed);     while (!g_memStack.compare_exchange_weak(listTail->m_next, listHead, std::memory_order_release, std::memory_order_relaxed)); }  void GiveBackToWaitings(MemUnit* listHead, MemUnit* listTail) {     listTail->m_next = g_waitingReclaims.load(std::memory_order_relaxed);     while (!g_waitingReclaims.compare_exchange_weak(listTail->m_next, listHead, std::memory_order_relaxed, std::memory_order_relaxed));     //Yes, it's 'relaxed' memory order when it's success. }  void InitMemPool(size_t poolSize, size_t blockSize) {     const size_t unitSize = sizeof(MemUnit) + blockSize;     g_buffer = reinterpret_cast<uint8_t *>(std::malloc(unitSize * poolSize));      MemUnit* next = nullptr;     uint8_t* rawBuffer = reinterpret_cast<uint8_t*>(g_buffer);     for (size_t i = 0; i != poolSize; ++i)     {         MemUnit* pObj = reinterpret_cast<MemUnit *>(rawBuffer);         pObj->m_next = next;         next = pObj;         rawBuffer += unitSize;     }     g_memStack.store(next, std::memory_order_relaxed); }  void UninitMemPool() {     assert(g_allocatingCounter.load(std::memory_order_relaxed) == 0);      g_memStack.store(nullptr, std::memory_order_relaxed);     g_waitingReclaims.store(nullptr, std::memory_order_relaxed);     std::free(g_buffer);     g_buffer = nullptr; }    void WorkThread() {     for (size_t i = 0; i != 128; ++i)     {         MemUnit *unit = Allocate();         if (unit != nullptr)         {             //do something use unit.m_data;             FreeMemUnit(unit);         }     } }  int main() {     InitMemPool(128, 1024);      std::vector<std::thread> allThreads;     for (size_t i = 0; i != 8; ++i)     {         std::thread t(WorkThread);         allThreads.push_back(std::move(t));     }     for (auto &t : allThreads)     {         t.join();     }     UninitMemPool();     return 0; } $$```$$ ``

## Can something be a Minimum Viable Product if it lacks features that will be necessary for sustainability?

I’ve heard various definitions of minimum viable product (MVP), but they all focus on a simplified, yet useful, version of the final product.

My team is building a product that currently appeals to a small group of people with special interests. We’re hoping that by integrating with other, existing platforms, we’ll be able to gain interest from a much larger audience. The latter step is critical to our business plan; the product can’t sustain itself unless we can reach the larger audience. It’s also the hardest part of the process and will take the most time.

Once we have a prototype without the systems integration, we’ll be able to test it with members of our core audience and start iterating on the functionality and UX. However, we’ll still need to do more testing with different audiences once the integration features are developed.

Would the version without the integration be considered an MVP? Or, since it lacks functionality necessary for our ultimate survival, would this be a useful test prototype but still short of MVP?

note: this is a simplified description of our product / plan, so I’m not seeking substantive feedback. I’d just like to better understand the concept of MVP.

## Microsoft email servers “require remote control of Android device security features”

Just tried to set up my student email address with the default email client on my Android device. The email servers used by the university are `outlook.office365.com` (incoming) and `smtp.office365.com` (outgoing). So I set it up like I always do with a new account, but at the very end I was presented with an alarming ultimatum:

Unusual. But okay, sure.

Slightly concerning, but it’s probably nothing.

???

I’m not usually one to freak out about smartphone app permissions, but this is different. This is directly from a Microsoft server. This is crazy. I just want to check my email. Why does that require me to surrender these remote administration capabilities to Microsoft? What is going on? Is it normal? Is it safe? Is it ridiculous; or is it nothing?

## Latest NBA News, Opinion and Features https://hdvstvon.co/76ersvsbucks/

Latest NBA News, Opinion and Features
https://hdvstvon.co/76ersvsbucks/
https://hdvstvon.co/kingsvscavaliers/
https://hdvstvon.co/lakersvswarriors/
——————-
https://hdvstvon.co/melvsess/
https://hdvstvon.co/essendonvsmelbourne/
——————–
https://hdvstvon.co/greenbayvsmarshall/
https://hdvstvon.co/marshallvsgreenbay/
https://hdvstvon.co/lipscombvstexas/…

Latest NBA News, Opinion and Features https://hdvstvon.co/76ersvsbucks/

## Improve Your Masculinity Features

Using my expertise in Vandafil, I developed a system to handle Power Health Body so that we must increase spending. I have been giving a few serious consideration to Vandafil. Take that wisdom very seriously. Aside from that, this takes the prize.
Some of you don't have the time for a Vandafil that establishes a scene for a Vandafil. Just take the time to glance at that case study. It's rarely worth it for me to…

Improve Your Masculinity Features

## how to introduce new features to players

I made really big changes to my game and obviously want all the existing players (as well as new ones) to start using the new features I’ve implemented.

It’s an MMORPG.

The updates make a lot of drastic differences to lots of parts of the game, and change a few fundamentals.

I am wondering whether I should:

1. Let old/high-level players continue from where they left off, and they will learn about the new features as they try to play the new expansion.
2. Force the old/high-level players — when they rejoin — to complete the new tutorial (that all new players will do).

I am worried with 1 that maybe they will find it overwhelming, or with 2 that they will be frustrated they can’t just get stuck into the game.

I feel like generally the best way to introduce players to features is to have them learn it by “doing”, like to progress through the world and learn the skills etc. necessary for the encounters they have “naturally”, in a way.

Is my intuition right? Does that suggest that letting the experienced older players continue from where they left off and pick up the updated content as they play is a better idea? (leaning towards 1?)

What should I do here? (And please if you can provide sources/references, I am v interested in the study of UX)