BestHub
Sign in
Tagged articles

serialization

268 articles · Page 2 of 3
Top Architect
Top Architect
May 3, 2023 · Backend Development

Understanding RPC: Principles, Implementation Details, and Code Walkthrough

This article explains the fundamentals of Remote Procedure Call (RPC), covering its definition, core challenges, service registration and discovery with Zookeeper, client proxy generation, network transmission using Netty, serialization and compression, server-side request handling via reflection or Javassist, and performance comparisons between proxy strategies.

JavaJavassistNetty
0 likes · 24 min read
Understanding RPC: Principles, Implementation Details, and Code Walkthrough
Java Interview Crash Guide
Java Interview Crash Guide
Apr 20, 2023 · Fundamentals

Master Java I/O: Streams, NIO, and Serialization Explained

This article introduces Java I/O streams, explains how to efficiently read large files using buffered streams and NIO, details the core components of Java NIO (Channel, Buffer, Selector), and covers object serialization, the role of serialVersionUID, and alternative serialization frameworks.

IONIOStreams
0 likes · 12 min read
Master Java I/O: Streams, NIO, and Serialization Explained
MaGe Linux Operations
MaGe Linux Operations
Feb 28, 2023 · Fundamentals

Why Protocol Buffers Outperform JSON: A Hands‑On Java Benchmark

This article introduces Google’s Protocol Buffers, explains its compilation process, walks through a complete Java example, and compares its encoding speed, data size, and memory usage against JSON, showing that ProtoBuf becomes significantly faster and more compact as the number of operations increases.

Data FormatsProtocol Buffersperformance
0 likes · 9 min read
Why Protocol Buffers Outperform JSON: A Hands‑On Java Benchmark
FunTester
FunTester
Feb 23, 2023 · Backend Development

Why RESTful APIs Simplify Testing: A Practical Guide for Test Engineers

This article explains how RESTful API design reduces testing complexity by using unique URIs, standard HTTP methods, and JSON data exchange, and shows how test engineers can extend their frameworks with serialization support and added PUT/DELETE operations.

API testingPythonRESTful
0 likes · 7 min read
Why RESTful APIs Simplify Testing: A Practical Guide for Test Engineers
Java Architect Essentials
Java Architect Essentials
Feb 22, 2023 · Backend Development

Pitfalls and Solutions for Converting Java Beans to Maps

This article examines common pitfalls when converting Java Beans to Map objects—such as type loss with JSON libraries and incorrect property name resolution in BeanMap utilities—and presents a robust solution using Dubbo's PojoUtils along with detailed code examples and analysis.

Bean to MapBeanUtilsDubbo
0 likes · 12 min read
Pitfalls and Solutions for Converting Java Beans to Maps
ITPUB
ITPUB
Feb 18, 2023 · Backend Development

Mastering High‑Performance Backend: Lock‑Free, Zero‑Copy, Serialization, and More

This comprehensive guide explores essential backend techniques—including lock‑free programming, zero‑copy I/O, efficient serialization, pooling, concurrency, async processing, caching strategies, sharding, storage optimizations, and queue mechanisms—to build high‑performance, scalable services while highlighting practical code examples and real‑world trade‑offs.

CachingQueueSharding
0 likes · 51 min read
Mastering High‑Performance Backend: Lock‑Free, Zero‑Copy, Serialization, and More
Code Ape Tech Column
Code Ape Tech Column
Feb 6, 2023 · Backend Development

Understanding the Basic Structure and Technical Stack of RPC Architecture

This article explains the fundamental components of RPC architecture, details the client‑server roles, communication protocols, serialization methods, transport protocols, and synchronous versus asynchronous invocation patterns, providing a comprehensive guide for building a custom RPC framework.

Backend DevelopmentRPCTransport Protocol
0 likes · 12 min read
Understanding the Basic Structure and Technical Stack of RPC Architecture
Zhuanzhuan Tech
Zhuanzhuan Tech
Jan 18, 2023 · Backend Development

Generic Invocation in RPC Frameworks: Principles, Implementations, and Practice at Zhuanzhuan

This article explains the need for generic RPC calls in gateway and testing scenarios, compares Java‑Bean‑based and serialization‑intermediate approaches, and shares Zhuanzhuan's practical implementation details, helping developers choose the most suitable generic invocation method for their RPC frameworks.

DubboGeneric InvocationJava
0 likes · 9 min read
Generic Invocation in RPC Frameworks: Principles, Implementations, and Practice at Zhuanzhuan
Alibaba Cloud Developer
Alibaba Cloud Developer
Dec 6, 2022 · Backend Development

