BestHub
Sign in
Tagged articles

jit

172 articles · Page 2 of 2
Sohu Tech Products
Sohu Tech Products
Aug 24, 2022 · Fundamentals

JVM JIT and CodeCache Parameter Configuration Guide

This article explains the JVM's Just‑In‑Time compilation mechanism and CodeCache memory area, detailing the purpose and default values of key JIT parameters such as TieredCompilation, CompileThreshold, OnStackReplacePercentage, CICompilerCount, as well as CodeCache settings like InitialCodeCacheSize, ReservedCodeCacheSize, Xmaxjitcodesize, CodeCacheMinimumFreeSpace and UseCodeCacheFlushing, and provides practical tuning advice for high‑traffic Java services.

HotSpotJVMcodecache
0 likes · 15 min read
JVM JIT and CodeCache Parameter Configuration Guide
Python Programming Learning Circle
Python Programming Learning Circle
Aug 16, 2022 · Fundamentals

Exploring Useful Python Decorators: @lru_cache, @jit, @do_twice, @count_calls, @dataclass, @singleton, @use_unit, @singledispatch

This article introduces Python decorators, explains how they can modify function behavior, and provides practical examples of eight useful decorators—including @lru_cache, @jit, @do_twice, @count_calls, @dataclass, @singleton, @use_unit, and @singledispatch—along with code snippets that demonstrate their implementation and benefits.

LRU cachecode examplesdataclass
0 likes · 10 min read
Exploring Useful Python Decorators: @lru_cache, @jit, @do_twice, @count_calls, @dataclass, @singleton, @use_unit, @singledispatch
NetEase Cloud Music Tech Team
NetEase Cloud Music Tech Team
May 26, 2022 · Backend Development

Investigation and Warm‑up Mitigation of JVM C2 CompilerThread CPU Spikes During Service Startup

The article details a real‑world case where JVM C2 CompilerThread CPU spikes during service startup caused request timeouts and GC pressure, explains how profiling identified the JIT compilation as the root cause, and describes a warm‑up replay strategy that pre‑compiles hotspot code to eliminate the spikes and stabilize deployments.

C2 CompilerThreadGCJVM
0 likes · 13 min read
Investigation and Warm‑up Mitigation of JVM C2 CompilerThread CPU Spikes During Service Startup
Tencent Cloud Developer
Tencent Cloud Developer
May 24, 2022 · Backend Development

Three Advanced Go Techniques: Minimal Runtime, JIT Compilation, and Bootstrap

The article demonstrates three advanced Go techniques—eliminating the standard runtime by custom entry points, building a simple Python JIT compiler that translates bytecode to optimized machine code, and bootstrapping the Go compiler itself via AST‑to‑LLVM translation—offering practical code examples that reveal compiler internals.

AssemblyBootstrapCompiler
0 likes · 21 min read
Three Advanced Go Techniques: Minimal Runtime, JIT Compilation, and Bootstrap
DaTaobao Tech
DaTaobao Tech
May 6, 2022 · Mobile Development

hyengine: A Unified Mobile Script Engine with JIT, Optimizations, and GC

hyengine is a lightweight, high‑performance mobile execution engine that unifies WebAssembly, JavaScript, Python and Lua via a compiler and VM, offering JIT compilation, register allocation, inline‑cache optimizations, a custom allocator (hymalloc) and a concurrent three‑color garbage collector (hygc), achieving substantial speed‑ups on macOS and Android.

Garbage CollectionJavaScriptMemory Management
0 likes · 34 min read
hyengine: A Unified Mobile Script Engine with JIT, Optimizations, and GC
macrozheng
macrozheng
Apr 27, 2022 · Backend Development

Why Your Java App Starts Slow and How JIT Optimization Fixes It

When a Java application launches, initial requests often feel sluggish because the JVM relies on an interpreter, but as frequently executed code becomes hot, JIT compilation translates it into optimized native machine code, dramatically improving response times—a process explained along with practical strategies like Dragonwell’s JWarmUp and request pre‑warming to accelerate performance.

