Prepare for your next technical interview

Prepare for your technical interviews and assessments with the essential knowledge from the areas relevant to your target role gathered in one place with content backed by verified sources.

Core Areas
6
Topics to review
Learning Paths with Lessons
13
Available to study
Concepts
123
Short and connected
Professional Profiles
46
Guidance by specialty

Choose your Direction

Explore roles from shared foundations to integration and specialization. The order and years for each stage are a guide and specialties are parallel paths with their own stages.

Choose a professional area

Roles in this area

Which career stage are you targeting?

Expand your Scope

Choose the next step on the path toward your career progression.

Specialization

Want to specialize?

Leadership

Want to lead?

Management

Want to manage teams?

Executive

Want to direct technology?

Lazy vs Eager Loading

They compare when JPA and Hibernate entity relationships are loaded. Spring Boot can host the application but does not define these strategies.

Department
idname
1HR
2Engineering
Employee
idnamedepartment_id
101Alice1
102Bob1
201Charlie2
Department department = departmentRepo.findById(1L).orElseThrow();
System.out.println(department.getName());
System.out.println(department.getEmployees());

LAZY

  1. The client requests a department.
  2. The application queries Department without needing its employees yet.
  3. Accessing employees may initialize the relationship and query Employee within an available persistence context.
@OneToMany(mappedBy = "department", fetch = FetchType.LAZY)
private List<Employee> employees;

SELECT * FROM Department WHERE id = ?;
SELECT * FROM Employee WHERE department_id = ?;

EAGER

  1. The client requests the same department.
  2. The provider must also load the relationship marked EAGER.
  3. It may use a JOIN or additional queries depending on the fetch plan. It does not guarantee a single query.
@OneToMany(mappedBy = "department", fetch = FetchType.EAGER)
private List<Employee> employees;

SELECT d.*, e.* FROM Department d
LEFT JOIN Employee e ON e.department_id = d.id
WHERE d.id = ?;
Lazy vs Eager Loading
AspectLAZYEAGER
Loading TimeLAZY requests deferred loading until needed. It is a hint that the provider may load earlier.EAGER requires eager loading of the relationship.
Queries and N+1Accessing relationships for many departments may produce additional queries and N+1.It may also produce N+1. Fetch timing alone does not determine query count.
Performance and MemoryIt may avoid loading unused relationships. The result depends on actual data access.It may load more data than needed. Data volume and query cost must be measured.
JPA 3.2 Defaults@OneToMany and @ManyToMany default to LAZY.@ManyToOne and @OneToOne default to EAGER.
Usage DecisionConsider deferred loading for relationships that are not always needed.Plan explicit fetching of the relationships each query needs.
  • The example uses Department with HR and Engineering. Employee contains Alice and Bob in HR and Charlie in Engineering.
  • The snippets show alternative mappings and illustrative SQL. Both mappings are not applied to the same relationship and this SQL is not guaranteed.
  • JOIN FETCH and EntityGraph express fetching needs. Inspect generated SQL and measure performance.
  • Accessing an uninitialized relationship without an available persistence context may fail.
Does changing a relationship to EAGER guarantee eliminating N+1?

No. EAGER determines when the relationship must be loaded but the provider may execute additional queries. Review the fetch plan and SQL.

Jakarta PersistenceHibernate

RAG vs KAG

Both bring external knowledge into generation. Here KAG refers to the OpenSPG approach that combines retrieval with structured knowledge and guided reasoning.

RAG

  1. The user asks which department has the most employees.
  2. The retriever finds relevant evidence. It may use vector search or combine other techniques.
  3. Documents or chunks about departments and employees are retrieved.
  4. The evidence is incorporated into the model context.
  5. The model generates an answer grounded in the retrieved material. Quality depends on the evidence and how it is used.

KAG · OpenSPG

  1. The user asks the same question.
  2. The system queries structured knowledge and associated text.
  3. Relationships between departments and employees can support reasoning operations.
  4. Results and evidence are organized into context.
  5. The model generates an answer with that support. Structure alone does not guarantee correctness.
RAG vs KAG
AspectRAGKAG · OpenSPG
Knowledge SourcesDocuments and other retrievable data. RAG can also use graphs.Structured knowledge and text connected within the OpenSPG approach.
UpdatesDepends on ingestion and the indexes used.Also depends on how structured relationships are built and maintained.
ReasoningDepends on retrieved evidence and the complete system. It is not necessarily limited.Incorporates guided reasoning mechanisms. Improvement depends on the task and available knowledge.
ComplexityCan start with a simple flow and grow with requirements.Adds work to represent and maintain structured knowledge.
  • The example evidence contains HR with Alice and Bob and Engineering with Charlie. The expected answer is HR with two employees.
  • Compare both approaches using the same questions and evidence. Measure answer quality and cost alongside latency and maintenance.
  • KAG is not a universal category opposed to all RAG. GraphRAG and other approaches may also use relationships and graphs.
Does adding a graph guarantee better answers than every RAG system?

No. Data and relationship quality must be evaluated alongside retrieval and generation for the specific task.

