## dnd 5e – How do Ethereal objects/creatures work on the Outer planes?

Looking over some creatures that spend time in the Ethereal plane such as Ghosts and Night Hags, they are able to move between the Ethereal and Material planes, so they would be acclimated to both sorts of environments. As you mentioned, the Ethereal doesn’t border the outer planes, these creatures being pushed into one of the outer planes and losing this ability to go between Ethereal / Material planes could be their biggest detriment.

On DMG 49, these Ethereal creatures would be used to non-physical travel:

Traveling through the Deep Ethereal to journey from one plane to another is unlike physical travel. Distance is meaningless, so although travelers feel as if they can move by a simple act of will, it’s impossible to measure speed and hard to track the passage of time

DMG: 48:

The Ethereal Plane also disobeys the laws of gravity: a creature there can move up and down as easily as walking.

solid objects on the overlapped plane don’t hamper the movement of a creature in the Border Ethereal

I think things will vary a lot per creature. If these things are their normal, “real/physical” things would be pretty weird. But if they have experience in multiple realms, no so bad.

Alignments: Each plane has an alignment which could have an effect on the particular creature:
DMG page 59:

Each of the Outer Planes has peculiar characteristics that make traveling through it a unique experience. A plane’s influence can affect visitors in various ways, such as causing them to take on personality traits or flaws that reflect the disposition of the plane, or even shift alignment to more closely match the native inhabitants of the plane. Each plane’s description includes one or more optional rules that you can use to help make the adventurers’ experiences on that plane memorable.

The 3e DMG on page 76 mentions that ethereal creatures (I haven’t been able to locate this description in a 5e book so far) aren’t subject to gravity or falling and can move in any direction, so if ethereal creatures retain this “etherealness” in other planes, they wouldn’t be so poorly off, but this could vary based on individual creature too.

Other thought: PHB 238 Etherealness spell

This spell has no effect if you cast it while you are on the Ethereal Plane or a plane that doesn’t border it, such as one of the Outer Planes.

If it’s impossible to go “ethereal” does this imply that the ethereal state requires to be on a bordering plane? I suspect the Ethereal stinger in the outlands was a mistake, and creatures would need to have the ability to be in their non-ethereal form to leave a location linked to the Ethereal plane.

I think this question will fall into how your world has been built. See DMG page 43 under “putting the planes together”:

A way for spells and monsters that use the Astral Plane and the Ethereal Plane to function

Can a creature/object in “Ethereal” state can leave?

According to the Forgotton Realms wiki all things have an Ethereal equivalent. Do also, all Ethereal things have a non-ethereal equivalent, or do they cease to exist? Perhaps this is left up to the DM.

When a traveler crossed into the Border Ethereal, she and all her possessions were converted to their Ethereal equivalents, metal became ethereal metal, flesh became ethereal flesh and so on

## Clean Architecture Gateway layer depends on outer layer

Looking at the clean architecture layers and flow diagrams, and implemented it my self in my applications, I’ve always wondered which layer is supposed to contain the DB, or any 3rd Party service or SDK.

Looking at both of these images raises the question if there isn’t violation in the outer layers.

I’ve imagined the layers division like this:

But this means that there is a violation of the dependancy rule. Since the gateway always knows about both the external service, and the application it self, the entities.

Is there a correct way to draw these layers? I’ve read a couple of resources asking this question, but didn’t really get a full answers to what I need. For example: https://groups.google.com/g/clean-code-discussion/c/oUrgGi2r3Fk?pli=1, Doesn’t repository pattern in clean architecture violate Dependency inversion principle?

I get it that the meaning of clean architecture is kept, and the inner layers, the entities and the use case, aren’t affected by a change in the DB and the gateway, but was just wondering if maybe this is more accurate:

edit:

From the book:

Recall that we do not allow SQL in the use cases layer; instead, we use gateway interfaces that have appropriate methods. Those gateways are implemented by classes in the database layer.

So I guess this means that the data access is really in the most outer layer:

Maybe for this specific example, there is no real use for the interface adapters layer?