DragonwellHotSpotJWarmUp
0 likes · 6 min read
Why Your Java App Starts Slow and How JIT Optimization Fixes It
IT Services Circle
IT Services Circle
Apr 15, 2022 · Backend Development

Understanding JIT Compilation and Its Impact on Application Startup Performance

The article explains why Java applications often experience high latency during the first few requests after startup, describes the role of the JVM interpreter and JIT compilation in creating hotspot code, and offers practical solutions such as JIT warm‑up techniques and traffic pre‑warming to improve performance.

HotSpotbackendjava
0 likes · 5 min read
Understanding JIT Compilation and Its Impact on Application Startup Performance
Alibaba Terminal Technology
Alibaba Terminal Technology
Mar 28, 2022 · Backend Development

hyengine: Unifying Mobile Script Execution with JIT and Multi‑Language Support

This article introduces hyengine, a lightweight, high‑performance engine designed to run multiple scripting languages such as JavaScript, WebAssembly, and Python on mobile devices, detailing its architecture, JIT compilation, optimizer passes, memory allocator, garbage collector, and performance benchmarks compared to LLVM and other runtimes.

CompilerGarbage CollectionOptimization
0 likes · 36 min read
hyengine: Unifying Mobile Script Execution with JIT and Multi‑Language Support
Tencent Cloud Developer
Tencent Cloud Developer
Mar 16, 2022 · Fundamentals

How V8 Executes JavaScript: From Parsing to JIT Optimization

This article explains the core concepts of compilation and interpretation, compares static and dynamic languages, and walks through the V8 engine’s workflow—including parsing, bytecode generation, JIT compilation, and TurboFan optimizations—providing concrete code examples and command‑line tips.

BytecodeCompilationJavaScript
0 likes · 8 min read
How V8 Executes JavaScript: From Parsing to JIT Optimization
IT Services Circle
IT Services Circle
Mar 15, 2022 · Frontend Development

Understanding How JavaScript Works: From Interpreted vs. Compiled Languages to the V8 Engine Execution Process

This article explains the fundamental principles behind JavaScript execution, covering the distinction between interpreted and compiled languages, the architecture of JavaScript engines (including V8, SpiderMonkey, and JavaScriptCore), runtime environments, the single‑threaded event loop, call‑stack processing, lexical analysis, parsing, bytecode, JIT compilation, and the role of Web Workers in off‑loading CPU‑intensive tasks.

EngineJavaScriptRuntime
0 likes · 13 min read
Understanding How JavaScript Works: From Interpreted vs. Compiled Languages to the V8 Engine Execution Process
JD Retail Technology
JD Retail Technology
Dec 29, 2021 · Backend Development

Microbenchmarking Integer-to-String Conversions in Java Using JMH

This article examines the performance of four Java integer-to-string conversion methods—Integer.toString, String.valueOf, a+"", and ""+a—by conducting raw loop tests and detailed JMH microbenchmarks, analyzing JVM warm-up, JIT, and OSR effects to reveal reliable measurement practices.

JMHPerformanceTestingjava
0 likes · 25 min read
Microbenchmarking Integer-to-String Conversions in Java Using JMH
Python Programming Learning Circle
Python Programming Learning Circle
Nov 8, 2021 · Artificial Intelligence

YOLOv5 Tutorial: From YOLOv3 to YOLOv5, Code Walkthrough, Model Export (JIT & ONNX) and Usage

This article provides a comprehensive guide on YOLOv5, covering its background from YOLOv3, detailed code analysis of the model architecture, step‑by‑step instructions for running detect.py, configuring yolov5s.yaml, exporting the model to TorchScript JIT and ONNX formats, and practical inference examples using PyTorch and ONNX Runtime.

ONNXPyTorchYOLOv5
0 likes · 16 min read
YOLOv5 Tutorial: From YOLOv3 to YOLOv5, Code Walkthrough, Model Export (JIT & ONNX) and Usage
ELab Team
ELab Team
Oct 13, 2021 · Frontend Development