How Fury Achieves 20‑200× Faster Java Serialization Than JDK, Hessian, and Kryo

Fury is a JIT‑compiled, multi‑language native serialization framework that fully implements JDK custom serialization, delivering 20‑200× speed improvements over JDK, Hessian, and Kryo, while preserving compatibility across Java, Python, Go, C++, and JavaScript, as demonstrated by detailed protocol analysis and performance benchmarks.

FuryHessianJDK
0 likes · 21 min read
How Fury Achieves 20‑200× Faster Java Serialization Than JDK, Hessian, and Kryo
ByteDance SYS Tech
ByteDance SYS Tech
Dec 2, 2022 · Backend Development

How Sonic‑CPP Boosts JSON Parsing Speed 2.5× Faster Than RapidJSON

Sonic‑CPP, an open‑source C++ JSON library co‑developed by ByteDance’s STE and Service Framework teams, leverages SIMD vectorization, optimized memory layout, on‑demand parsing, and a compact DOM design to achieve up to 2.5× faster parsing than RapidJSON and competitive serialization performance, with extensive benchmark results and production‑grade usage.

C++ParsingSIMD
0 likes · 13 min read
How Sonic‑CPP Boosts JSON Parsing Speed 2.5× Faster Than RapidJSON
Python Programming Learning Circle
Python Programming Learning Circle
Nov 25, 2022 · Fundamentals

Python File I/O, CSV Handling, and Data Serialization Tutorial

This tutorial explains Python's file opening and closing methods, various file path formats, reading and writing techniques including with‑open, pointer manipulation, copying files, CSV read/write operations, in‑memory streams with StringIO/BytesIO, sys.stdin/stdout usage, and data serialization/deserialization using JSON and pickle.

CSVPicklefile-io
0 likes · 15 min read
Python File I/O, CSV Handling, and Data Serialization Tutorial
Java Backend Technology
Java Backend Technology
Nov 22, 2022 · Backend Development

Why Adding a Simple Log Triggered NPE in FastJSON Serialization – Lessons Learned

A recent production incident caused by inserting a single log statement revealed how FastJSON's ASM‑generated serializer invokes methods like isChinaName(), leading to a NullPointerException, and the article dissects the root cause, serialization mechanics, and best‑practice annotations to prevent similar bugs.

Javaannotationsdebugging
0 likes · 9 min read
Why Adding a Simple Log Triggered NPE in FastJSON Serialization – Lessons Learned
Selected Java Interview Questions
Selected Java Interview Questions
Nov 14, 2022 · Backend Development

Understanding RPC Architecture: Basic Structure and Technical System

This article explains the fundamental structure of Remote Procedure Call (RPC) architecture, detailing its core components such as providers, consumers, channels, protocols, and processors, and discusses the supporting technical system including network communication, serialization methods, transport protocols, and synchronous versus asynchronous remote invocation strategies.

JavaRPCnetwork communication
0 likes · 10 min read
Understanding RPC Architecture: Basic Structure and Technical System
Python Programming Learning Circle
Python Programming Learning Circle
Nov 10, 2022 · Fundamentals

Comprehensive Guide to Python File Operations, CSV Handling, and Data Serialization

This article provides a thorough tutorial on Python file I/O, covering opening and closing files, mode flags, absolute and relative paths, reading and writing techniques, file copying, CSV read/write, in‑memory streams, sys module redirection, and serialization with JSON and pickle, including code examples and best practices.

CSVPicklefile-io
0 likes · 20 min read
Comprehensive Guide to Python File Operations, CSV Handling, and Data Serialization
Programmer DD
Programmer DD
Nov 10, 2022 · Backend Development

Why Does FastJSON Invoke isChinaName() During Serialization? A Deep Dive

The article recounts a production incident caused by a simple log addition, then analyzes FastJSON’s serialization process, explaining why methods like isChinaName() are invoked, how ASM-generated serializers work, and offers best‑practice guidelines using @JSONField(serialize = false) to control serialization.

ASMBackend DevelopmentFastJSON
0 likes · 9 min read
Why Does FastJSON Invoke isChinaName() During Serialization? A Deep Dive
DeWu Technology
DeWu Technology
Nov 7, 2022 · Backend Development

Design and Implementation of a Custom RPC Framework

The article explains RPC fundamentals and why they are vital for distributed systems, then details the core components—service provider, consumer, and registry—along with extensions such as load‑balancing, circuit breaking, and serialization, and walks through a concrete Java implementation using Zookeeper, Netty, custom protocol, JSON/Protobuf, and Spring Boot SPI plugins.

JavaNettyRPC
0 likes · 11 min read
Design and Implementation of a Custom RPC Framework
IT Services Circle
IT Services Circle
Nov 7, 2022 · Backend Development

