Coming soon, this December
C & C++ Low Latency Engineering
Exclusive
With an exciting offer for existing students
New Batch . Enrolling Now
HPC | FPGA
Low latency engineering and FPGA development
HFT doors - They don't open for everyone and neither are they easy to open.
Some need a key. Some need a kick. We will teach you both.
Mode of lecture delivery -
Online via Zoom
STARTS
15
Dec 2026
Timing . Night
11 PM - 12:15 AM
Duration : 24 months
Days
MTWTFS
Fee for new students
Rs.30,000/-
To be paid in 2 installments across 12 months gap
Fee for existing students & old students who are not part of online recorded video version of full course.
Rs.12,000/-
To be paid in one shot
Fee for those who have purchased recorded video version of FULL COURSE.
Rs.2,000/-
This is the operational cost for live lectures
Those who are currently attending online HPC course.
Pay nothing
FPGA Development will be integrated in your course for free
Prerequisite: You should know C & C++ and you should be comfortable with writing code in C & C++. Working with pointers should not be a nightmare for you.
Note : This is a long term plan. It won't be easy, it won't be quick, but if you work hard and make necessary sacrifices, you will live the future that you once only imagined.
Even if you are unable to get into HFT firm, the learned skills can get you into many other cutting edge technology and engineering domains.
Hardware cost (not part of course fee) : For those who are in Ujjain, they can perform practicals in person at our institute. We will provide the essential hardware. For those who are not in Ujjain will have to to purchase the necessary hardware. The cost of hardware varies according to the configuration of the hardware. (Rs.10,000/- to Rs.35,000/-) We will guide you for that.
Warning : If you miss a lecture, no video recording will be available. You will have to learn from the audio recording and code pdf of the missed lecture.
Warning : If you just know some basics of C & C++ that you studied in college or you have been using AI for creating projects without understanding the generated code,
this course is not for you, you will be wasting your and our time.
New Batch . Enrolling Now
C, C++ & DSA
From your first line of code to clearing competitive coding assessments.
Offline
Online via Zoom
STARTS
16
Nov 2026
Timing . Evening
5:30 PM - 6:30 PM
Days
MTWTFS
Offline Class Fee
Rs. 12,000/-
In-person classroom sessions
Online Class Fee
Rs. 12,000/-
Live on the Zoom platform
Prerequisite: None. We will start from scratch.
Fee Payment
Scan & Pay
Pay using any UPI app at the code below
1Scan
2Pay
3Share screenshot
After payment, please share the payment screenshot along with your name and mobile number on WhatsApp to confirm your seat.
WhatsApp screenshot to +91 98270 69627
Our Placements
OCT 2026
Shreeya Nemade
Yearly Package
Rs. 15 LPA
Hard work always compiles!
Student of C,C++,DSA, Java & compiler designing batch.
Our Programs
Explore the Course Curriculum
We will teach you to think like the people who built PyTorch and Spring Boot.
C Programming
- Fundamentals
- Structure of a program
- Installing MinGW
- Compiling
- why include header files
- Performing I/O
- if/else
- switch/case
- for/while/do-while loop
- Array
- Array algorithms
- Sorting algorithms
- Creating functions other than main
- Pointers
- Call by value / reference
- Passing array as arguments
- Using Pointers as an array
- Global variable
- Dynamic memory allocation
- malloc & free
- Character data type
- Strings
- scanf / format specifiers / stdin buffer
- Clearing stdin buffer
- String algorithms & functions
- Structures
- Pointer to structure
- Structure padding & packing
- Pointer to function
- Passing command line arguments
- Creating macros
- typedef
- Linked list and tree algorithms
- File handling
- Reading/writing char to file
- Reading/writing string to file
- Reading/Writing structures to file
- Creating header files
- Include guards
- Creating library
- Application development
C++ & Object Oriented Programming
- Polymorphism
- Call by reference (Creating alias)
- Encapsulation
- Static method
- Static property
- this pointer
- Procedural vs. Object oriented programming
- namespaces
- Overloading insertion operator
- Overloading extraction operator
- Creating Monitor / Keyboard classes
- cout / cin
- Dynamic memory allocation
- new and delete operators
- Function parameter with default argument
- Empty Constructor
- Default Constructor
- Parameterized Constructor
- Default argument constructor
- Copy constructor
- Move constructor
- Copy assignment operator
- Move assignment operator
- Overloading data type
- Friend function
- Friend class
- Return Value Optimization (RVO)
- Creating TMString class
- Overloading arithmetic operators
- Overloading relational operators
- Overloading dereferencing operator
- Functors (callable objects)
- Class templates
- Function templates
- Creating TMVector class
- Overloading [] subscript operator
- Creating TMList class
- Overloading increment/decrement operators
- Creating Iterators
- Standard Template Library
- STL Types: List,Stack,Queue,Map & Set
- STL - When to use what, in online assessment coding rounds
- Inheritance
- Virtual Inheritance
- Constructor execution sequence in case of inheritance
- Destructor execution sequence in case of inheritance
- Method Overriding
- Virtual functions
- Virtual destructor
- Virtual polymorphism
- Pure virtual functions
- Abstract class
- File Handling
- Smart Pointers (Unique/Shared/Weak)
- Exception handling
- cache hit/cache miss
- Code Optimization to avoid cache miss
- lambdas
- Multithreading
- Synchronizing threads
- Communication between threads
Data Structures & Algorithms
- Linear sort
- Bubble sort
- Selection sort
- Insertion sort
- Shell sort
- Creating Max/Min Heap
- Heap sort
- Priority Queue using heap
- Stack
- Queue
- Quick Sort using recursion
- Quick Sort without recursion
- Merge Sort using recursion
- Merge Sort without recursion
- Singly Linked List
- add at end
- insert at top
- insert at position
- traverse top to bottom
- traverse bottom to top
- remove from position
- clear list
- Doubly Linked List
- add at end
- insert at top
- insert at position
- traverse top to bottom
- traverse bottom to top
- remove from position
- clear list
- Binary Search Tree
- insert
- search
- remove
- inorder traversal with recursion
- inorder traversal without recursion
- preorder traversal with recursion
- preorder traversal without recursion
- postorder traversal with recursion
- postorder traversal without recursion
- level order traversal
- getting the height of the tree
- clear tree
- AVL Tree (Self balanced tree)
- insert
- search
- remove
- inorder traversal with recursion
- inorder traversal without recursion
- preorder traversal with recursion
- preorder traversal without recursion
- postorder traversal with recursion
- postorder traversal without recursion
- level order traversal
- getting the height of the tree
- clear tree
- Red Black Tree
- insert
- search
- remove
- inorder traversal with recursion
- inorder traversal without recursion
- preorder traversal with recursion
- preorder traversal without recursion
- postorder traversal with recursion
- postorder traversal without recursion
- level order traversal
- getting the height of the tree
- clear tree
- Creating Map class by wrapping up Red Black Tree
- Creating HashTable
- Converting infix expression to prefix/postfix
- Evaluating prefix/postfix expressions
- Graph (Shortest Path Algorithms)
- Dijkstra's (Shortest path algorithm)
- Platform dependent vs. independent programming languages
- JDK / JRE
- The Java Virtual Machine
- Setting up JDK
- Primitive data types
- Pointers/references in java
- Encapsulation
- Polymorphism
- Inheritance
- Why java doesn't support multiple inheritance ?
- Method overriding
- Constructors
- Automatic garbage collector
- Object / class and local variables
- static methods
- Rules of assignment in context to object / class and local variables
- final variables
- final methods
- final class
- Creating abstract class to impose guidelines
- Interface, an alternative to creating abstract class
- Creating packages
- Compiling and running with classpath
- Separating source code and compiled code while creating packages
- Creating JAR files
- String
- Deep comparison
- Array in java as an object
- Exception handling
- Creating custom exceptions
- Throwing exceptions
- Checked vs. unchecked exceptions
- AutoCloseable
- try with resources
- Reading from stdin
- Creating io tool for input
- File handling
- Performing CRUD Operation
- Creating data layer
- Using AI Tools to recreate data layer and understand the process
- Creating presentation layer for CLI
- Setting up MySQL
- JDBC Programming
- Using VS Code and integrating AI tools
- Creating data layer for database
- Abstract Window Toolkit - Graphical user interface
- Event programming
- Creating presentation layer using AWT
- Swing - Better Graphical user interface
- GUI with tabular user interfaces
- Using Cursor with AI Integration
- Creating presentation layer using Swing
- Multi threading
- Thread management
- Race conditions
- Synchronization
- Synchronizing producer / consumer
- Thread pools and executor framework
- Network programming
- Creating multi threaded server
- Using build tools
- Reflection API
- Creating magic with reflection API
- Using IntelliJ IDEA with AI Integration
- Project with client / server programming
- What is the role of HTTP Server
- Setting up Tomcat 11 (J2EE Compliant web server)
- Servlet
- Deployment descriptor and servlet mapping
- HttpClient for Java Desktop Applications
- Posting & saving form data
- HTML
- JavaScript for validating form data
- CRUD Application using html/css/JavaScript & servlets
- Session tracking - hidden form field
- Session tracking - URL rewriting
- Session tracking - Cookies
- Session tracking - Session object
- Page, request, session & application scope
- User authentication and session tracking
- Java Server Pages (JSP)
- CRUD Application using HTML/CSS & JSP
- Separation of concerns
- JSP to bridge the gap between programmer and designer
- JSP / Beans / Servlet integration
- Creating custom tags library using TagSupport and BodyTagSupport
- Adding support for scripting variables and attributes against custom tags
- A module using (jsp/css/JavaScript/jsp/beans/servlets/custom tags/jdbc)
- AJAX implementation
- A module using AJAX
- Project : Creating JavaScript MVC framework
- Reflection API
- JDBC - Database metadata
- Project : Creating ORM framework
- Project : Creating Web services framework
- A Project using our custom JavaScript, ORM and Web services framework
- Maven / Gradle
- Hibernate
- Spring boot (Spring MVC)
- Spring boot (Spring Data JPA)
- Spring boot (Spring Security)
- A project using Spring Boot modules
- TypeScript & React
- Using IDEs and and AI Tools
- Guidelines to create a project using TypeScript & React
!
Important Note About the Course Contents
01
HPC vs. HFT & the HFC overlap
- What is HPC ?
- What is HFT ?
- How HFC is intersection of both ?
- Can it be learned on one machine or a cluster is required ?
02
Minimizing Latency
- Understanding latency
- Measuring latency
- Is it always related to network programming ?
- Cache hit/miss
- Cache friendly data access to maximize cache hit
- Aligning Data
- Alternative to virtual polymorphism
- Optimizing DS, loops, function calls
- Exception handling will slow down
- Compiler optimization flags
- Dynamic memory allocation will slow down
- Avoiding dynamic memory allocations
- Creating memory pools
- Creating lock free data structures to avoid wait times
- Low latency logging
- Network programming
03
Multi-threading
- Matrix multiplication
- Measuring processing time
- Understanding cache hit/cache miss
- Revised matrix multiplication
- Concurrency
- Creating threads
- Threaded matrix multiplication
- lambdas
- Locks
- Lock guards
- Preventing deadlocks
- Condition variables
- Atomics
- Tasks and futures
- Synchronizing threads
- Communication between threads
- Creating lock based data structures
- Creating thread pools
- Creating lock free data structures
- Parallel Standard Template Library
- execution policies
- vectors in parallel
- for_each in parallel
- load balancing
- exception handling in parallel execution
- for_each_n and ranges
- custom iterators in parallelism
- synchronization
- parallel data transformation using transform
- reduce and accumulate in parallel
- sorting in parallel
- searching in parallel
04
Open Multi-Processing (OpenMP)
- OpenMP Directives
- Parallelize loops
- Implementing reduction
- Environment variables
- Parallel Regions
- Work sharing
- Decomposing data structures for parallelism
- Controlling / Removing data dependencies
- Synchronization
- Mutual exclusion
- Synchronizing events
- Communication between threads
- Thread affinity
- SIMD Vectorization
- GPU Offloading
05
io_uring
- Asynchronous Server Programming
- Writing an epoll server
- Writing server using io_uring
- Create client - server application for remote file io_uring server
06
Compute Unified Device Architecture (CUDA)
- CPU vs. GPU
- Which GPU for learning CUDA ?
- Data vs. Task parallelism
- GPU Architecture
- Setting up development environment for CUDA Programming
- Parallel programming begins with SIMD
- Compilation
- Writing kernel function
- Measuring GPU processing time
- Thread / Block / Grid
- Organizing parallel threads
- Query GPU Information
- Error handling
- CUDA Memory model
- Asynchronous execution with streams/events
- Setting up launch configurations
- Designing parallel algorithms
- Reduction algorithm
- Sorting in parallel
- Profiling and optimizing code
- Unrolling loops
- Debugging techniques
- CUDA Streams
- Creating library for integration with other programming languages
07
Orientation - FPGA Development
- Why FPGA ?
- Why FPGA in HFT
- CPU v/s GPU v/s FPGA v/s ASIC
- nanoseconds vs. microseconds
- Sequential code vs. parallel circuits
- Mental model of the code that become wires
08
Digital foundations
- Number systems
- Logic gates
- Truth tables
- Truth tables to circuits
- Logic minimization
- Multiplexers, decoders, encoders, adders & comparators
- ALU design
- Latches, flip-flops, the clock, registers and counters
- Design an ALU
09
Electronics for programmers
- Calculate (V) voltage (I) current (R) resistance
- DC Circuits (parallel and sequential)
- Capacitors and inductors
- Current limiting resistors, diodes and LEDs
- Transistors as switches
- Capture and measure clock signal
- Transmission lines
- Reading a schematic
10
Sequential logic and state machines
- Know the rules
- Finite state machine
- Storage
- Pipelining
- Parallelism
- Synchronous vs. asynchronous
11
FPGA & HDL
- What in inside FPGA
- How Look Up Table implements function
- Hard blocks and clocking resources
- I/O - banks, standards and constraints
- The toolchain
- RTL designs and design flow
- What is synthesizing ?
- Various FPGA boards
- Verilog - unlearn the sequential mental model
- Verilog programming
- Modules, wires, ports, logic and vector literals
- Our first module
- Blink and Button logic
- Code a finite state machine
- UART Transmitter- transmit text to PC
- UART Receiver - receive text from PC
- structs,packages, unions and interfaces
- Synchronous FIFO design
- Designing a command processor
- Arithmetic in hardware
- Clocks and designing for speed
- Verification and simulation
- Test benches
12
HSL in C/C++ to HDL
- C++ to RTL
- Controlling the hardware interface
- HSL Stream
- HSL vs. hand written RTL
- Working HSL block
13
Networking
- OSI & TCP/IP Models
- What a frame and a packet looks like on wire
- Various other protocols
- TCP - 3 way handshake
- TCP - Sliding window, retransmitting, acknowledge, keeping the connection alive
- How FPGA can beat kernel bypass on CPU
- Design a Hardware TCP Client
14
HFT Domain
- Market micro structure
- Market data protocols
- Order book
- Parsing binary market data
- Tick to trade system
- Simulating exchange
- Full order life cycle
- Build a full system against simulated exchange
The ML/AI Course parts
Part 1
Supervised learning - Linear regression - C++
- Linear Regression using gradient descent
- A Gentle introduction to fitting line, hypothesis, cost, derivation and convergence
- Vectorized operations
- Creating components for infrastructure framework
- Vectors and Matrices (With support for parallel operations)
- CSV to matrix
- add
- subtract
- multiply
- divide
- transpose
- Copy
- Function to load CSV into matrix/vector
- Function to save matrix/vector to CSV
- Scalers
- Standard Scaler
- Min Max Scaler
- Robust Scaler
- Encoders
- One Hot Encoder
- Ordinal Encoder
- Target Encoder
- Sum Encoder
- Regularizers
- L1
- L2
- Elastic Net
- Cost function
- MSE
- L2
- Elastic Net
- Dataset tools
- Column Cutter
- Splitter to create training and testing dataset
- Applying Linear regression to train model
- Creating x_y_generator to generate feature matrix and target vector
- Fit line function to train model using training dataset and save model
- Batch Gradient Descent
- Stochastic Gradient Descent
- Mini Batch Gradient Descent
- Gnuplot - plot regression line and error curve
- Evaluate model function to test model on test data and calculate evaluation metrics
- Fine-tuning after evaluation
- Function to predict using saved model data
- Applying Linear regression using direct method utilizing normal equation
- Linear regression using Gradient Descent in Python (Using available libraries)
Part 2
Supervised learning - Polynomial & logistic regression - C++
- Creating components for infrastructure framework
- Creating N Dimensional Array class (with support for parallel operations and iterators)
- Making scalers, encoders, regularizer, MSE to work on ndarray object
- Functions to save ndarray object to CSV/binary and load ndarray object from CSV/binary
- Revisiting linear regression done in part one using ndarray objects.
- Applying Polynomial regression to train model
- Fit curve function to train model using training dataset and save model
- Batch Gradient Descent
- Stochastic Gradient Descent
- Mini Batch Gradient Descent
- Gnuplot - plot regression curve and error curve
- Evaluate model function to test model on test data and calculate evaluation metrics
- Fine-tuning after evaluation
- Function to predict using saved model data
- Logistic regression using Gradient Descent in Python (Using available libraries)
Part 3
Supervised learning - Deep neural network - C++
- Creating components for infrastructure framework
- Creating view classes for ndarray class to save memory.
- Refactoring operator functions to avoid creating temporary objects
- Functions to save ndarray object to CSV/binary and load ndarray object from CSV/binary
- Switching from shallow to deep - Deep neural network
- Deep learning - Introduction to neural network
- Forward and backward propagation
- Activation and loss functions
- Logistic regression to deep neural network
- Data structure, hypothesis, cost, derivation and updating model
- All from training, testing, fine tuning and making predictions.
- Creating neural network class
- saving and loading neural network object to binary file
- Digit classifier using neural network
- Digit classifier in Python (Using available libraries)
- Loading and saving JPEG using libjpeg and libjpeg-turbo
- Essential Image pre-processing for preparing data for machine learning
- Data augmentation
- Resizing and Scaling
- Color space conversion
- Normalizing
- Noise reduction
- Adding contrast
- Adding brightness
- Flipping
- Rotating
- Binarization
- Shearing
- Creating components for infrastructure framework
- Creating Image class with functions for loading, saving and image processing.
- Creating Image to ndarray function
Part 4
Supervised learning - Convolutional neural networks
- Perceptrons & backprop
- Activation functions
- Optimizers
- Regularization
- Introduction to Convolutional neural networks (CNNs)
- CNN for Image recognition, Computer vision and Pattern detection
- Forward and backward propagation
- Data structure, hypothesis, cost, derivation and updating model
- All from training, testing, fine tuning and making predictions.
- Creating CNN class
- saving and loading CNN object to binary file
- Digit classifier using CNNs
- Creating Bounding box tool using Java/Python (We will use AI Tools to create it)
- Getting image dataset
- Pre-processing images from image dataset to create dataset for training
- Object detection using CNNs
- Object detection using Python (Using available libraries)
Part 5
Building an MCP Server - Python
- Introduction to Model Context Protocol
- MCP - Hosts, Servers and Interfaces
- Creating a Filesystem MCP Server
- Caching, Logging and monitoring
- Setting up security modules
- Configuring LLM clients to interact with our MCP Server
- Creating MCP server to automate tasks
- Creating MCP Server to access data from the web/databases
- Optimizing for low latency
What next ?
Part 6
Unsupervised Learning using Python - Recorded videos
Part 7
Natural Language Processing using Python - Recorded videos
Part 8
LLM for generative AI using Python - Recorded videos
Phase 1
Writing Compiler using C++
In this phase, we will focus on elements of designing a compiler. We won't try to write optimized code.
We won't create required data structures, we will make use of C++ Standard Template Library.
We won't implement Theory of Computation.
- Implementing lexer
- Implementing parser
- Generating intermediate code
- Assembly language programming
- Assembly language code generator
- Compiling and linking
- Testing our compiler
Phase 2
Writing Compiler using C
Now we are aware of the steps involved in creating a compiler and we have created a compiler.
In this phase we will not use predefined data structures, we will write code to implement algorithms
in context to theory of computation. We will optimize our compiler code and we also optimize the
generated assembly language code. We will write scalable code, so that new keywords can be added in future.
- Automata
- Context free grammar
- Creating syntax tree
- Creating symbol table
- Semantic analysis
- Creating data structures for lexer and parser
- Implementing lexer
- Generating intermediate code
- Assembly language code generator
- Optimizing assembly language code
- Compiling and linking
- Testing our compiler
Phase 3
Adding support for creating vectors and matrices
In this phase we will add vector and matrix creation feature as part of language with support for
performing math operation on them. This will help the user in creating machine learning algorithms.
Phase 4
Adding support for multi-threading
In this phase we will add keywords that would allow the programmer to create threads
Note
Important
Our compiler won't be anyway comparable or be even near to C or C++ compilers. This course is about understanding
all the aspects of creating a compiler. It is about creating actual compiler and experiencing priceless joy of creating something cool that every programmer dreams of doing.
$
g++ -O3 -Wall classroom.cpp -o rock_solid_foundation.out