I would like to share some of the best thoughts,stories and reviews with you :-)
Tuesday, 30 September 2025
24x7 Movement
๐งจ “The Quiet Betrayal: Alternate India that wants an Outsmarted Constitution”
Monday, 29 September 2025
From Vote Chori to Rath Chori: A Systematic Undermining of Indian Institutions
From Vote Chori to Rath Chori: A Systematic Undermining of Indian Institutions
We have seen, as highlighted by the leader of the opposition, how the ruling government has been accused of vote chori (electoral theft). The methods may differ, but the intent remains the same. For the people of Bihar, this may feel familiar — or it may not. This isn’t their fault; over generations, they have been conditioned to accept such realities as part of political life.
But the real issue today is not vote chori. It is something far deeper — rath chori.
The rath (chariot) has always held a deep fascination for Sanatanis. It was the first symbol they weaponized during the Ram Janmabhoomi movement, where the political war cries began with a Rath Yatra that swept across the country. This wasn’t just a journey — it was a spectacle of mobilization and polarization.
That weaponization of the Rath Yatra also carried with it an implicit clarion call: to overthrow the Indian Constitution, which had stood as a beacon of welfare, justice, and equality for millions. But their plans went astray. The Constitution survived, and it became firmly entrenched as the supreme law of the land.
However, having tasted the power of using the rath as a political weapon, these forces have now shifted to what can only be described as Rath Chori. They have hijacked the Constitutional chariot that carried the message of peace, justice, and welfare.
In truth, the rath that carries the Indian Constitution today is its institutions — the judiciary, the legislature, the media, and other pillars of democracy. Rath Chori is, therefore, nothing less than the systematic capture of these institutions.
Unfortunately, the Indian Constitution does not clearly spell out what must be done when the very system meant to protect it is used to undermine it. This institutional capture — this Rath Chori — represents the gravest threat to our democracy yet.
Saturday, 20 September 2025
Hot topic called Gen-Z
Gen-Z vs. the System: A Tussle Over the Future
One of the hottest topics right now is Gen-Z — not just as a demographic, but as a rising force shaping the political and social landscapes. From youth-led movements in Sri Lanka and Bangladesh to recent upheavals in Nepal, we're witnessing a global trend: young people challenging—and in some cases, toppling—unpopular governments through sheer collective force.
We hear phrases like “reclaim history” and “make history.” But what is this history really about? For many in Gen-Z, it's about demanding a future where they are not sidelined. It's about proving their relevance by dismantling systems that no longer serve them—or never did.
Democracy was supposed to give people the power to choose leaders who would shape a future inclusive of all generations. But when those in power are more focused on extracting benefits from the system than serving the people, dysfunction follows. The system stops being a neutral tool and starts evolving into something with its own self-interest — its own “future” to protect.
This is where tension escalates. A system worried about its own survival creates leaders who are more concerned with securing their legacy than with enabling the next generation. Meanwhile, Gen-Z, fueled by adrenaline and urgency, sees this as a call to action — or even confrontation.
Here lies the core conflict: the system’s obsession with preserving itself leaves less space for Gen-Z’s future to unfold. The question isn’t whether Gen-Z has the energy or will to challenge this — they clearly do. The real question is: Is adrenaline enough to resolve this generational standoff?
Or does something deeper need to change — both in the system, and in how we define leadership, legacy, and shared future?
Wednesday, 17 September 2025
Look Beyond the Numbers: See the Game
Look Beyond the Numbers: See the Game
The one who speaks of universal connections sees a very different picture.
As Prime Minister Modi celebrates his 75th birthday, millions across the country — especially many Sanatanis — join in the celebrations. But what about the minorities? Who listens to their silence?
When numbers speak for Modiji — in lakhs, in crores — it feels like the whole nation is celebrating. But in the wave of such massive support, who cares if a few thousand choose not to participate?
We often get lost in the noise of numbers. But numbers, by themselves, are meaningless unless they tell us something deeper.
Imagine this: someone says they scored 100 points in a competition. Impressive, right? But what if the competition was about something horrific — say, beheading people, with one point awarded per victim? Suddenly, those 100 points paint a very different picture. At first glance, the number may impress, but once you understand the context, it shocks.
The same applies to social media. We hear things like "100 lakh followers" or "1 million likes." But before being impressed, ask: what is the content? what is the message? Without context, numbers are just distractions — tools used to manipulate perception.
So, the next time you hear that thousands are protesting a project while lakhs are in support, don't be fooled by the scale. For those thousands, it might be a matter of survival, of life and death. Numbers alone can’t measure that kind of truth.
Don’t follow the numbers. Understand the game. Game lies in how the numbers are connected.
Sunday, 14 September 2025
Great Indian Path (ology)
Thursday, 11 September 2025
Constitution and local interpretation
Tuesday, 2 September 2025
MQTT_Firebase bridge
In my previous post, I had shared a tutorial about posting data from ESP32 to Firebase using Arduino Firebase client.
But what if you want to use MQTT on ESP32 side and still post messages to Firebase. This made me to work upon an intermediate C program which receives data from ESP32 MQTT client and post the data to Firebase REST API.
A MQTT_Firebase bridge couples an MQTT enabled IOT device to talk to Firebase without additional work in IOT end. With IOT device having access to Firebase database which serves as a backend for mobile and web applications, we are moving towards an unified backend for embedded, mobile and web applications. There are many advantages of having an unified backend which enables seamless integration of application across the domain.
Here is a simple C program which you can execute on your Rasberry Pi that can execute C program.
Prerequisites to execute this C program
1. A linux OS on your Rasberry Pi
2. Install Paho MQTT client and libcurl using the command sudo apt install libcurl4-openssl-dev libpaho-mqtt-dev
3. Run the Program using gcc name_of_program.c -o name_of_program -lcurl -lpaho-mqtt3c
4. Execute the program using ./name_of_program
To test the program
1. Run the C program
2. Open an Online Mqtt client and publish to the Mqtt broker & Topic configured in your C program.
3. Once you publish the data to the topic, you should see the output of the C program listening to the topic and posting the topic data to the Firebase URL. On successful posting to the Firebase URL you will see an appropriate success message or the error code.
Once the program is tested, you can replace the online MQTT client with ESP32 MQTT client.
Here is the C Program
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <curl/curl.h>
#include "MQTTClient.h"
// MQTT Config
#define MQTT_ADDRESS "tcp://broker.hivemq.com:1883"
#define MQTT_CLIENTID "MQTT_FIREBASE_BRIDGE"
#define MQTT_TOPIC "test/int"
#define MQTT_QOS 1
#define MQTT_TIMEOUT 10000L
// Firebase Config
#define FIREBASE_URL "https://your-project-id.firebaseio.com/test_int.json" // Must end with .json
// POST to Firebase
void post_to_firebase(const char *value) {
CURL *curl;
CURLcode res;
char json_data[256];
snprintf(json_data, sizeof(json_data), "{\"value\": \"%s\"}", value);
curl_global_init(CURL_GLOBAL_ALL);
curl = curl_easy_init();
if (curl) {
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Content-Type: application/json");
curl_easy_setopt(curl, CURLOPT_URL, FIREBASE_URL);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json_data);
printf("Sending to Firebase: %s\n", json_data);
res = curl_easy_perform(curl);
long response_code = 0;
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
if (res != CURLE_OK || response_code != 200) {
fprintf(stderr, "POST failed. CURL error: %s, HTTP response: %ld\n",
curl_easy_strerror(res), response_code);
} else {
printf("POST successful. HTTP %ld\n", response_code);
}
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
}
// MQTT Message Callback
int message_arrived(void *context, char *topicName, int topicLen, MQTTClient_message *message) {
char *payload = malloc(message->payloadlen + 1);
memcpy(payload, message->payload, message->payloadlen);
payload[message->payloadlen] = '\0';
printf("MQTT Message received: %s\n", payload);
post_to_firebase(payload);
free(payload);
MQTTClient_freeMessage(&message);
MQTTClient_free(topicName);
return 1;
}
// Main Function
int main() {
MQTTClient client;
MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
int rc;
MQTTClient_create(&client, MQTT_ADDRESS, MQTT_CLIENTID, MQTTCLIENT_PERSISTENCE_NONE, NULL);
conn_opts.keepAliveInterval = 20;
conn_opts.cleansession = 1;
MQTTClient_setCallbacks(client, NULL, NULL, message_arrived, NULL);
printf("Connecting to MQTT broker...\n");
rc = MQTTClient_connect(client, &conn_opts);
if (rc != MQTTCLIENT_SUCCESS) {
fprintf(stderr, "MQTT connection failed: %d\n", rc);
return EXIT_FAILURE;
}
printf("Subscribed to topic: %s\n", MQTT_TOPIC);
MQTTClient_subscribe(client, MQTT_TOPIC, MQTT_QOS);
// Keep running
while (1) {
sleep(1);
}
MQTTClient_disconnect(client, MQTT_TIMEOUT);
MQTTClient_destroy(&client);
return 0;
}
✅ Final Thoughts
This C-based bridge lets you decouple your ESP32 from directly interacting with Firebase, which is useful in systems that prefer lightweight MQTT communication. You can now process or filter data at the intermediary (Raspberry Pi) before sending it to Firebase.