# Git Version Manager: Ace Your Java LLD Interview You're in the hot seat. The interviewer just dropped the bomb: "Design a simplified Git version manager in Java." Your mind races. This isn't just about remembering data structures; it's about showing how you think, how you structure a complex problem, and how you design a system that works, not just compiles. I've been there, on both sides of that table, and trust me, they're not looking for a perfect Git clone. They want to see your design chops, especially with object-oriented principles, and how you handle state and operations for a version control system. ## The Core Concept: What Even *Is* Git? Before you write a single class, pause. Git, at its heart, isn't about files; it's about snapshots. Every commit captures the *entire state* of your repository at that moment. This is a crucial distinction. Many junior engineers try to design Git around tracking file diffs, which is a massive red herring for LLD. Forget diffs initially. Think about immutable snapshots, content-addressable storage, and a directed acyclic graph (DAG) of commits. This foundational understanding immediately tells your interviewer you're thinking at the right level of abstraction. Your design for a Git version manager needs to reflect this snapshot-based philosophy from the ground up, especially when considering how you'll manage file content and history in Java. ## Breaking Down the Problem: Key Components Okay, so we're building a simplified Git. What absolutely *must* it do? Let's list the minimum viable features they expect in a typical 60-90 minute interview: 1. **Initialize a repository:** Create an empty Git directory. 2. **Add files:** Stage changes for the next commit. 3. **Commit changes:** Create a snapshot of the repository's state. 4. **View commit history:** See the sequence of commits. 5. **Checkout:** Move to a specific commit or branch. We'll skip remote operations, branching/merging complexities, and advanced features like rebasing. Stick to the basics. You want to show a solid foundation, not a sprawling, half-baked mess. If you get through the core, you can always discuss extensions. ## Data Model First: The Building Blocks of Versioning This is where you earn your stripes. Your data model dictates everything. Start with the core entities. ### Blob, Tree, Commit: The Git Trinity * **Blob:** Represents the content of a file. It's essentially a byte array. The key insight here: store content, not file paths. Git doesn't care about the filename until it's part of a tree. Each unique file content gets a unique ID (a SHA-1 hash in real Git, but for us, a simple UUID or even a hash of the content itself will do). ```java public class Blob { private String id; // SHA-1 hash of content private byte[] content; // File content public Blob(byte[] content) { this.content = content; this.id = calculateHash(content); // Implement SHA-1 or similar } // Getters and helper methods } ``` * **Tree:** Represents a directory. It maps filenames to Blobs or other Trees. A Tree, like a Blob, is content-addressable. Its ID is a hash of its contents (the list of entries it contains). This nesting is how Git represents directory structures. ```java public class Tree { private String id; // SHA-1 hash of its entries private Map fileEntries; // filename -> Blob ID private Map directoryEntries; // directory name -> Tree ID public Tree() { this.fileEntries = new HashMap<>(); this.directoryEntries = new HashMap<>(); } // Methods to add/remove entries, calculate hash, etc. } ``` * **Commit:** The big one. A commit points to a single root Tree (the state of the repository at that commit), a parent commit (or multiple parents for merges, but let's stick to one for now), an author, a timestamp, and a commit message. Its ID is a hash of *all* this information. This is what forms your DAG. ```java public class Commit { private String id; // SHA-1 hash of its contents private String treeId; // ID of the root Tree for this commit private String parentId; // ID of the parent Commit, null for initial commit private String author; private long timestamp; private String message; public Commit(String treeId, String parentId, String author, String message) { this.treeId = treeId; this.parentId = parentId; this.author = author; this.timestamp = System.currentTimeMillis(); this.message = message; this.id = calculateHash(); // Hash of all fields } // Getters } ``` ### Repository Management: The Git Object Store You need a way to store these `Blob`, `Tree`, and `Commit` objects. A simple `Map` or `Map` mapping object IDs to their serialized content works for an in-memory or file-system-backed store. Real Git uses a `.git/objects` directory where objects are stored by their SHA-1 hash. Mimic this with a `Map` that simulates persistent storage. ```java public class ObjectStore { // In a real system, this would be backed by files, not memory. // For interview, a HashMap is fine, but mention the file system aspect. private Map objects = new HashMap<>(); public void putObject(String id, byte[] data) { objects.put(id, data); } public byte[] getObject(String id) { return objects.get(id); } // Helper to serialize/deserialize objects } ``` This `ObjectStore` is critical. It's how you retrieve any Git object given its ID. ## The GitManager Class: Orchestrating Operations Now, bring it all together into a `GitManager` class. This is your main entry point for all Git operations. ```java public class GitManager { private ObjectStore objectStore; private Path repositoryRoot; // Where the user's files live private String head; // Points to the current commit ID private Map branches; // branchName -> commitId public GitManager(Path repoRoot) { this.repositoryRoot = repoRoot; this.objectStore = new ObjectStore(); this.branches = new HashMap<>(); // Initialize HEAD to null or a default branch (e.g., "master" or "main") this.head = null; // No commits yet this.branches.put("main", null); // "main" branch exists, points to no commit } // ... public methods for Git operations ... } ``` ### Initializing the Repository `init()` simply creates the `.git` directory (conceptually, for our in-memory version, it just initializes the `ObjectStore` and `branches` map). ```java public void init() { // In a real Git, this creates the .git directory structure. // For our LLD, it ensures the object store and branches are ready. System.out.println("Initialized empty Git repository."); } ``` ### Adding Files: The Staging Area (Index) This is a subtle but important part of Git. When you `git add`, files don't go directly into a commit. They go into a "staging area" or "index." This is a temporary Tree-like structure that represents what *will be* in the next commit. ```java public class Index { private Map stagedFiles; // filepath -> Blob ID public Index() { this.stagedFiles = new HashMap<>(); } public void addFile(String filePath, String blobId) { stagedFiles.put(filePath, blobId); } public Map getStagedFiles() { return stagedFiles; } // Clear after commit public void clear() { stagedFiles.clear(); } } ``` Your `GitManager` will hold an instance of `Index`. ```java public class GitManager { // ... private Index index; // The staging area public GitManager(Path repoRoot) { // ... this.index = new Index(); } public void add(String filePath) throws IOException { Path fullPath = repositoryRoot.resolve(filePath); if (!Files.exists(fullPath) || Files.isDirectory(fullPath)) { throw new IllegalArgumentException("File not found or is a directory: " + filePath); } byte[] content = Files.readAllBytes(fullPath); Blob blob = new Blob(content); objectStore.putObject(blob.getId(), serialize(blob)); // Store the blob index.addFile(filePath, blob.getId()); System.out.printf("Added file %s (blob ID: %s)%n", filePath, blob.getId()); } // ... } ``` ### Committing Changes: Building the Snapshot This is where the `Blob`s and `Tree`s from the `Index` get formalized into a `Commit`. 1. **Build the root Tree:** Take all the staged files from the `Index` and recursively build a `Tree` structure. This involves creating intermediate `Tree`s for directories. 2. **Store the Tree:** Serialize and store all created `Tree` objects in the `ObjectStore`. 3. **Create the Commit:** Instantiate a `Commit` object, linking it to the root `Tree` ID and the current `HEAD` as its parent. 4. **Store the Commit:** Serialize and store the `Commit` object. 5. **Update HEAD and Branch:** Point the current branch (and `HEAD`) to the new commit. 6. **Clear Index:** The staging area is now empty. ```java public String commit(String message, String author) { if (index.getStagedFiles().isEmpty()) { System.out.println("No changes to commit. Staging area is empty."); return null; } // 1. Build the root Tree from the staged files // This part is tricky and often simplified in interviews. // You need to parse file paths and build nested Tree objects. // For simplicity, let's assume a flat structure for now or a helper method. Tree rootTree = buildTreeFromIndex(index.getStagedFiles()); objectStore.putObject(rootTree.getId(), serialize(rootTree)); // Store the root tree // 2. Create the Commit String parentCommitId = branches.get(getCurrentBranch()); // Get parent from current branch Commit commit = new Commit(rootTree.getId(), parentCommitId, author, message); objectStore.putObject(commit.getId(), serialize(commit)); // Store the commit // 3. Update HEAD and Branch head = commit.getId(); branches.put(getCurrentBranch(), commit.getId()); // Update current branch to point to new commit index.clear(); // Clear staging area System.out.printf("Committed changes (ID: %s)%n", commit.getId()); return commit.getId(); } private Tree buildTreeFromIndex(Map stagedFiles) { // This is a simplified version. A real Git builds a proper nested tree. // For interview, you might just put all files directly into one root tree. Tree root = new Tree(); for (Map.Entry entry : stagedFiles.entrySet()) { // Assume file path is just filename for simplicity, or // implement logic to create nested trees for directories. // E.g., for "src/main/App.java", you'd need a "src" tree, then a "main" tree. root.addFileEntry(entry.getKey(), deserializeBlob(objectStore.getObject(entry.getValue()))); } return root; } ``` Realistically, building the `Tree` from the `Index` is quite involved. You'd traverse the staged file paths, creating `Tree` objects for each directory level and linking `Blob`s to their correct spots. For an interview, if time is tight, you might simplify and just say "the `buildTreeFromIndex` method recursively creates `Tree` objects based on the file paths in the index." That's a reasonable trade-off. ### Viewing Commit History: Log This is a simple traversal of the commit graph, starting from `HEAD` and following `parentId` pointers. ```java public void log() { if (head == null) { System.out.println("No commits yet."); return; } String currentCommitId = head; while (currentCommitId != null) { Commit commit = deserializeCommit(objectStore.getObject(currentCommitId)); System.out.printf("Commit ID: %s%n", commit.getId()); System.out.printf("Author: %s%n", commit.getAuthor()); System.out.printf("Date: %s%n", new Date(commit.getTimestamp())) ; System.out.printf("Message: %s%n%n", commit.getMessage()); currentCommitId = commit.getParentId(); } } ``` ### Checkout: Recreating the Working Directory This takes a commit ID (or branch name), finds its root `Tree`, and reconstructs the working directory based on that `Tree`'s contents. ```java public void checkout(String commitOrBranchName) throws IOException { String targetCommitId = branches.get(commitOrBranchName); if (targetCommitId == null) { targetCommitId = commitOrBranchName; // Assume it's a commit ID if not a branch // You'd want to validate if this ID actually exists and is a commit } if (targetCommitId == null) { throw new IllegalArgumentException("Commit or branch not found: " + commitOrBranchName); } Commit targetCommit = deserializeCommit(objectStore.getObject(targetCommitId)); if (targetCommit == null) { throw new IllegalArgumentException("Invalid commit ID: " + targetCommitId); } // 1. Clear the current working directory (careful with real files!) // For interview, you can simulate this or assume it's okay to overwrite. clearWorkingDirectory(); // 2. Reconstruct files from the target commit's tree Tree rootTree = deserializeTree(objectStore.getObject(targetCommit.getTreeId())); reconstructWorkingDirectory(rootTree, repositoryRoot); // 3. Update HEAD head = targetCommitId; // If checking out a branch, update the current branch pointer if (branches.containsKey(commitOrBranchName)) { // This means we're still on a branch, just moved its HEAD } else { // "Detached HEAD" state - for simplicity, you might skip this in LLD System.out.println("Checked out to commit " + targetCommitId + " (detached HEAD state)."); } System.out.printf("Checked out to commit %s%n", targetCommitId); } private void clearWorkingDirectory() throws IOException { // This is a dangerous operation in a real system. // For LLD, you can just print a message or delete synthetic files. // Files.walk(repositoryRoot) // .filter(Files::isRegularFile) // .forEach(p -> { try { Files.delete(p); } catch (IOException e) { /* handle */ } }); System.out.println("Simulating clearing working directory."); } private void reconstructWorkingDirectory(Tree currentTree, Path currentPath) throws IOException { for (Map.Entry entry : currentTree.getFileEntries().entrySet()) { Path filePath = currentPath.resolve(entry.getKey()); Files.createDirectories(filePath.getParent()); Files.write(filePath, entry.getValue().getContent()); } for (Map.Entry entry : currentTree.getDirectoryEntries().entrySet()) { Path dirPath = currentPath.resolve(entry.getKey()); Files.createDirectories(dirPath); reconstructWorkingDirectory(entry.getValue(), dirPath); } } ``` The `serialize` and `deserialize` methods are crucial. For a Java interview, you could use standard Java serialization, JSON (with a library like Jackson), or just `ByteArrayOutputStream` for `byte[]`. Mentioning these choices shows awareness. ## Handling Branches Branches are just pointers to commits. Your `GitManager` already has a `Map branches` (name -> commit ID). ```java // In GitManager private String currentBranch; // e.g., "main" public void createBranch(String branchName) { if (branches.containsKey(branchName)) { throw new IllegalArgumentException("Branch " + branchName + " already exists."); } if (head == null) { throw new IllegalStateException("Cannot create branch: no commits yet."); } branches.put(branchName, head); // New branch points to current HEAD System.out.printf("Created branch '%s' pointing to commit %s%n", branchName, head); } public void switchBranch(String branchName) { if (!branches.containsKey(branchName)) { throw new IllegalArgumentException("Branch " + branchName + " does not exist."); } // Need to handle pending changes here, similar to real Git // For LLD, you can assume a clean working directory or mention the need for stashing/merging. // Also, perform a checkout to the branch's commit. try { checkout(branches.get(branchName)); this.currentBranch = branchName; System.out.printf("Switched to branch '%s'%n", branchName); } catch (IOException e) { System.err.println("Failed to switch branch: " + e.getMessage()); } } private String getCurrentBranch() { // This would typically be stored as part of the repo state, e.g., in .git/HEAD // For simplicity, let's assume we track it in memory. if (currentBranch == null && !branches.isEmpty()) { return branches.keySet().iterator().next(); // Default to first branch if not set } return currentBranch != null ? currentBranch : "main"; // Default to "main" if nothing else } ``` ## Caveats and Trade-offs (This is where you shine) This simplified model has significant limitations. Acknowledging them shows maturity. 1. **No Diffs/Patching:** Real Git doesn't store full files per commit unless absolutely necessary. It uses diffs and delta compression. Our model stores full `Blob`s for every version, which is space-inefficient. Mention this. 2. **No Merging/Conflict Resolution:** This is a huge area skipped. Merging involves identifying a common ancestor, applying changes, and resolving conflicts. For an LLD, it's out of scope unless specifically asked as a follow-up. 3. **Performance:** Reading files from disk, hashing content, and writing them back for every `add` and `commit` can be slow for large repositories. Real Git uses a highly optimized index and object packing. 4. **Error Handling & Edge Cases:** What if a user tries to `add` a non-existent file? What if the working directory has uncommitted changes during `checkout`? My code snippets only touch on this. In a full design, you'd layer robust error handling. 5. **Concurrency:** Multiple users pushing/pulling to the same remote. Our design is purely local. 6. **Persistence:** My `ObjectStore` is in-memory. For persistence, you'd use `java.nio.file` to write objects to disk, similar to Git's `.git/objects` structure. Serializing objects (e.g., using `ObjectOutputStream` or JSON) would be necessary for disk storage. Remember to explicitly call out these simplifications. For example, "For this interview, I'm using an in-memory `Map` for the `ObjectStore`, but in a production system, this would persist objects to disk, perhaps using a content-addressable file system structure like Git's `.git/objects` directory." This demonstrates you understand the trade-offs. ## Putting it into Practice: A Small Main Method Let's quickly put together a `main` method to show how someone would use your `GitManager`. ```java import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; import java.util.Date; import java.util.HashMap; import java.util.Map; import java.util.UUID; // For simple IDs, replace with SHA-1 in real design // Placeholder serialization/deserialization methods for brevity // In a real system, use JSON, Java Serialization, or custom byte formats. interface Serializer { byte[] serialize(Object obj); T deserialize(byte[] data, Class clazz); } class SimpleSerializer implements Serializer { // This is a minimal, non-production serialization for demonstration. // For Blobs, it's just the content. For others, it's toString().getBytes(). @Override public byte[] serialize(Object obj) { if (obj instanceof Blob) return ((Blob) obj).getContent(); if (obj instanceof Commit) return ((Commit) obj).toString().getBytes(); // Needs proper fields if (obj instanceof Tree) return ((Tree) obj).toString().getBytes(); // Needs proper fields return null; } @Override public T deserialize(byte[] data, Class clazz) { // This is highly simplified and will likely break for complex objects. // It's just to make the example compile. if (clazz == Blob.class) return (T) new Blob(data); // Re-calculate ID if needed return null; // Don't implement for Commit/Tree here for brevity } } // Assume Blob, Tree, Commit, Index, ObjectStore, GitManager classes are defined above. // Add a helper method to GitManager for serialization/deserialization internally // Or pass a Serializer dependency. // Simplified Blob (needs proper hash calculation) class Blob { private String id; private byte[] content; public Blob(byte[] content) { this.content = content; this.id = UUID.randomUUID().toString(); } // Simplified ID public String getId() { return id; } public byte[] getContent() { return content; } private String calculateHash(byte[] content) { return UUID.randomUUID().toString(); } // Simplified } // Simplified Tree (needs proper hash calculation and entry management) class Tree { private String id; private Map fileEntries; private Map directoryEntries; public Tree() { this.fileEntries = new HashMap<>(); this.directoryEntries = new HashMap<>(); this.id = UUID.randomUUID().toString(); // Simplified ID } public void addFileEntry(String name, Blob blob) { this.fileEntries.put(name, blob); this.id = calculateHash(); // Re-calculate on change } // Add directory entry, etc. public String getId() { return id; } public Map getFileEntries() { return fileEntries; } public Map getDirectoryEntries() { return directoryEntries; } private String calculateHash() { return UUID.randomUUID().toString(); } // Simplified } // Simplified Commit (needs proper hash calculation) class Commit { private String id; private String treeId; private String parentId; private String author; private long timestamp; private String message; public Commit(String treeId, String parentId, String author, String message) { this.treeId = treeId; this.parentId = parentId; this.author = author; this.timestamp = System.currentTimeMillis(); this.message = message; this.id = calculateHash(); // Simplified ID } public String getId() { return id; } public String getTreeId() { return treeId; } public String getParentId() { return parentId; } public String getAuthor() { return author; } public long getTimestamp() { return timestamp; } public String getMessage() { return message; } private String calculateHash() { return UUID.randomUUID().toString(); } // Simplified @Override public String toString() { return String.format("Commit(id=%s, treeId=%s, parentId=%s, msg='%s')", id, treeId, parentId, message); } } // ObjectStore class ObjectStore { private Map objects = new HashMap<>(); private Serializer serializer = new SimpleSerializer(); // Use an actual serializer public void putObject(String id, byte[] data) { objects.put(id, data); } public byte[] getObject(String id) { return objects.get(id); } // Helper methods to store/retrieve actual objects public void putBlob(Blob blob) { putObject(blob.getId(), serializer.serialize(blob)); } public Blob getBlob(String id) { return serializer.deserialize(getObject(id), Blob.class); } public void putTree(Tree tree) { putObject(tree.getId(), serializer.serialize(tree)); } public Tree getTree(String id) { return serializer.deserialize(getObject(id), Tree.class); } // Needs proper Tree deserialization public void putCommit(Commit commit) { putObject(commit.getId(), serializer.serialize(commit)); } public Commit getCommit(String id) { return serializer.deserialize(getObject(id), Commit.class); } // Needs proper Commit deserialization } // Index class (as defined before) class Index { private Map stagedFiles; public Index() { this.stagedFiles = new HashMap<>(); } public void addFile(String filePath, String blobId) { stagedFiles.put(filePath, blobId); } public Map getStagedFiles() { return stagedFiles; } public void clear() { stagedFiles.clear(); } } // GitManager (as defined before, with serialization/deserialization helpers) // NOTE: I'm embedding serialize/deserialize directly here to keep the example self-contained, // but passing a Serializer dependency is cleaner. class GitManager { private ObjectStore objectStore; private Path repositoryRoot; private String head; private Map branches; private Index index; private String currentBranch; // Which branch we are currently on public GitManager(Path repoRoot) { this.repositoryRoot = repoRoot; this.objectStore = new ObjectStore(); this.branches = new HashMap<>(); this.head = null; this.branches.put("main", null); this.index = new Index(); this.currentBranch = "main"; } public void init() { System.out.println("Initialized empty Git repository."); } public void add(String filePath) throws IOException { Path fullPath = repositoryRoot.resolve(filePath); if (!Files.exists(fullPath) || Files.isDirectory(fullPath)) { throw new IllegalArgumentException("File not found or is a directory: " + filePath); } byte[] content = Files.readAllBytes(fullPath); Blob blob = new Blob(content); objectStore.putBlob(blob); index.addFile(filePath, blob.getId()); System.out.printf("Added file %s (blob ID: %s)%n", filePath, blob.getId()); } public String commit(String message, String author) { if (index.getStagedFiles().isEmpty()) { System.out.println("No changes to commit. Staging area is empty."); return null; } Tree rootTree = buildTreeFromIndex(index.getStagedFiles()); objectStore.putTree(rootTree); // Store the root tree String parentCommitId = branches.get(getCurrentBranch()); Commit commit = new Commit(rootTree.getId(), parentCommitId, author, message); objectStore.putCommit(commit); head = commit.getId(); branches.put(getCurrentBranch(), commit.getId()); index.clear(); System.out.printf("Committed changes (ID: %s)%n", commit.getId()); return commit.getId(); } private Tree buildTreeFromIndex(Map stagedFiles) { Tree root = new Tree(); for (Map.Entry entry : stagedFiles.entrySet()) { root.addFileEntry(entry.getKey(), objectStore.getBlob(entry.getValue())); } return root; } public void log() { if (head == null) { System.out.println("No commits yet."); return; } String currentCommitId = head; while (currentCommitId != null) { Commit commit = objectStore.getCommit(currentCommitId); if (commit == null) { // Handle case where commit might not be found (e.g., malformed history) System.err.println("Error: Commit object not found for ID: " + currentCommitId); break; } System.out.printf("Commit ID: %s%n", commit.getId()); System.out.printf("Author: %s%n", commit.getAuthor()); System.out.printf("Date: %s%n", new Date(commit.getTimestamp())); System.out.printf("Message: %s%n%n", commit.getMessage()); currentCommitId = commit.getParentId(); } } public void checkout(String commitOrBranchName) throws IOException { String targetCommitId = branches.getOrDefault(commitOrBranchName, commitOrBranchName); // Try branch then assume ID Commit targetCommit = objectStore.getCommit(targetCommitId); if (targetCommit == null) { throw new IllegalArgumentException("Invalid commit ID or branch name: " + commitOrBranchName); } clearWorkingDirectory(); Tree rootTree = objectStore.getTree(targetCommit.getTreeId()); if (rootTree == null) { throw new IllegalStateException("Root tree not found for commit " + targetCommitId); } reconstructWorkingDirectory(rootTree, repositoryRoot); head = targetCommitId; if (branches.containsKey(commitOrBranchName)) { currentBranch = commitOrBranchName; } else { System.out.println("Checked out to commit " + targetCommitId + " (detached HEAD state)."); } System.out.printf("Checked out to %s%n", commitOrBranchName); } private void clearWorkingDirectory() throws IOException { System.out.println("Simulating clearing working directory."); // In a real system, you'd iterate and delete files/dirs in repositoryRoot } private void reconstructWorkingDirectory(Tree currentTree, Path currentPath) throws IOException { for (Map.Entry entry : currentTree.getFileEntries().entrySet()) { Path filePath = currentPath.resolve(entry.getKey()); Files.createDirectories(filePath.getParent()); Files.write(filePath, entry.getValue().getContent()); } for (Map.Entry entry : currentTree.getDirectoryEntries().entrySet()) { Path dirPath = currentPath.resolve(entry.getKey()); Files.createDirectories(dirPath); reconstructWorkingDirectory(entry.getValue(), dirPath); } } public void createBranch(String branchName) { if (branches.containsKey(branchName)) { throw new IllegalArgumentException("Branch " + branchName + " already exists."); } if (head == null) { throw new IllegalStateException("Cannot create branch: no commits yet."); } branches.put(branchName, head); System.out.printf("Created branch '%s' pointing to commit %s%n", branchName, head); } public void switchBranch(String branchName) throws IOException { if (!branches.containsKey(branchName)) { throw new IllegalArgumentException("Branch " + branchName + " does not exist."); } checkout(branchName); // Checkout the head of the branch this.currentBranch = branchName; // Update current branch tracker System.out.printf("Switched to branch '%s'%n", branchName); } private String getCurrentBranch() { return currentBranch; } } public class GitClient { public static void main(String[] args) throws IOException { Path repoPath = Paths.get("./my_repo"); Files.createDirectories(repoPath); GitManager git = new GitManager(repoPath); git.init(); // Create some files Files.write(repoPath.resolve("file1.txt"), "Version 1 of file1".getBytes()); Files.write(repoPath.resolve("file2.txt"), "Initial content of file2".getBytes()); git.add("file1.txt"); git.add("file2.txt"); String commit1Id = git.commit("Initial commit", "Alice"); Files.write(repoPath.resolve("file1.txt"), "Version 2 of file1".getBytes()); git.add("file1.txt"); String commit2Id = git.commit("Update file1", "Alice"); git.log(); git.createBranch("feature-a"); git.switchBranch("feature-a"); Files.write(repoPath.resolve("file3.txt"), "Content for feature-a".getBytes()); git.add("file3.txt"); git.commit("Add file3 on feature-a", "Bob"); git.log(); // Should show feature-a's history git.switchBranch("main"); // file3.txt should disappear from working directory after checkout System.out.println("Does file3.txt exist after switching to main? " + Files.exists(repoPath.resolve("file3.txt"))); git.checkout(commit1Id); // Go back to first commit // file1.txt should be "Version 1 of file1" System.out.println("Content of file1.txt after checkout commit1: " + new String(Files.readAllBytes(repoPath.resolve("file1.txt")))); // Clean up Files.walk(repoPath) .sorted(java.util.Comparator.reverseOrder()) .map(Path::toFile) .forEach(java.io.File::delete); } } ``` This `main` method demonstrates the flow and interaction. It shows you've thought about how a user would interact with your system. ## Performance Considerations: Scaling Up You've built the core. Now, let's talk about making it better, because interviewers love to push on scale. For performance, hashing content (e.g., SHA-1) can be CPU-intensive, especially for large files. Real Git uses a combination of techniques: * **Loose objects:** Initially, objects are stored as individual files. * **Packfiles:** Over time, Git "packs" these loose objects into a single, compressed file (`.git/objects/pack/pack-*.pack`) and builds an index (`.git/objects/pack/pack-*.idx`) for fast lookup. This significantly reduces disk space and I/O. * **Delta Compression:** Instead of storing full `Blob`s for every version, Git often stores only the *differences* (deltas) between a new version and an older, similar version. This is a massive space saver. Mentioning these points shows a deeper understanding of version control systems beyond just the basic LLD. You don't need to implement them, just explain their relevance for a production-grade system. ## Conclusion: What They're Really Looking For An LLD interview isn't about writing runnable, bug-free code for a complex system in an hour. It's about demonstrating: * **Problem Decomposition:** Can you break down a big problem into manageable, object-oriented components? * **Core Concepts:** Do you understand the fundamental principles (e.g., Git's snapshot model, content-addressable storage)? * **Object-Oriented Design:** Proper use of classes, encapsulation, relationships, and responsibilities. * **Trade-offs:** Can you identify limitations, discuss design choices, and suggest improvements? * **Communication:** Can you articulate your thought process clearly and defend your design? Focus on these, and you'll do fine. Don't get lost in the weeds of perfect syntax or implementing every Git feature. Nail the foundation. ## Ready to Ace Your Next Interview? Practice with AI-powered [mock interview](/en/interview-prep)s tailored to your target role and company. [Start Practicing for Free](/sign-up) | [Explore Interview Prep](/en/interview-prep)