Similarly, data is converted, in this layer, from the form most convenient for entities and use cases, to the form most convenient for whatever persistence framework is being used (i.e., the database). No code inward of this circle should know anything at all about the database. If the database is a SQL database, then all SQL should be restricted to this layer—and in particular to the parts of this layer that have to do with the database.

Also in this layer is any other adapter necessary to convert data from
some external form, such as an external service, to the internal form
used by the use cases and entities.

So it kinda contradicts that the data access is in the database layer, since this is what it does, converts from the DB, for example SQL rows, into the application’s entities. Are these layers not really separated? I’m confused.

## PC Games – The Outer Worlds Peril on Gorgon-CODEX | NulledTeam UnderGround

Genre: RPG
Developer: Obsidian Entertainment
Publisher: Private Division
Language: English
Size: 46 GB

STEAM

SYSTEM REQUIREMENTS

MINIMUM:

Requires a 64-bit processor and operating system

OS: Windows 7 (SP1) 64bit

Processor: Intel Core i3-3225 or AMD Phenom II X6 1100T

Memory: 4 GB RAM

Graphics: Nvidia GTX 650 Ti or AMD HD 7850

Storage: 40 GB available space

RECOMMENDED:

Requires a 64-bit processor and operating system

OS: Windows 10 64bit

Processor: Intel Core i7-7700K or Ryzen 5 1600

Memory: 8 GB RAM

Graphics: GeForce GTX 1060 6GB or Radeon RX 470

Storage: 40 GB available space

nitroflare

## dnd 5e – Will the Astral Projection spell end upon entering an Outer Plane?

The astral projection spell states:

If you enter a new plane or return to the plane you were on when casting this spell, your body and possessions are transported along the silver cord, allowing you to re-enter your body as you enter the new plane. Your astral form is a separate incarnation. Any damage or other effects that apply to it have no effect on your physical body, nor do they persist when you return to it.

The highlighted text seems to suggest that, when you enter a new plane via astral projection, your body is transported there as well and you may re-enter your body. This suggests you have lost your astral form and are now physical.

However, DMG 47 implies something different. This section talks about the astral projection spell for the purposes of traveling in the Astral Plane.

Astral Projection

Since the Outer Planes are as much spiritual states of being as they are physical places, this allows a character to manifest in an Outer Plane as if he or she had physically traveled there, but as in a dream.

It further goes on to saying that high level adventurers will often prefer to travel to the Outer Planes via astral projection because dying in this form doesn’t mean “real” death.

So which is the right interpretation? Does astral projection put you back in your real body when entering an Outer Plane, thus ending the spell, or do you remain an astral projection?

## javascript – Multiple anonymous IIFEs inside outer function

Modules You’re already using `export` syntax, so you’re currently in a module. Rather than defining multiple IIFEs, you might consider using separate sub-modules:

``````// fadeInHeadings.js

const triggerHeight = parent.offsetTop - window.innerHeight / 1.5;

if (window.scrollY > triggerHeight) {
}

);
for (const id of headingIds) {
}
};
``````
``````// scrollHandler.js
import { transformBars } from './transformBars';
import { transformReviews } from './transformReviews';

