Getting 401 unauthorized on Asterisk Login in spite of correct creds in PJSIP.Conf

Rest all being good, the issue was the credentials from chan_sip module (sip.conf) were being picked up.

Do these:

asterisk -rx "module show like chan_sip"
asterisk -rx "module unload chan_sip.so"
# persistently disable:
sudo sed -i 's/^load=chan_sip\.so$/noload=chan_sip.so/' /etc/asterisk/modules.conf || echo 'noload=chan_sip.so' | sudo tee -a /etc/asterisk/modules.conf

The Universe May Be Running at 10⁴³ FPS — And Planck Already Knew It

In 1899, Max Planck uncovered something timeless: the smallest unit of time that still has physical meaning.

We now call it Planck time:

tP​≈5.39×10−44 seconds

It’s unimaginably short — far beyond direct measurement — but incredibly profound.

Because if we treat that as the duration of a single frame of reality, then we’re forced to ask:

Is the universe updating frame by frame?

Reality as a Causal Engine

Let’s follow that thought. If each Planck time is one “tick” of the universal clock, then the frame rate of the universe is:

FPS=tP​1​≈1.855×1043 frames per second

Yes. Roughly 185 trillion trillion trillion trillion frames per second.

That’s not science fiction. That’s the math baked into physical constants.

And you heard that frame rate here first.

From Time to Space: The Planck Grid

It gets more intriguing when we realize that:

ℓP​=c⋅tP​

That is, Planck time multiplied by the speed of light gives us Planck length, the smallest measurable unit of space.

So we now have:

  • A pixel size: 1.616×10⁻³⁵ meters
  • A frame duration: 5.39×10⁻⁴⁴ seconds
  • A universal constraint: No signal or event can propagate faster than one pixel per frame.

Which is exactly what we mean by the speed of light.

But maybe we’ve been calling it the wrong thing all along.

It’s the Speed of Events

What we call “c” isn’t about photons. It’s a fundamental limit on how fast any event can ripple through the fabric of spacetime.

Like updates in a distributed system, or signals in a finite-element simulation, every interaction can only spread to adjacent nodes — one at a time — per frame.

In this light (no pun intended), the universe appears less like a smooth continuum, and more like a vast, local-update-driven causal mesh.

Planck gave us the constants. The frame rate, pixel size, and speed limit all emerge from them.

All we’re doing now is connecting the dots.

Why This Matters

This framing — no longer poetic but grounded in physical constants — has implications across:

  • Quantum gravity
  • Simulation hypotheses
  • Discrete spacetime models
  • Relativistic causality
  • The intersection of computation and cosmology

It might help explain why spacetime resists division beyond certain limits, why causality holds, and how the “engine” of the cosmos keeps time.

And just maybe, it hints that reality is more digital than continuous.


Next time someone says “the speed of light is the fastest thing in the universe”, you can tell them:

It’s not the speed of light.
It’s the speed of reality itself.

And it’s running at ~10⁴³ frames per second.

Intriguing right?
And yes, you read the FPS here first.

Heard of ScyllaDB? A Glitch Reveals My Data Stack’s Limits – And Our Response to it.

Deployed systems have a knack for humbling even experienced engineers. You trust your stack—until one morning it silently fails. Last week, during DheeGPT’s development, that exact scenario unfolded and forced us to rethink our infrastructure.

The Day Cassandra Let Us Down

We chose Apache Cassandra to power DheeGPT, our agentic AI engine for Indic languages. It had handled thousands of writes per second in our legacy and production systems — however in the development environment of our newest platform, a routine query returned zero rows:

  • The data was unquestionably in the table.
  • A secondary-index query returned no results.
  • A full table scan confirmed the rows existed—but the index was stale.

No errors. No alerts. Just missing data. Numerous minutes of debugging later, we traced the fault to Cassandra’s secondary index divergence. Invisible failures like this are unacceptable for real-time AI and and automations which are mission critical.