Understanding JDK Serialization Issues and the Importance of serialVersionUID

This article narrates a real‑world debugging scenario where adding a new field to a Java class stored in Redis caused deserialization failures, explains why missing serialVersionUID leads to mismatched versions, and demonstrates how explicitly defining serialVersionUID resolves the issue.

Backend DevelopmentJavaserialVersionUID
0 likes · 6 min read
Understanding JDK Serialization Issues and the Importance of serialVersionUID
ITPUB
ITPUB
Oct 26, 2022 · Backend Development

How to Choose the Right Components When Building a Go Microservice Framework

This article walks through practical trade‑offs in designing a Go microservice framework, covering protocol choices, data transport, network handling, serialization methods, service registry options, routing algorithms, and rate‑limiting strategies, while highlighting real‑world implementation details and pitfalls.

GoMicroservicesRouting
0 likes · 12 min read
How to Choose the Right Components When Building a Go Microservice Framework
FunTester
FunTester
Sep 9, 2022 · Backend Development

Performance Comparison of Java Object Serialization Methods Using Chronicle Queue

This article compares Java object serialization approaches—including default Serializable, explicit SelfDescribingMarshallable, and trivially copyable techniques—by benchmarking them with JMH and Chronicle Queue, showing that explicit serialization is roughly twice as fast as default and trivially copyable is over ten times faster.

chronicle-queueperformanceserialization
0 likes · 10 min read
Performance Comparison of Java Object Serialization Methods Using Chronicle Queue
Cognitive Technology Team
Cognitive Technology Team
Sep 8, 2022 · Backend Development

Recommendation: Use Wrapper Types for POJO Fields and Avoid Default Values to Prevent Common Pitfalls

The article advises that POJO class attributes should always use wrapper types without preset default values, illustrating several pitfalls such as null‑overridden defaults during Jackson deserialization, BeanUtils copy failures, MyBatis dynamic SQL issues, and RPC/API default‑value bugs.

Backend DevelopmentJavaMyBatis
0 likes · 7 min read
Recommendation: Use Wrapper Types for POJO Fields and Avoid Default Values to Prevent Common Pitfalls
Top Architect
Top Architect
Aug 25, 2022 · Backend Development

Building a Custom RPC Spring Starter: Architecture, Principles, and Code Walkthrough

This article explains the fundamentals of remote procedure call (RPC), presents a complete system architecture diagram, and provides a step‑by‑step implementation of a custom rpc‑spring‑starter using Java, Spring, Zookeeper for service registration, Netty for network communication, and dynamic proxy techniques for client‑side invocation.

Dynamic ProxyJavaNetty
0 likes · 18 min read
Building a Custom RPC Spring Starter: Architecture, Principles, and Code Walkthrough
ByteFE
ByteFE
Aug 22, 2022 · Backend Development

Comparison of JDK, Fastjson, and Hessian Serialization Protocols and Practical Hessian Serialization

This article examines the reasons for using serialization, compares three serialization protocols (JDK built‑in, Fastjson, and Hessian) with performance metrics, and provides a detailed Hessian serialization implementation, including class definitions, test results, hex analysis, and troubleshooting of common issues.

HessianJavadeserialization
0 likes · 12 min read
Comparison of JDK, Fastjson, and Hessian Serialization Protocols and Practical Hessian Serialization
Alibaba Cloud Developer
Alibaba Cloud Developer
Aug 5, 2022 · Fundamentals

Why Fury Serialization Beats Kryo: 20‑200× Faster Cross‑Language Performance

Fury is a JIT‑based native multi‑language serialization framework that automatically handles shared and cyclic references, offers zero‑copy support, and delivers 20‑200× speed improvements over existing solutions, making it a high‑performance drop‑in replacement for Java, Python, Go, and C++ serialization needs.

Cross-languagePythonZero‑copy
0 likes · 38 min read
Why Fury Serialization Beats Kryo: 20‑200× Faster Cross‑Language Performance
IT Architects Alliance
IT Architects Alliance
Aug 3, 2022 · Big Data

Kafka Producer: Overview, Detailed Process, Key Challenges, and Configuration

This article provides a comprehensive English guide to Kafka's producer component, covering its end‑to‑end workflow, detailed steps such as record creation, serialization, partitioning, batching, sender thread, custom data structures, send modes, common exceptions, and essential configuration parameters for optimal performance.

Avropartitioningserialization
0 likes · 16 min read
Kafka Producer: Overview, Detailed Process, Key Challenges, and Configuration
Wukong Talks Architecture
Wukong Talks Architecture
Aug 3, 2022 · Backend Development

