Tagged articles
Large Files
32 articles · Page 1 of 1
The article explains why the standard MultipartFile upload fails for multi‑gigabyte files, then details a Spring Boot solution that splits files into 10 MB chunks, uses SHA‑256 hashes for identification, supports resumable and instant uploads, and safely merges chunks on the server.
JavaLarge FilesSpring Boot
0 likes · 11 min read

The article explains why traditional single‑file uploads fail for files over 100 MB, introduces a chunked upload architecture, provides complete Spring Boot controller code for initializing, uploading, merging chunks, shows high‑performance merging with RandomAccessFile, front‑end chunk handling with progress, resumable checks, HMAC verification, and optional MinIO storage.
BackendJavaLarge Files
0 likes · 11 min read

This article explains the challenges of uploading very large files, introduces chunked (splitting files into parts) and resumable upload techniques, and provides a step‑by‑step guide to implement the logic on the server side.
File UploadLarge Filesbackend development
0 likes · 3 min read

An in‑depth guide walks through the challenges of enterprise‑grade large file uploads—covering chunked transfer, resumable uploads, security, audit trails, and a complete set of RESTful endpoints with database schema, state‑machine handling, and both local and cloud storage integration for AI‑driven document processing.
Backend APIDatabase DesignFile Upload
0 likes · 33 min read

This guide shows how to efficiently extract timestamp‑filtered logs from a 16 GB text file in Go by reading the file in chunks, reusing memory with sync.Pool, and parallelising processing with goroutines, achieving roughly 25 seconds runtime.
File ProcessingGoLarge Files
0 likes · 10 min read

This guide introduces nine Python libraries—including smart_open, filelock, watchdog, zstandard, dataclasses-json, polars, fsspec, pandas, and tracemalloc—that together enable fast, memory‑efficient, and reliable handling of large files, remote storage, and concurrent workflows.
Large FilesPythonWatchdog
0 likes · 11 min read

This guide explains how to read and process files that exceed available memory by using line‑by‑line iteration, chunked reads, memory‑mapped files, generators, streaming decompression, parallel execution, and specialized libraries such as Dask and PyTables, while providing practical code examples and performance tips.
Large Filesdata processingmemory-efficient
0 likes · 9 min read

This article walks through the complete process of integrating MinIO into a Spring Boot project, covering why MinIO is chosen, environment setup, configuration, utility and controller implementation for simple and batch uploads, downloads, previews, large‑file multipart uploads, instant upload checks, and testing procedures.
File DownloadFile UploadLarge Files
0 likes · 22 min read

This article explains why traditional single-file uploads fail for large files, outlines the benefits of chunked uploading, and provides a complete Spring Boot implementation—including core dependencies, controller logic, high‑performance merging, Vue front‑end code, enterprise‑level optimizations, and performance test results.
BackendLarge FilesSpring Boot
0 likes · 11 min read

This article explains why traditional large‑file uploads fail, introduces the benefits of chunked uploading, and provides a complete Spring Boot implementation—including backend controllers, high‑performance merging, Vue front‑end code, enterprise‑level optimizations, performance benchmarks, and best‑practice recommendations—for building a robust, resumable file transfer solution.
Large FilesSpring Bootchunked upload
0 likes · 12 min read

This article explains why traditional single‑file uploads fail for large files, outlines the benefits of chunked uploading, and provides a complete Spring Boot implementation—including backend controllers, high‑performance merge logic, Vue front‑end code, enterprise‑grade optimizations, performance test results, and best‑practice recommendations.
Large Fileschunked uploadfile transfer
0 likes · 12 min read

This article explains why traditional file uploads fail for large files, outlines the advantages of chunked uploading, and provides a complete Spring Boot implementation—including backend controllers, high‑performance merging, Vue front‑end code, enterprise‑level optimizations, performance benchmarks, and best‑practice recommendations.
JavaLarge Fileschunked upload
0 likes · 12 min read

The author compares IntelliJ IDEA's built‑in database tool with Navicat for running massive SQL dump files, showing that IDEA consistently achieves higher execution speed, lower CPU usage, and no freezes even on multi‑gigabyte scripts, contrary to common expectations.
BackendIDEALarge Files
0 likes · 5 min read

Processing large files efficiently in Python requires techniques such as line-by-line iteration, chunked reads, generators, buffered I/O, and streaming, which help avoid memory errors, improve speed, and optimize resources for tasks like log analysis, data scraping, and real-time API handling.
File I/OLarge Filesperformance
0 likes · 5 min read

This article explains how to efficiently read large files in PHP line by line with the fread function, provides a complete code example, and discusses additional techniques such as buffering, fseek positioning, and adjusting memory limits to avoid memory overflow.
BackendLarge Filesfile-handling
0 likes · 4 min read

