Live boot error – ASPM could not configure common clock

I have followed the procedure in to create a bootable USB with ubuntu-18.04.3-desktop-amd64.iso. The USB boots fine on an old Dell PC but when I boot from it on an old Asus P6T based gaming machine that has Windows 7 and Windows 10 installed I get this error message (and no others) during the boot sequence, and the sequence then hangs.

[ 1.355109] pci 0000:07:00.0: ASPM: Could not configure common clock

I have done an internet search for this message but found very little. What there is suggests the issue may have to do with having a PCIe NVIDIA graphics card (GeForce GTX 460) installed or VT-d enabled. However, I have updated to the latest Nvidia driver and checked the VT-d setting in BIOS (it was already disabled), to no avail. I have also checked the Windows logs for any kind of PCI/PCIe issue but found nothing.

Can anyone suggest what to look at next?

What common combat actions does the Fascinate status effect block?

The Fascinate status effect says that it prevents a creature from using actions with the Concentrate trait. Casting a spell with a verbal component is included here, which seems to be the most common action a creature might use in combat, so at first glance it seems like Fascinate is primarily useful for disabling spellcasters.

I want to know if it has any other common combat uses apart from disabling spellcasters. It’s rather difficult to catalogue all the other actions with the Concentrate trait, however. From a cursory glance, the Barbarian’s Rage action, as well as the Command an Animal actions both have the concentrate trait.

Are there any other common actions that non-spellcasters might use in combat, which have the Concentrate trait?

C++ How to build a common interface with the possibility to call functions specific to only one class

I am building a common interface for several different backends that are shared libs loaded at runtime dependend on the used platform. It looks basically like the code below. My problem is, that while 90% of the functions of all backends are the same (just different implementations but same purpose) some of them have features that are not available to other platforms at all.

If I had a wrapper function for all features than they would run into the void for backends that do not support them which I want to avoid. I also don’t like the idea of having implementations of backend functions that just return errors.

What would be a good way to have a generic common interface while still being able to call functions specific to a backend if the user wants to limit his application to that platform?

class CommonInterface {     void DoA(); // Calls InternalDoA() of loaded backend      void DoB(); // Calls InternalDoB() of loaded backend      void DoC(); // Calls InternalDoC() of loaded backend ??? };  class BackendOne {     void InternalDoA();      void InternalDoB();      // DoC does not exist! };  class BackendTwo {     void InternalDoA();      void InternalDoB();      void InternalDoC(); }; 

Thanks a lot in advance!

What are the common conversational design patterns used by voice-based assistants like Siri, Alexa, Google Assistant and Cortana?

Conversational UI is common in IoT and other connected devices these days, not to mention smartphones and also computers. The main players in the market would probably be Siri from Apple, Alexa from Amazon, Google Assistant and Cortana from Microsoft.

It is typically rare for someone to own products from all of these vendors, but I wonder if there are some common conversational design patterns that are shared by these types of devices in the way they interact with the user, or if they are designed to behave differently to suit the particular target market or group, and where these differences might be.

The specific areas that I am thinking about from a user experience point of view are:

