Hello Maksim!

Sorry for my delayed response, but I've been continuing digging into Ignite 
just simply in the method Ignition.startClient(clientCfg). Actually you are 
right, I did encounter some problems in Ignite and I think it's a little bit 
tough to fix them since much of the information that I searched online about 
these problems are very inaccurate and of little use, so I consider it would be 
helpful to (though much more time is needed) go deep into the source code of 
Ignite to see for myself how the whole thing is running up and where & how 
exactly the problems occur and try to come up with some solutions. On the other 
hand I think it is a good opportunity to build up my understanding of Ignite 
and the structure of some big projects (I'm a junior programmer and I find 
myself have much more to learn). In fact I looked into the test examples you 
mentioned in your response email and I can see some stream operations and short 
snippet demo codes but I can't quite know how I can take advantages of these 
tests or modify them to build up my understanding for Ignite. Please give my a 
hint if it is to your convenient, thank you very much! As to the deepwiki, it's 
a great AI bot and I've asked it tons of questions already. It's very helpful 
and convenient!


Thank you for these valuable advice and websites you offered! They helped me a 
lot!


Cup
Aug 25, 2025
---- Replied Message ----
| From | Maksim Timonin<timoninma...@apache.org> |
| Date | 8/19/2025 16:21 |
| To | <user@ignite.apache.org> |
| Subject | Re: Suggestion request - How can I go deeper in understanding 
Ignite? |
Hello Cup,


Recently I started to get down to read the source code


Are you currently trying to solve a problem related to Apache Ignite?


If so, the best approach is usually to reproduce the issue. Writing tests with 
the Ignite framework is a good starting point. For example, check these simple 
tests:

modules/core/src/test/java/org/apache/ignite/client/ConnectionTest.java
modules/indexing/src/test/java/org/apache/ignite/cache/query/IndexQueryKeepBinaryTest.java


I can also recommend an external service that generates documentation based on 
the codebase and Javadocs. It even includes a chatbot that helps with 
navigation over Ignite code: https://deepwiki.com/apache/ignite.

Maksim








On Tue, Aug 19, 2025 at 10:13 AM Sergey Chugunov <sergey.chugu...@gmail.com> 
wrote:

Hello Cup,


Apache Ignite source code is hard to grasp indeed and unfortunately there is no 
detailed explanation for each and every class in its codebase.


Some components of Ignite 2.x codebase are covered in wiki pages though: take a 
look at persistent store overview and more detailed under the hood description. 
More general description of multi-tiered storage is also available. There is 
also a page dedicated to the main discovery component: Tcp Discovery under the 
hood. Look around there, there are some other useful pages too. At the same 
time some pages there are out-of-date and aren't relevant anymore. Community 
will clean them up at some point.


But in my opinion the best way to build your understanding of how Ignite works 
is to use tests. Take a look at suite classes in org.apache.ignite.testsuites 
package, they group individual tests more or less by component or feature. Set 
the project up in your favorite IDE and start debugging the code - this way 
you'll understand how the whole thing works much faster than reading tons of 
documentation or wiki pages.


There is also an Ignite 3.x project, and it's important to understand that it 
is a completely new codebase with very little shared code. One cannot easily 
transfer their knowledge from one codebase to another. Unfortunately I cannot 
point you to documentation of that project, maybe other community members will.


--
Thank you,
Sergey.


On Tue, Aug 19, 2025 at 6:13 AM ddd_ot <ddd...@163.com> wrote:

Hello!


I am a junior programmer new to Java and Ignite, and currently I am working on 
some projects where Ignite 2.16 is adopted. I have implemented some toy demos 
and hope to further explore Ignite from top to bottom.


Recently I started to get down to read the source code of Ignite 2.16 but I 
encountered a lot of problems while reading the code. When I dig into some of 
the inheritance chains in the core of Ignite I found it hard to tell the 
function and design of each class merely from the code, so I was wondering if 
there is any demonstration or illustration to the top-level structure design of 
Ignite to help me better understand the code (e.g. I found Grid a high 
frequency keyword in the code but I failed to find the meaning of the Grid or 
the design behind it). On the other hand, I searched the official doc and API 
of Ignite but I can't find the description for some specific classes. Is there 
any websites or references that could provide the detailed description of the 
implementation for every class in Ignite's source code so I can understand the 
bottom-level implementation of Ignite better? Or could you please offer me some 
advice or suggestions on reading the source code and get a deeper understanding 
of Ignite itself?


I am not a native English speaker so please forgive me for my poor English 
expression, but I truly appreciate any guidance you can provide! Thank you for 
your time and patience reading my email.


Sincerely,
Cup
August 19, 2025





Reply via email to