The author compares IDEA's built‑in database tool with Navicat for running massive SQL scripts, showing that IDEA consistently uses less CPU, avoids freezes, and achieves higher execution speed—even on files up to 1.83 GB—making it the preferred choice for large‑scale database migrations.
IDEALarge FilesNavicat
0 likes · 5 min read

This article explains how to efficiently read large files in PHP by using the fread function to process files line by line, includes a complete code example, and offers additional techniques such as buffering, fseek usage, and memory limit adjustments to prevent overflow.
Large FilesPHPbackend development
0 likes · 4 min read

This article explains how to efficiently read large files in PHP by using the fread function to process the file line by line, includes code examples, and discusses additional techniques such as buffering, fseek positioning, and increasing memory limits to avoid memory overflow.
BackendLarge Filesfile-handling
0 likes · 4 min read

This article explains the limitations of open‑source Argo Workflows for handling massive artifact files, and shows how ACK One Serverless Argo adds multipart upload, automatic garbage collection, and OSS streaming to enable efficient, secure, and scalable artifact management on Kubernetes.
Argo WorkflowsArtifactsKubernetes
0 likes · 10 min read

This article explains how to handle log files that are too large to fit into memory by reading them line‑by‑line with Java streams, using a Counter class and BitSet to track service usage and efficiently generate a top‑10 report.
BackendFile ProcessingJava
0 likes · 9 min read

This article explains how to efficiently read large files in PHP using the fread function line by line, providing code examples, buffering tips, fseek usage, and memory‑limit adjustments to avoid memory overflow while processing massive data streams.
Large Filesfile-handlingfread
0 likes · 4 min read

This article walks through using Rust and the AWS SDK to connect to object storage services, perform basic CRUD operations, and handle large file uploads and downloads efficiently with multipart techniques.
AWS SDKFile UploadLarge Files
0 likes · 9 min read

This article explains how to build a high‑performance large‑file HTTP upload system with breakpoint resume, detailing server‑side C implementation, immediate disk writes, client‑side hash generation, cookie‑based IDs, and JavaScript code for chunked uploading, progress tracking, and error handling.
C serverFile UploadHTML5
0 likes · 10 min read

This article outlines a practical approach for implementing high‑performance large file HTTP uploads with breakpoint resume, covering server‑side C implementation, client‑side hash generation, progress tracking, chunked uploads using HTML5 File.slice, and detailed JavaScript code examples for robust file transfer.
C serverHTTP uploadJavaScript
0 likes · 14 min read

This tutorial explains how to extract logs from a 16 GB file in about 25 seconds by reading the file in chunks, reusing buffers with sync.Pool, and processing those chunks concurrently with Go goroutines, avoiding full‑memory loads or slow line‑by‑line scans.
ConcurrencyFile ProcessingGo
0 likes · 9 min read


21CTOJun 16, 2021 · Backend Development
This article explains how to efficiently extract time‑range logs from a massive 16 GB .txt/.log file using Go's bufio.NewReader, sync.Pool for buffer reuse, and concurrent goroutines, achieving processing times of around 25 seconds.
ConcurrencyLarge Fileslog processing
0 likes · 9 min read

Learn how to efficiently extract timestamped logs from a massive 16 GB file in seconds using Go's buffered I/O, sync.Pool, and goroutine concurrency, with step‑by‑step code examples, performance tips, and a complete runnable program.
ConcurrencyLarge Fileslog processing
0 likes · 10 min read

This article explains how to build a high‑performance large‑file HTTP upload service with resumable support by using a C‑based server, client‑side hash generation, cookie‑based browser IDs, AJAX queries for upload progress, and JavaScript code that slices files and tracks upload speed and progress.
C++File UploadHTML5
0 likes · 12 min read

This article explains how to read large files in Java without running out of memory by comparing full‑file loading, line‑by‑line reading using BufferedReader, Apache Commons IO, and Java 8 streams, and shows how to boost throughput with batch processing and multithreaded file splitting.
ConcurrencyFile I/OJava
0 likes · 12 min read


21CTOMay 17, 2018 · Backend Development
Learn how to overcome PHP memory limits and improve user experience when handling huge files by using the SplFileObject class, generators, and NoRewindIterator, with complete code examples for reading both text and binary data efficiently.
Large FilesPHPgenerators
0 likes · 5 min read

This tutorial demonstrates how to efficiently read large files in Java by avoiding loading all lines into memory, comparing in‑memory approaches with streaming techniques using Scanner and Apache Commons IO, and showing memory usage metrics for each method.
Apache Commons IOFile I/OLarge Files
0 likes · 5 min read

This article provides a comprehensive overview of the Lustre parallel distributed file system, detailing its architecture, stripe configuration, I/O performance traits, challenges with small files, and practical optimization techniques for high‑performance computing environments.
HPCLarge FilesLustre
0 likes · 17 min read