How to Assemble a Service Registry: Requirements, Interfaces, and Technical Choices

This article explains how to assemble a production‑grade service registry by analyzing requirements, defining registration/discovery interfaces, comparing push and health‑check mechanisms, selecting long‑connection technologies, and choosing data‑storage and high‑availability strategies, all illustrated with JSON examples and design guidelines.

Service Registrybackend-architecturehealth-check
0 likes · 14 min read
How to Assemble a Service Registry: Requirements, Interfaces, and Technical Choices
Java Backend Technology
Java Backend Technology
Jun 28, 2022 · Backend Development

Why ArrayList.subList Can Leak Memory, Loop Forever, and Crash Your Java App

This article explains how improper use of Java's ArrayList.subList can cause hidden memory leaks, infinite loops, ConcurrentModificationExceptions, and serialization failures in RPC frameworks, and provides concrete best‑practice solutions such as copying to a new list or using stream operations.

ArrayListConcurrentModificationExceptionJava
0 likes · 9 min read
Why ArrayList.subList Can Leak Memory, Loop Forever, and Crash Your Java App
MaGe Linux Operations
MaGe Linux Operations
Jun 8, 2022 · Backend Development

Simplify JSON Handling in Go: From Maps to Structs and Powerful Libraries

This article explains why processing JSON in a statically‑typed language like Go can be cumbersome, demonstrates two basic approaches—using map[string]interface{} and struct tags—highlights their limitations, and introduces third‑party libraries such as SJSON and GJSON that make JSON reading and writing more concise and efficient.

backendgjsonjson
0 likes · 9 min read
Simplify JSON Handling in Go: From Maps to Structs and Powerful Libraries
Tencent Cloud Developer
Tencent Cloud Developer
Apr 25, 2022 · Databases

Implementing a Simple SQLite‑like Database in Go

The article walks through building a minimal SQLite‑style database in Go, covering memory‑disk page storage, B‑tree indexing, simple SQL parsing for INSERT and SELECT, row serialization, a pager that flushes pages, and a basic REPL, while highlighting current single‑page limits and future extensions.

B+TreeBackend DevelopmentGo
0 likes · 12 min read
Implementing a Simple SQLite‑like Database in Go
Programmer DD
Programmer DD
Apr 22, 2022 · Backend Development

Master FastJSON 2.0: Maven Setup, Core APIs, and JSONPath Guide

This article introduces FastJSON 2.0, explains how to add the Maven dependency, outlines the main classes and methods for JSON, JSONB, and JSONPath, and provides code examples for serializing and deserializing Java objects as well as partial parsing with JSONPath.

JavaJsonPathdeserialization
0 likes · 10 min read
Master FastJSON 2.0: Maven Setup, Core APIs, and JSONPath Guide
Code Ape Tech Column
Code Ape Tech Column
Apr 16, 2022 · Backend Development

Design and Implementation of a Custom RPC Framework with Spring Boot and Netty

This article presents a comprehensive overview of designing and implementing a custom RPC framework using Spring Boot and Netty, covering concepts, architecture, service registration with Zookeeper, load balancing, custom message protocol, serialization, handling TCP fragmentation, and various client invocation modes.

NettyRPCSpring Boot
0 likes · 14 min read
Design and Implementation of a Custom RPC Framework with Spring Boot and Netty
Sanyou's Java Diary
Sanyou's Java Diary
Apr 5, 2022 · Fundamentals

Master Java I/O: From Byte Streams to Object Serialization

This article provides a comprehensive guide to Java I/O, explaining the concepts of input and output streams, distinguishing byte and character streams, detailing node and processing streams, and offering practical code examples for file handling, buffering, conversion, and object serialization.

File I/OI/OStreams
0 likes · 22 min read
Master Java I/O: From Byte Streams to Object Serialization
Refining Core Development Skills
Refining Core Development Skills
Mar 23, 2022 · Backend Development

Understanding RPC and Its Implementation with SRPC in C++

This article explains the concepts, components, and lifecycle of Remote Procedure Call (RPC), compares it with HTTP, and demonstrates how to use the open‑source C++ SRPC framework to build client and server applications, including code generation, serialization, compression, and protocol handling.

C++IDLNetwork Protocols
0 likes · 11 min read
Understanding RPC and Its Implementation with SRPC in C++
IT Services Circle
IT Services Circle
Feb 14, 2022 · Fundamentals

Six Ways to Create Objects in Java

This article presents six Java object‑creation techniques—including direct instantiation, cloning, reflection‑based allocation, dynamic class loading, constructor invocation via reflection, and deserialization—explaining each method with code examples and practical notes for developers.