Lewis et al.OpenSPG
ACTIVE REVIEW
1 / 5System Design

How would you explain this to someone else?

Recall it first. Then check your answer.

Keep learning

A definition is a starting point. Explore the documentation and original references to learn more.

The Single Responsibility PrincipleThe Open-Closed PrincipleA Behavioral Notion of SubtypingThe Interface Segregation PrincipleThe Dependency Inversion PrincipleFactory Comparison — Simple FactoryBuilder — Design PatternsPrototype — Design PatternsSingleton — Design PatternsFactory Method — Design PatternsFacade — Design PatternsAdapter — Design PatternsDecorator — Design PatternsIterator — Design PatternsStrategy — Design PatternsObserver — Design PatternsState — Design PatternsMediator — Design PatternsVisitor — Design PatternsHow do Transformers work?TokenizersContext windowsGenerative AI ProfileBuilding effective agentsPromptTemplateChain-of-Thought PromptingFine-tuning a pretrained modelZero-shot classificationSpeech and Language ProcessingRetrievalThe Probabilistic Relevance FrameworkText feature extractionReciprocal Rerank Fusion RetrieverVector Similarity SearchFaiss indexesHierarchical Navigable Small World GraphsIndexLSHCollectionsPointsRetrieval-Augmented Generation for Knowledge-Intensive NLP TasksFour Principles of Explainable Artificial IntelligenceMessagesEdge Computing: Vision and ChallengesReActReflexionInterruptsArchitecture overviewAgent Communication ProtocolLangChainGraph APIRunnableSequence — LCEL compositionMessageGraph — Graph API referencePersistence and checkpointsIntroductionFlask QuickstartHub documentationImage generationModelsLlama 4 model cardVisual Instruction TuningQwen2.5-VLDALL·E 2 — retired modelRobust Speech Recognitionedge-tts READMEMultimodal tasks and modelsLearning Transferable Visual ModelsDenoising Diffusion Probabilistic ModelsAuto-Encoding Variational BayesVideo generationInpaintingDALL·E generations, edits and variations — historical exampleCreate image variation — retired endpointHow to get started on storyboardingText-to-speechIslands architectureBuffer · Java SE 22HTTP Semantics · RFC 9110REST · Architectural StyleConnect Claude Desktop to local MCP serversDocs MCPConnect Claude Code to tools via MCPMCP servers with Gemini CLIAdd MCP servers in VS CodeAI language models in VS CodeBuild an MCP clientBuild an MCP serverOfficial TypeScript SDKTypeScript SDK v2 · Build your first serverMCP InspectorSpring ProjectsHibernate ORMJavaFXAndroid SDK ToolsMavenJenkins DocumentationKafka IntroductionSelenium DocumentationJakarta Pages · JSPMicroservicesSpring BootSpring Data JPASpring SecuritySpring Web MVCSpring WebFluxSpring CloudSpring Cloud OpenFeignSpring AMQPSpring for Apache KafkaCache AbstractionSpring BatchJUnitMockitoSpringdoc OpenAPISpring Boot ActuatorFetchType · Jakarta Persistence 3.2Hibernate ORM · FetchingKAGSoftware System Decomposition · Avoid Functional DecompositionBinary PrefixesMonitoring Distributed SystemsCompletion SuggesterWell-Architected FrameworkDynamoDB Read ConsistencyDynamo ArchitectureStorage EngineHTTP 429 · RFC 6585UUID · RFC 9562SnowflakeRobots Exclusion Protocol · RFC 9309Amazon SNSWebSocket · RFC 6455MediaConvertHTTP Live Streaming · RFC 8216Object VersioningOpenAI GPTAnthropic ClaudeGoogle GeminiMeta LlamaMistral AICohereHugging FaceOllamavLLMLangGraphCrewAIMicrosoft AutoGenMicrosoft Agent FrameworkLlamaIndexAWS Strands AgentsCAMELAgnoOpenAI Agents SDKPydanticAISemantic KernelGoogle ADKAWS Bedrock AgentsAzure AI Foundry Agent ServiceHaystackDSPyRAGFlowGraphRAGUnstructuredEmbedChainOpenAI EmbeddingsCohere EmbedVoyage AISentence TransformersBGEGoogle Vertex AI EmbeddingsAzure OpenAI EmbeddingsMCP SDKFastMCPMCP RegistryGitHub MCP ServerSlack MCP ServerPostgreSQL MCP ServerGoogle Drive MCP ServerFilesystem MCP ServerNVIDIA NeMo GuardrailsGuardrails AIMicrosoft PresidioLakera GuardPrompt SecurityProtect AIAzure AI Content SafetyAWS Bedrock GuardrailsLangSmithLangfuseArize PhoenixWeights & Biases WeaveTruLensRagasPromptfooHeliconeMem0ZepLettaRedisPostgreSQLNeo4jChroman8nZapierMakeMicrosoft Power AutomateTemporalApache AirflowPrefectKestraPipedreamPineconeWeaviateQdrantMilvuspgvectorElasticsearchMongoDB Atlas Vector Search

Your progress and menu state are stored only in this browser.