Instead of getting better, it got dramatically worse!

Boosteroid (a cloud gaming app) became borderline unusable over Wi‑Fi, with latency spiking into the 100–300 ms range in a very regular pattern.

The weird part was that everything else looked normal: speed tests were fine, Wi‑Fi was fine, but inside Boosteroid the stream kept hitching, freezing, and stuttering hard enough to make gaming miserable.

After a lot of digging, the actual culprit turned out to be AWDL — not Boosteroid itself.

What AWDL Is

AWDL stands for Apple Wireless Direct Link. It powers nearby Apple features like AirDrop, Handoff, AirPlay, and other continuity features.

The likely reason it causes these spikes is that your Mac has one Wi‑Fi radio, and AWDL makes it periodically hop off your normal Wi‑Fi channel onto Apple’s peer-to-peer channel to listen for or talk to nearby devices. While that is happening, normal traffic can get delayed because the radio is briefly busy elsewhere.

That is why the pattern is so odd: the connection can look fine overall, but real-time traffic like cloud gaming, voice chat, or remote desktop gets hit by regular bursts of latency, jitter, packet delay, and short freezes.

The usual workaround is to disable the awdl0 interface while gaming. The problem is that macOS can turn it back on by itself after a while, so disabling it once is often not enough. And you probably do not want it permanently off anyway, because it can interfere with useful Apple features.

This is a long-standing macOS bug. There is no proper fix, only workarounds like temporarily disabling AWDL while you play — so here we are…

The Fix We Used

I started from this Reddit post:

Stuttering issues with GeForce NOW on MacOS over WiFi solved with this simple script

And then I adapted it for Boosteroid and made it a bit better and cleaner for this use case.

The original script keeps AWDL disabled while GeForce NOW is open. What I changed was adapting it for Boosteroid, adding AWDL restoring on quit, and making the script close itself when Boosteroid exits.

So it works as a small Boosteroid launcher with a watchdog, not just a one-off toggle. What it basically does:

• disables awdl0
• launches Boosteroid
• keeps checking whether macOS silently turned awdl0 back on
• disables it again if needed
• restores awdl0 when Boosteroid closes

Step 1: Add the Sudoers Rule or the Script Will Not Work

This part is required. The script uses sudo -n, which means it cannot stop and ask for your password. Without this rule, it just fails.

We are allowing only these two exact commands without a password, nothing else.

Edit sudoers safely with visudo. Open Terminal and run:

EDITOR=nano sudo visudo

Enter your password when asked. Then find this section:

# root and users in group wheel can run anything on any machine as any user
root            ALL = (ALL) ALL
%admin          ALL = (ALL) ALL

Add the new line directly after that block, not before it. Paste this, replacing <your-user-name> with your actual macOS username:

<your-user-name> ALL=(root) NOPASSWD: /sbin/ifconfig awdl0 down, /sbin/ifconfig awdl0 up

How to Save and Exit Nano

• Press Control + O to write the file
• Press Enter to confirm
• Press Control + X to exit

Step 2: Create the Boosteroid Launcher Script

Open Script Editor via Spotlight, create a new script, and paste this in:

property shouldMonitor : false
property isShuttingDown : false
property awdlWasDisabled : false

on set_awdl0(state)
 try
  do shell script "sudo -n /sbin/ifconfig awdl0 " & state
  return true
 on error errMsg
  if not isShuttingDown then
   display notification ("Failed to set awdl0 " & state & ": " & errMsg) with title "Boosteroid"
  end if
  return false
 end try
end set_awdl0

on boosteroid_is_running()
 try
  do shell script "/usr/bin/pgrep -x Boosteroid >/dev/null"
  return true
 on error
  return false
 end try
end boosteroid_is_running

on awdl0_is_active()
 try
  set awdl0Status to do shell script "/sbin/ifconfig awdl0"
  return awdl0Status contains "status: active"
 on error
  return false
 end try
end awdl0_is_active

on begin_shutdown()
 set isShuttingDown to true
 set shouldMonitor to false
 quit
end begin_shutdown

on run
 if set_awdl0("down") then
  set awdlWasDisabled to true
  set shouldMonitor to true
  display notification "awdl0 is now disabled." with title "Boosteroid"
  
  tell application "Boosteroid"
   activate
  end tell
 else
  display notification "Could not disable awdl0." with title "Boosteroid"
  set isShuttingDown to true
  quit
 end if
end run