JavaLombokObject Creation
0 likes · 7 min read
Six Ways to Create Objects in Java
Architecture Digest
Architecture Digest
Feb 12, 2022 · Backend Development

Understanding RPC Implementation Principles and a Basic Java RPC Framework Example

This article explains the fundamentals of Remote Procedure Call (RPC), detailing the end‑to‑end workflow from defining service interfaces and implementations, registering services in a Zookeeper registry, handling network communication with Netty, and generating client‑side proxies using Spring and JDK dynamic proxies, all illustrated with complete Java code examples.

JavaRPCSpring
0 likes · 19 min read
Understanding RPC Implementation Principles and a Basic Java RPC Framework Example
JavaEdge
JavaEdge
Jan 2, 2022 · Big Data

Mastering ZooKeeper: Core Concepts, Architecture, and Practical Setup

This article provides a comprehensive overview of ZooKeeper, covering its role in distributed systems, common use cases, source code setup, serialization and persistence mechanisms, network communication models, and the watcher workflow, enabling developers to understand and deploy ZooKeeper effectively.

Big DataPersistenceWatcher
0 likes · 12 min read
Mastering ZooKeeper: Core Concepts, Architecture, and Practical Setup
Selected Java Interview Questions
Selected Java Interview Questions
Dec 18, 2021 · Backend Development

Deep Copy in Java: Multiple Implementation Methods

This article explains the difference between shallow and deep copying in Java and provides five practical techniques—including constructor copying, overriding clone(), Apache Commons Lang serialization, Gson serialization, and Jackson serialization—complete with code examples and test cases to demonstrate each approach.

Gsonclonedeep-copy
0 likes · 8 min read
Deep Copy in Java: Multiple Implementation Methods
Sohu Tech Products
Sohu Tech Products
Dec 8, 2021 · Backend Development

Design and Implementation of a Kotlin Compiler Plugin (KCP) for Efficient Serialization and Faster Compilation

This article presents a Kotlin compiler plugin that replaces verbose annotation‑based serialization with delegate‑based syntax, dramatically improves code readability, reduces boilerplate, and achieves up to 20% faster compilation while providing detailed implementation steps, performance results, and practical guidelines.

Compiler PluginKCPKotlin
0 likes · 29 min read
Design and Implementation of a Kotlin Compiler Plugin (KCP) for Efficient Serialization and Faster Compilation
Tencent Cloud Developer
Tencent Cloud Developer
Nov 18, 2021 · Backend Development

From RPC to Service‑Oriented Framework Design: Principles, Governance, and Common Frameworks

Modern micro‑service architectures evolve from basic RPC protocols—covering serialization, transport, invocation modes, and governance—into comprehensive service‑oriented frameworks that integrate registration, load balancing, fault tolerance, observability, and automation, with popular open‑source tools like Dubbo, gRPC, and Thrift guiding implementation choices.

MicroservicesRPCService Governance
0 likes · 19 min read
From RPC to Service‑Oriented Framework Design: Principles, Governance, and Common Frameworks
MaGe Linux Operations
MaGe Linux Operations
Nov 16, 2021 · Backend Development

Why Loguru Beats Python’s Built‑in Logging: A Hands‑On Guide

This article introduces Loguru, a third‑party Python logging library, explains why it simplifies logging compared to the standard logging module, outlines its key features such as out‑of‑the‑box setup, async safety, lazy evaluation, and file rotation, and provides practical code examples for quick integration into scripts, libraries, and frameworks.

LoggingLoguruasync
0 likes · 11 min read
Why Loguru Beats Python’s Built‑in Logging: A Hands‑On Guide
Sohu Tech Products
Sohu Tech Products
Nov 10, 2021 · Backend Development

Improving Kotlin Data Class Serialization with a Compiler Plugin: Design, Implementation, and Performance Evaluation

This article presents a Kotlin compiler plugin that replaces verbose annotation‑based serialization with concise delegated properties, explains its design and implementation details, demonstrates significant compilation‑time reductions of up to 20% and cleaner code, and provides a step‑by‑step guide for developers interested in building similar compiler extensions.

Compiler PluginKCPKotlin
0 likes · 21 min read
Improving Kotlin Data Class Serialization with a Compiler Plugin: Design, Implementation, and Performance Evaluation
Amap Tech
Amap Tech
Nov 4, 2021 · Backend Development

Simplifying Java Backend Unit Testing with JSON Serialization

This article shows how to streamline Java backend unit tests by loading JSON fixtures, deserializing them into objects, and re‑serializing results for concise assertions, while providing naming conventions, Maven setup, FastJSON tricks, and advanced Mockito techniques to replace verbose manual object construction.

