## Is determining if a Turing Machine stops for at least one entry decidable?

I can’t find how to prove the decibility with a reduction.

## Wall of fire: What’s a ‘solid surface’ and what happens if it stops existing?

Wall of fire has to be cast on a solid surface. What’s a solid surface? Can it be the back of a dragon? Dragon scales are pretty solid..

If the solid surface disappears (ice melts away, roof collapses) does the spell then fail or stay where it was cast for the duration?

## proving that a turing machine which stops at every input and recognize the complement of L

i would like to prove that the deterministic TM M stops on every input and L(M) = L. Prove that there exists a deterministic TM M1 that stops on every input and recognizes the complement L of language L, that is L(M1) = L.

## What stops you from crafting items such as wands with Shadow Evocation/Conjuration/Shades?

Since Wish/Limited Wish can indeed be used to craft items(Can you craft magic items using Wish instead of the required spell?)

What stops me from creating a wand of fireball with the help of the spell Shadow Evocation to mimic the spell instead? (or a staff since Shadow Evocation is a 5th level spell and that might not work on a wand)

There might not be RAW solutions to this, but if I ever allow this I’ll treat the wand as a Shadow Evocation (fireball) with the same limitations, but what about Wondrous items that require a certain spell to be crafted? Wish does work per RAW since it provides the prerequisites of the item.

I guess I should just not allow it, much simpler that way.

## Where is a grappled and carried creature placed when the grappler stops moving?

The Grappled condition states (from the point of view of the grappler):

Moving a Grappled Creature: When you move, you can drag or carry the Grappled creature with you, but your speed is halved, unless the creature is two or more sizes smaller than you.

I have no issue with the dragging portion of moving with a grappled creature but when carrying the creature where does it find itself on the end of your turn?

Can the grappling PC place the carried target down into whichever square in range they choose?

I have some issues with that, namely the ability to pass the grappled creature into a hazard with no difficulty. Imagine moving to the edge of a cliff and simply holding the grappled creature over the edge and then releasing the grapple. It seems too simple.

Other options include holding them in a fire, dropping them into a known trap, etc or simply stating that you’ve lifted the grappled creature over your head and placed them down on the other side of you so your allies can attack it.

None of seems right to me but I find anything to explicitly state how to handle carrying a grappled creature.

## How come RFC7636 (PKCE) stops malicous app doing the same code challenge and get legitimate access to API

As per the RFC7636 it stops malicious apps which pretend to be legitimate apps, gaining access to OAuth2.0 protected API’s.

The flow suggests a method of having a runtime level secret which generated from the client and letting the Auth server knows it. This allows token issuer to verify the secret with auth server and grant a proper access token.

However lets assume a malicous app, as the RFC paper suggests, with a correct client_id and client_secret, it can do the same PKCE process and gain access to protected resources.

Is this RFC doesn’t meant to protect those kind of attacks or simply I’m missing something here?

## Does a generator really stops the execution at the machine code level, and does it not use the stack?

Never have I heard of a partially executed function before. But it seems the idea of it has been out for some time. Does a generator really stop execution at the machine code level, and that next time when the iterator is invoked, then there is a jump back to that machine code location to continue the execution?

It seems quite strange, as

1. it differ from mathmatics for what a function is.
2. the traditional function will add to the stack, and once finished, everything is popped from the stack. But the generator is like a function that stays… so nothing is popped from the stack. So does it use something other than the stack for memory?

Example: JavaScript ES6 Generator:

``function* generator() {     yield 1;     yield 3;     yield 5; }  const iterator = generator();  console.log(iterator.next()); console.log(iterator.next()); console.log(iterator.next()); console.log(iterator.next()); ``

result:

``{value: 1, done: false} {value: 3, done: false} {value: 5, done: false} {value: undefined, done: true} ``

## Unity Editor stops updating ScriptableObjects if I click away from them in editor

I’m trying to be better about structuring my code, and I think I’m doing it right. The issue I’ve got right now is I need to get joystick inputs, scale those values appropriately, and then use that scaled data on any number of MonoBehaviour scripts.

I’m trying to split the input conditioning from the end user, and I’d like to do that by using a ScriptableObject to hold the conditioned data.

