BLOG POSTS
How to Use Loops in Java – For, While, Do-While
Loops are the backbone of iterative programming in Java, allowing developers to execute code blocks multiple times without manually duplicating statements. Whether you’re processing arrays, handling user input, or managing server operations, mastering Java’s three primary loop types – for, while, and do-while – is essential for writing efficient applications. This guide will walk you through each loop type with practical examples, performance considerations, and real-world applications that system administrators and developers encounter daily.
Understanding Java Loop Mechanics
Java loops operate on the principle of conditional iteration, where code blocks execute repeatedly until specific conditions are met. Each loop type serves different scenarios based on initialization requirements, condition checking, and execution patterns.
The three loop types handle iteration differently:
- For loops – Best for known iteration counts with built-in initialization and increment
- While loops – Ideal for condition-based iterations with unknown cycles
- Do-while loops – Ensures at least one execution before condition checking
Understanding the underlying bytecode generation helps optimize loop performance. The Java compiler converts loops into conditional jump instructions, making proper loop selection crucial for application efficiency.
For Loops: Complete Implementation Guide
For loops excel when you know the exact number of iterations or need structured increment patterns. The syntax provides three components: initialization, condition, and increment/decrement.
Basic For Loop Syntax
for (initialization; condition; increment/decrement) {
// Code block to execute
}
Here’s a practical example for processing server log entries:
import java.util.ArrayList;
import java.util.List;
public class LogProcessor {
public static void main(String[] args) {
List<String> logEntries = List.of(
"2024-01-15 10:30:22 INFO User login successful",
"2024-01-15 10:31:15 ERROR Database connection failed",
"2024-01-15 10:32:01 WARN High memory usage detected"
);
// Process each log entry with traditional for loop
for (int i = 0; i < logEntries.size(); i++) {
String entry = logEntries.get(i);
if (entry.contains("ERROR")) {
System.out.println("Critical issue found: " + entry);
}
}
}
}
Enhanced For Loop (For-Each)
Enhanced for loops simplify collection iteration and reduce array index errors:
// Enhanced for loop for the same log processing
for (String entry : logEntries) {
if (entry.contains("ERROR")) {
System.out.println("Critical issue found: " + entry);
}
}
Nested For Loops for Complex Operations
System administrators often need nested loops for processing multi-dimensional data like server metrics:
public class ServerMetricsAnalyzer {
public static void main(String[] args) {
int[][] serverLoad = {
{45, 67, 23, 89, 12}, // Server 1 hourly loads
{78, 34, 56, 90, 45}, // Server 2 hourly loads
{23, 78, 45, 67, 89} // Server 3 hourly loads
};
for (int server = 0; server < serverLoad.length; server++) {
System.out.println("Server " + (server + 1) + " Analysis:");
int totalLoad = 0;
for (int hour = 0; hour < serverLoad[server].length; hour++) {
totalLoad += serverLoad[server][hour];
System.out.printf("Hour %d: %d%% load%n", hour + 1, serverLoad[server][hour]);
}
double averageLoad = (double) totalLoad / serverLoad[server].length;
System.out.printf("Average load: %.2f%%%n%n", averageLoad);
}
}
}
While Loops: Flexible Iteration Control
While loops provide maximum flexibility for condition-based iterations, making them perfect for scenarios where iteration count depends on runtime conditions or external factors.
Basic While Loop Structure
while (condition) {
// Code block
// Remember to modify condition variables
}
Real-World Example: Database Connection Retry Logic
This example demonstrates while loops in connection handling – a common requirement for VPS applications:
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class DatabaseConnector {
private static final int MAX_RETRY_ATTEMPTS = 5;
private static final int RETRY_DELAY_MS = 2000;
public static Connection connectWithRetry(String url, String username, String password) {
int attempts = 0;
Connection connection = null;
while (attempts < MAX_RETRY_ATTEMPTS && connection == null) {
try {
System.out.println("Attempting database connection... (Attempt " + (attempts + 1) + ")");
connection = DriverManager.getConnection(url, username, password);
System.out.println("Connection successful!");
} catch (SQLException e) {
attempts++;
System.err.println("Connection failed: " + e.getMessage());
if (attempts < MAX_RETRY_ATTEMPTS) {
try {
Thread.sleep(RETRY_DELAY_MS);
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
break;
}
}
}
}
if (connection == null) {
System.err.println("Failed to establish connection after " + MAX_RETRY_ATTEMPTS + " attempts");
}
return connection;
}
}
File Processing with While Loops
While loops excel at processing files line by line, especially for log analysis on dedicated servers:
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class LogAnalyzer {
public static void analyzeLogFile(String fileName) {
try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
String line;
int errorCount = 0;
int warningCount = 0;
int totalLines = 0;
while ((line = reader.readLine()) != null) {
totalLines++;
if (line.contains("ERROR")) {
errorCount++;
} else if (line.contains("WARN")) {
warningCount++;
}
// Process line for specific patterns
if (line.contains("OutOfMemoryError")) {
System.out.println("Critical memory issue at line " + totalLines + ": " + line);
}
}
System.out.println("Log Analysis Complete:");
System.out.println("Total lines processed: " + totalLines);
System.out.println("Errors found: " + errorCount);
System.out.println("Warnings found: " + warningCount);
} catch (IOException e) {
System.err.println("Error reading log file: " + e.getMessage());
}
}
}
Do-While Loops: Guaranteed Execution
Do-while loops guarantee at least one execution before condition evaluation, making them ideal for user input validation, menu systems, and operations requiring initial execution.
Do-While Syntax
do {
// Code block (executes at least once)
} while (condition);
Interactive Server Management Menu
import java.util.Scanner;
public class ServerManager {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int choice;
do {
System.out.println("\n=== Server Management Console ===");
System.out.println("1. Check server status");
System.out.println("2. Restart services");
System.out.println("3. View system logs");
System.out.println("4. Monitor resource usage");
System.out.println("5. Exit");
System.out.print("Enter your choice (1-5): ");
while (!scanner.hasNextInt()) {
System.out.print("Invalid input. Please enter a number (1-5): ");
scanner.next();
}
choice = scanner.nextInt();
switch (choice) {
case 1:
checkServerStatus();
break;
case 2:
restartServices();
break;
case 3:
viewSystemLogs();
break;
case 4:
monitorResources();
break;
case 5:
System.out.println("Exiting server management console...");
break;
default:
System.out.println("Invalid choice. Please select 1-5.");
}
} while (choice != 5);
scanner.close();
}
private static void checkServerStatus() {
System.out.println("Checking server status...");
// Implementation for server status check
System.out.println("All services running normally.");
}
private static void restartServices() {
System.out.println("Restarting services...");
// Implementation for service restart
System.out.println("Services restarted successfully.");
}
private static void viewSystemLogs() {
System.out.println("Displaying recent system logs...");
// Implementation for log viewing
}
private static void monitorResources() {
System.out.println("Current resource usage:");
// Implementation for resource monitoring
System.out.println("CPU: 45%, Memory: 67%, Disk: 23%");
}
}
Input Validation with Do-While
import java.util.Scanner;
public class ConfigurationSetup {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// Port number validation
int port;
do {
System.out.print("Enter server port (1024-65535): ");
while (!scanner.hasNextInt()) {
System.out.print("Invalid input. Enter a valid port number: ");
scanner.next();
}
port = scanner.nextInt();
if (port < 1024 || port > 65535) {
System.out.println("Port must be between 1024 and 65535");
}
} while (port < 1024 || port > 65535);
System.out.println("Server configured to run on port: " + port);
scanner.close();
}
}
Performance Comparison and Best Practices
Different loop types offer varying performance characteristics depending on use cases. Here’s a comprehensive comparison:
| Loop Type | Best Use Case | Performance | Memory Usage | Common Pitfalls |
|---|---|---|---|---|
| For Loop | Known iterations, array processing | Excellent | Low | Index out of bounds |
| Enhanced For | Collection iteration | Very Good | Low | Cannot modify collection |
| While Loop | Condition-based iteration | Good | Low | Infinite loops |
| Do-While | Guaranteed first execution | Good | Low | Logic errors in conditions |
Performance Testing Example
Here’s a practical performance comparison for processing large datasets:
import java.util.ArrayList;
import java.util.List;
public class LoopPerformanceTest {
private static final int DATASET_SIZE = 1_000_000;
public static void main(String[] args) {
List<Integer> dataset = generateDataset(DATASET_SIZE);
// Test traditional for loop
long startTime = System.nanoTime();
long sum1 = traditionalForLoop(dataset);
long forLoopTime = System.nanoTime() - startTime;
// Test enhanced for loop
startTime = System.nanoTime();
long sum2 = enhancedForLoop(dataset);
long enhancedForTime = System.nanoTime() - startTime;
// Test while loop
startTime = System.nanoTime();
long sum3 = whileLoop(dataset);
long whileLoopTime = System.nanoTime() - startTime;
System.out.println("Performance Results for " + DATASET_SIZE + " elements:");
System.out.printf("Traditional For: %d ns (Sum: %d)%n", forLoopTime, sum1);
System.out.printf("Enhanced For: %d ns (Sum: %d)%n", enhancedForTime, sum2);
System.out.printf("While Loop: %d ns (Sum: %d)%n", whileLoopTime, sum3);
}
private static List<Integer> generateDataset(int size) {
List<Integer> data = new ArrayList<>(size);
for (int i = 0; i < size; i++) {
data.add(i);
}
return data;
}
private static long traditionalForLoop(List<Integer> data) {
long sum = 0;
for (int i = 0; i < data.size(); i++) {
sum += data.get(i);
}
return sum;
}
private static long enhancedForLoop(List<Integer> data) {
long sum = 0;
for (Integer value : data) {
sum += value;
}
return sum;
}
private static long whileLoop(List<Integer> data) {
long sum = 0;
int i = 0;
while (i < data.size()) {
sum += data.get(i);
i++;
}
return sum;
}
}
Common Issues and Troubleshooting
Infinite Loop Prevention
Infinite loops are the most common loop-related issue. Here are prevention strategies:
// BAD: Infinite loop example
int count = 0;
while (count < 10) {
System.out.println("Processing...");
// Missing increment - causes infinite loop
}
// GOOD: Proper loop with safeguards
int count = 0;
int maxIterations = 1000; // Safety limit
while (count < 10 && count < maxIterations) {
System.out.println("Processing item " + count);
count++; // Proper increment
}
Memory Leak Prevention
Large loops can cause memory issues if not handled properly:
// BAD: Potential memory leak
List<String> processedData = new ArrayList<>();
for (int i = 0; i < 1_000_000; i++) {
processedData.add("Data " + i); // Accumulates memory
}
// GOOD: Process in batches
private static void processBatchWise(List<String> data, int batchSize) {
for (int i = 0; i < data.size(); i += batchSize) {
int endIndex = Math.min(i + batchSize, data.size());
List<String> batch = data.subList(i, endIndex);
// Process batch
processBatch(batch);
// Clear references to allow garbage collection
batch.clear();
}
}
private static void processBatch(List<String> batch) {
for (String item : batch) {
// Process individual item
System.out.println("Processing: " + item);
}
}
Concurrent Modification Issues
Modifying collections during iteration causes ConcurrentModificationException:
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
public class SafeCollectionModification {
public static void main(String[] args) {
// BAD: Direct modification during iteration
List<String> badList = new ArrayList<>(Arrays.asList("item1", "item2", "item3"));
try {
for (String item : badList) {
if (item.equals("item2")) {
badList.remove(item); // Throws ConcurrentModificationException
}
}
} catch (ConcurrentModificationException e) {
System.out.println("Concurrent modification detected!");
}
// GOOD: Use Iterator for safe removal
List<String> goodList = new ArrayList<>(Arrays.asList("item1", "item2", "item3"));
Iterator<String> iterator = goodList.iterator();
while (iterator.hasNext()) {
String item = iterator.next();
if (item.equals("item2")) {
iterator.remove(); // Safe removal
}
}
// GOOD: Collect items to remove, then remove them
List<String> anotherList = new ArrayList<>(Arrays.asList("item1", "item2", "item3"));
List<String> toRemove = new ArrayList<>();
for (String item : anotherList) {
if (item.equals("item2")) {
toRemove.add(item);
}
}
anotherList.removeAll(toRemove);
// GOOD: Use concurrent collections for multi-threaded scenarios
List<String> concurrentList = new CopyOnWriteArrayList<>(
Arrays.asList("item1", "item2", "item3")
);
for (String item : concurrentList) {
if (item.equals("item2")) {
concurrentList.remove(item); // Safe in CopyOnWriteArrayList
}
}
}
}
Advanced Loop Patterns and Real-World Applications
Server Monitoring Dashboard
This comprehensive example combines all loop types for a practical server monitoring application:
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
public class ServerMonitoringDashboard {
private static final String[] SERVER_NAMES = {"web-01", "web-02", "db-01", "cache-01"};
private static final String[] METRICS = {"CPU", "Memory", "Disk", "Network"};
public static void main(String[] args) {
ServerMonitoringDashboard dashboard = new ServerMonitoringDashboard();
// Simulate continuous monitoring
Scanner scanner = new Scanner(System.in);
boolean monitoring = true;
do {
dashboard.displayDashboard();
System.out.print("\nContinue monitoring? (y/n): ");
String response = scanner.nextLine().trim().toLowerCase();
monitoring = response.equals("y") || response.equals("yes");
if (monitoring) {
try {
Thread.sleep(3000); // Wait 3 seconds before next update
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
} while (monitoring);
System.out.println("Monitoring stopped.");
scanner.close();
}
private void displayDashboard() {
System.out.println("\n" + "=".repeat(60));
System.out.println("SERVER MONITORING DASHBOARD");
System.out.println("=".repeat(60));
// Use nested for loops to display server metrics
for (int serverIndex = 0; serverIndex < SERVER_NAMES.length; serverIndex++) {
String serverName = SERVER_NAMES[serverIndex];
System.out.printf("%-10s | ", serverName);
// Display metrics for current server
for (int metricIndex = 0; metricIndex < METRICS.length; metricIndex++) {
String metric = METRICS[metricIndex];
int value = generateMetricValue();
String status = getStatusColor(value);
System.out.printf("%s: %3d%% %s | ", metric, value, status);
}
System.out.println();
}
// Check for critical issues using while loop
List<String> criticalAlerts = generateCriticalAlerts();
if (!criticalAlerts.isEmpty()) {
System.out.println("\n" + "!".repeat(40));
System.out.println("CRITICAL ALERTS:");
System.out.println("!".repeat(40));
int alertIndex = 0;
while (alertIndex < criticalAlerts.size()) {
System.out.println("• " + criticalAlerts.get(alertIndex));
alertIndex++;
}
}
// Display enhanced summary using enhanced for loop
Map<String, List<Integer> > serverMetrics = generateServerMetrics();
System.out.println("\nSERVER PERFORMANCE SUMMARY:");
System.out.println("-".repeat(40));
for (Map.Entry<String, List<Integer>> entry : serverMetrics.entrySet()) {
String server = entry.getKey();
List<Integer> metrics = entry.getValue();
double average = metrics.stream().mapToInt(Integer::intValue).average().orElse(0.0);
int max = metrics.stream().mapToInt(Integer::intValue).max().orElse(0);
System.out.printf("%-10s | Avg: %5.1f%% | Peak: %3d%%\n", server, average, max);
}
}
private int generateMetricValue() {
return ThreadLocalRandom.current().nextInt(10, 101);
}
private String getStatusColor(int value) {
if (value >= 90) return "🔴";
else if (value >= 70) return "🟡";
else return "🟢";
}
private List<String> generateCriticalAlerts() {
List<String> alerts = new ArrayList<>();
Random random = new Random();
if (random.nextDouble() < 0.3) { // 30% chance of alerts
alerts.add("High CPU usage detected on web-01 (95%)");
}
if (random.nextDouble() < 0.2) { // 20% chance
alerts.add("Database connection pool exhausted on db-01");
}
if (random.nextDouble() < 0.1) { // 10% chance
alerts.add("Disk space critical on web-02 (98% full)");
}
return alerts;
}
private Map<String, List<Integer>> generateServerMetrics() {
Map<String, List<Integer>> metrics = new HashMap<>();
for (String server : SERVER_NAMES) {
List<Integer> serverMetrics = new ArrayList<>();
for (int i = 0; i < 4; i++) { // 4 metrics per server
serverMetrics.add(generateMetricValue());
}
metrics.put(server, serverMetrics);
}
return metrics;
}
}
Batch Processing System
This example demonstrates loop optimization for large-scale data processing typically required on dedicated servers:
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
public class BatchProcessingSystem {
private static final int BATCH_SIZE = 1000;
private static final int THREAD_POOL_SIZE = 4;
public static void main(String[] args) {
BatchProcessingSystem processor = new BatchProcessingSystem();
// Generate sample data
List<DataRecord> records = processor.generateSampleData(50000);
System.out.println("Generated " + records.size() + " records for processing");
// Process using different strategies
processor.processSequentially(records);
processor.processInBatches(records);
processor.processInParallel(records);
}
private List<DataRecord> generateSampleData(int count) {
List<DataRecord> records = new ArrayList<>(count);
Random random = new Random();
for (int i = 0; i < count; i++) {
records.add(new DataRecord(
"RECORD_" + i,
random.nextInt(1000),
System.currentTimeMillis() + random.nextInt(86400000)
));
}
return records;
}
private void processSequentially(List<DataRecord> records) {
System.out.println("\n--- Sequential Processing ---");
long startTime = System.currentTimeMillis();
int processedCount = 0;
for (DataRecord record : records) {
processRecord(record);
processedCount++;
if (processedCount % 10000 == 0) {
System.out.println("Processed " + processedCount + " records");
}
}
long duration = System.currentTimeMillis() - startTime;
System.out.printf("Sequential processing completed: %d records in %d ms\n",
processedCount, duration);
}
private void processInBatches(List<DataRecord> records) {
System.out.println("\n--- Batch Processing ---");
long startTime = System.currentTimeMillis();
int totalProcessed = 0;
int batchNumber = 1;
for (int i = 0; i < records.size(); i += BATCH_SIZE) {
int endIndex = Math.min(i + BATCH_SIZE, records.size());
List<DataRecord> batch = records.subList(i, endIndex);
System.out.printf("Processing batch %d (%d records)... ",
batchNumber++, batch.size());
int batchProcessed = 0;
for (DataRecord record : batch) {
processRecord(record);
batchProcessed++;
}
totalProcessed += batchProcessed;
System.out.println("completed");
// Simulate batch completion delay
try {
Thread.sleep(10);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
long duration = System.currentTimeMillis() - startTime;
System.out.printf("Batch processing completed: %d records in %d ms\n",
totalProcessed, duration);
}
private void processInParallel(List<DataRecord> records) {
System.out.println("\n--- Parallel Processing ---");
long startTime = System.currentTimeMillis();
ExecutorService executor = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
List<Future<Integer>> futures = new ArrayList<>();
// Submit batches to thread pool
for (int i = 0; i < records.size(); i += BATCH_SIZE) {
int endIndex = Math.min(i + BATCH_SIZE, records.size());
List<DataRecord> batch = records.subList(i, endIndex);
Future<Integer> future = executor.submit(() -> {
int processed = 0;
for (DataRecord record : batch) {
processRecord(record);
processed++;
}
return processed;
});
futures.add(future);
}
// Collect results
int totalProcessed = 0;
int completedBatches = 0;
while (completedBatches < futures.size()) {
for (int i = 0; i < futures.size(); i++) {
Future<Integer> future = futures.get(i);
if (future.isDone()) {
try {
totalProcessed += future.get();
completedBatches++;
System.out.printf("Batch %d completed\n", i + 1);
futures.set(i, null); // Mark as processed
} catch (Exception e) {
System.err.println("Error processing batch: " + e.getMessage());
}
}
}
// Remove processed futures
futures.removeIf(Objects::isNull);
try {
Thread.sleep(50);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
executor.shutdown();
try {
executor.awaitTermination(30, TimeUnit.SECONDS);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
long duration = System.currentTimeMillis() - startTime;
System.out.printf("Parallel processing completed: %d records in %d ms\n",
totalProcessed, duration);
}
private void processRecord(DataRecord record) {
// Simulate processing time
try {
Thread.sleep(1);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
// Simulate some processing logic
record.setValue(record.getValue() * 2);
}
private static class DataRecord {
private String id;
private int value;
private long timestamp;
public DataRecord(String id, int value, long timestamp) {
this.id = id;
this.value = value;
this.timestamp = timestamp;
}
public String getId() { return id; }
public int getValue() { return value; }
public void setValue(int value) { this.value = value; }
public long getTimestamp() { return timestamp; }
}
}
Best Practices and Optimization Tips
Loop Selection Guidelines
- Use enhanced for loops when iterating collections without index requirements
- Choose traditional for loops when you need index access or custom increment patterns
- Prefer while loops for condition-based iterations with unknown cycle counts
- Use do-while sparingly – only when guaranteed first execution is required
- Avoid nested loops beyond 2-3 levels to maintain code readability
Performance Optimization Strategies
// BAD: Inefficient loop with repeated method calls
List<String> items = getItemList();
for (int i = 0; i < items.size(); i++) { // size() called every iteration
processItem(items.get(i));
}
// GOOD: Cache method calls outside loop
List<String> items = getItemList();
int size = items.size(); // Cache size
for (int i = 0; i < size; i++) {
processItem(items.get(i));
}
// BETTER: Use enhanced for loop for collections
List<String> items = getItemList();
for (String item : items) {
processItem(item);
}
Error Handling in Loops
import java.util.List;
import java.util.ArrayList;
public class RobustLoopProcessing {
public static void processDataSafely(List<String> data) {
int successCount = 0;
int errorCount = 0;
List<String> failedItems = new ArrayList<>();
for (int i = 0; i < data.size(); i++) {
try {
String item = data.get(i);
// Validate item before processing
if (item == null || item.trim().isEmpty()) {
System.out.println("Skipping empty item at index " + i);
continue;
}
processItem(item);
successCount++;
} catch (Exception e) {
errorCount++;
String errorItem = (i < data.size()) ? data.get(i) : "unknown";
failedItems.add(errorItem);
System.err.printf("Error processing item %d ('%s'): %s\n",
i, errorItem, e.getMessage());
// Continue processing other items instead of failing completely
}
}
// Summary report
System.out.printf("\nProcessing Summary: %d successful, %d failed\n",
successCount, errorCount);
if (!failedItems.isEmpty()) {
System.out.println("Failed items: " + failedItems);
}
}
private static void processItem(String item) throws Exception {
if (item.equals("ERROR")) {
throw new Exception("Simulated processing error");
}
// Normal processing logic
System.out.println("Processed: " + item);
}
}
Mastering Java loops requires understanding when to use each type, recognizing performance implications, and implementing proper error handling. Whether you’re managing server processes, analyzing log files, or building interactive applications, these loop patterns provide the foundation for robust, efficient Java applications. For more advanced server-side implementations, consider the scalability benefits offered by modern infrastructure solutions.
For additional information on Java loop optimization and best practices, refer to the Oracle Java Tutorial on Control Flow Statements and the Java 8 Streams API documentation for modern alternatives to traditional loops.
This article incorporates information and material from various online sources. We acknowledge and appreciate the work of all original authors, publishers, and websites. While every effort has been made to appropriately credit the source material, any unintentional oversight or omission does not constitute a copyright infringement. All trademarks, logos, and images mentioned are the property of their respective owners. If you believe that any content used in this article infringes upon your copyright, please contact us immediately for review and prompt action.
This article is intended for informational and educational purposes only and does not infringe on the rights of the copyright owners. If any copyrighted material has been used without proper credit or in violation of copyright laws, it is unintentional and we will rectify it promptly upon notification. Please note that the republishing, redistribution, or reproduction of part or all of the contents in any form is prohibited without express written permission from the author and website owner. For permissions or further inquiries, please contact us.
More stories
admin, August 13, 2025
Debian 13 “Trixie” Released: Major Upgrades...
admin, August 8, 2025
Proxmox VE 9.0: The Ultimate Virtualization Beast is He...
admin, August 4, 2025
Install and Uninstall Node.js on Ubuntu – Step-by-Step