How V8 Supercharges JavaScript: Inside the Engine’s Magic

This article explores the V8 JavaScript engine’s architecture, from its historical origins and source‑code acquisition to its loading strategies, lexical analysis, parsing, compilation, and execution optimizations, illustrating how V8 achieves high performance in browsers and Node.js.

CompilationEngineJavaScript
0 likes · 23 min read
How V8 Supercharges JavaScript: Inside the Engine’s Magic
Tencent Cloud Developer
Tencent Cloud Developer
Sep 29, 2021 · Fundamentals

Building a Simple LLVM-Based Compiler: Lexer, Parser, SSA, Optimizer, JIT and Mutable Variables

The tutorial walks through building a complete LLVM‑based Kaleidoscope compiler—from a tokenizing lexer and recursive‑descent parser, through AST construction, LLVM IR generation with SSA and phi nodes, optimization passes, JIT execution, and mutable variable handling via stack allocation—providing full C++ source examples.

KaleidoscopeLLVMOptimizer
0 likes · 47 min read
Building a Simple LLVM-Based Compiler: Lexer, Parser, SSA, Optimizer, JIT and Mutable Variables
DeWu Technology
DeWu Technology
Aug 1, 2021 · Backend Development

Understanding Service Jitter and JVM JIT Compilation

The article explains how intermittent latency spikes (jitter) in a high‑throughput service can be triggered when the JVM’s Just‑In‑Time compiler activates, detailing interpreter vs. JIT, C1/C2 tiered compilation, hot‑spot detection thresholds and compilation stages, and recommends pre‑warming code, disabling tiered compilation, or tuning thresholds and JVM flags to eliminate jitter.

HotSpotJVMbackend
0 likes · 12 min read
Understanding Service Jitter and JVM JIT Compilation
ByteFE
ByteFE
Jun 28, 2021 · Fundamentals

How V8 Executes JavaScript: From Source Code to Optimized Machine Code

This article explains the complete lifecycle of JavaScript execution in the V8 engine, covering language fundamentals, AST generation, bytecode compilation, interpretation, just‑in‑time optimization, hidden classes, inline caches, and other performance strategies used by both browsers and Node.js.

BytecodeEngineHiddenClass
0 likes · 15 min read
How V8 Executes JavaScript: From Source Code to Optimized Machine Code
政采云技术
政采云技术
Jun 8, 2021 · Frontend Development

The Process of Executing JavaScript in V8

This article explains how the V8 engine parses JavaScript into an AST, generates bytecode, employs lazy compilation, caches machine code, and uses the TurboFan optimizing compiler with JIT techniques to balance speed and memory consumption during script execution.

BytecodeEngineV8
0 likes · 12 min read
The Process of Executing JavaScript in V8
Python Programming Learning Circle
Python Programming Learning Circle
May 19, 2021 · Fundamentals

Pyston v2: A JIT‑Enhanced Python Interpreter 20% Faster Than CPython

Released in October 2020, Pyston v2 is a JIT‑based Python implementation that delivers roughly 20% speed improvements over CPython 3.8 in macro‑benchmarks, offers easy deployment, maintains high compatibility with CPython, and incorporates techniques such as DynASM JIT, quickening, and process‑building optimizations.

PystonRuntimeinterpreter
0 likes · 5 min read
Pyston v2: A JIT‑Enhanced Python Interpreter 20% Faster Than CPython
MaGe Linux Operations
MaGe Linux Operations
May 8, 2021 · Fundamentals

Why PyPy Can Run Python Faster Than C: JIT Explained with Benchmarks

The article explains how PyPy’s just‑in‑time compilation can make Python code run faster than even native C implementations, demonstrates benchmark results comparing default Python, PyPy, and C, and outlines the differences between ahead‑of‑time compilation, interpretation, and JIT.

CompilationPyPyPython
0 likes · 5 min read
Why PyPy Can Run Python Faster Than C: JIT Explained with Benchmarks
Senior Brother's Insights
Senior Brother's Insights
Jan 6, 2021 · Backend Development

