DSPy
DSPy = Declarative Self-improving Python.
Components
1. language model — LLM that will answer our questions,
2. signature —a declaration of the program’s input and output (what task we want to solve),
- 1. inline
- 2. class
dspy.InputField()
List[Literal['', '', '']] = dspy.OutputField()
3. module — the prompting technique (how we want to solve the task).
- Building blocks
- different prompting strategies,
- 1. dspy.Predict
- 2. dspy.ChainOfThought
- 3. dspy.ReAct (to add tools = function calling
4. Optimiser
- 1. Automatic few-shot learning (e.g. BootstrapFewShot or BootstrapFewShotWithRandomSearch)
- 2. Automatic instructions optimisation (e.g. MIPROv2)
- 3. Automatic fine-tuning (e.g, BootstrapFinetune)
Other points
- dspy.inspect_history for logs
- Caching
# 1. updating config
dspy.configure_cache(enable_memory_cache=False, enable_disk_cache=False)
# 2. not using cache for specific module
math = dspy.Predict("question -> answer: float", cache = False)
- dspy.configure(adapter=dspy.JSONAdapter())
- DSPy is integrated with MLFlow (an observability tool)
Identity Provider
https://github.com/pando85/kaniop Kaniop is a Kubernetes operator for managing Kanidm.
https://kanidm.com/ Kanidm is a modern, secure identity management system that provides authentication and authorization services with support for POSIX accounts, OAuth2, and more. It is simple and written in rust
IDP
(1)
https://github.com/JanssenProject/jans
https://github.com/JanssenProject/jans/tree/main/jans-keycloak-link
https://imshakil.medium.com/janssen-mod-auth-openidc-module-to-test-openid-connect-single-sign-on-s…
It is by Glu
(2) Vault it self support OIDC https://developer.hashicorp.com/vault/docs/secrets/identity/oidc-provider https://brian-candler.medium.com/using-vault-as-an-openid-connect-identity-provider-ee0aaef2bba2
-------------
Why Choose Keycloak?. Understanding the Need for an Identity… | by J3 | Jungletronics | Medium
Ory
GitHub - ory/k8s: Kubernetes Helm Charts for the ORY ecosystem. · GitHub
The Paper That Changed Everything: Attention is All You Need
Here are few links
The Paper
https://arxiv.org/pdf/1706.03762.pdf
------------------------
Medium
https://medium.com/@SimplifyingFutureTech/understanding-attention-is-all-you-need-750713a1631b
https://medium.com/codex/attention-is-all-you-need-explained-ebdb02c7f4d4
-------------
PoloClub
https://poloclub.github.io/transformer-explainer/
https://arxiv.org/abs/2408.04619
https://www.youtube.com/watch?v=ECR4oAwocjs
-----------
Last Few videos of https://www.youtube.com/watch?v=2dH_qjc9mFg&list=PLKnIA16_RmvYuZauWaPlRTC54KxSNLtNn
https://hasgeek.com/fifthelephant/paper-reading-meet-up-december-2023/
https://www.linkedin.com/pulse/decoding-attention-all-you-need-how-transformers-ai-yuri-sylse/
--------------
Embedding is representation of text in multi dimensional space
Diffusion model add noise and then remove it. It is for multimodal.
Multi head = syntax + semantics + position. It improves expressiveness and captures richer patterns.
Attention is about which embedding to look at. It does not change embedding.
Few other miscellaneous link from event https://luma.com/d0yhf0ib
1. IronClaw
https://github.com/nearai/ironclaw
https://www.ironclaw.com/
IronClaw is the secure, open-source alternative to OpenClaw that runs in encrypted enclaves on NEAR AI Cloud. TEE (Trusted Execution Environment)
Transformers & Large Language Models - 1 of 9
• Background on NLP and tasks
NLP Tasks
1. Classification
- Sentimental analysis :
* Examples: Amazon reviews, IMDB critiques, Twitter.
* Many to one RNN example.
Input: sequence of data
Output: scaler.
- Intent detection
- Language detection
* One to many RNN example.
Example: Image Captioning and Topic modeling
Input: single or scaler
output: sequence of data
2. "Multi"-Classification
* Synchronous Many to many RNN example.
Example: Part of speech tagging and Named entity recognition (NER): Dataset = annotated Reuters newspaper (CONLL-2003, CONLL+)
Input: sequence of data
output: sequence of data
- Dependency parsing
- Constituency parsing
3. Generation
* Asynchronous Many to many RNN example.
Example : Machine translation: Dataset = WMT'14 Translation quality unit is , Question answering, Summarization, Speech to text
Input: sequence of data
output: sequence of data
Length is not equal. No one to one mapping.
This RNN example is now done with transformer, LLM.
- Text generation
History of LLM
1980 RNN
1997 LSTM (Theoretical Foundation)
2013 Word2Vec
2014 Sequence to Sequence Learning with NN
2015: "Neural machine translation by jointly learning to align and translate" It introduced attention mechanism. Here sequential nature of processing at encoder and decoder.
2017: Transformer. Parallel processing. "Attention is all you need". Encoder and decoder both have self attention.
2018: Transfer learning. "Universal language model fine tuning (ULMFit) for text classification"
- Introduced language modelling
- Now common model for all usecases
- No need of supervised data
- It is about predicating next word.
Transformer Language Model
1. BERT by Google (encoder only model)
2. GPT by OpenAI (decoder only model). Then GPT2, GPT3 etc.
2020s LLM
• Tokenization
1. Arbitrary (n/a)
2. Word (multiple tokens with similar meanings need same embedding, so Word variations not handled)
3. sub-word : focus on common root. Increase sequence length. Tokenization more complex
4. character level: can correct mis-spelled word & CasINg. Sequence length is much longer. No OOV
• Embeddings
Word (Token) Representation by vector
OHE = One Hot Encoding
cosine similarity
• Word2vec, RNN, LSTM
1. Word2Vec
It is ANN with proxy-task
1. CBOW: Continuous Bag of Words. You predict the target word
2. Skip-gram : You take the target word and predict words around it
Word order does not matter
Embeddings is not context aware
Dimension size example 768
Special token to indicate "end of sequence"
2. RNN Recurrent Neural Network
Connection forms a temporal sequence
H = Hidden state = A = Activation Vector = Context Vector.
RNN is used for all 3 NLP tasks
1. Classification
2. "Multi"-Classification
3. Generation
RNN is keep forgetting the past. This phenomena is called "vanishing gradient"
Word order matters in RNN
3. LSTM = Long short-term memory
1. hidden state
2. cell state
• Attention mechanism
Attention tries to have a direct link between next word that we are predicting and something from the past.
"self-attention" is main principle of "Attention is all you need" 2017 paper
"self-attention" = Instead of sequential, let direct connection with all part of text at once.
Concept of Query, Key and Value
We compare Q to K. How they are similar and then take corresponding value
Softmax converts unnormalized network output into probability for different class such that value is [0,1] and sum is 1.
Formula – Given a query Q, we want to know which key K the query should pay "attention" to with respect to the associated value V.
attention = softmax ( Q * K ^ T / Sqrt (dimension of K) ) * V
There are three attention layers
1. Attention layer at encoder to compute embeddings from input
2. Decoder-decoder attention OR self-attention layer in decoder, It is is masked, because it only look at those token that are translated. It determines: what other token of output sentence is useful to predict next token.
3. cross-attention layer : expressed as function of what is seen in input. Last part of encoder. it is fetch to decoder.
We have direct link to all token. So order words does not matter. (unlike RNN). So we have Position Encoding: to inform position of word in sequence.
BOS Token: Beginning of Sequence.
EOS Token: End of Sequence
• Transformer architecture
Self-attention is achieved by transformer = encoder and decoder
1. Encoder computes meaningful embedding from input text. We have N such encoders. Input layer generates position aware embedding matrix with size d = model size and length = length of input sequence = n
Encoder projects input sequence on 3 spaces Wk, Wq and Wv. so model learns.
attention = softmax ( Q * K ^ T / Sqrt (dimension of K) ) * V
Projecting on Wq gives a matrix where each row represents a given query Q. So we get matrix Wo that is project back to original dimension of embedding.
K^T is each column represents key of each token.
When we multiple K^T and Wq, Each row represents projection of query over each key and then get probability distribution.
Now multiple with matrix V
This is self-attention mechanism. means compute representation of each token as function of other tokens. it is done by attention layer.
Multi-Head Attention (MHA) means this computation is done in different way. So model can learn
- different representation
- different projections
so all token of input text attend each other.
It is masked self-attention layer.
A Multi-Head Attention (MHA) layer performs attention computations across multiple heads, then projects the result in the output space.
2. FFNN (Feed Forward Neural Network) : so model learn another kind of projection
so we get rich representation of input token
In LLM, hidden layer has higher dimension. So model has enough degree of freedom to learn useful representation.
3. output is for decoder
It takes Q from output.
K, V from encoder.
we have N decoders.
New Terms
- Perplexity is an evaluation matrix for machine translation. It quantifies how 'surprised' the model is to see some words together. Lower is better.
- OOV = out of vocabulary
- RNN is keep forgetting the past. This phenomena is called "vanishing gradient"
Label Smoothing Purpose
- prevent overfitting
- introduce noise
- let model be little unsure about prediction.
It improves accuracy and BLEU score of translation.
RLHF : Reinforcement learning from human feedback
References
https://cme295.stanford.edu/
Syllabus : https://cme295.stanford.edu/syllabus/
CheatSheet
https://cme295.stanford.edu/cheatsheet/
https://github.com/afshinea/stanford-cme-295-transformers-large-language-models/tree/main/en
https://www.youtube.com/watch?v=Ub3GoFaUcds
https://www.youtube.com/watch?v=8fX3rOjTloc
Text Book Super Study Guides
------------------------------------------------------
Sequence to Sequence model has
1. Encoder, Decoder
2. Attention Mechanism
3. Transformer architecture
4. Fine tuning of Transformer Architecture
Usecases
1. Language, sentence has words in sequecne
2. Time series data
3. Biology: Genes, DNA
4.
------------------------------------------------------
Some more relevant stuff:
Each layer has
1. Attention and
2. Fast Forward
Between two layers we have high dimension 'hidden state vector' in activation space.
LLM encodes concepts as distributed patterns accross layers = Superposition.
Antropic has series of papers on superposition and monosemanticity
https://www.youtube.com/watch?v=F2jd5WuT-zg
https://www.neuronpedia.org
https://huggingface.co/collections/dlouapre/sparse-auto-encoders-saes-for-mechanistic-interpretability
https://huggingface.co/spaces/dlouapre/eiffel-tower-llama
------------------------------------------------------------
Sanskrit speech at closing ceremony of spoken Sanskrit workshop
10 days Spoken Sanskrit workshops (Sanskrit Sambhaasan Shibir) held from July14 2025 to July 23 2025 at BEML Balaji Temple and at Skylark Arcadia Bangalore, by Samskrita Bharati Marathahalli bhaga, Bangalore, India.
Spoken Sanskrit workshops - closing ceremony on 26th July 2025.
Sanskrit speech by chief guest Shri Manish Panchmatia
Greetings!
A warm welcome to everyone present—teachers, volunteers from Samskrita Bharati, students, and all those passionate about Sanskrit. After bowing down to each of you, I am honored to begin my speech.
First, let me ask: “How was the Spoken Sanskrit Workshop?” Was it “Good”? “Very good”? I’m certain it was a positive experience. Whenever Samskrita Bharati organizes a workshop, the teachers impart their knowledge with dedication, don’t they? Over the past ten days, each one of you demonstrated incredible determination to learn Sanskrit. No matter what, you attended all the classes and gave your best effort. Kudos to you all for your commitment and enthusiasm. You sang songs in Sanskrit, offered prayers, performed dramas, and narrated stories—all in Sanskrit. I am truly impressed by your efforts and progress.
As you may know, NASA called Sanskrit the most suitable language for computers. I won’t repeat those facts, but I do want to share a story about Sanskrit’s vast vocabulary. Just now, we sang about great poets—Vyasa, Bhasa, Kalidasa, Banabhatta—yet there is another renowned poet: Dandi, who composed “Dasakumaracharitam,” the story of ten princes. One prince, wounded in the lower lip, could not pronounce certain sounds: "pa," "fa," "ba," "bha," and "ma." Dandi skillfully chose synonymous words without those sounds for all of that prince’s dialogue. This was possible only because Sanskrit’s vocabulary is so rich.
Sanskrit grammar is exceptionally precise; in fact, the very meaning of the word “Sanskrit” is “well-formed” or “perfect.” Sanskrit has maintained its grammar rules since Vedic times—pronunciation, grammar, language rules—all unchanged. Even though new inventions like mobile phones have appeared, in Sanskrit, we create new words effortlessly. “Mobile phones” in Sanskrit is “Jangam Door-Vani”—a moving telephone. Artificial intelligence becomes “Krutrim Buddhi.” Thanks to Sanskrit’s structure, new words can always be formed. This habit of following rules brings discipline to our lives.
We all are Indians. Sanskrit is deeply imprinted in our consciousness. Just as our childhood photos make us happy, speaking Sanskrit awakens ancient impressions within us—it fills the soul with joy. Throughout these ten days, you learned Sanskrit joyfully, supported by equally joyful teachers.
How do we gain these benefits? By giving your 100% effort to learning Sanskrit. What does 100% effort mean? Here is another story from the Mahabharata. Karna is renowned as the greatest giver. Once, Arjuna asked Krishna, "Why is Karna more famous for charity than my brother Yudhishthira?" Krishna replied, “Let’s see for ourselves.” Disguised as BRAHMINs, Arjuna and Krishna visited Yudhishthira and requested sandalwood for a yagna. Yudhishthir responded, "OK". Then, what did Yudhishthir do? He searched. Remember the story of the crow. The crow was searching for water. Here Yudhishthir is searching for sandalwood. He looked here . He looked there. Right side. Left side. Front side. Back side. He looked for Sandalwood everywhere. The sandalwood is nowhere. Then he went outside. Looked at the garden. He searched everywhere. The sandalwood is nowhere. He returned back and told BRAHMIN: "Sorry sir. The sandalwood is nowhere. I will surely make a little more effort to arrange for sandalwood. Please come tomorrow. I will give." BHRAMIN said, "OK". Then, they visited Karna with the same request. Karna eagerly searched, and when he could not find sandalwood, he noticed his door was made of sandalwood. Without hesitation, he dismantled it and gave it to them. True charity is giving with 100% effort. It is the same with learning Sanskrit—when you give your wholehearted effort, you will gain both knowledge and discipline.
Further, speaking Sanskrit even helps with breathing exercises—“ma” and “ha” are frequently used, which naturally leads to “pranayama.”
This spoken Sanskrit workshop is just the beginning. Explore further—enroll in correspondence Sanskrit learning courses, Gita Sopanam etc. There are many Sanskrit books here, for sale. Buy them, read them and then, become Sanskrit teachers yourselves! Spread and promote Sanskrit to others just as your teachers did for you. You all know Swami Vivekananda. Right? "Yes". On 4th July, it was his death anniversary. On the last day of life, he taught Sanskrit to the students. You all know that? It is in his biography. Let us honor this legacy by teaching and learning Sanskrit.
Having spoken much about Sanskrit, let me turn briefly to our IT professionals. When we hear the word “language,” we often think of C, C++, Java, Python, NodeJS, ReactJS, and so on. Recently, I attended a "PyKrit" (Python + Sanskrit) workshop at Aksharam, Samskrita Bharati’s center. This workshop was not for IT people. It was for Sanskrit scholars. I saw Sanskrit scholars name Python functions in Sanskrit, such as “YANA SANDHI” (a grammar topic). We truly can create software for Sanskrit grammar, using modern programming languages like Python, and even coding in Sanskrit.
Lastly, my wish: While we use AI/GenAI tools like ChatGPT, we mostly interact in English. Wouldn’t it be wonderful to have a large language model (LLM) in Sanskrit? Imagine asking questions in Sanskrit and receiving answers, back in Sanskrit, from AI tools, such as ChatGPT. That is my hope for the future.
Best wishes to everyone, and thank you all.
LLMOps
For AI application, we need automation of
1. Data preparation
2. model tuning
3. Deployment
4. Maintenance and
5. Monitoring
- Managing Dependency adds complexity.
E2E workflow for LLM based application.
MLOps framework
1. data ingestion
2. data validation
3. data transformation
4. model
5. model analysis
6. serving model
7. logging.
LLM System Design
boarder design of E2E app including front end, back end, data engineering etc.
Chain multiple LLMs together
* Grounding : provides additional information/fact with prompt to LLM.
* Track History. how it works past.
LLM App
User input->Preprocessing->grounding->prompt goes to LLM model->LLM Response->Grounding->Post processing + Responsible AI->Final output to user.
Model Customization
1. Data Prep
2. Model Tuning
3. Evaluate
It is iterative process
LLMOps Pipeline (Simplified)
1. Data Preparation and versioning (for training data)
2. Supervised tuning (pipeline)
3. Artifact = config and workflow : are generated.
- config = config for workflow
E.g.
Which data set to use
- Workflow = steps
4. Pipeline execution
5. deploy LLM
6. Prompting and predictions
7. Responsible AI
Orchestration = 1 + 2 . Orchestration : What is first, then next step and further next step. sequence of step assurance.
Automation = 4 + 5
Fine Tuning Data Model using Instructions (Hint)
1. rules
2. step by step
3. procedure
4. example
File formats
1. JSONL: JSON Line. Human readable. For small and medium size dataset.
2. TFRecord
3. Parquet for large and complex dataset.
MLOps Workflow for LLM
1. Apache Airflow
2. KubeFlow
DSL = Domain Specific Language
Decorator
@dls.component
@dls.pipeline
Next compiler will generate YAML file for pipeline
YAML file has
- components
- deploymentSpec
Pipeline can be run on
- K8s
- Vertex AI pipeline execute pipeline in serverless enviornment
PipelineJob takes inputs
1. Template Path: pipline.yaml
2. Display name
3. Parameters
4. Location: Data center
5. pipeline root: temp file location
Open Source Pipeline
https://us-kfp.pkg.dev/ml-pipeline/large-language-model-pipelines/tune-large-model/v2.0.0
Deployment
Batch and REST
1. Batch. E.g. customer review. Not real time.
2. REST API e.g. chat. More like teal time library.
* pprint is library to format
LLM provides output and 'safetyAttributes'
- blocked
* We can find citation also from output of LLM
===========
vertexAI SDK
https://cloud.google.com/vertex-ai
BigQuery
https://cloud.google.com/bigquery
sklearn
To decide data 80-20% for training and evaluation.
Building AI/ML apps in Python with BigQuery DataFrames | Google Cloud Blog
===========
AI Bootcamp for students
8 Day Live Online Workshop
AI Bootcamp for Students
Make Your Child Future-Ready with AI
by Timesof Inida
https://www.notion.com/product Documentation
https://www.todoist.com/ To Do List
https://gamma.app/ For presentation
https://openai.com/index/sora/ Cinematic Video
https://www.midjourney.com/home Art Grade Visuals for story telling
https://ideogram.ai/t/explore Typography to image. Communicate in style
https://lovable.dev/ No code web apps
https://n8n.io/ Workflow automation tools
Few more tools
TachyonGPT accelerate the project planning process, potentially saving weeks of effort. This powerful AI assistant allows you to create a complex backlog structure for your project in very little time. Tachyon GPT gives you the power to improve existing work items or generate new work items based on brief titles or descriptions. https://marketplace.visualstudio.com/items?itemName=Neudesic.TachyonGPT
windserf editor and cascade. Agentic code IDE
Reference: https://economictimes.indiatimes.com/masterclass/ai-for-students
https://www.msn.com/en-in/money/news/chatgpt-to-google-gemini-top-5-ai-tools-to-enhance-productivity-mostly-free/ar-AA1GRlt1
CAMARA - NaaS
Keywords
- CAMARA APIs
- Open GW
- Network API
- NaaS
AI impacts API development
Usecase
1. anti fraud
2. location API : book cab for people not having smart phone
3. voice activated AI transaction. book a cab
4. geo fencing. warn people when other people comes close to them. logistic when truck reaches store, offloading
5. future Quality in demand
Challenges
1. monetizing
2. standardizing
3. presenting to non-telco audience
4. focus on right APIs: There are 15 fraud APIs, customer only wants to know is it fraud or not?
5. scale and coverage: approach operator and help them coming to eco system
6. data privacy and consent: no need for customer to provide consent for each new API. it is bad experience
7. education and certification about API. Let developer make new business models and business case.
8. telco shall listen to industry need. how to solve challenges using advance connectivity and APIs. demand side focus.
https://www.youtube.com/watch?v=Rg-TKpBuiPI
Popular APIs
- Messaging
- authentication
- Device location,
- QoS,
- fraud prevention,
- identity verification
- age verification
https://cpaasaa.com/post-mwc-aduna-vonage-and-the-future-of-network-apis/
Network API centralizes complexity and distribute simplicity
https://www.youtube.com/watch?v=4C9zrRNoxas
Vonage and Infobip : service aggregation
https://www.youtube.com/watch?v=Jh8iUuNHFYw
Network APIs, allow operators to virtualize parts of their networks and provide tailored data and features to developers
Network API v/s Usecase
1. Verify Location: Navigation, geotagging and location-aware notifications, personalized marketing
2. Device Status: Optimize resource usage based on device health and network condition. Identify issue and proactive customer support
3. SIM Density: Ensure optimal user experience during peak hours, SON
4. SIM swap: Fraud Prevention
5. QoD
6. Device identification, device location, and phone number verification
7. Identity and consent management
8. OTP validation
https://www.vonage.com/resources/articles/what-is-a-network-api/
Vonage Network Registry
CSP can find who developer uses
Developer can decide which CSP to choose.
We are moving from Transactional world to conversational world.
https://camaraproject.org/resources/
अष्टाध्यायी - 2
This article is my key take away points from PythonKrit workshop, at Samskrit Bharti Bangalore during March 2025
Dr. Amba Kulkarni explains how ASHTADHYAYI by sage PAANINI is similar to computer programming and compiler design
https://sanskrit.uohyd.ac.in/faculty/amba/ and https://www.sanskritstudiespodcast.com/1759898/episodes/12324157-16-amba-kulkarni-sanskrit-and-computers
ASHTADHYAYI is also Algorithm and Data structure. Class/Object has data and function. Paanini's DHTAATU list has name of DHAATU and "इत् प्रत्यय". Here "इत् प्रत्यय" indicates, which operation to be performed. We know the challenges with multiple inheritance in Object Oriented Programming. Prof. Ashvini Bhave shows how TADDHITTA indicates single inheritance.
Sage PAANINI introduced a new data structure SHIVA-SUTRA. He rearranged all character and did slicing then perform Boolean operation that input character belongs to given list or not, given input set of character is subset or not.
Meta language itself is part of ASHTADHYAYI .
Three types of rules
1. regular rules
2. context free rules
3. context sensitive rules
We use regular expression * for beginning AADI , UPAADHAA for set of characters in middle with [] and $ for end of line (ANTHA).
We know yacc and bison tools are for context free grammar. If we write all PAANINI rules as per syntax of yacc and bison then we can analyze the complexity of PAANINI's ASHTADHYAYI grammar. There are few non-formal aspects in ASHTADHYAYI, as it was written to understand by human brain, not by computer.
Sage PAANINI was about 1500 years ahead of time compare to today's computing power.
Rules are like event in programming. To understand grammar one of the rule shall be evaluated, it is like firing an event.
ANUVRUTI is similar to factorization in Maths.
Slides: https://web.stanford.edu/~kiparsky/Papers/paris.pdf and Stream rtsp://stream-serv.inrialpes.fr/Roc/Symposiums_2007/Sanskrit291007B_Gillon.rm by Paul Kiparsky
The entire data that powers https://ashtadhyayi.com https://github.com/chaitanya-lakkundi/ashtadhyayi-com-data/
https://github.com/chaitanya-lakkundi/ashtadhyayi-commentaries/
https://drdhaval2785.github.io/siddhantakaumudi/
https://github.com/drdhaval2785/siddhantakaumudi
https://en.wikipedia.org/wiki/Mahabhashya
Books
https://en.wikipedia.org/wiki/Algorithms_%2B_Data_Structures_%3D_Programs
https://www.sushmajee.com/reldictionary/literature/grammar/sanskrit-grammar.htm
Books: https://www.ebharatisampat.in/
https://www.amazon.com/Vaiyakaran-Siddhant-Kaumudi-Set-Volumes/dp/B00LND3A5U
Papers
https://sanskrit.inria.fr/Symposium/Program.html
https://upenn.academia.edu/Cardona
https://independent.academia.edu/SarojaBhate
YouTube / Videos:
https://www.youtube.com/ashtadhyayi
https://www.youtube.com/playlist?list=PLxPxgIW05q49w0453x8iDZpfv0fNH8ujK
https://www.youtube.com/watch?v=gs0c4UXgM8M
https://www.youtube.com/@prasarbharatisanskrit
https://www.sanskritstudiespodcast.com/1759898
https://www.youtube.com/watch?v=7X5uqiODNPw&list=PLEKLkZ5fxeD0Xt4TKUwAkiRVw_AUV3y_X
https://www.youtube.com/watch?v=_OkzIE61EMg
https://www.youtube.com/watch?v=AGPfSgVqb78
https://www.youtube.com/watch?v=9tndwY-pJAk&list=PLeCoRXpRAy9iK1CTKseX_Vgg9-RcV-Uql
PythonKrit
This article is my key take away points from PythonKrit workshop, at Samskrit Bharti Bangalore during March 2025.
XML to Mindmap generation : https://sambhasha.ksu.ac.in/CompLing/tarkasangraha/live/
We can have special tag like
<PAA-LAXANAM>
<PAA-UDAA>
<PAA-VAKYAM>
Other Tools
https://sambhasha.ksu.ac.in/projects/
Aksharamukha
https://github.com/chaitanya-lakkundi/aksharamukha
Vaijayantīkośa Knowledge-Net https://sambhasha.ksu.ac.in/CompLing/VK_ACL.pdf
A directory of Indic (Indian) language computing projects and resources https://indic.page/
https://sambhasha.ksu.ac.in/CompLing/chandas/chandas.html
https://www.gitasupersite.iitk.ac.in/conceptmaps Good resource for Neo4J graph DB
https://sanskritlibrary.org/downloads.html
https://sanskritlibrary.org/projects.html
https://sanskritlibrary.org/tools.html
Krudanta Rupa: https://github.com/chaitanya-lakkundi/kridanta-rupa-android/blob/master/kridanta_rupa_samgraha.pdf
Aadi Shankaracharya : https://www.sankara.iitk.ac.in/ and https://www.advaita-vedanta.org/texts/index.html
https://www.gitasupersite.iitk.ac.in/
GitHub
https://github.com/chaitanya-lakkundi/
https://github.com/drdhaval2785
Useful Sanskrit Alphabet https://github.com/chaitanya-lakkundi/varnamala/blob/main/varnamala.py
https://github.com/drdhaval2785/SanskritVerb/
https://github.com/drdhaval2785/SanskritSubanta
For Kids
https://bala.sambhasha.ksu.ac.in/
https://www.samskritpromotion.in/samskrit-toys
Scholars
https://sanskrit.uohyd.ac.in/faculty/amba/ and https://www.sanskritstudiespodcast.com/1759898/episodes/12324157-16-amba-kulkarni-sanskrit-and-computers
https://web.stanford.edu/~kiparsky/ and https://en.wikipedia.org/wiki/Paul_Kiparsky
Python
List Tuple Dictionary
Ordered? Yes Yes No
Mutable? Yes No Yes
Different Data Types? Yes Yes Yes
Can be indexed? Yes Yes Yes by keys
Syntax [] () {}
Duplicate elements? Yes Yes Yes, but key must be unique
- Both List and tuple supports: Slicing and skipping index
- Tuple is immutable, so faster
eBPF
- eBPF programme in C, Rust or other programming languages.
- Compiler converts it to bytecode (obj file)
- Application pass this OBJ to kernel using eBPF library
- Kernel verifies it
- When event happens the program runs
- eBPF programme in C, Rust or other programming languages.
- Compiler converts it to bytecode (obj file)
- Application pass this OBJ to kernel using eBPF library
- Kernel verifies it
- JIT compiler converts byte code to machine code
- When event happens the program runs
- eBPF programme in C, Rust or other programming languages.
- Compiler converts it to bytecode (obj file)
- Application pass this OBJ to kernel using eBPF library
- Kernel verifies it
- JIT compiler converts byte code to machine code
- When event happens the program runs
- Multiple eBPF programs can access eBPF map at Kernel space
- Userspace App load config to map
- eBPF program pull config from map
- eBPF program sends metrics to map
- eBPF program stores/retrieve data from/to map
- eBPF map can store state in eBPF program
- BPF_TABLE
- BPF_HASH
- BPF_ARRAY
- BPF_HISTOGRAM
- BPF_PERF_ARRAY
- eBPF programme in C, Rust or other programming languages.
- Compiler converts it to bytecode (obj file)
- Application pass this OBJ to kernel using eBPF library
- Kernel verifies it
- JIT compiler converts byte code to machine code
- When event happens the program runs
- Multiple eBPF programs can access eBPF map at Kernel space
- Userspace App load config to map
- eBPF program pull config from map
- eBPF program sends metrics to map
- eBPF program stores/retrieve data from/to map
- eBPF map can store state in eBPF program
- BPF_TABLE
- BPF_HASH
- BPF_ARRAY
- BPF_HISTOGRAM
- BPF_PERF_ARRAY
- eBPF program can call Kernel function (eBPF helper)