on idle
 if isShuttingDown then return 60
 if not shouldMonitor then return 1
 
 if not boosteroid_is_running() then
  begin_shutdown()
  return 60
 end if
 
 if awdl0_is_active() then
  if set_awdl0("down") then
   display notification "awdl0 was re-enabled. Disabling again..." with title "Boosteroid"
  end if
 end if
 
 return 1
end idle

on quit
 set isShuttingDown to true
 set shouldMonitor to false
 
 if awdlWasDisabled then
  set_awdl0("up")
  set awdlWasDisabled to false
 end if
 
 continue quit
end quit

Step 3: Save It as an App

In Script Editor:

• click File → Export
• name it something like Boosteroid Without AWDL
• set File Format to Application
• enable Stay open after run handler
• save it to your Applications folder

After that, launch that app whenever you want to use Boosteroid.

What Changed for Us

In our case, the difference was immediate. The regular latency spikes were gone, and Boosteroid finally became usable again over Wi‑Fi!

It is a ridiculous fix, but it works.

The Bigger Point

Boosteroid and other cloud gaming apps should probably add this as a built-in option on macOS until Apple fixes the underlying problem.

Most people are not going to edit sudoers or build a small launcher app just to get stable latency. A simple temporarily disable AWDL while streaming toggle would help a lot.

And this is also something they should keep escalating to Apple, because a background Apple wireless feature should not be able to wreck cloud gaming like this!

But why just “software development”? People should really think of the endgame. Everything will change.

I mean, what business, science, art, and even politics are all essentially? Just a clever optimization process against the real world. Throw ideas/hypotheses on the wall and see what sticks.

Computers are very good at optimization! No reason to believe it won’t all be solved in N years, with like 100x more efficient compute and a couple more cool math tricks.

Give future “GPT-10” interfaces for interacting with the real world, and it could do everything — no human supervision/”prompting” needed at all. Humans would only be an unneeded bottleneck in that optimization process.

There will be big companies consisting only of their founder and no one else. And I am not sure there will be many such companies (so like “everyone could have one”) — no, it is more likely that due to economies of scale, there will be only a few megacorps, owning all the compute.

What we should worry about is how to avoid the extreme wealth disparity/centralization that seems imminent in that future…

I truly, deeply hate it.

—

P.S. I am a Russian citizen, and you need to know that for this words I can be criminally prosecuted, because it is a crime in Russia to call things what they are. This gets you up to 15 years of sentence in prison, due to recent law changes. Don’t worry about me — I’m out of their reach (hopefully). But there are millions of my fellow Russian people who are forced to keep their mouth shut. Don’t let this fool you — lots of people do not support the war, but they are too scared to tell openly about that, they are too scared even to participate in anonymous polls, and this is the reason of those “73% of Russians support the war” numbers. This is a lie, because people just can’t tell the truth.

GPT-3, a newest and biggest OpenAI’s language model is all the hype right now. If you have missed the train, here’s a list of cool demos that people already make using the private beta access.

I unfortunately don’t possess the API keys, but there is a nice text adventure game AI Dungeon, which can be used as a “backdoor” for hacking around with GPT-3, for a modest price. I don’t know whether it’s a full model or some fine-tuned version of it trained on text-based RPG scripts, but it’s surprisingly good at coding, to the point of making me a bit nervous ;)

To find out, I launched the game with a “custom” preset and put the “Randomness” setting near minimal (I used 0.2) —as you generally don’t do drugs at a coding interview, we don’t want the AI to output some incoherent garbage in our little experiment!

From now on, my input is bold, and the AI’s response is italic.

The Interview

You are a senior programmer at Google and you are having a phone screening interview with a candidate. You are going to ask him a couple of coding questions.

You say, “Hello, who are you?”

The candidate says, “I’m John Doe.”

You say “Are you ready to write some JavaScript code?”

“Yes!” he exclaims.

You say “Can you write a function that filters odd numbers from an array?”

“Sure,” he says.

He types for a few seconds and shows you the following code:

function filterOdd(array) {
return array.filter(function(value) {
return value % 2 === 1;

“What do you think?” he asks.

Okay, but that wasn’t quite unexpected. It surely could just have pulled it off from its vast memory, as there are tons of StackOverflow answers with the relevant code. A search engine could do the same.

There are also some minor issues with indentation and with the closing curly braces — but it’s highly likely an issue with the AI Dungeon’s HTML output (like ignoring the whitespace), so I didn’t bother. Let’s ask it to do some non-trivial stuff rather than fixing the formatting!

You say “Great! Could you use arrow function in the filter callback?”

“Sure,” he says. He types for a few seconds and shows you the following code:

function filterOdd(array) {
return array.filter(value => value % 2 === 1);

“What do you think?” he asks.

You say “What if we want to filter even numbers instead?”

“OK,” he says. He types for a few seconds and shows you the following code:

function filterOdd(array) {
return array.filter(value => value % 2 === 0);

You say “You forgot to change the name of the function to filterEven. Can you fix that?”

“Sure,” he says. He types for a few seconds and shows you the following code:

function filterEven(array) {
return array.filter(value => value % 2 === 0);

You say “Good! Can you now make filterEven an arrow function as well?”

“OK,” he says. He types for a few seconds and shows you the following code:

let filterEven = (array) => array.filter(value => value % 2 === 0);

You say “Amazing! And how about making it a const instead of let?

“OK,” he says. He types for a few seconds and shows you the following code:

const filterEven = (array) => array.filter(value => value % 2 === 0); 

“What do you think?” he asks.

You say “Enough for now, I see you can write code :) We’ll contact you soon for a more technical interview.”

“OK, thank you!” he says.

Conclusion

So could it get a job? Probably not yet — if you make more complex inquiries, it won’t be able to answer, outputting broken code with silly mistakes, not being able to capture the full depth of what you’re asking for. But it certainly understands the basic grammar and the syntax of many popular programming languages, and it also appears that it has memorized a lot of stuff from the internet, being able to creatively recombine it according to the context you provide to it. Somewhat similar to what humans do, just at not that level of sophistication. Yet :)

So if not AGI, it could certainly be a next generation of search — it would be very nice to have such a “smart all-encompassing assistant” at a hand that understands the context and does not require a structured input — you just ask it politely, just as you would’ve done it with a human.

Can’t wait to see the applications of it.

1. They’re essentially a centralized tech, pretending to be decentralized. They have failed to solve the theoretical problems, patchworking it with a central server (“the Coordinator”) that settles the transaction order. My guess is that they honestly tried to solve the essential problems with DAGs, but when they realized that it’s not gonna happen, they have invented their “Coordinator”, claiming that one day they will figure how to get rid of it… I wouldn’t believe them, because their tech is not built “from first principles” (like ZK-SNARKs in ZCash, as an example of some credible science) — I mean, there is no solid theoretical background, which is really required to solve the problems they faced. As far as I know, there is no coin yet that solves the “scalability trilemma”. If it was, it would be a major breakthrough. “Extraordinary claims require extraordinary evidence”!
2. On the low level, they use ternary (base-3) for encoding their data structures, which is a complete nonsense unless you have a ternary computer (we don’t). It adds a significant overhead, unnecessarily complexifying the whole system. This is an extreme case of the so-called “NIH (not invented here) syndrome”.
3. They rolled their own hash function — which is a major no-no in cryptography, unless you are an academic expert with a lifetime’s experience in (de)constructing hash functions and finding vulnerabilities in them. Needless to say, their hash function was cracked, putting all their system to risk. Good for them is that the crack was performed by MIT scientists — they’re “white hat hackers” so they reported the vulnerability instead of exploiting it for stealing the users’ money. Here’s a blog post about this (by the scientists who have found the vulnerability): https://medium.com/@neha/cryptographic-vulnerabilities-in-iota-9a6a9ddc4367

To me, these mistakes cannot be justified, when talking about multi-billion dollar business. We all make mistakes, but these ones are usually being made by young careless amateurs, who don’t really think about the reliability and security of their system — it is more important to them to explore things (by re-inventing the wheel) and to prove themselves (and the world) that they are competent in building complex stuff. This is perfectly OK when you’re young and inexperienced (in fact, we often become experienced by doing this), but I would not put a cent in this kind of “currency” — the risk is too high.

The funny thing is that V. Buterin and his creation (ETH) is also subject to this kind of criticism. They have their own hash function (Ethash) and also their own programming language (Solidity) — which is a mistake (NIH syndrome again).. But Vitalik is really a smart and wise person and he’s learning fast. Maybe I just like him because I’m also “Vitalik” :) But really the most important thing is that in contrast to IOTA creators, he doesn’t act like an asshole… Take a look at this, for example (if it’s true, then IOTA creators are complete assholes, and if it’s not, then they are pathetic liars — in either way, it doesn’t add credibility to them):

Next, and in my mind most damningly, Sergey Ivancheglo, Iota’s cofounder, claims that the flaws in the Curl hash function were in fact deliberate; that they were inserted as ‘copy protection’, to prevent copycat projects, and to allow the Iota team to compromise those projects if they sprang up.

See more here: https://hackernoon.com/why-i-find-iota-deeply-alarming-934f1908194b

UPD: see also the recently leaked internal IOTA Foundation conversation, which clearly reveals the immaturity of the key people behind IOTA.

UPD: IOTA Co-Founder Sells All His Coins and Leaves Project

UPD: IOTA Being Shut Off Is the Latest Chapter in an Absurdist History

About the Author

I’m a member of the developer team behind the open-source cross-language CCXT Library (available for JavaScript, Python or PHP). The library is used to connect and trade with more than 100 cryptocurrency exchanges worldwide.

class MyError extends Error {

   constructor (message) {

      super (message)

      this.constructor = MyError
      this.__proto__   = MyError.prototype
      this.message     = message
   }
}

The above is necessary in many popular frameworks. The popularcreate-react-app framework, for example, forces us to transpile everything down to ES5 when building for production. This is required by some outdated dependencies like Uglify, that don’t even recognize classes despite the broad adoption of ES6 in modern browsers…

…and the instanceof just stops working after that. Here’s a simple test:

// test.js

class MyError extends Error {}
let myerr = new MyError ()

console.log (myerr instanceof MyError)

Guess what happens if you run it? It prints true, obviously. But after your code goes through Babel with ES5 preset enabled (in order to meet the popular frameworks’ requirements), the outcome isn’t true anymore:

babel test.js --out-file test.es5.js --presets=es2015
node test.es5.js

Will print false, which is quite unexpected… The problem described above can be easily solved by adding a hack shown in the beginning of this article.

Happy coding!

For the sake of even greater niceness, I tried replacing that “time” title with the 🕑 symbol from Unicode…

Whoa. Something wrong happened, obviously. Quite quickly I discovered that the computed length of symbol 🕑 turned out to be 2!

Initially, I suspected a bug in the module that incorrectly determined the true optical length of a string (it’s the printable-characters that does the job, BTW). WTF? Looks like you can’t rely on str.length to get its rendered length: you have to strip zero-width characters and ANSI escape sequences first, otherwise your string might end up being wider than it actually is!

So, I thought that 🕑.length could be erroneously computed as 2, and that miscalculation lead to an observed disruption of the table’s layout. That happens because the “clock”-symbol occupies multiple Unicode code points or something, and the built-in .length just isn’t smart enough to manage it. Here’s a thorough explanation of the issue and I highly recommend reading it:

Jonathan New | "💩".length === 2

…but then, suddenly, I realized one more thing. The actual visible width of 🕑 might be “2” indeed, from VSCode:

But not quite… As you can see, it is not exactly 2 nor 1(and that puts things out of alignment). But how do various console terminals render it? Check it out in VSCode’s Integrated Terminal:

…and the built-in terminal app from MacOS:

It seems that popular terminals render everything strictly monospaced, and it’s up to the user himself to put an empty space after each of those new fancy Unicode glyphs, to make room for them in a monospaced grid, manually:

Thus, our initial suggestion must have been true, and we should’ve patched printable-characters, enabling it to comprehend those symbols. The article referenced above helped me a lot with that task. So all essential bits required for a proper ASCII layout now work like a charm without breaking on zero-width characters, Emojis and ANSI escape codes:

// determining the real length of a string
strlen ('💩') === 1

// getting first N visible symbols
first  ('💩23456789', 3) === '💩23'

// filling with whitespace
blank  ('\t💩foo') === '\t    '

Yay! Now the as-table is capable of rendering those fancy characters nicely:

xpl/as-table

About the Author

I’m a member of the developer team behind the open-source cross-language CCXT Library (available for JavaScript, Python or PHP). The library is used to connect and trade with more than 85 cryptocurrency exchanges worldwide.

Protecting your Python sources from unwanted readers is easier said than done, because .pyc bytecode is decompileable and the obfuscation is easily reverse-engineered. It took me a while to figure out a proper way to hide Python code…

Meet Cython, an optimizing static compiler that takes your .py modules and translates them to high-performant C files. Resulting C files can be compiled into native binary libraries with no effort. When the compilation is done there’s no way to reverse compiled libraries back to readable Python source code! Cython supports both Python 2 and 3, including the modern async/await syntax. From my experience, the only thing it couldn’t do is asynchronous generators.

1. Install Cython

Installation is as easy as typing pip install cython or pip3 install cython (for Python 3).

2. Add compile.py

Add the following script to your project folder (as compile.py). It will act as a “makefile” for the build:

from distutils.core import setup
from distutils.extension import Extension
from Cython.Distutils import build_ext

ext_modules = [
    Extension("mymodule1",  ["mymodule1.py"]),
    Extension("mymodule2",  ["mymodule2.py"]),

#   ... all your modules that need be compiled ...

]

setup(
    name = 'My Program Name',
    cmdclass = {'build_ext': build_ext},
    ext_modules = ext_modules
)

The script should explicitly enumerate files that you want to be compiled. You can also leave some files uncompiled as well, if you want. Those will still remain importable from binary modules.

3. Add main.py

Make the entry point Python file for your application. You will import and launch all the compiled logic from there. An entry point file is required because Cython does not generate executable binaries by default (though it is capable to), so you will need a dummy Python file, where you simply import all the compiled logic and run it. It can be as simple as:

from logic import main      # this comes from a compiled binary
main ()

4. Run compile.py

Depending on the Python version you use, run:

python compile.py build_ext --inplace

…or, for Python 3:

python3 compile.py build_ext --inplace

The above command will generate .so and .c files next to your .py source files:

The .c files are intermediate sources used to generate .so files, which are binary modules you want to distribute. When building on Windows these files will probably have the .dll extension (UPD: in the comments people suggest that they actually have the .pyd extension on Windows).

You can delete .c and .py files after a successful build and keep the .so files only.

Note that .so-files contain the target platform in their names (e.g. darwin on my MacOS). Obviously, the compiled modules are not cross-platform. If you distribute your program to Ubuntu Linux users, you should compile it on Linux. Otherwise you won’t be able to load these binaries. So you’ll have to compile a platform-specific version of your code for each of your targeted platforms.

Luckily, there are tools like Vagrant that can help reduce all the OS installation burden to a couple of simple commands…

Setting Up a Different OS Environment Using VirtualBox and Vagrant

Here’s an example of how I’ve managed to compile my project on Ubuntu 16.04, while using MacOS.

1. Install VirtualBox and Vagrant.
2. Run export VAGRANT_DEFAULT_PROVIDER=virtualbox (you can add it to your Bash startup script at ~/.bash_profile for convenience).
3. Choose an OS here: https://app.vagrantup.com/boxes/search. Then click the New tab in “How to use” section. You’ll find setup instructions and commands there. Run those commands in your Python project folder:

Finally, run vagrant ssh to get into a freshly installed Ubuntu console (type exit to exit):

cd to the /vagrant folder to see your project files. Then perform steps 1, 4 from this manual, and you’re done:

For projects with a short build/release cycle, multi-plaform builds could be automated using a CI (Continuous Integration) service, like TravisCI, but that’s a story for another article.

About The Author

Check out my other stuff:

👉 LinkedIn: https://linkedin.com/in/xpl/
👉 GitHub: https://github.com/xpl

It will return z, evaluating a, b, ... first. At first it seems not very useful, but consider this example:

const fun = x => x + 1

What if you want to add a console.log call before x + 1 ? With comma operator, adding side-effects to functional expressions is simple:

const fun = x => (console.log (x), x + 1)

And in comparison with…

const fun = x => { console.log (x); return x + 1 }

…it requires fewer modifications.

P.S. you could actually create a wrapper over console.log that returns its first argument:

const fun = x => log (x) + 1

There’s even a library that does that (and much more): Ololog

Finally, someone did it ;)

1. Drop hot-reload.js to your extension's directory.
2. Add it to your background scripts section in the manifest.json file:

"background": { "scripts": ["hot-reload.js"] }

After startup, it will watch for file changes in the extension’s directory. When a change detected, it will reload itself, refreshing the active tab (to re-trigger updated content scripts).

And there’s no need to manually de-activate it before publishing, as it disables itself automagically™ in the production configuration!

The script is amazingly simple, everything fits into just ~50 lines of code. Here’s also a blog post explaining the internals:

Hot Reloading for Chrome Extensions

…in Russian @ habrahabr.ru

P.S. You can also simply clone the GitHub repository and use it as a boilerplate for your extension.

About the author

Check out my other stuff:

👉 LinkedIn: https://linkedin.com/in/xpl/
👉 GitHub: https://github.com/xpl