Master Java Microbenchmarking with JMH: A Hands‑On Guide

This article introduces JMH, the Java Microbenchmark Harness, explains why traditional main‑method benchmarks are unreliable, and provides step‑by‑step instructions, code examples, and best‑practice annotations for accurately measuring method‑level performance in Java applications.

BenchmarkingJMHJVM
0 likes · 20 min read
Master Java Microbenchmarking with JMH: A Hands‑On Guide
Senior Brother's Insights
Senior Brother's Insights
Dec 28, 2020 · Fundamentals

Why Java’s JIT Compiler Matters: How HotSpot Optimizes Your Code

This article explains the role of Java's Just‑In‑Time compiler, how HotSpot combines interpretation and compilation, the mechanisms for hotspot detection, the differences between C1 and C2 compilers, performance testing across modes, and the key optimization techniques that make JIT‑generated code faster.

HotSpotJVMOptimization
0 likes · 16 min read
Why Java’s JIT Compiler Matters: How HotSpot Optimizes Your Code
Qunar Tech Salon
Qunar Tech Salon
Dec 23, 2020 · Fundamentals

Exploring Java Serviceability Agent (SA): JVM Memory Model, JIT, and Low‑Level Debugging Tools

This article provides a comprehensive, English‑language walkthrough of Java Serviceability Agent (SA), covering how to obtain and analyze JVM internal structures, the memory model and Linux process layout, the oop/klass split, JIT compilation mechanics, and the implementation of tools such as jmap and jstack, all illustrated with code snippets and diagrams.

JVMLow‑Level ToolsMemory Model
0 likes · 35 min read
Exploring Java Serviceability Agent (SA): JVM Memory Model, JIT, and Low‑Level Debugging Tools
MaGe Linux Operations
MaGe Linux Operations
Dec 15, 2020 · Fundamentals

Boost Python Speed: 5 Proven Techniques to Outrun C and Java

Although Python is slower than C, Java, or JavaScript for CPU‑intensive tasks, several projects—including PyPy, Pyston, Nuitka, Cython, and Numba—offer distinct approaches such as JIT compilation, LLVM back‑ends, or C conversion to significantly improve Python’s runtime performance.

CythonLLVMPython
0 likes · 5 min read
Boost Python Speed: 5 Proven Techniques to Outrun C and Java
Laravel Tech Community
Laravel Tech Community
Nov 27, 2020 · Backend Development

Highlights of PHP 8.0: JIT and Major New Features

PHP 8.0 introduces a suite of major enhancements—including named arguments, union types, attributes, constructor property promotion, match expressions, null‑safe operator, and especially JIT compilation—aimed at improving performance, type safety, and overall language consistency.

jitperformancephp8
0 likes · 3 min read
Highlights of PHP 8.0: JIT and Major New Features
php Courses
php Courses
Nov 27, 2020 · Backend Development

Phoronix PHP 8 Performance Benchmark Report Highlights JIT Gains

Phoronix’s benchmark of PHP 8 (built from the latest Git source) compares it with previous PHP releases, showing modest gains for the stable version but a dramatic 92% speed increase when JIT is enabled, while also revealing mixed results across different test suites due to I/O bottlenecks.

benchmarkjitperformance
0 likes · 3 min read
Phoronix PHP 8 Performance Benchmark Report Highlights JIT Gains
php Courses
php Courses
Nov 27, 2020 · Backend Development

Key New Features and Improvements in PHP 8.0

The article outlines the major enhancements introduced in PHP 8.0, including the Just‑In‑Time compiler, performance optimizations, built‑in JSON support, named parameters, attributes, union types, static return types, new string functions, the nullsafe operator, and provides download links and further reading resources.

New Featuresjitphp8
0 likes · 3 min read
Key New Features and Improvements in PHP 8.0
Meituan Technology Team
Meituan Technology Team
Oct 22, 2020 · Fundamentals

Java JIT Compilation: Principles, Optimizations, and Practical Tips

