F.X. Holden’s Antarctica Storm is a thrilling, high-stakes entry into the Aggressor series that plunges the reader immediately into a covert new arms race. This book is set in a world recovering from a devastating Pacific War and poses a serious question to the reader of the entire series: are America’s adversaries truly beaten, or are they secretly preparing to rise again?
The plot centres around the elite Aggressor Inc. team of private security contractors who are drawn into a deadly race to protect a groundbreaking weapon based on antimatter technology. This power source is supposedly so potent that a mere 0.1 ounces could flatten Manhattan. The US research program developing it has been hidden beneath the ice at Antarctica’s remote Concordia Station.
The team includes Captain Karen ‘Bunny’ O’Hare and Captain Rory O’Donoghue, both from the previous series. This team oversees a critical test of this new technology, the geopolitical tension explodes. The situation is complicated by the presence of an unidentified spy deep inside the program. To increase the pulse, the Russian operatives launch a covert sabotage operation which threatened not only the mission but global stability.
Holden masterfully uses the icy, isolated setting of Antarctica to heighten the sense of claustrophobia and danger. The story weaves together the scientific brilliance of a physicist with the sharp instincts of the Aggressor Inc. team. Together they detect the first mysterious radiation spike that signals a very cold war is about to turn hot. The introduction of Chinese and Russian research teams in the desolate landscape cleverly plants the seeds of international conspiracy and conflict.
This book is a page-burning thriller that captures the paranoia and high-tech stakes of the next arms race.
यह कहानी कोलकाता के बाहरी इलाके के एक विश्वविद्यालय हॉस्टल में रहने वाले युवाओं के इर्द-गिर्द घूमती है, जिनकी ज़िंदगी अचानक डरावनी और रहस्यमयी घटनाओं से भर जाती है।
कहानी की शुरुआत एक हॉस्टल और एक अभिशप्त आत्मा से होती है, जो मुख्य किरदारों की गलती के कारण वहां आ जाती है। यह आत्मा बच्चों को परेशान तो करती है, पर मारती नहीं। डर और बचने के इंतज़ामों से उपजा यही हास्य इस उपन्यास का मूल है।
सत्य व्यास ने डरावनी घटनाओं को हास्य के तड़के के साथ इस तरह पेश किया है कि पाठक एक साथ डरता भी है और हँसता भी है। यह एक जोखिम भरा मेल था, जिसे लेखक ने बखूबी निभाया है।
कहानी में भूत-प्रेत और रहस्यमयी घटनाएँ हैं, लेकिन पात्रों की नोकझोंक, उनका बनारसी अंदाज़ (जो सत्य व्यास की कहानियों की पहचान है) और व्यंग्यात्मक संवाद आपको पूरे समय बाँधे रखते हैं। यह आपको हॉरर के तनाव से बचाता है और मनोरंजन को प्राथमिकता देता है। उपन्यास की भाषा सहज, संवाद चुटीले और कहानी तेज़ रफ़्तार है। यह गति सुनिश्चित करती है कि पाठक कहीं भी बोर न हो। कहानी ख़त्म होते-होते एक ऐसा हतप्रभ कर देने वाला मोड़ लेती है, जिसके लिए सत्य व्यास जाने जाते हैं। यह क्लाइमेक्स पूरे सफर को यादगार बना देता है।
अगर आप एक हल्की-फुल्की, तेज़-तर्रार और अनोखे विषय पर आधारित हिंदी किताब ढूँढ रहे हैं, तो ‘उफ़्फ़ कोलकाता’ निश्चित रूप से आपकी पठन सूची में होनी चाहिए।
Myra Macdonald’s Defeat Is an Orphan, published in 2017, is a compelling and incisive examination of the turbulent post-nuclear history of India-Pakistan relations. Long unread on my own bookshelf, I found the book to be a crucial read for understanding the current geopolitical landscape of South Asia.
Macdonald, with her journalist’s eye for detail and a historian’s depth, masterfully traces the rollercoaster ride of conflict and diplomacy that followed the 1998 nuclear tests. The central argument is stark: Pakistan decisively lost the Great South Asian War, not because of India’s overwhelming military victory, but because of Pakistan’s own strategic miscalculations and dysfunction.
The core of Macdonald’s analysis lies in the paradoxical impact of nuclear weapons. While they restored a certain strategic parity and shielded Pakistan from full-scale retaliation due to its smaller size, they ultimately proved to be its undoing. The book effectively dissects how the nuclear shield encouraged a reckless reliance on militant proxies (jihadis) even as those proxies began to spin out of control both internally and externally. This reliance sealed Pakistan into a cycle of militarism and denial.
Macdonald successfully argues that while India, despite its flaws, was able to move toward economic and political consolidation, Pakistan became increasingly trapped. The book chronicles this downward spiral through key moments—from the Kargil conflict and military confrontation in the plains to the hijacking of an Indian plane and the horrific assault on Mumbai—showing how the ability to stake a serious claim to Kashmir and influence events in Afghanistan diminished rapidly.
Defeat Is an Orphan is thought-provoking and exceptionally well-researched. It offers a nuanced perspective on South Asia’s geopolitical dynamics by focusing on the military’s dominant role in shaping Pakistan’s national policy and the country’s repeated failures to adapt.
This is not merely a historical account; it is a critical analysis that remains remarkably relevant years after its publication. For anyone seeking to understand the roots of ongoing regional tensions and the complex interplay of nuclear deterrence, proxy warfare, and state policy in South Asia, this book is an essential reading. It powerfully makes the case that this “war… was not so much won by India as lost by Pakistan.“
Telegram is a cloud based messaging application which provides an excellent set of APIs to allow developers to automate on top of the platform. It is increasingly being used to automate various notifications and messages. It has become a platform of choice to create bots which interact with users and groups.
Telethon is an asyncio Python 3 library for interacting with telegram API. It is one of the very exhaustive libraries which allows users to interact with telegram API as a user or as a bot.
Recently I have written some AWS Lambda functions to automate certain personal notifications. I could have run the code as a container on one of my VPSs or on Hulu or other platforms, but I took this exercise as an opportunity to learn more about serverless and functions. Also, my kind of load is something which can easyly fall under the Lambda free tier.
In this post we will look into the process of how to start with the development and write some basic python applications.
Registering As a Telegram Developer
Following steps can be followed to obtain the API ID for telegram –
Sign up for Telegram using any application
Login to the https://my.telegram.org/ website using the same mobile number. Telegram will send you a confirmation code on Telegram application. After entering the confirmation code, you will be seeing the following screen –
In the above screen select the API Development Tools and complete the form. This page will provide some basic information in addition to api_id and api_hash.
Setting up Telethon Development Environment
I assume that the reader is familiar with basic python and knows how to set up a virtual environment, so rather than explaining, I would more focus on quick code to get the development environment up and running.
I will be using .env file for storing the api_id and api_hash so that the same can be used in the code which we will write. Replace NNNNN with your api_id and XX with your api_hash
Next we will need to create a session to be used in our code. For full automation, it is needed that we store the session either as a file or as a string. Since the cloud environments destroy the ephimeral storage they provide, so I will get the session as a string. The following python code will help obtain the same.
#! /usr/bin/env python3
import os
from dotenv import load_dotenv
from telethon.sync import TelegramClient
from telethon.sessions import StringSession
load_dotenv()
with TelegramClient(StringSession(), os.getenv("TELEGRAM_API_ID"), os.getenv("TELEGRAM_API_HASH")) as client:
print(client.session.save())
When this code is executed, it will prompt for your phone number. Here you would need to print the phone number with the country code. In the next step, an authorization code will be received in the telegram application which would need to be entered in the application prompt. Once the authorization code is typed correctly, the session will be printed as a string value on standard output. You would need to save the same.
(venv-telethon) $ ./get_string_session.py
Please enter your phone (or bot token): +91xxxxxxxxxx
Please enter the code you received: zzzzz
Signed in successfully as KKKKKK KKKKKKK
9vznqQDuX2q34Fyir634qgDysl4gZ4Fhu82eZ9yHs35rKyXf9vznqQDuX2q34Fyir634qgDyslLov-S0t7KpTK6q6EdEnla7cqGD26N5uHg9rFtg83J8t2l5TlStCsuhWjdzbb29MFFSU5-l4gZ4Fhu9vznqQDuX2q34Fyir634qgDysl9vznqQDuX2q34Fyir634qgDy_x7Sr9lFgZsH99aOD35nSqw3RzBmm51EUIeKhG4hNeHuF1nwzttuBGQqqqfao8sTB5_purgT-hAd2prYJDBcavzH8igqk5KDCTsZVLVFIV32a9Odfvzg2MlnGRud64-S0t7KpTK6q6EdEnla7cqGD26N5uHg9rFtg83J8t2l5TlStCsuhWjdzbb29MFFSU5=
I normally put the string session along with the API ID and Hash in the .env file. All these three values would need to be protected and should never be shared with a third party.
For the next code, I will assume that you have used a variable TELEGRAM_STRING_SESSION. So the final .env file will look like below –
Now we have the ground work done, so we will write a simple python application to send a message to a contact. The important point to note here is that the recipient must be in your telegram contacts.
#! /usr/bin/env python3
import os
from telethon.sync import TelegramClient
from telethon.sessions import StringSession
from dotenv import load_dotenv
load_dotenv()
try:
client = TelegramClient(StringSession(os.getenv("STRING_TOKEN")), os.getenv("API_ID"), os.getenv("API_HASH"))
client.start()
except Exception as e:
print(f"Exception while starting the client - {e}")
else:
print("Client started")
async def main():
try:
# Replace the xxxxx in the following line with the full international mobile number of the contact
# In place of mobile number you can use the telegram user id of the contact if you know
ret_value = await client.send_message("xxxxxxxxxxx", 'Hi')
except Exception as e:
print(f"Exception while sending the message - {e}")
else:
print(f"Message sent. Return Value {ret_value}")
with client:
client.loop.run_until_complete(main())
Next Steps
The telethon API is quite versatile, a detailed API documentation can be find at https://tl.telethon.dev/. Hope this post will help the reader quickly start off with the telegram messaging with telethon module.
Python is a popular language along with Javascript (NodeJS) for writing AWS lambda functions. Lambda function written in Python support the core modules, so one may choose to use the http.client instead of much simpler requests. However, if the function is to use some custom or non-native packages such as request and response we have few methods available to us.
In this article I will be discussing one such method of uploading a zip file containing all such custom packages and adding an AWS Lambda Layer to use this zip file for the particular function. We will be making use of Docker containers for this process. To be honest we actually do not need to go through the process of using a docker container. We can use only a simple pip install -t, zip the directory and upload it. However, certain python modules need to compile extensions written in C or C++. For such modules, the pip install -t approach will not work as the AWS Lambda functions use AWS Linux environment and you may have OSX, Windows or any other linux distribution of your choice. If you are sure that your modules do not have compiled extensions, please follow steps 2 and 3 below in this post.
Step 1 – Build and Run the Docker Container
The pre-requisite for this step is to have Docker installed. If you are on OSX, you can use Docker for Desktop. In this step we will use Amazon Linux base image and install desired version of python and few modules and OS packages. Amazon Linux 2 is a long term support release available at this moment. Amazon Linux 2 provides amazon-linux-extras which allows availability of newest application software on a stable base. At the time of writing this, Python 2.7 has been depricated by Amazon and the recommended version is Python 3.8. We would be needing to use amazon-linux-extras to install Python 3.8. Following Dockerfile is a very simple and self-explanatory file which we will be using to build our container –
FROM amazonlinux:2
RUN amazon-linux-extras enable python3.8 && \
yum install -y python38 && \
yum install -y python3-pip && \
yum install -y zip && \
yum clean all
RUN python3.8 -m pip install --upgrade pip && \
python3.8 -m pip install virtualenv
user1@macbook-air $ docker run -it --name aws_lambda_layer aws_lambda_layer:latest bash
This will give the bash shell inside the container. Next step will install the required modules in a python 3.8 virtual-environment and package as a zip file
Step 2 – Install Non-Native Packages and Package These As A Zip File
We will install the required packages inside a virtual environment, this will allow to reuse the same container for other future packaging also.
# python3.8 -m venv venv-telethon
Next, activate the virtual environment and install the packages in it under a specific folder, so that the same can be packaged. After packaging the folder, the zip file needs to be copied outside the container so that the same can be uploaded –
Step 3 – Upload the Package to the AWS Lambda Layer or S3
If the zip file is more than 50 MB, it has to be uploaded to Amazon S3 store. In case you decide to upload it S3 store, ensure that the path of the file is recorded carefully.
To upload the file, under the Lambda->Layer, click on Create Layer and fill up the form. The form will allow to upload the zip file or specify the path of the AWS S3 location where the file is uploaded.
Now write your lambda function and use the modules which were uploaded as a part of the zip file.