Check our Programming Sample Library

# Student Level: Senior / Expert # Logic: Uses Generators (yield) to stream the file line-by-line. # Memory Usage: Constant O(1), regardless of file size. import os def stream_error_logs(file_path): """Generator that yields error lines one by one to save memory.""" if not os.path.exists(file_path): raise FileNotFoundError(f"Log file not found: {file_path}") # Context Manager handles closing automatically with open(file_path, 'r', encoding='utf-8') as f: for line in f: # Optimized check & strip whitespace if 'ERROR' in line: yield line.strip() # Consumption of the generator try: error_count = 0 for err in stream_error_logs("server_logs.txt"): # Process logic here (e.g., send alert) error_count += 1 print(f"Processing complete. Total Errors: {error_count}") except Exception as e: print(f"Critical Failure: {e}")

# Student Level: Senior / Expert # Logic: Recursive generator. Handles infinite depth. # Scalable: Works on any JSON structure. def flatten_json(y): out = {} def flatten(x, name=''): # Check if item is a dictionary if type(x) is dict: for a in x: # Recursively call flatten on the child flatten(x[a], name + a + '_') else: # Base case: It's a value, strip trailing underscore out[name[:-1]] = x flatten(y) return out # Usage print(flatten_json(data))

# Student Level: Senior # Logic: ThreadPoolExecutor. # Speed: Fast. Downloads 5 images simultaneously. import concurrent.futures import requests def download_image(url): try: r = requests.get(url, timeout=5) return f"{url} Done" except Exception as e: return f"{url} Failed" # Multi-Threaded Execution with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor: # Map the function to the list of URLs results = executor.map(download_image, urls) for result in results: print(result)

# Student Level: Senior / Data Scientist # Logic: Pandas 'groupby' (C-optimized backend). # Performance: Instant (Milliseconds). import pandas as pd # Load data into DataFrame df = pd.DataFrame(sales_data) # One-liner to group and sum # Vectorization applies the math to the whole column at once totals = df.groupby('region')['amount'].sum() print(totals)

# Student Level: Senior / Security Engineer # Logic: Parameterized Queries (Prepared Statements). # Safety: 100% Safe. The DB engine treats input as data, not code. def check_login_safe(cursor, username, password): # Use '?' placeholder (SQLite) or %s (Postgres) query = "SELECT * FROM users WHERE user=? AND pass=?" # Pass variables as a separate tuple cursor.execute(query, (username, password)) return cursor.fetchone()

// Student Level: Senior / Systems Architect // Logic: Using ReentrantLock with tryLock() to prevent Deadlocks. // This allows threads to "give up" if the lock is busy, rather than freezing. import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; import java.util.concurrent.TimeUnit; public class SafeAccount { private double balance; private final Lock lock = new ReentrantLock(); public boolean transfer(SafeAccount to, double amount) throws InterruptedException { // Try to lock both accounts to ensure atomicity if (this.lock.tryLock(1, TimeUnit.SECONDS)) { try { if (to.lock.tryLock(1, TimeUnit.SECONDS)) { try { if (this.balance >= amount) { this.balance -= amount; to.balance += amount; return true; // Success } } finally { to.lock.unlock(); // Always release lock B } } } finally { this.lock.unlock(); // Always release lock A } } return false; // Failed to acquire locks } }

// Student Level: Senior / Backend Eng // Logic: Using a HashMap for constant time lookup. // Performance: O(1) - Instant. Finds the user in 1 step, even with 10M records. import java.util.HashMap; import java.util.Map; public class UserSearchOptimized { // Pre-process list into a Map for fast access private Map<Integer, User> userMap = new HashMap<>(); public void loadUsers(List<User> users) { for (User u : users) { userMap.put(u.getId(), u); } } public User getUser(int id) { // Instant hash lookup return userMap.get(id); } }

// Student Level: Senior / Java Developer // Logic: Java Stream API (Functional Programming). // Readability: Clean, declarative, and easily parallelizable. public List<String> getDiscountedItems(List<Product> items) { return items.stream() .filter(Product::isInStock) // 1. Filter .peek(p -> p.setPrice(p.getPrice() * 0.8)) // 2. Apply logic .map(Product::getName) // 3. Transform to String .collect(Collectors.toList()); // 4. Collect results }

