الفرق بين مبرمج جونيور وسينيور: ما الذي يحدث خلف الكواليس فعلاً؟

// Junior approach: simple validation
function validateCreditCard(cardNumber) {
 // Remove non-digit characters
 const cleanedNumber = cardNumber.replace(/\D/g, '');
 
 // Luhn algorithm
 let sum = 0;
 let shouldDouble = false;
 for (let i = cleanedNumber.length - 1; i >= 0; i--) {
 let digit = parseInt(cleanedNumber.charAt(i));
 if (shouldDouble) {
 digit *= 2;
 if (digit > 9) digit -= 9;
 }
 sum += digit;
 shouldDouble = !shouldDouble;
 }
 return sum % 10 === 0;
}

// Senior approach: system-aware validation
function validateCreditCardSystemAware(cardNumber, source) {
 // Validate source (e.g., API, user input)
 if (!isTrustedSource(source)) {
 throw new Error('Untrusted data source');
 }
 
 // Clean and normalize input
 const cleanedNumber = cardNumber.replace(/[^0-9]/g, '');
 if (cleanedNumber.length < 13 || cleanedNumber.length > 19) {
 return false;
 }
 
 // Additional checks for known card patterns
 if (!isValidCardPattern(cleanedNumber)) {
 return false;
 }
 
 // Luhn algorithm
 return validateWithLuhn(cleanedNumber);
}

function isTrustedSource(source) {
 // Implementation depends on system architecture
 return ['payment_gateway', 'internal_api'].includes(source);
}

function isValidCardPattern(number) {
 // Check against known card patterns (Visa, MasterCard, etc.)
 return /^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|6(?:011|5[0-9]{2})[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11})$/.test(number);
}

function validateWithLuhn(number) {
 let sum = 0;
 let shouldDouble = false;
 for (let i = number.length - 1; i >= 0; i--) {
 let digit = parseInt(number.charAt(i));
 if (shouldDouble) {
 digit *= 2;
 if (digit > 9) digit -= 9;
 }
 sum += digit;
 shouldDouble = !shouldDouble;
 }
 return sum % 10 === 0;
}

# Junior approach: load entire image into memory
from PIL import Image

def process_image_junior(input_path, output_path):
 image = Image.open(input_path) # Loads entire image into memory
 image = image.resize((800, 600))
 image = image.convert('L') # Convert to grayscale
 image.save(output_path)

# Senior approach: process image in chunks (simplified example)
import cv2
import numpy as np

def process_image_senior(input_path, output_path):
 # Use OpenCV to read and process image in a memory-efficient way
 cap = cv2.VideoCapture(input_path)
 
 # Read first frame to get dimensions
 ret, frame = cap.read()
 if not ret:
 raise ValueError("Could not read image")
 
 # Process frame (resize and convert to grayscale)
 processed_frame = cv2.resize(frame, (800, 600))
 processed_frame = cv2.cvtColor(processed_frame, cv2.COLOR_BGR2GRAY)
 
 # Save processed frame
 cv2.imwrite(output_path, processed_frame)
 cap.release()

# For very large images, we might use chunking
from PIL import Image

def process_large_image_in_chunks(input_path, output_path, chunk_size=1024):
 image = Image.open(input_path)
 width, height = image.size
 
 # Create a new image for the result
 result = Image.new('L', (800, 600))
 
 # Process in chunks to avoid high memory usage
 for y in range(0, height, chunk_size):
 for x in range(0, width, chunk_size):
 # Define the chunk boundaries
 right = min(x + chunk_size, width)
 bottom = min(y + chunk_size, height)
 
 # Crop the chunk
 chunk = image.crop((x, y, right, bottom))
 
 # Process the chunk (resize and convert to grayscale)
 chunk = chunk.resize((int(chunk.size[0] * 800 / width), 
 int(chunk.size[1] * 600 / height)))
 chunk = chunk.convert('L')
 
 # Paste the processed chunk into the result
 result.paste(chunk, (int(x * 800 / width), int(y * 600 / height)))
 
 result.save(output_path)

// Junior approach: blocking the event loop
const fs = require('fs');

function readFileBlocking(filePath) {
 try {
 const data = fs.readFileSync(filePath, 'utf8'); // Blocks the event loop
 console.log('File read successfully');
 return data;
 } catch (err) {
 console.error('Error reading file:', err);
 throw err;
 }
}

// Senior approach: non-blocking I/O
function readFileNonBlocking(filePath) {
 return new Promise((resolve, reject) => {
 fs.readFile(filePath, 'utf8', (err, data) => {
 if (err) {
 console.error('Error reading file:', err);
 reject(err);
 } else {
 console.log('File read successfully');
 resolve(data);
 }
 });
 });
}

// Even better: using streams for large files
function readLargeFileWithStream(filePath) {
 return new Promise((resolve, reject) => {
 const stream = fs.createReadStream(filePath, { encoding: 'utf8' });
 let data = '';
 
 stream.on('data', (chunk) => {
 data += chunk;
 });
 
 stream.on('end', () => {
 console.log('File read successfully with stream');
 resolve(data);
 });
 
 stream.on('error', (err) => {
 console.error('Error reading file with stream:', err);
 reject(err);
 });
 });
}

// Junior approach: basic API call
async function fetchUserDataJunior(userId) {
 const resp await fetch(`https://api.example.com/users/${userId}`);
 const data = await response.json();
 return data;
}