Backend DevelopmentJavaMockito
0 likes · 30 min read
Simplifying Java Backend Unit Testing with JSON Serialization
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 16, 2021 · Backend Development

Ten Everyday Analogies to Explain Core Backend Interview Topics

The article uses vivid real‑life analogies to clarify ten essential backend interview concepts—including HTTP statelessness, serialization, rate limiting, TCP handshakes, thread‑pool mechanics, flow‑control windows, BIO/NIO/AIO, deadlocks, and select versus epoll—helping readers grasp complex ideas through familiar scenarios.

interviewrate limitingserialization
0 likes · 9 min read
Ten Everyday Analogies to Explain Core Backend Interview Topics
Architecture Digest
Architecture Digest
Oct 13, 2021 · Backend Development

Design and Implementation of a Java Open Platform SDK

This article explains how to design a modular Java SDK for an open platform, covering HTTP data transmission, flexible JSON/XML serialization adapters, and a simple API client with request/response abstractions, complete with code examples and practical implementation tips.

JavaOpen Platformbackend
0 likes · 14 min read
Design and Implementation of a Java Open Platform SDK
Python Crawling & Data Mining
Python Crawling & Data Mining
Sep 20, 2021 · Fundamentals

Master Python’s Pickle: Serialize Objects Easily with Real Code Examples

This article introduces Python’s pickle module, explains its purpose for object persistence, details key functions like dump, dumps, load, and loads with code snippets and example outputs, and demonstrates practical usage scenarios and common pitfalls, helping readers efficiently serialize and deserialize data in Python.

Data persistenceFile I/OPickle
0 likes · 6 min read
Master Python’s Pickle: Serialize Objects Easily with Real Code Examples
Big Data Technology & Architecture
Big Data Technology & Architecture
Sep 13, 2021 · Big Data

Understanding Bytecode, Code Generation, Serialization, and Data Processing Techniques in Spark and Flink

This article explains how bytecode and code‑generation improve Spark SQL performance, compares Java I/O and MapReduce InputFormats, reviews serialization choices in Spark and Flink, and describes reflection‑based DataFrame creation, storage‑memory eviction, fail‑fast design, and ConcurrentHashMap usage in big‑data frameworks.

FlinkJavaSpark
0 likes · 11 min read
Understanding Bytecode, Code Generation, Serialization, and Data Processing Techniques in Spark and Flink
MaGe Linux Operations
MaGe Linux Operations
Sep 6, 2021 · Backend Development

Why orjson Beats ujson for Fast Python JSON Serialization

This article compares Python's built‑in json module with faster alternatives like ujson, rapidjson, and the Rust‑based orjson, showing benchmark results, installation steps, code examples, and a known ujson indentation bug to help developers choose the most efficient JSON library.

RapidJSONjsonorjson
0 likes · 6 min read
Why orjson Beats ujson for Fast Python JSON Serialization
MaGe Linux Operations
MaGe Linux Operations
Aug 29, 2021 · Backend Development

How Python’s singledispatch Simplifies Custom JSON Serialization

This article explores Python’s underused singledispatch feature from PEP 443 as a clean, extensible way to serialize arbitrary objects to JSON, comparing it with traditional json module approaches and showing how it avoids cumbersome if‑elif‑else logic while keeping classes untouched.

Pythonbackendfunctools
0 likes · 6 min read
How Python’s singledispatch Simplifies Custom JSON Serialization
Big Data Technology Architecture
Big Data Technology Architecture
Aug 24, 2021 · Big Data

Comprehensive Guide to Spark Performance Optimization, Data Skew Mitigation, and Troubleshooting

This article presents a detailed collection of Spark performance‑tuning techniques—including submit‑script parameters, RDD and operator optimizations, parallelism and memory settings, broadcast variables, Kryo serialization, locality wait adjustments—as well as systematic methods for detecting and resolving data skew and common runtime issues such as shuffle failures, serialization errors, and JVM memory problems.

Data SkewJVM TuningShuffle
0 likes · 21 min read
Comprehensive Guide to Spark Performance Optimization, Data Skew Mitigation, and Troubleshooting
Python Programming Learning Circle
Python Programming Learning Circle
Aug 9, 2021 · Backend Development

How to Choose the Fastest JSON Library for Python: A Practical Benchmarking Guide

This article explains a systematic process for evaluating and selecting the most suitable high‑performance JSON library for Python, covering the need assessment, benchmark definition, filtering by additional requirements, and detailed benchmark results that highlight orjson as the fastest option for small‑message encoding while discussing trade‑offs such as safety, customizability, and ecosystem support.

