Home

Author: Sreekumar Kj

  • 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 Absurdity of Western Double-Entry Accounting: Time to Reclaim Intuition from Rote Formalism

    The Absurdity of Western Double-Entry Accounting: Time to Reclaim Intuition from Rote Formalism

    Accounting is supposed to reflect reality. Yet, the modern double-entry system often asks us to ignore common sense. In this post, we explore the absurdities of the Western model, its forgotten Indian roots, and why it’s time to build systems that honor both logic and legacy.

    In the world of finance and accounting, there are few systems as universally entrenched as the double-entry bookkeeping system. Taught in every business school and embedded in every ERP software, it’s hailed as the gold standard of financial integrity and balance. But beneath its structured columns and polished jargon lies an inconvenient truth: the double-entry system, as formalized in the West, is needlessly counterintuitive.

    A System That Punishes Intuition

    Let’s get to the crux of the absurdity: when a business acquires a laptop, the accountant is expected to debit the laptop account and credit cash. Intuitively, this makes no sense to the average person. One might naturally think:

    “I gained a laptop, shouldn’t that be a positive entry? I lost money, shouldn’t that be a negative one?”

    But no — in the Western formalization, you must first memorize a matrix of account types and their behaviors:

    Account TypeDebit MeansCredit Means
    AssetIncreaseDecrease
    LiabilityDecreaseIncrease
    IncomeDecreaseIncrease
    ExpenseIncreaseDecrease
    EquityDecreaseIncrease

    To operate this system, you’re expected to detach from logic and cling to a chart.

    But It Didn’t Start This Way

    What’s truly ironic is that this system wasn’t even born in the West. Indian merchant communities had well-developed double entry accounting systems centuries before Luca Pacioli ever picked up a pen. These systems, such as “Bahi-Khata” and “Lekha-Jokha,” were intuitive, narrative-based, and required no memorization of abstract roles. They used terms like Jama (प्राप्ति – what is receivable to you) and Udhar (देय – what you owe) — simple, human, understandable.

    It was only after Western formalization that accounting became a cold abstraction. Pacioli, a mathematician and priest, didn’t invent double-entry — he codified it in a way that suited the legal and ecclesiastical machinery of Renaissance Italy. But in the process, he stripped it of its cultural intelligence.

    The Emperor Has No Ledger

    The double-entry system is often praised for its elegance and balance. But elegance is not the same as usability. Systems should not require rote memorization of arbitrary rules just to reflect a transaction as simple as “I bought a thing.”

    Modern accounting education forces students to contort their minds around rules that make sense only on paper. When an asset increases, we call it a debit. When money leaves, we call it a credit. But try explaining that to a child, or a farmer, or a shopkeeper — they’ll look at you sideways. And rightly so.

    When Software Saves Us from Ourselves

    Interestingly, modern accounting tools and platforms are beginning to mask this absurdity by adding a layer of intuitive design. Today’s user interfaces rarely show raw debits and credits. Instead, they ask users what happened:

    “Did you purchase something? From where? Using what method?”

    Behind the scenes, the software still performs the debit-credit logic — but it no longer asks humans to think like ledgers. Tools like Tally, Zoho Books, QuickBooks, and even personal finance apps present transactions in a way that mirrors natural human thinking: money came in, money went out, you gained an asset, you paid a bill.

    In essence, these tools are quietly abstracting away the rigid mechanics and restoring the clarity that the original Indian systems once had. Perhaps they are unknowingly inching closer to the clarity of प्राप्ति-देय.

    Time to Reclaim Accounting from Rote Learning

    We live in an age of intuitive design. We expect apps, services, and tools to be user-friendly. Why should accounting be stuck in the 15th century?

    Perhaps it’s time to return to our roots — not to reject structure, but to rebuild it with clarity. Systems like प्राप्ति-देय (Jama-Udhar), or reimagined versions of them, could provide the intuitive foundation we’ve lost. They’re not only culturally resonant, they’re logically superior for most human contexts.

    Final Word

    Western double-entry accounting, as it stands today, is a twisted plot built on a beautiful foundation of accounting from India. It’s time to stop pretending this current system is beyond question. It’s not divine, it’s designed — and like all designs, it can be improved.

    Let’s stop teaching people to memorize irrational mappings. Let’s build systems that work with our minds, not against them.

    Intuition is not the enemy of precision. It’s the path to it.

    🧠 Food for Thought:
    Have you ever felt frustrated trying to “get” accounting? Do you think systems should serve people — not the other way around? Share your thoughts in the comments. Let’s spark a conversation about building better, more intuitive frameworks for the next generation.

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

    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.

    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.

  • 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.

  • Tweaked steps to prevent path errors in ionic capacitor + reactJS projects

    Follow these:

    sudo chmod -R 777 . #incase sudo trapped at install time.
    ionic capacitor copy ios
    cp -r build/static ios/App/App/public/{custom-context-path-if-any}
    ionic capacitor update ios
    npx cap open ios

    On Xcode,

    • clean build folder
    • build
    • run on device or simulator

  • 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;

  • Ubuntu Fix: Newly added volume shows size of only few 100 MBs

    Run this command, (assuming the format and mounting was done correctly).

    sudo resize2fs /dev/{device}

    Kj

      

  • 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