Where Cassandra’s Design Reveals Strain

Cassandra excels as a write-optimized ledger. Yet when you layer on dynamic queries and tight consistency, its limits appear:

  1. Secondary indexes can silently desynchronize.
  2. Rigid schemas force costly refactors if access patterns evolve.
  3. JVM GC pauses inject unpredictable P99 spikes.

As we built DheeGPT, these factors made us question whether Cassandra could sustain our reliability bar.

The Pivot to ScyllaDB During Development

Facing looming deadlines, we swapped in ScyllaDB mid-development. The transition was surprisingly smooth:

  • Zero code changes — Same CQL, same Spring Data drivers.
  • C++ Seastar lock-free, thread-per-core design.
  • Up to 10× throughput on identical hardware.
  • Sub-10 ms P99 latencies, even under traffic surges.

Though ScyllaDB launched in 2016, it still flies under the radar. License concerns and slower early evangelism held it back—yet today it’s a mature, high-performance alternative.

How DheeYantra Leverages Robust Infra

At DheeYantra, we build Dhee.AI Digital Employees that:

  • Power 24×7 customer support in Hindi, Tamil, Bengali, and more
  • Automate document processing and data extraction
  • Orchestrate workflows across enterprise systems in real time

For us, infrastructure reliability isn’t optional—it’s the core of our product promise. With ScyllaDB, we maintain sub-second response times at scale, reduce cluster size (and costs), and shift focus from firefighting infra to advancing AI logic.

Key Takeaways

  1. Revisit your defaults. Even proven tech can hide silent failure modes.
  2. Decouple API from engine. A compatible interface lets you switch back ends with minimal friction.
  3. Benchmark real workloads. Surface tail-latency and consistency issues before they reach prod.
  4. Invest in observability. Detect index divergence proactively, not after customers complain.

What’s Next: Digital Employees Powered by Indic Agentic LLMs

We’re excited to announce that next week we’re rolling out the new DheeGPT platform alongside our first Indic Agentic LLMs. These models will underpin Dhee.AI Digital Employees—reliable, multilingual agents tailored for Indian enterprises.

👉 Keep an eye on DheeYantra’s page for the official launch and demos.

👉 Reach out to explore how Dhee-powered Digital Employees can transform your workflows—whether in support, finance, HR, or field services.

Reliable AI starts with dependable infrastructure—and when it comes to reliability – we don’t “play”.

Mail me your digital employee requirements at Sales at DheeYantra dot Com. Let’s build the future, together.

Activate back lighting of LIVE TECH gaming keyboard on Ubuntu

To enable the back light LEDs of the Live Tech keyboard in Ubuntu follow these steps

sudo apt install brightnessctl
sudo brightnessctl -ls #note the scrolllock input with a suffix greater than 5
sudo brightnessctl --device input16::scrolllock s 1 #Assuming the suffix is 16

This should light up the LEDs in the Keyboard.

Link Keyboard Lighting Script to a Function Key

Want to control your keyboard backlight with a simple function key? Follow ahead.


Step 1: Create the Keyboard Lighting Script

  1. Open Terminal
  2. Create the script: vi ~/lightupKeyboard.sh
  3. Add the following content: pkexec brightnessctl --device input16::scrolllock s 1 >> /tmp/lightupKB.log 2>&1
  4. Save and exit
  5. Make the script executable: chmod +x ~/lightupKeyboard.sh

Step 2: Link to a Function Key

  1. Open Keyboard Shortcuts Settings:
    • On GNOME: Settings > Keyboard > View and Customize Shortcuts
    • On KDE: System Settings > Shortcuts
  2. Create a New Shortcut:
    • Name: Light Up Keyboard
    • Command: bash ~/lightupKeyboard.sh
  3. Assign a Key: Press the desired Function Key (e.g., F6) when prompted.
  4. Save and Close Settings.

Press the assigned function key to turn on your keyboard lighting. You will also see a log entry in /tmp/lightupKB.log for each press.