// Student Level: Senior / Architect // Logic: "Double-Checked Locking" with volatile keyword. // Safety: 100% Thread Safe and Performant. public class DBConnection { // 'volatile' ensures atomic reads across CPU cores private static volatile DBConnection instance; private DBConnection() {} public static DBConnection getInstance() { if (instance == null) { // Lock ONLY the creation block synchronized (DBConnection.class) { // Double check inside the lock if (instance == null) { instance = new DBConnection(); } } } return instance; } }

// Student Level: Senior // Logic: Try-With-Resources syntax (Java 7+). // Safety: Automatically calls .close() when block exits. public void readFileSafe(String path) { // Resource declared inside parentheses is auto-managed try (BufferedReader br = new BufferedReader(new FileReader(path))) { System.out.println(br.readLine()); } catch (IOException e) { // No finally block needed! e.printStackTrace(); } }

// Student Level: Senior / Systems Eng // Logic: Implementing a custom Smart Pointer using Templates. // Uses Destructor logic to auto-delete memory when it goes out of scope. template <typename T> class SmartPtr { private: T* ptr; public: // Constructor: Takes ownership of the pointer explicit SmartPtr(T* p = nullptr) : ptr(p) {} // Destructor: Automatically cleans up memory ~SmartPtr() { if (ptr) { delete ptr; std::cout << "Auto-cleaned memory." << std::endl; } } // Overloading operators to act like a real pointer T& operator*() { return *ptr; } T* operator->() { return ptr; } }; void useSmartPointer() { // No 'delete' needed! It cleans itself up when function ends. SmartPtr sp(new MyClass()); sp->sayHello(); }

// Student Level: Senior / Embedded Systems // Logic: Bitwise AND. // Performance: O(1) - Executed in a single CPU cycle. bool isPowerOfTwo(int n) { // Powers of 2 have exactly one bit set (e.g., 1000). // Subtracting 1 flips bits (e.g., 0111). // ANDing them results in 0. return (n > 0) && ((n & (n - 1)) == 0); }

// Student Level: Senior // Logic: Using std::lock_guard (RAII pattern). // Safety: Automatically unlocks even if an error occurs. #include <mutex> int counter = 0; std::mutex mtx; // The lock void incrementCounter() { // Lock is acquired when 'guard' is created std::lock_guard<std::mutex> guard(mtx); counter++; // Lock is automatically released here when 'guard' is destroyed }

// Student Level: Senior // Logic: Using .reserve() to allocate memory once. // Performance: Fast. Zero resizing/copying occurs. void fillVector() { std::vector<int> v; // Request memory for 1M ints upfront v.reserve(1000000); for (int i = 0; i < 1000000; i++) { // Memory is already there, just filling it. v.push_back(i); } }

// Student Level: Senior / Security Eng // Logic: Using strncpy or std::string. // Safety: Limits copy to buffer size. void copyInput(const char* input) { char buffer[10]; // Safe Copy: Only copy max 9 chars + null terminator // sizeof(buffer)-1 ensures we don't overflow strncpy(buffer, input, sizeof(buffer) - 1); // Manually ensure null termination buffer[sizeof(buffer) - 1] = '\0'; }

// Student Level: Senior / Full-Stack Dev // Logic: Async/Await with a recursive Retry pattern. // Robustness: Tries 3 times before throwing an error. async function fetchWithRetry(url, retries = 3) { try { // Await the fetch response const response = await fetch(url); if (!response.ok) throw new Error(`Server error: ${response.status}`); return await response.json(); } catch (error) { // Check if we have retries left if (retries > 0) { console.warn(`Failed. Retrying... (${retries} left)`); // Wait 1 second before retrying (Backoff) await new Promise(r => setTimeout(r, 1000)); // Recursively call function again return fetchWithRetry(url, retries - 1); } throw error; // Give up after 3 tries } }