Java’s JIT compilation transforms bytecode into optimized native code at runtime using tiered C1 and C2 compilers—or Graal—to apply SSA, inlining, escape analysis, loop unrolling, and other optimizations, while profiling‑driven thresholds and tuning flags let developers balance startup speed, peak throughput, and latency.

JVMOptimizationjava
0 likes · 36 min read
Java JIT Compilation: Principles, Optimizations, and Practical Tips
Laravel Tech Community
Laravel Tech Community
Sep 22, 2020 · Backend Development

Overview of HHVM 4.75: Features, Improvements, and Upcoming Changes

The article introduces Facebook's HipHop VM (HHVM) as a PHP JIT compiler, highlights the performance gains and memory savings, details the release of version 4.75 with its supported versions, and outlines new highlights and upcoming deprecations such as the removal of is_array().

Hack languagePHPhhvm
0 likes · 2 min read
Overview of HHVM 4.75: Features, Improvements, and Upcoming Changes
JD Cloud Developers
JD Cloud Developers
Sep 9, 2020 · Fundamentals

Unlocking JVM Secrets: A Visual Guide to Java Memory and Execution

This article demystifies the JVM’s memory architecture and execution engine, walking through class loading, the runtime data areas, JIT versus interpreter, and native interactions, complemented by clear diagrams to help developers understand how Java manages memory and executes code.

ClassLoadingJVMMemory
0 likes · 7 min read
Unlocking JVM Secrets: A Visual Guide to Java Memory and Execution
Laravel Tech Community
Laravel Tech Community
Jun 8, 2020 · Backend Development

PHP 8 Performance Benchmark Report by Phoronix

Phoronix benchmarked multiple PHP versions, including PHP 8 with and without JIT, revealing that PHP 8 offers modest gains over PHP 7.4 but a dramatic 92% speed increase when JIT is enabled, while older versions lag far behind.

PHPbackendbenchmark
0 likes · 5 min read
PHP 8 Performance Benchmark Report by Phoronix
21CTO
21CTO
Jun 8, 2020 · Backend Development

How PHP 8’s JIT Boosts Performance: Benchmark Insights from Phoronix

Phoronix’s benchmark of PHP 8 (built from the latest Git source) compares it with PHP 7‑4, older 7.x releases, and legacy 5.x versions, showing a modest 7% speed gain without JIT and a dramatic 92% improvement when JIT is enabled, while highlighting I/O bottlenecks that limit gains in some tests.

benchmarkjitperformance
0 likes · 5 min read
How PHP 8’s JIT Boosts Performance: Benchmark Insights from Phoronix
Java Captain
Java Captain
Mar 28, 2020 · Fundamentals

Understanding the Impact of Print Statements, sleep, and Integer on Java Thread Safety

This article explores how adding print statements, using Thread.sleep, and employing Integer objects affect thread safety in Java, illustrating why a non‑volatile flag can cause infinite loops, how synchronized I/O and sleep influence memory visibility, and why seemingly unrelated changes sometimes make the program terminate.

Thread Safetyjavajit
0 likes · 15 min read
Understanding the Impact of Print Statements, sleep, and Integer on Java Thread Safety
FunTester
FunTester
Mar 10, 2020 · Backend Development

Understanding JVM Hotspot Compilation and Performance Gains in Java

The article explains how the JVM selectively compiles frequently executed Java code into optimized native code, demonstrates significant performance improvements through JIT compilation with two demo programs, and highlights the trade‑offs between interpretation and compilation for hotspot methods.

HotSpotJVMOptimization
0 likes · 5 min read
Understanding JVM Hotspot Compilation and Performance Gains in Java
macrozheng
macrozheng
Nov 19, 2019 · Backend Development

Why Java Reflection Is Slow and How It Works Under the Hood

This article explains the internal workings of Java reflection, from obtaining Method objects via getMethod and getDeclaredMethod to the invoke process, and details why reflection incurs significant performance overhead due to argument boxing, visibility checks, parameter validation, lack of inlining, and JIT optimization limits.