// Senior approach: robust API call with error handling and retries
async function fetchUserDataSenior(userId, retries = 3, timeout = 5000) {
 const controller = new AbortController();
 const timeoutId = setTimeout(() => controller.abort(), timeout);
 
 try {
 const response = await fetch(`https://api.example.com/users/${userId}`, {
 signal: controller.signal,
 headers: {
 'Content-Type': 'application/json',
 'Authorization': `Bearer ${getAuthToken()}`
 }
 });
 
 clearTimeout(timeoutId);
 
 if (!response.ok) {
 throw new Error(`HTTP error! status: ${response.status}`);
 }
 
 const data = await response.json();
 
 // Validate the data structure
 if (!isValidUserData(data)) {
 throw new Error('Invalid user data structure');
 }
 
 return data;
 } catch (err) {
 clearTimeout(timeoutId);
 
 if (retries > 0 && isRetryableError(err)) {
 console.warn(`Retrying... (${retries} attempts left)`);
 await new Promise(resolve => setTimeout(resolve, 1000));
 return fetchUserDataSenior(userId, retries - 1, timeout);
 }
 
 console.error('Failed to fetch user data:', err);
 throw err;
 }
}

function isValidUserData(data) {
 return data && typeof data.id === 'number' && typeof data.name === 'string';
}

function isRetryableError(err) {
 return err.name === 'AbortError' ||
 err.message.includes('network') ||
 err.message.includes('timeout') ||
 err.message.includes('503');
}

function getAuthToken() {
 // Implementation depends on your auth system
 return 'your-auth-token';
}

// Junior approach: monolithic, tightly coupled code
class BlogSystem {
 private posts: any[] = [];
 private users: any[] = [];
 
 addUser(user: any) {
 this.users.push(user);
 }
 
 addPost(post: any) {
 if (!this.users.some(u => u.id === post.authorId)) {
 throw new Error('Author not found');
 }
 this.posts.push(post);
 }
 
 getPostsByAuthor(authorId: number) {
 return this.posts.filter(p => p.authorId === authorId);
 }
 
 // ... more methods mixing users and posts logic
}

// Senior approach: modular, loosely coupled design
interface User {
 id: number;
 name: string;
 email: string;
}

interface Post {
 id: number;
 title: string;
 content: string;
 authorId: number;
 createdAt: Date;
}

class UserRepository {
 private users: User[] = [];
 
 addUser(user: User) {
 this.users.push(user);
 }
 
 getUserById(id: number): User | undefined {
 return this.users.find(u => u.id === id);
 }
}

class PostRepository {
 private posts: Post[] = [];
 
 constructor(private userRepository: UserRepository) {}
 
 addPost(post: Post) {
 if (!this.userRepository.getUserById(post.authorId)) {
 throw new Error('Author not found');
 }
 this.posts.push(post);
 }
 
 getPostsByAuthor(authorId: number): Post[] {
 return this.posts.filter(p => p.authorId === authorId);
 }
}

class BlogService {
 constructor(
 private userRepository: UserRepository,
 private postRepository: PostRepository
 ) {}
 
 createPost(title: string, content: string, authorId: number) {
 const post: Post = {
 id: Date.now(),
 title,
 content,
 authorId,
 createdAt: new Date()
 };
 this.postRepository.addPost(post);
 return post;
 }
 
 // ... other business logic methods
}

// Usage
const userRepo = new UserRepository();
const postRepo = new PostRepository(userRepo);
const blogService = new BlogService(userRepo, postRepo);

userRepo.addUser({ id: 1, name: 'John Doe', email: 'john@example.com' });
blogService.createPost('My First Post', 'Hello World!', 1);

-- Junior approach: fetch all users and filter in code
-- This query might return thousands of rows unnecessarily
SELECT * FROM users;

-- Then in code:
const activeUsers = users.filter(user => user.postCount > 10);

-- Senior approach: filter in the database using indexes
-- This query uses an index on post_count and only returns the needed rows
SELECT id, name, email
FROM users
WHERE post_count > 10
ORDER BY post_count DESC
LIMIT 100;

-- For even better performance, add a composite index
CREATE INDEX idx_users_post_count ON users(post_count);

// Junior approach: recalculate every time
function sumOfOddsJunior(numbers) {
 return numbers.filter(n => n % 2 !== 0).reduce((sum, n) => sum + n, 0);
}

// Senior approach: memoization for expensive calculations
const sumOfOddsCache = new Map();

function sumOfOddsSenior(numbers) {
 const key = numbers.join(','); // Simple key generation (not perfect but works for demo)
 
 if (sumOfOddsCache.has(key)) {
 console.log('Returning cached result');
 return sumOfOddsCache.get(key);
 }
 
 const result = numbers.filter(n => n % 2 !== 0).reduce((sum, n) => sum + n, 0);
 sumOfOddsCache.set(key, result);
 
 return result;
}

// For production, you might use a more robust memoization library
import memoize from 'lodash.memoize';

const sumOfOddsProduction = memoize((numbers) => {
 return numbers.filter(n => n % 2 !== 0).reduce((sum, n) => sum + n, 0);
}, (numbers) => numbers.join(','));

// Usage
export { sumOfOddsJunior, sumOfOddsSenior, sumOfOddsProduction };