BenchmarkingPythonRapidJSON
0 likes · 5 min read
How to Choose the Fastest JSON Library for Python: A Practical Benchmarking Guide
Top Architect
Top Architect
Aug 3, 2021 · Backend Development

Java Serialization vs Binary Encoding: Size and Performance Comparison

The article examines Java's built‑in Serializable interface, highlights its cross‑language incompatibility, large payload size, and low efficiency, then presents benchmark code comparing it with a custom binary encoding, showing significant reductions in data size and processing time, and recommends modern frameworks such as Protobuf or Thrift.

JavaThriftbinary encoding
0 likes · 6 min read
Java Serialization vs Binary Encoding: Size and Performance Comparison
Senior Brother's Insights
Senior Brother's Insights
Aug 2, 2021 · Backend Development

Mastering Protocol Buffers: From Installation to Java Integration

This tutorial explains what Protocol Buffers are, why they outperform JSON/XML, and provides a step‑by‑step guide for installing the compiler, defining .proto schemas, generating Java code, integrating with Maven, and using protobuf for fast serialization in micro‑service RPC.

Protocol BuffersRPCprotobuf
0 likes · 12 min read
Mastering Protocol Buffers: From Installation to Java Integration
Big Data Technology Architecture
Big Data Technology Architecture
Jul 15, 2021 · Big Data

Resolving Spark Task Not Serializable Errors: Causes, Code Examples, and Best Practices

This article analyzes why Spark tasks fail with a "Task not serializable" exception when closures reference class members, demonstrates the issue with Scala code examples, and provides practical solutions such as using @transient annotations, moving functions to objects, and ensuring proper class serialization.

ScalaSparkTask Not Serializable
0 likes · 12 min read
Resolving Spark Task Not Serializable Errors: Causes, Code Examples, and Best Practices
Intelligent Backend & Architecture
Intelligent Backend & Architecture
May 25, 2021 · Fundamentals

Unlock Java Mastery: 52 Essential Tips from Effective Java

This article distills the core lessons from Effective Java, presenting 52 practical guidelines on coding style, object creation, generics, enums, concurrency, and serialization, complete with clear explanations and code examples to help Java developers write cleaner, safer, and more efficient programs.

best-practiceseffective-javagenerics
0 likes · 87 min read
Unlock Java Mastery: 52 Essential Tips from Effective Java
MaGe Linux Operations
MaGe Linux Operations
May 24, 2021 · Fundamentals

Mastering Python Object Persistence: A Deep Dive into Pickle and Advanced Serialization

This article explains how Python persistence works by serializing objects with pickle and cPickle, compares file‑based and database storage, demonstrates basic and advanced usage—including handling circular references, custom classes, and versioning—and offers practical tips for maintaining pickled data across code changes.

Object PersistencePicklePython
0 likes · 22 min read
Mastering Python Object Persistence: A Deep Dive into Pickle and Advanced Serialization
Intelligent Backend & Architecture
Intelligent Backend & Architecture
May 24, 2021 · Fundamentals

Master Java Best Practices: 75 Essential Tips from Effective Java

This comprehensive guide distills the key lessons from Effective Java, covering static factories, builder patterns, singleton pitfalls, generics, enums, serialization, concurrency, and many other best‑practice recommendations, providing Java developers with actionable advice to write cleaner, safer, and more maintainable code.

Effective Javabest practicesgenerics
0 likes · 83 min read
Master Java Best Practices: 75 Essential Tips from Effective Java
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 11, 2021 · Fundamentals

Understanding Java's transient Keyword: Definition, Conventions, Usage Scenarios, and Serialization Behavior

This article explains the transient keyword in Java, covering its definition, the rules that govern its use, practical examples with Gson serialization, the impact on object fields during serialization, and how Externalizable can override its behavior, providing a comprehensive guide for developers.

ExternalizableGsonJava
0 likes · 10 min read
Understanding Java's transient Keyword: Definition, Conventions, Usage Scenarios, and Serialization Behavior
Selected Java Interview Questions
Selected Java Interview Questions
Feb 25, 2021 · Backend Development

Understanding serialVersionUID and Java Serialization Mechanism

This article explains how Java's serialization mechanism uses serialVersionUID to ensure class version compatibility, demonstrates default and explicit UID generation, shows code examples for serialization and deserialization, and explores various scenarios including field changes, static variables, inheritance, and the transient keyword.

JavaObjectInputStreamObjectOutputStream
0 likes · 13 min read
Understanding serialVersionUID and Java Serialization Mechanism
DeWu Technology
DeWu Technology
Feb 19, 2021 · Backend Development