I was thinking that a MonoBehaviour script would run, get the joystick data, scale it, and then push that data to variables in the ScaledJoystickData ScriptableObject. Later, a second MonoBehaviour script would access the variables in the ScaledJoystickData and use those to move the things in the game.

I’m understanding the benefits of structuring the code this way, especially in that I can access the ScriptableObject from the editor and manipulate those values; I don’t actually need to have a joystick connected, and I’m free to test either end of the input handling independently.

The problem is that, if I am looking at the ScriptableObject instance in the editor, it stops updating as soon as I click away from it (to the consuming GameObject). If I click back to the ScriptableObejct instance, none of the values update. Nothing on the GameObject’s script updates unless I start the game with that GO selected in-editor, and again THAT fails to update if I click off and click back.

The GameObject script is currently using the values from the ScriptableObject instance and piping them to public variables, and the public variables aren’t updating.

Is there some bug with ScriptableObjects, or am I doing this wrong?

## Ubuntu 18.04.3 LTS stops working

I’m not a master but also not a beginner in the linux system, I’ve installed Ubuntu 18.04.3 LTS on dual boot with windows 10 and I’ve been facing a big issue in the Ubuntu 18.04.3 LTS. The issue is that the complete OS stops working, like not a single click and it never starts again, I’ve tried waiting for 10 hrs, the only solution is that I have to press the power key of my laptop and start the laptop again. My laptop is powered by core i5-6200U 2.30 GHz x4 4 GB RAM Intel HD Graphics 520 GNOME version: 3.28.2 This issue mostly happens while debugging the android application in my phone (no emulator) or sometimes while working on terminal. I have some Gnome shell extensions installed, can this be the main cause of problem? Also I’ve install the CPU Power Manager to overclock my CPU. I’m expecting a big help from here or I’ll switch to manjaro, as I’ve tried reinstalled the complete OS.

## Server stops accepting connections after ~120,000 active on 18.04.3

I’m running a type of perf test where I have a simple TCP server with 4 IP addresses that is listening on a port and getting connections from several other computers on the local network. Everything works fine up to just under 120,000 active connections, clients are able to get messages from client and create new connections. At just under 120,000, new connections just stop appearing. There is no log activity on server and clients start getting timeouts after a bit. There is no firewall that would be getting in the way. I have tweaked a bunch of settings already:

/etc/sysctl.conf

``net.core.netdev_max_backlog = 1000000  net.core.netdev_budget = 50000 net.core.netdev_budget_usecs = 5000  net.core.somaxconn = 1024000  net.core.rmem_default = 1048576 net.core.rmem_max = 16777216  net.core.wmem_default = 1048576 net.core.wmem_max = 16777216  net.core.optmem_max = 65536  net.ipv4.tcp_rmem = 4096 1048576 2097152 net.ipv4.tcp_wmem = 4096 65536 16777216 net.ipv4.udp_rmem_min = 8192 net.ipv4.udp_wmem_min = 8192 net.ipv4.tcp_fastopen = 3 net.ipv4.tcp_max_syn_backlog = 3000000 net.ipv4.tcp_max_tw_buckets = 2000000  net.ipv4.tcp_tw_reuse = 1 net.ipv4.tcp_fin_timeout = 10 net.ipv4.tcp_slow_start_after_idle = 0 net.ipv4.tcp_keepalive_time = 60 net.ipv4.tcp_keepalive_intvl = 10 net.ipv4.tcp_keepalive_probes = 6 net.ipv4.tcp_mtu_probing = 1 net.ipv4.tcp_syncookies = 1 net.ipv4.tcp_rfc1337 = 1 net.ipv4.conf.default.rp_filter = 1 net.ipv4.conf.all.rp_filter = 1 ``

/etc/security/limits.conf

``* soft nofile 6553600 * hard nofile 6553600 ``

The limits are intentionally completely overkill because it’s just a test. Are there some other settings I am missing that would enable more connections? Neither the CPU nor RAM is being stressed so I would like to keep pushing the hardware. Server and clients are all running on AWS EC2 t3a.xlarge instances, if that makes any difference.