  • Choice of default voice (and variety available for customization)
  • Language used to trigger specific actions
  • Type of language used by voice assistant to respond
  • Type of audio cues and indicators for specific actions/status

Can/should multiple application contexts share a common microservice in a single namespace?

My current employer has a single namespace into which all microservices for all projects are deployed.

Projects A, B and C all use microservice x in this common namespace:

enter image description here

Rather than each design and implement their own microservice that performs the same behaviour (for example for some common domain object CRUD operations against a database), Projects A, B and C all use and claim shared-ownership of a common implementation – microservice x – and service it in accordance with their project requirements.

Projects are upsetting the shared ecosystem for each other when deploying revised versions of x (downtime, breaking changes).

I am unclear if this is an example of what Kubernetes best practices considers to be an example of an “overcrowded namespace” anti-pattern – I am thrown by the fact that each project utilises a common microservice and I thought one of the points of microservices was to expose common things in a kind of public way like this?

Is it appropriate for this “public exposure” to manifest as a single service instance in a common namespace?

Or should the namespaces split apart and they all have their own deployment of microservice x like this?

enter image description here

How to decide if two conjunctive queries cannot have any result in common

Consider the following queries:

Q1: age > 18 & age < 24 & gender = ‘male’

Q2: age > 25 & gender = ‘male’ & major = ‘CS’

Q3: age = 20 & major = ‘CS’

Clearly, given any database instance $ D$ , we can decide $ Q1(D) \cap Q2(D) = \emptyset$ and $ Q2(D) \cap Q3(D) = \emptyset$ . However, we cannot decide about the result of $ Q1(D) \cap Q3(D)$ .

I’m aware of query containment, in where the result of one query always is a subset of the results of another query. Also, I’m aware of query equivalence, in where the results of two queries should be exactly the same given any database instance.

However, I’m looking for an algorithm/terminology for my case, where before evaluating the two queries, I can decide the intersection of their results are always empty. Indeed, due to conflicting selection conditions, they cannot have any common result.

What’s the most common way to handle API integration?

I work with some not-monolithic applications, meaning that at some level, it depends on other applications to do the work. At the moment, each application on our stack, when there is an API change, generates a new API SDK, that can be used by other applications that rely on it. The issue is that this adds an explicit dependency and another thing to maintain, since the API needs to be generated.

I read that our current approach should be avoided when building microservices and that’s our main goal. The other approach is to have a well defined API and the services that rely on it should handle the API integration by themselves. But if more than one application has to build it’s integration layer, code gets duplicated across applications and it’s also time consuming when the team could be building features.

What’s the best approach when working in such environment?

Edit 1: The main concern is that every API change requires the API SDK to be generated (we do that with Swagger) and published to our internal maven repository). I wonder if there is more transparent way of doing that.

efficiently calculate nearest common ancestor in a family tree (each person has two parents)

I’m well aware of ways to efficiently calculate the lowest common ancestor in a tree of nodes which converge to a single root (ie, each node has only one parent). Just iterate back to root for each person, then walk back from root tossing off anything common.

In a matriarchal society, for example, this could be used to quickly calculate how any two people are related as long as only the mothers are considered.

But if both parents are considered, eg mother AND father, then the algorithm just described breaks down.

So I wondered is there an algorithm to tell two people how they are related in a family tree where both parents are considered? For example, see the Icelandic genealogy app ( which does precisely that. How’s it done, algorithmically speaking?

How to go ahead with methods that only one derived class implements from a common interface?

I have one interface (let’s say in C++) that has been implemented by some derived classes. Let’s suppose that the interface is like this:

class IBase {   virtual bool method_1() = 0;   virtual long method_2(const std::string str) = 0;   // other methods   virtual long method_10(int value) = 0; }; 

and up to now 6 different derived classes (will be more in future) have implemented the interface. In lots of algorithms in my code, I have used this interface polymorphically. e.g:

// some usage obj = getObject(); if (obj->method_1()) {   return obj->method_2("Hello"); } else {   return obj->method_10(12); } 

Over the time, I have found that there would be lots of methods that only one derived class implements them. So, the Q is that is it the right design to put these methods in the interface or should I put them directly in the derived classes? But note that:

  • If I put them in the interface, only one derived class will implement them and for the rest of the derived classes the implementation will be empty.
  • If I put them in the derived classes, my implemented algorithms will not be generic anymore and I need to check the type of the derived class during my algorithm implementation.

What is the right way to go ahead in this case?

Outlook rule to forward all emails – is that a common scam?

Recently we had a security problem. One email account which is based on MS Exchange 365 was hacked and the hacker forwarded all emails per rule to a Gmail account.

I checked all relevant PCs and I didn’t find any viruses. And I changed the passwords. But in this case changing the passwords didn’t change anything because the rule which forwarded all the emails also worked after I changed the passwords. The forwarding only stopped once I discovered that such a rule was setup and then I deleted the rule.

How common is this hack? I never heard or read about it before. It is also still a mystery for me how the attacker accessed the email account. Probably he stole the password somewhere but I can’t figure out how.