Understanding Protobuf Serialization in Dubbo with Protostuff

The article explains how Dubbo can use the Protostuff library as a drop‑in replacement for .proto files to perform Protobuf TLV serialization, detailing the wire‑type encoding, Maven setup, POJO example, byte‑level analysis, Dubbo configuration, and tips for reducing serialization overhead.

DubboNetworkProtostuff
0 likes · 12 min read
Understanding Protobuf Serialization in Dubbo with Protostuff
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Feb 5, 2021 · Backend Development

Scaling Netty RPC with Protostuff: 400k Objects/sec per Server

An in‑depth guide demonstrates how to combine Netty with Protostuff for high‑performance RPC, detailing serialization setup, custom encoder/decoder implementation, multi‑threading pitfalls, and stress‑testing results that achieve up to 400,000 objects per second per server in a clustered environment.

JavaNettyProtostuff
0 likes · 11 min read
Scaling Netty RPC with Protostuff: 400k Objects/sec per Server
21CTO
21CTO
Jan 29, 2021 · Backend Development

Scaling Netty RPC with Protostuff: High‑Throughput Serialization Tips

This article details how to build a high‑performance Netty RPC system using Protostuff for serialization, covering dependency setup, custom encoder/decoder implementation, multithreaded buffer handling, and stress‑test results that achieve hundreds of thousands of objects per second per server.

NettyProtostuffRPC
0 likes · 10 min read
Scaling Netty RPC with Protostuff: High‑Throughput Serialization Tips
Architect's Tech Stack
Architect's Tech Stack
Nov 24, 2020 · Backend Development

Understanding RPC: Principles, Architecture, and Common Frameworks

This article explains why RPC is essential for distributed services, defines its core concepts and architecture, compares it with REST, SOAP and SOA, outlines the components and call flow, and reviews key technologies and popular Java‑based RPC frameworks such as Dubbo, Thrift and Avro.

Backend DevelopmentRPCService Architecture
0 likes · 15 min read
Understanding RPC: Principles, Architecture, and Common Frameworks
MaGe Linux Operations
MaGe Linux Operations
Nov 7, 2020 · Backend Development

Which Python JSON Library Is Fastest? ujson vs rapidjson vs orjson

This article compares the performance of Python's built‑in json module with popular third‑party libraries ujson, rapidjson, and the Rust‑based orjson, showing benchmark results, installation tips, code examples, and known bugs to help developers choose the most efficient JSON serializer.

RapidJSONorjsonserialization
0 likes · 7 min read
Which Python JSON Library Is Fastest? ujson vs rapidjson vs orjson
Laiye Technology Team
Laiye Technology Team
Nov 4, 2020 · Backend Development

Protobuf Practices and Lessons Learned at Laiye Technology

This article shares Laiye Technology's practical experience with Protobuf and gRPC, covering performance benefits, common pitfalls such as naming and compatibility issues, and the engineering solutions they implemented—including naming conventions, review processes, unified CI compilation, automatic client generation, version tagging, and Swagger documentation—to streamline large‑scale microservice development.

API documentationMicroservicesNaming Conventions
0 likes · 17 min read
Protobuf Practices and Lessons Learned at Laiye Technology
Programmer DD
Programmer DD
Oct 30, 2020 · Backend Development

5 Ways to Create Java Objects: From new Keyword to Deserialization

This article explains five core techniques for instantiating Java objects—including the new keyword, Class.newInstance(), Constructor.newInstance(), clone(), and deserialization—provides code examples for each method, and demonstrates their usage in a complete program with sample output.

JavaObject CreationReflection
0 likes · 8 min read
5 Ways to Create Java Objects: From new Keyword to Deserialization
Programmer DD
Programmer DD
Oct 22, 2020 · Backend Development

Master Java Serialization: Why serialVersionUID Matters and Common Pitfalls

This article explains Java's Serializable interface, the concepts of serialization and deserialization, when to use them, how to implement them with code examples, and dives into common issues such as transient fields, static variables, and mismatched serialVersionUID values that can cause runtime errors.

JavaObjectOutputStreamserialVersionUID
0 likes · 13 min read
Master Java Serialization: Why serialVersionUID Matters and Common Pitfalls
The Dominant Programmer
The Dominant Programmer
Sep 20, 2020 · Backend Development

Integrating Protobuf with Netty for Java Object Transmission

This guide walks through building a Netty server and client that exchange Java objects using Protobuf serialization, covering .proto definition, code generation with protoc, pipeline configuration with Netty's Protobuf handlers, and full example implementations for both sides.

JavaNettySocket
0 likes · 8 min read
Integrating Protobuf with Netty for Java Object Transmission