JDKMethod Invocationjava
0 likes · 24 min read
Why Java Reflection Is Slow and How It Works Under the Hood
Programmer DD
Programmer DD
Sep 21, 2019 · Backend Development

Unlocking the JVM: A Deep Dive into Java’s Runtime Architecture

This article explains the Java Virtual Machine’s architecture, covering its role as the JRE implementation, the three main subsystems—class loader, runtime data area, and execution engine—and detailing components such as class loading phases, memory areas, the interpreter, JIT compiler, and garbage collection.

Class LoaderJVMjava
0 likes · 7 min read
Unlocking the JVM: A Deep Dive into Java’s Runtime Architecture
System Architect Go
System Architect Go
Sep 18, 2019 · Fundamentals

Understanding How JavaScript Works: Optimizing the V8 JIT Compiler

This article explains the three-stage execution process of JavaScript in V8, compares interpreter and compiler approaches, describes how the JIT combines their strengths, and provides practical tips for writing JavaScript that maximizes performance by leveraging V8’s optimization mechanisms.

FrontendJavaScriptOptimization
0 likes · 6 min read
Understanding How JavaScript Works: Optimizing the V8 JIT Compiler
Xianyu Technology
Xianyu Technology
Apr 11, 2019 · Cloud Computing

Performance Evaluation of Dart Compilation Modes for Server‑Side FaaS Applications

Evaluating Dart’s AoT, AppJIT, Kernel, and JIT compilation for server‑side FaaS shows AoT yields the fastest runtime (≈6× JIT), AppJIT with aggressive optimization slightly outperforms Kernel, startup latency rivals Java, and for long‑running services JIT modes with tuning provide comparable throughput while minimizing build time.

AOTCompilationDART
0 likes · 10 min read
Performance Evaluation of Dart Compilation Modes for Server‑Side FaaS Applications
21CTO
21CTO
Apr 1, 2019 · Backend Development

Why PHP’s JIT Matters: Boosting Performance in PHP 8.0

This article explains how PHP’s upcoming JIT compiler and the PHP 8.0 release aim to improve performance, why the gains are most noticeable in CPU‑bound code, and what developers can expect from these new features.

backendjitperformance
0 likes · 6 min read
Why PHP’s JIT Matters: Boosting Performance in PHP 8.0
Programmer DD
Programmer DD
Aug 25, 2018 · Backend Development

Mastering Java Microbenchmarking with JMH: 12 Common Pitfalls and How to Avoid Them

This article introduces Java Microbenchmark Harness (JMH), explains why precise benchmarking matters, and walks through twelve typical testing pitfalls—such as dead‑code elimination, constant folding, loop misuse, fork isolation, method inlining, false sharing, branch prediction, and multithreading—showing how JMH helps developers obtain reliable performance measurements.

JMHPerformance Testingbenchmark
0 likes · 25 min read
Mastering Java Microbenchmarking with JMH: 12 Common Pitfalls and How to Avoid Them
High Availability Architecture
High Availability Architecture
Jul 2, 2018 · Backend Development

Java Performance Optimization Practices and the VJTools Open‑Source Toolkit

This article shares Vipshop’s extensive Java performance‑optimization experience, introduces the open‑source VJTools project for profiling and troubleshooting, and presents practical insights on common pitfalls, reliable techniques, JIT fundamentals, micro‑benchmarking, useful tools, and real‑world case studies from Vipshop’s architecture.

VJToolsjavajit
0 likes · 5 min read
Java Performance Optimization Practices and the VJTools Open‑Source Toolkit
21CTO
21CTO
Mar 21, 2018 · Backend Development

Unlocking Java Performance: How Graal Replaces C2 in HotSpot JIT

This article explains Java's traditional JIT compilers, introduces Graal as a modular Java‑level JIT and AOT compiler, compares its optimizations with HotSpot's C2, and provides practical steps to enable Graal in Java 10, offering deeper insight into JVM performance tuning.