Network devices not found after Ubuntu upgrade from 20.04 LTS to 22.04 LTS

I had recently upgraded my laptop from Ubuntu 20.04 from 22.04. Once restarted after the upgrade, my laptop just wouldn’t connect to any network (LAN/Wifi/USB tethering)

I ran this command to see the network devices:

sudo lshw -c network

Which gave a very similar result as this:

*-network UNCLAIMED       
   description: Ethernet controller
   product: RTL8111/8168/8411 PCI Express Gigabit Ethernet Controller
   vendor: Realtek Semiconductor Co., Ltd.
   physical id: 0
   bus info: pci@0000:03:00.0
   version: 03
   width: 64 bits
   clock: 33MHz
   capabilities: pm msi pciexpress msix vpd bus_master cap_list
   configuration: latency=0
   resources: ioport:d800(size=256) memory:f8fff000-f8ffffff memory:f8ff8000-f8ffbfff memory:f9ee0000-f9efffff


 *-network UNCLAIMED
   description: Network controller
   product: RTL8812AE 802.11ac PCIe Wireless Network Adapter
   vendor: Realtek Semiconductor Co., Ltd.
   physical id: 0
   bus info: pci@0000:02:00.0
   version: 01
   width: 64 bits
   clock: 33MHz
   capabilities: pm msi pciexpress bus_master cap_list
   configuration: latency=0
   resources: ioport:c800(size=256) memory:f9dfc000-f9dfffff

Solution

After some research these were the steps which I followed to get the network devices and the network connectivity back

In terminal, run

uname -r
6.5.0-25-generic

Note the output, for me it was “6.5.0-25-generic”

From another computer, download linux-modules-extra-6.5.0-25-generic.deb from here.

Please note that depending on the kernel version you are running (as indicated by the uname output,) your exact .deb file will be different.

Copy the downloaded .deb file into the network-broken laptop using a pen-drive.

Now in the network-broken laptop, cd to the location of the .deb file.

Run

sudo dpkg -i linux-modules-extra-6.5.0-25-generic_6.5.0-25.25~22.04.1_amd64.deb

Restart the laptop.

The network devices and network connectivity was restored.

Fix ChromaDB startup error: Your system has an unsupported version of sqlite3.

Problem:

After installing chromadb, when we try to start it using the command

 chroma run --host localhost --port 8000 --path /home/user/chromadata

Its give this error:

Traceback (most recent call last):
  File "/home/dheeyantra/.local/bin/chroma", line 5, in <module>
    from chromadb.cli.cli import app
  File "/home/dheeyantra/.local/lib/python3.8/site-packages/chromadb/__init__.py", line 79, in <module>
    raise RuntimeError(
RuntimeError: Your system has an unsupported version of sqlite3. Chroma                     requires sqlite3 >= 3.35.0.
Please visit                     https://docs.trychroma.com/troubleshooting#sqlite to learn how                     to upgrade.

Fix:

pip install pysqlite3-binary
vi ~/.local/lib/python3.8/site-packages/chromadb/__init__.py

#add these lines to the TOP OF THE FILE and save it.
__import__('pysqlite3')
import sys
sys.modules['sqlite3'] = sys.modules.pop('pysqlite3')

Start the chromadb. Should work now.

A QR Code Scanner Component for Cordova in ReactJS that works on Android.

Yes, a component that does the job well. Code below, customise for your use case.

Note: It does not use the “cordova-plugin-qrscanner” which is broken at the time of writing.

import React, { Component } from "react";
import jsQR from "jsqr";
import $ from "jquery";

class QrCodeScanner extends Component {
  constructor(props) {
    super(props);
    this.videoRef = React.createRef();
    this.state = {
      qrcode: "",
      videoError: false
    }
  }

  componentDidMount() {
    this.checkCameraPermissions();
  }

  componentWillUnmount() {
    this.stopScanner();
  }

  checkCameraPermissions = async () => {
    var thisController = this;

    cordova.plugins.permissions.requestPermission(
      cordova.plugins.permissions.CAMERA,
      function (status) {
        if (status.hasPermission) {
          console.log("Camera permission granted");
          thisController.startScanner();
        } else {
          console.log("Camera permission denied");
          thisController.state.videoError = true;
          thisController.setState(thisController.state);
        }
      },
      function () {
        console.log("Error requesting camera permission");
        thisController.state.videoError = true;
        thisController.setState(thisController.state);
      }
    );
  };

  startScanner = () => {
    navigator.mediaDevices.getUserMedia({ video: { facingMode: "environment" } })
      .then((stream) => {
        this.videoRef.current.srcObject = stream;
        this.videoRef.current.play();
        this.videoRef.current.addEventListener("loadedmetadata", this.scanFrame);
      })
      .catch((error) => {
        console.error("Error starting scanner: ", error);
        this.state.videoError = true;
      });
  };

  stopScanner = () => {
    const stream = this.videoRef.current.srcObject;
    if (stream) {
      const tracks = stream.getTracks();
      tracks.forEach((track) => {
        track.stop();
      });
    }
    document.getElementById("qrScannerPreview").pause();
  };

  scanFrame = () => {
    var thisController = this;
    const canvas = document.createElement("canvas");
    const context = canvas.getContext("2d");
    const video = this.videoRef.current;

    canvas.width = video.videoWidth;
    canvas.height = video.videoHeight;
    context.drawImage(video, 0, 0, canvas.width, canvas.height);
    const imageData = context.getImageData(0, 0, canvas.width, canvas.height);

    const code = jsQR(imageData.data, imageData.width, imageData.height);
    if (code) {
      console.log("QR code detected: ", code.data);
      //Do something with the extracted code.

        return;
      }

    }

    requestAnimationFrame(this.scanFrame);
  };


  render() {

    return (
      <div style={{ height: "90vh", marginTop: "7vh" }} >

        <div id="view-qrscanner" >
          <div>
            <div className="container-qr">
              <div style={{ paddingTop: "1vh" }} >
                <div align="center">
                  <h3 style={{ fontWeight: 'bold', fontSize: "1.28rem", color: 'white' }}>Scan your onboarding QR code</h3>
                  <label style={{ padding: "10vw", fontSize: "0.92rem", color: 'white' }}>Postion the QR Code a few inches away</label>
                </div>
                <div id="camera" className="pre_capture_frame" style={{ width: '95vw' }} />
                {!this.state.videoError && <video style={{ width: "85vw", height: "85vw", margin: '4.5vw', borderRadius: '12px' }}
                  ref={this.videoRef} id="qrScannerPreview" />}
                {this.state.videoError && <div>Could not start the video source.
                  Please ensure that you have granted camera permissions and that 
                  the camera is not being used by another app.</div>}
                <br />
                <div id="tick" align="center" style={{ display: 'none', color: '#94bde9',
                                                     fontSize: '108px', width: '95vw' }}>
                  &#10004;
                </div>
              </div>

            </div>
          </div>
        </div>

      </div>
    );
  }
}

export default QrCodeScanner;

Runbook: Upgrade NodeJS on Ubuntu

Here are the steps you can follow to upgrade NodeJS on an Ubuntu system.

sudo rm -rf /usr/local/bin/npm /usr/local/share/man/man1/node* ~/.npm
sudo rm -rf /usr/local/lib/node*
sudo rm -rf /usr/local/bin/node*
sudo rm -rf /usr/local/include/node*

sudo apt-get purge nodejs npm
sudo apt autoremove

Download the latest installable archive for your OS from https://nodejs.org/en/download/

tar -xf your-archiveFile
sudo mv extracted-archiveFolder-name/bin/* /usr/local/bin/
sudo mv extracted-archiveFolder-name/lib/node_modules/ /usr/local/lib/
node -v
#should display the latest version of node