export default function scrollHandler() {

const { capToggled, newTriggerCalculateHeight } = transformBars();
capToggle ||= capToggled;
triggerCalculateHeight ||= newTriggerCalculateHeight;

transformReviews();

// ...
``````

This way, when, for example, a review isn’t scaling properly, you can navigate directly to `transformReviews` to debug and fix the problem, rather than wander around in a significantly larger file looking for where reviews are referenced.

Variable names and iteration Your two `forEach`es are a bit confusing:

``````bars.forEach((i, index) => {
``````

When `i` is used as a variable name, it’s almost always used to reference the index of a collection. To have `i` not only not refer to an index, but to also have an `index` variable, is confusing. Instead, consider:

``````bars.forEach((bar, index) => {
``````

Same sort of thing in `Contact`:

``````const groups = document.querySelectorAll('.form-group');
if (!groups) return;
groups.forEach((i, index) => {
``````

`i` should probably be renamed to `formGroup` or something similar. Also, `querySelectorAll` will return an array-like NodeList. Even if it’s empty, it’ll never be falsey, so you can remove the `if (!groups) return;` line.

children You have

``````formGroup.childNodes(1).blur();
``````

`childNodes` returns a collection that includes text nodes. Text nodes can be empty, and including them in a collection can make logic more tedious than it needs to be. Since you want to select an element with that, better to use `.children` (which only returns element children nodes), so you can do

``````formGroup.children(1).blur();
// or
formGroup.children(0).blur();
// or, be more specific and use a CSS selector
formGroup.querySelector(<some-selector>).blur();
``````

Persistent variables? The persistent module variables seem a bit odd. If they really need to be in persistent state, it might make sense to expose a function that returns their current values. If they aren’t meant to be persistent, initialize them to `false` inside `scrollHandler` instead – or, inside the sub-module which reassigns its value, which is returned to `scrollHandler` and then returned by `scrollHandler`. For example, it’d be great if you could do this:

``````// showFormGroups.js
export const showFormGroups = () => {
const groups = document.querySelectorAll('.form-group');
let scrollEnd = false;
groups.forEach((formGroup, index) => {
formGroup.children(1).blur();
if (window.scrollY > (formGroup.getBoundingClientRect().top * 10) / 1.5) {
formGroup.style.opacity = '1';
if (index >= groups.length - 1) {
scrollEnd = true;
}
}
});
return scrollEnd;
};
``````
``````// scrollHandler.js
export default function scrollHandler() {
// ...
const scrollEnd = showFormGroups();
// ...
return { capToggle, triggerCalculateHeight, scrollEnd };
``````

Styles into CSS You have

``````if (window.scrollY > bound) {
mainBackground.style.opacity = '1';
mainBackground.style.transform = 'scale(1) rotate(45deg)';
backgrounds.forEach(i => (i.style.opacity = '1'));
backgrounds(0).style.transform = 'translate(-4%, -9%) skew(45deg)';
backgrounds(1).style.transform = 'translate(-6%, -2%) skew(45deg)';
backgrounds(2).style.transform = 'translate(-5%, 1%) skew(45deg)';
texts.forEach(i => (i.style.opacity = '1'));
}
``````

To apply this logic, I think it’d make more sense to put the CSS rules in your CSS file, and then just toggle a class. Something like:

``````// SCSS for brevity
body.showReviews {
#ul-bg {
opacity: 1;
transform: scale(1) rotate(45deg);
}
.blockquote-bg {
opacity: 1;
}
.blockquote-bg:nth-of-type(1) {
transform: translate(-4%, -9%) skew(45deg);
}
.blockquote-bg:nth-of-type(2) {
transform: translate(-6%, -2%) skew(45deg);
}
.blockquote-bg:nth-of-type(3) {
transform: translate(-5%, 1%) skew(45deg);
}
.reviews-toggle {
opacity: 1;
}
}
``````
``````// transformReviews.js
export const transformReviews = () => {
const el = document.getElementById('reviews-inner');
if (!el) return;
const bound = el.getBoundingClientRect().top * 10;
document.body.classList.toggle('showReviews', window.scrollY > bound);
};
``````

Framework On a larger scale, all of this careful element selecting, iterating, examining, and manual manipulation of the DOM seems a bit tedious. For a professional project that isn’t tiny, I would prefer to look into a framework like React to tie element state directly to their respective DOM elements.

## real analysis – Existence of a subset of \$Asubset R\$such that for all open sets containing it, G, outer measure of G-A if infinite

The following is a question from a real analysis text.

Prove that there exists a set $$A subset mathbf{R}$$ such that $$|G backslash A|=infty$$ for every open set $$G$$ that contains $$A$$

I am not too sure where to start with such a problem. I do not see how this would even be possible either. Only assumption I could make would be setting $$|G|=infty$$

## What is the intuition behind the outer product of two eigenvectors?

I know that the outer product of every two eigenvector forms a 2-D basis for the 2-D matrices. For example, when we write a matrix based on its eigenvectos, we have:

$$X = sum_{i,j} lambda_{i,j}u_iu_j^T$$

where $$lambda_{i,j}$$ is equal to zero when $$ineq j$$ and is eigenvalue otherwise. But what is the intuition behind the basis? Why in the eigen-decomposition the coefficient of cross eigenvectors are zero?

## complex analysis – Regarding subspace generated by the polynomial multiples of outer functions.

Let $$mathbb{D}$$ and $$mathbb{T}$$ denote the open unit disk and unit circle in $$mathbb{C}$$ respectively. We write $$Hol(mathbb{D})$$ for the space of all holomorphic functions on $$mathbb{D}.$$ The Hardy spaces on $$mathbb{D}$$ are defined as:
$$H^{p}:= left{ fin Holleft( mathbb{D}right) :sup _{r < 1}int ^{2pi }_{0}left| fleft( re^{itheta}right) right| ^{p}dtheta < infty right} ;;;;(0
$$H^{infty }:= left{ fin Holleft( mathbb{D}right) :sup_{zin D}left| fleft( zright) right| < infty right}.$$
A function $$gin H^p(mathbb{D})$$ is outer if there exists a function $$G:mathbb{T}longrightarrow (0,infty)$$ with $$Gin L^1(mathbb{T})$$ such that
$$gleft( zright) =alpha text{exp}left( int ^{2pi }_{0}dfrac {e^{itheta }+z}{e^{itheta }-z}Gleft( e^{itheta }right) dfrac {dtheta }{2pi }right) qquad(zin mathbb{D})$$ and $$|alpha|=1$$.
Let $$mathscr{P}(h)$$ denote the subspace generated by the functions $$z^n h(z),; n=0,1,2,….$$, ie $$mathscr{P}(h)$$ consists of all $$H^p$$ functions that can be approximated by polynomial multiples of $$h$$. Note that $$mathscr{P}(1)=H^p$$, since polynomials are dense in $$H^p$$.

(1) Is for every $$h$$, $$mathscr{P}(h)$$ a closed subspace of $$H^p$$?

(2) I know that if $$h$$ is not outer, then $$mathscr{P}(h)neq H^p$$.
Will this also imply that $$1notin mathscr{P}(h)$$ with dist$$(1,mathscr{P}(h))>0.$$? Will this distance be bounded below by some +real number?

## postgresql – Caveats of OUTER JOIN on nested JSON value

I’m writing a query which is supposed to find the elements from a list which DO NOT exist in the DB. My first attempt at this was to use a nested query where the first query fetches the ids, then I `right join` on that query to get what I need, and this works well:

``````select v.id from (
select distinct json_data ->> 'elementId' as elementId
from content
and json_data->> 'elementId' in ('id1', 'id2', 'id3')
) as a
right join (values('id1'), ('id2'), ('id3')) as v(id)
on v.id = a.elementId
where a.elementId is null
``````

The above query works perfect except for the fact that I want to I should be able to reduce the nested query to a regulat `select` if I do the comparison on `json_data ->> 'elementId'` directly.

My attempt:

``````select v.id
from content a
right join (values('id1'), ('id2'), ('id3')) as v(id)
on json_data ->> 'elementId' = v.id
``````

After some debugging I realized that this will never work because the `content` table will always contain a row even if `json_data ->>'elementId'` is `null`.

My question is; Is there a way to avoid using a nested query when wanted to do a `left join` or `right join ` on `JSON` data?

## sass – A styled ordered list whose outer list should have numbers and inner list should have letters using CSS counter property

I am trying to styles an ordered list where i want all the outer list elements to have numeric list style and inner list item to have letters.

The below is my structure.

`````` <div class="subitems">
<ol><li>This is a list with numeric list style
<ol><li>This is a list with numeric list style
<ol class="rulebook-alpha"><li>This is a list with numeric list style</li>
<li>This is a list with numeric list style</li>
</ol></li>
<li>This is a list with numeric list style</li>
</ol></li>
</ol>
</div>
``````

This is my css

``````div.subitems {
ol {
list-style-type: none;
counter-reset: item;
li {
counter-increment: item;
position: relative;
z-index: 0;

&::before {
content: counters(item, ".") ". ";
display: table-cell;
position: absolute;
left: -22px;
}
ol.rulebook-alpha {
counter-reset: alpha;

li {

&::before {
counter-increment: alpha;
content: "("counter(alpha, lower-alpha) ") ";
}
}
}

}
}

}
``````

This is my output