CompilerGraalVMHotSpot
0 likes · 11 min read
Unlocking Java Performance: How Graal Replaces C2 in HotSpot JIT
Programmer DD
Programmer DD
Nov 23, 2017 · Fundamentals

What Is JIT Compilation in Java and How Does It Boost Performance?

Java’s JIT compilation transforms bytecode into optimized machine code at runtime, offering benefits like hardware-specific optimization and portability, and the article explains compilation types, JVM flags for tracing JIT activity, inlining, and other optimizations such as dead code elimination and loop transformations.

BytecodeCompilationJVM
0 likes · 7 min read
What Is JIT Compilation in Java and How Does It Boost Performance?
Tencent Cloud Developer
Tencent Cloud Developer
Feb 15, 2017 · Backend Development

PHP7 Upgrade Practice for QQ Member Activity Platform (AMS)

The QQ Member Activity Platform upgraded its legacy PHP 5.2/Apache 2.0 stack to PHP 7.0 with Apache 2.4 through staged migrations, extensive extension refactoring, and rigorous debugging, ultimately achieving roughly double the request‑handling performance and significant hardware cost savings while maintaining service stability.

Extension DevelopmentPHP Upgradeapache
0 likes · 23 min read
PHP7 Upgrade Practice for QQ Member Activity Platform (AMS)
21CTO
21CTO
Sep 16, 2015 · Backend Development

How PHP7 Boosts Performance: Key Engine Optimizations Explained

This article examines the PHP7 alpha release, detailing how its revamped Zend engine, memory management, hash handling, and new opcodes dramatically improve execution speed, while also introducing type declarations, exception handling, anonymous classes, and the Swoole extension for asynchronous programming.

SwooleZend enginejit
0 likes · 10 min read
How PHP7 Boosts Performance: Key Engine Optimizations Explained
Qunar Tech Salon
Qunar Tech Salon
Apr 3, 2015 · Fundamentals

Python Performance Optimization: Alternatives and Techniques

This article examines why Python’s execution speed can lag behind compiled languages and presents five practical approaches—using alternative runtimes like PyPy, JIT‑based implementations such as Pyston, compilation tools like Nuitka, C extensions via Cython, and JIT acceleration with Numba—to improve Python performance.

Alternative ImplementationsPythonjit
0 likes · 6 min read
Python Performance Optimization: Alternatives and Techniques
Qunar Tech Salon
Qunar Tech Salon
Jan 5, 2015 · Fundamentals

Understanding Java Compilers and JVM Optimization Techniques

This article explains the role of Java compilers, compares static, client, server and tiered compilation, and describes common JVM optimizations such as dead‑code elimination, inlining, and loop transformations to improve Java application performance.

BytecodeCompilerJVM
0 likes · 19 min read
Understanding Java Compilers and JVM Optimization Techniques
Qunar Tech Salon
Qunar Tech Salon
Jan 3, 2015 · Fundamentals

Introduction to the Java Virtual Machine: Architecture, Garbage Collection, and Performance

This article provides a comprehensive overview of the Java Virtual Machine, explaining its role in enabling "write once, run anywhere," detailing the compilation process, JIT optimization, memory allocation strategies such as TLAB, various garbage‑collection algorithms, and how these factors impact Java application performance and scalability.

Garbage CollectionJVMjava
0 likes · 19 min read
Introduction to the Java Virtual Machine: Architecture, Garbage Collection, and Performance
Baidu Tech Salon
Baidu Tech Salon
Mar 19, 2014 · Backend Development

Understanding HHVM: Facebook's High-Performance PHP Virtual Machine and Its JIT Optimization

HHVM, Facebook’s high‑performance PHP virtual machine, uses a type‑driven tracelet JIT and custom bytecode to achieve up to nine‑fold speed gains, making runtime optimization the only practical solution for Facebook’s massive codebase while requiring careful compatibility testing, memory management, and Hack language support.

FacebookPHPbackend development
0 likes · 18 min read
Understanding HHVM: Facebook's High-Performance PHP Virtual Machine and Its JIT Optimization