JavaScript vs Kotlin 2026 | Web vs Android
JavaScript is a dynamically-typed, interpreted language primarily for web browsers and Node.js with 97.3% adoption among web developers, while Kotlin is a statically-typed, compiled language running on the JVM designed specifically for Android development with 44% adoption among Android developers. JavaScript dominates web development; Kotlin dominates Android native development.
JavaScript
Dynamic, interpreted programming language for web browsers, Node.js, and full-stack applications.
Web developers, full-stack engineers, startups prioritizing time-to-market, mobile web development, and developers building cross-platform apps with React Native or Electron.
Kotlin
Statically-typed, compiled language running on the JVM, officially supported for Android development since 2019.
Android native developers, teams requiring compile-time safety guarantees, backend JVM services, organizations with existing Java codebases, and performance-critical applications.
Quick Answer
AI SummaryJavaScript is a dynamically-typed, interpreted language primarily for web browsers and Node.js with 97.3% adoption among web developers, while Kotlin is a statically-typed, compiled language running on the JVM designed specifically for Android development with 44% adoption among Android developers. JavaScript dominates web development; Kotlin dominates Android native development.
Our Verdict
AI-assistedChoose JavaScript if you're building web applications, progressive web apps, full-stack applications with Node.js, or targeting multiple platforms through frameworks like React Native or Electron—it offers the fastest time-to-market and largest ecosystem. Choose Kotlin if you're developing Android native applications, need compile-time type safety and null safety, or require maximum performance and access to rich JVM libraries—it provides superior compile-time error detection and native Android tooling integration.
Was this verdict helpful?
Choose JavaScript if
Best pickWeb developers, full-stack engineers, startups prioritizing time-to-market, mobile web development, and developers building cross-platform apps with React Native or Electron.
Choose Kotlin if
Android native developers, teams requiring compile-time safety guarantees, backend JVM services, organizations with existing Java codebases, and performance-critical applications.
Track this comparison
Get notified when prices change, new specs ship, or our verdict updates.
Triggers: price change new spec verdict update
No spam. Stop anytime.
Key Differences at a Glance
- Primary Runtime Environment:Browser, Node.js, Deno, Bun vs Java Virtual Machine (JVM), Android Runtime
- Type System:✓ Kotlin wins(Static typing (compile-time type checking) vs Dynamic typing (runtime type checking))
- Developer Adoption (Web/Mobile respectively):✓ JavaScript wins(97.3% of web developers (Stack Overflow 2023) vs 44% of Android developers (JetBrains 2023))
Key Facts & Figures
73 numeric metrics compared
| Metric | JavaScript | Kotlin | Ratio |
|---|---|---|---|
| Professional Developer Adoption Rate(%) | 33% | — | — |
| LLM-Generated Code Error Detection Rate(%) | ~6% | — | — |
| Initial Setup Time(minutes) | 0 (run immediately) | — | — |
| Optimal Codebase Size(lines of code) | Under 5,000 LOC | — | — |
| Developers Writing Only This Language Professionally(%) | ~15% | — | — |
| Learning Curve (Hours to Proficiency)(hours) | 20-30 hours | — | — |
| Build/Compilation Time(seconds) | 0 seconds (direct execution) | — | — |
| AI Code Error Prevention Rate(%) | 0% compile-time validation | — | — |
| Enterprise Adoption (Fortune 500)(%) | 100% as runtime deployment | — | — |
| Typical Execution Speed vs C(slower ratio) | 30-80x slower | — | — |
| Package Repository Size(count) | 2,200,000+ | — | — |
| Global Developer Population(millions) | 19.0 million | — | — |
| Machine Learning Framework Quality(adoption %) | 12% (TensorFlow.js, limited capabilities) | — | — |
| Memory Overhead vs C(multiple) | 1.5-2.5x higher | — | — |
| Job Market Growth (2023-2025)(% growth) | +15% (stable web demand) | — | — |
| Browser Native Support(compatibility %) | 100% (all modern browsers) | — | — |
| Data Analysis Library Maturity(years in production) | 4-6 years (Danfo.js, early stage) | — | — |
| Developer Population(millions) | 22.3 million developers | 1.5 million developers | |
| NPM/Package Ecosystem Size(packages) | 2.1 million packages | 400,000+ Maven Central packages | |
| Browser Support Coverage(percent) | 97.3% of all browsers | 0% (JVM-only) | |
| Null-Safety Rating(score) | Limited (optional chaining only) | Built-in (T vs T? syntax) | |
| Estimated Learning Time (beginner to intermediate)(hours) | 40-60 hours to proficiency | 80-120 hours to proficiency | |
| Production Runtime Error Reduction vs Dynamic Languages(percent) | Baseline (0% improvement) | 30-50% fewer null-pointer errors | |
| Execution Speed (Fibonacci 40)(seconds) | 12.4 seconds (Node.js v20) | — | — |
| Memory Usage (Hello World)(megabytes) | 28-35 MB (Node.js overhead) | — | — |
| Time to First Execution(milliseconds) | Instant (node script.js) | — | — |
| Package Ecosystem Size(packages) | 4.9 million (npm registry) | 500K+ Maven Central | |
| Typical Onboarding Time(weeks) | 2-4 weeks to competency | — | — |
| Website Adoption Rate (2024)(percent) | 98.8% of all websites | — | — |
| GitHub Project Usage (2024)(percent of projects) | ~25% of GitHub projects | — | — |
| Development Speed (days to simple app)(days) | 1-2 days | 3-4 days | |
| Runtime Performance (complex task ms)(milliseconds) | 250-400ms | 80-150ms | |
| Ecosystem Package Count(millions of packages) | 2.3 million (npm) | 500k (Maven Central) | |
| Compile Time (typical project)(seconds) | 0s (interpreted) | 3-5s (compiled) | |
| Type Safety Score(% of errors caught at compile-time) | 5-10% | 70-80% | |
| Developer Adoption (primary domain)(% of developers) | 97.3% web developers | 44% Android developers | |
| Memory Overhead (hello world app)(MB) | ~25-50MB (Node.js) | ~200-300MB (JVM startup) | |
| Clean Build Speed Improvement (K2 Compiler)(%) | 94% faster | 94% faster | |
| Enterprise Backend Market Share(%) | 15-20% | 15-20% | |
| Android Development Market Share(%) | 70% | 70% | |
| Median Developer Salary (US)(USD) | $95,000 | $95,000 | |
| Framework Ecosystem Maturity (Years)(years) | 11 years (stable KMP 2025) | 11 years (stable KMP 2025) | |
| Learning Difficulty Ranking(position (lower is easier)) | 24th easiest (Slant.co 2026) | 24th easiest (Slant.co 2026) | |
| Native Compilation Speed Improvement(% faster) | 40% faster (Kotlin/Native v2.3.0) | 40% faster (Kotlin/Native v2.3.0) | |
| Weekly Downloads(millions) | 1.2M+ weekly (Maven) | 1.2M+ weekly (Maven) | |
| K2 Clean Build Time (Kotlin) / Standard Compilation (Java)(% improvement) | 94% faster | 94% faster | |
| Enterprise Market Share(percentage) | ~25% of JVM workloads | ~25% of JVM workloads | |
| Developer Salary Premium(%) | +12% average salary | +12% average salary | |
| Kotlin/Native Performance Improvement(%) | Up to 40% faster (Kotlin/Native) | Up to 40% faster (Kotlin/Native) | |
| Compilation Time (Small Project)(seconds) | ~8 seconds | ~8 seconds | |
| Binary Size (Hello World)(MB) | ~100 MB (with JVM) | ~100 MB (with JVM) | |
| Available Libraries(count) | ~2,000,000+ libraries | ~2,000,000+ libraries | |
| Runtime Performance vs C(% overhead) | 10-20% | 10-20% | |
| Android Market Adoption(% of new projects) | ~65-70% (official language) | ~65-70% (official language) | |
| Concurrent Tasks Per GB RAM(thousands) | ~1,000-10,000 threads | ~1,000-10,000 threads | |
| Language Maturity(years since v1.0) | 8 years (2016) | 8 years (2016) | |
| Developer Population (2025)(developers) | 1.2 million | 1.2 million | |
| Runtime Performance (Data Processing)(milliseconds) | ~35ms (100K operations) | ~35ms (100K operations) | |
| Annual Language Updates(updates per year) | 3-4 feature releases (1.0 to 2.1 in ~2 years) | 3-4 feature releases (1.0 to 2.1 in ~2 years) | |
| Compilation Speed (vs Java baseline)(percentage) | 10-15% faster | 10-15% faster | |
| GitHub Repositories(count) | ~15,000+ | ~15,000+ | |
| Job Market Postings (2025)(estimated count) | 18,000+ | 18,000+ | |
| Learning Curve for Java Developers(weeks to proficiency) | 2-3 weeks | 2-3 weeks | |
| Boilerplate Code Reduction vs Java(percentage) | 35-40% less code | 35-40% less code | |
| Incremental Build Time(seconds) | 3.2 seconds | 3.2 seconds | |
| Professional Developer Adoption(%) | 70% (Android developers) | 70% (Android developers) | |
| Available Packages/Libraries(count) | 170,000+ (Maven Central) | 170,000+ (Maven Central) | |
| Flutter App Cold Start Time(milliseconds) | 500ms (Android native) | 500ms (Android native) | |
| Code Reuse Across Platforms(%) | 25-40% (Android-specific code) | 25-40% (Android-specific code) | |
| Community GitHub Stars(stars) | 0.52M (Kotlin language) | 0.52M (Kotlin language) | |
| Time to Learn Core Language(hours) | 80-120 hours (with JVM concepts) | 80-120 hours (with JVM concepts) | |
| Incremental Build Time (Hello World)(seconds) | 3-5 seconds | 3-5 seconds | |
| Job Market Availability (US 2026)(active postings) | 28,000+ | 28,000+ |
Sourced from publicly available data ·
Key Differences
7 attributes compared head-to-head
- Browser, Node.js, Deno, BunPrimary Runtime EnvironmentJava Virtual Machine (JVM), Android Runtime
- Dynamic typing (runtime type checking)Type SystemStatic typing (compile-time type checking)(winner)
- 97.3% of web developers (Stack Overflow 2023)(winner)Developer Adoption (Web/Mobile respectively)44% of Android developers (JetBrains 2023)
- Interpreted (JIT compilation in modern engines)Compilation ModelCompiled to bytecode, then JVM/Android Runtime(winner)
- Easier (1-2 weeks to basic competency)(winner)Learning Curve for BeginnersHarder (requires JVM/Android knowledge, 3-4 weeks)
- No (causes ~50% of runtime errors)Null Safety Built-inYes (null-safe by default with ? operator)(winner)
- Moderate (V8 avg 250-400ms for complex tasks)Code Execution Speed (typical operations)Fast (JVM avg 80-150ms for complex tasks, 2-3x faster)(winner)
- Primary Runtime Environment
JavaScript
Browser, Node.js, Deno, Bun
Kotlin
Java Virtual Machine (JVM), Android Runtime
- Type System
JavaScript
Dynamic typing (runtime type checking)
Kotlin
Static typing (compile-time type checking)(winner)
- Developer Adoption (Web/Mobile respectively)
JavaScript
97.3% of web developers (Stack Overflow 2023)(winner)
Kotlin
44% of Android developers (JetBrains 2023)
- Compilation Model
JavaScript
Interpreted (JIT compilation in modern engines)
Kotlin
Compiled to bytecode, then JVM/Android Runtime(winner)
- Learning Curve for Beginners
JavaScript
Easier (1-2 weeks to basic competency)(winner)
Kotlin
Harder (requires JVM/Android knowledge, 3-4 weeks)
- Null Safety Built-in
JavaScript
No (causes ~50% of runtime errors)
Kotlin
Yes (null-safe by default with ? operator)(winner)
- Code Execution Speed (typical operations)
JavaScript
Moderate (V8 avg 250-400ms for complex tasks)
Kotlin
Fast (JVM avg 80-150ms for complex tasks, 2-3x faster)(winner)
Full Comparison
| Attribute | JavaScript | Kotlin |
|---|---|---|
| Stack Overflow Most Used (2024) | #1 | — |
| Weekly Downloads(millions) | 1.2M+ weekly (Maven) | — |
| AI/ML Libraries | TensorFlow.js (limited) | — |
| Package Repository Size(count) | 2,200,000+ | — |
| NPM/Package Ecosystem Size(packages) | 2.1 million packages(winner) | 400,000+ Maven Central packages |
| Package Ecosystem Size(packages) | 4.9 million (npm registry)(winner) | 500K+ Maven Central |
| Ecosystem Package Count(millions of packages) | 2.3 million (npm)(winner) | 500k (Maven Central) |
Show 5 more attributesFramework Ecosystem Maturity (Years)(years) 11 years (stable KMP 2025) — Available Libraries(count) ~2,000,000+ libraries — GitHub Repositories(count) ~15,000+ — Available Packages/Libraries(count) 170,000+ (Maven Central) — Java Ecosystem Integration(libraries available) Full native access to 3M+ Maven packages — | ||
| Execution Speed | Fast (V8 engine) | — |
| Typical Execution Speed vs C(slower ratio) | 30-80x slower | — |
| Memory Overhead vs C(multiple) | 1.5-2.5x higher | — |
| Execution Speed (Fibonacci 40)(seconds) | 12.4 seconds (Node.js v20) | — |
| Runtime Performance (complex task ms)(milliseconds) | 250-400ms | 80-150ms(winner) |
Show 12 more attributesMemory Overhead (hello world app)(MB) ~25-50MB (Node.js) ~200-300MB (JVM startup) Clean Build Speed Improvement (K2 Compiler)(%) 94% faster — Native Compilation Speed Improvement(% faster) 40% faster (Kotlin/Native v2.3.0) — K2 Clean Build Time (Kotlin) / Standard Compilation (Java)(% improvement) 94% faster — Kotlin/Native Performance Improvement(%) Up to 40% faster (Kotlin/Native) — Compilation Time (Small Project)(seconds) ~8 seconds — Binary Size (Hello World)(MB) ~100 MB (with JVM) — Runtime Performance vs C(% overhead) 10-20% — Runtime Performance (Data Processing)(milliseconds) ~35ms (100K operations) — Compilation Speed (vs Java baseline)(percentage) 10-15% faster — Incremental Build Time(seconds) 3.2 seconds — Flutter App Cold Start Time(milliseconds) 500ms (Android native) — | ||
| Professional Developer Adoption Rate(%) | 33% | — |
| Developers Writing Only This Language Professionally(%) | ~15% | — |
| LLM-Generated Code Error Detection Rate(%) | ~6% | — |
| Initial Setup Time(minutes) | 0 (run immediately) | — |
| Optimal Codebase Size(lines of code) | Under 5,000 LOC | — |
| Concurrent Tasks Per GB RAM(thousands) | ~1,000-10,000 threads | — |
| Major Companies Using (2026)(count) | Legacy systems, older startups | — |
| IDE Autocompletion Quality(accuracy rating) | Basic (no type info) | — |
| Compilation Required (Pre-Node 22.6)(boolean) | No | — |
| Type Checking Model | Dynamic (runtime) | — |
| Null-Safety Rating(score) | Limited (optional chaining only) | Built-in (T vs T? syntax)(winner) |
| Type System(null) | Dynamic (runtime) | Static (compile-time) |
| Null Safety Mechanism | Built-in (nullable/non-nullable types) | — |
| Multiplatform Capability | Kotlin Multiplatform (stable, iOS/Android/web) | — |
Show 5 more attributesNull Safety Model(null) Compile-time enforcement with String vs String? distinction — Null Safety Enforced at compile-time (non-nullable by default) — Functional Programming Support Good (extension functions, lambdas, HOF) — Null Safety Implementation(status) Built-in nullable/non-nullable types — Type System Null Safety(compile-time safety) Nullable/non-nullable types enforced — | ||
| Learning Curve (Hours to Proficiency)(hours) | 20-30 hours | — |
| Build/Compilation Time(seconds) | 0 seconds (direct execution) | — |
| Time to First Execution(milliseconds) | Instant (node script.js) | — |
| Typical Onboarding Time(weeks) | 2-4 weeks to competency | — |
| IDE Support Quality(rating) | Excellent (IntelliJ IDEA, Android Studio) | — |
| Boilerplate Code Reduction vs Java(percentage) | 35-40% less code | — |
| AI Code Error Prevention Rate(%) | 0% compile-time validation | — |
| Type Safety Score(% of errors caught at compile-time) | 5-10% | 70-80%(winner) |
| Enterprise Adoption (Fortune 500)(%) | 100% as runtime deployment | — |
| Enterprise Backend Market Share(%) | 15-20% | — |
| Android Development Market Share(%) | 70% | — |
| Community GitHub Stars(stars) | 0.52M (Kotlin language) | — |
| Global Developer Population(millions) | 19.0 million | — |
| Developer Population(millions) | 22.3 million developers(winner) | 1.5 million developers |
| Developer Adoption (primary domain)(% of developers) | 97.3% web developers(winner) | 44% Android developers |
| Machine Learning Framework Quality(adoption %) | 12% (TensorFlow.js, limited capabilities) | — |
| Data Analysis Library Maturity(years in production) | 4-6 years (Danfo.js, early stage) | — |
| Job Market Growth (2023-2025)(% growth) | +15% (stable web demand) | — |
| Browser Native Support(compatibility %) | 100% (all modern browsers) | — |
| Browser Support Coverage(percent) | 97.3% of all browsers(winner) | 0% (JVM-only) |
| Multiplatform Support(targets) | iOS, Android, Web, Desktop (KMP stable) | — |
| Platform Support(platforms) | Android, JVM, Web (Kotlin/JS), Multiplatform (iOS via KMP), Desktop (Compose) | — |
| Supported Platforms | Android, JVM (Linux/Windows/macOS) | — |
| Android Development Official Status(null) | Supported via React Native (third-party) | Official preferred language (Google 2019) |
| Android Official Status | Official first-class language (2019) | — |
| Estimated Learning Time (beginner to intermediate)(hours) | 40-60 hours to proficiency(winner) | 80-120 hours to proficiency |
| Production Runtime Error Reduction vs Dynamic Languages(percent) | Baseline (0% improvement) | 30-50% fewer null-pointer errors(winner) |
| Memory Usage (Hello World)(megabytes) | 28-35 MB (Node.js overhead) | — |
| Website Adoption Rate (2024)(percent) | 98.8% of all websites | — |
| GitHub Project Usage (2024)(percent of projects) | ~25% of GitHub projects | — |
| Compilation Target Support(platforms) | Any platform with Node.js or browser | — |
| Development Speed (days to simple app)(days) | 1-2 days(winner) | 3-4 days |
| Compile Time (typical project)(seconds) | 0s (interpreted)(winner) | 3-5s (compiled) |
| Multi-threading Support(native capability) | Limited (Web Workers, cluster module) | Full (Java threads) |
| Concurrency Model | Coroutines (stackless, lightweight) | — |
| Median Developer Salary (US)(USD) | $95,000 | — |
| Developer Salary Premium(%) | +12% average salary | — |
| Null Safety (Compile-Time Default) | Non-nullable by default | — |
| Virtual Threading Maturity | Coroutines (requires libraries) | — |
| Job Market Demand(postings) | Growing enterprise/mobile niche | — |
| Learning Difficulty Ranking(position (lower is easier)) | 24th easiest (Slant.co 2026) | — |
| Primary Target Platforms | Android, JVM, iOS (Native), desktop | — |
| Latest Version Release(year) | Kotlin 2.3.0 (Mar 2026) - new language features | — |
| Enterprise Market Share(percentage) | ~25% of JVM workloads | — |
| Current Stable Release (2026) | Kotlin 2.3.20 (March 2026) | — |
| Android Market Adoption(% of new projects) | ~65-70% (official language) | — |
| Language Maturity(years since v1.0) | 8 years (2016) | — |
| Developer Population (2025)(developers) | 1.2 million | — |
| Official Language Status(null) | Google's preferred/recommended language for Android (2019-present) | — |
| Java/Legacy Code Interoperability(null) | 100% transparent interop—calls Java directly without wrappers | — |
| Annual Language Updates(updates per year) | 3-4 feature releases (1.0 to 2.1 in ~2 years) | — |
| Job Market Postings (2025)(estimated count) | 18,000+ | — |
| Learning Curve for Java Developers(weeks to proficiency) | 2-3 weeks | — |
| Professional Developer Adoption(%) | 70% (Android developers) | — |
| Code Reuse Across Platforms(%) | 25-40% (Android-specific code) | — |
| Time to Learn Core Language(hours) | 80-120 hours (with JVM concepts) | — |
| Incremental Build Time (Hello World)(seconds) | 3-5 seconds | — |
| Job Market Availability (US 2026)(active postings) | 28,000+ | — |
| Hot Reload Capability(state preservation) | Basic (requires app restart) | — |
| Official Android Support Status(endorsement level) | Google's preferred language (2019+) | — |
JavaScriptShow 5 more attributes
Show 12 more attributes
Show 5 more attributes
Pros & Cons
10 pros·6 cons across both
JavaScript
Pros
- Runs natively in all modern browsers without installation (zero deployment friction)
- Massive ecosystem with 2.3 million npm packages (largest package registry globally)
- Full-stack capability with Node.js allows single language across frontend and backend
- Async/await and Promise support for non-blocking I/O operations
- Exceptional for rapid prototyping with frameworks like React, Vue, Next.js
Cons
- Dynamic typing causes ~50% of production bugs discoverable only at runtime
- Single-threaded event loop limits CPU-intensive tasks (weak for computational workloads)
- Inconsistent performance across different JavaScript engines and browsers
Kotlin
Pros
- Compile-time type checking eliminates entire categories of runtime errors (null safety with ? operator)
- 2-3x faster execution speed than JavaScript due to JVM bytecode compilation and JIT optimization
- 100% interoperability with existing Java libraries and frameworks (27+ million Java developers ecosystem)
- Coroutines for lightweight asynchronous programming more efficient than JavaScript promises
- Official Google endorsement for Android development with seamless Android Studio integration
Cons
- Steeper learning curve requires understanding JVM concepts, increasing onboarding time by 2-3 weeks
- Smaller ecosystem (2.2 million GitHub projects vs 28 million for JavaScript) limits third-party tooling
- Longer compilation time (average 3-5 seconds per build) reduces iteration speed in development
Frequently Asked Questions
5 questions
Kotlin is 2-3x faster than JavaScript for most operations. Kotlin compiles to JVM bytecode and uses JIT (Just-In-Time) compilation, achieving typical execution times of 80-150ms for complex tasks, compared to JavaScript's 250-400ms average in V8. However, for I/O-bound operations (APIs, database queries), the difference is negligible as both are limited by network latency. For CPU-intensive algorithms, Kotlin's performance advantage becomes significant.
Resources & Learn More
Curated sources to dive deeper
Where to Buy
As an affiliate, we may earn a commission from qualifying purchases at no extra cost to you. Learn more about our affiliate disclosure
Wikipedia
Related Comparisons
12 more to explore
JavaScript vs Kotlin
softwareJava vs Kotlin 2026
softwareJavaScript vs TypeScript
softwareKotlin vs TypeScript
softwareGolang vs Kotlin
softwarePython vs JavaScript
softwareKotlin vs Swift
softwareKotlin vs Scala
softwareKotlin vs Dart
softwareJavaScript vs Rust
softwareKotlin vs Dart
softwareWordPress vs Wix
software
Related Articles
5 articles
- technology
Best Streaming Services in 2026: Top Picks for Every Budget & Interest
Navigating the crowded streaming landscape in 2026 can be overwhelming. We've tested and ranked the best streaming services that offer the most value, from Netflix's massive library to budget-friendly options like Tubi, helping you cut cable and find your perfect entertainment solution.
Read article - technology
Best Live TV Streaming Services & Plans for Spring 2026: Complete Buyer's Guide
Tired of overpaying for cable? Discover the best live TV streaming services and plans for Spring 2026, including YouTube TV's new genre-based packages starting at $55/month. Our comprehensive guide breaks down pricing, channels, and features to help you cut the cord.
Read article - technology
Philo in 2026: Streaming TV Service Review, Pricing & Reddit Community Insights
Explore Philo's evolution heading into 2026, including pricing tiers, channel lineup, and how it compares to competitors like Sling TV. Discover what the r/PhiloTV Reddit community thinks about the service's current offerings and future prospects.
Read article - technology
Best US Fighter Jets 2026: Top American Combat Aircraft Ranked
Discover the most advanced US fighter jets dominating the skies in 2026. From the legendary F-22 Raptor to the versatile F-35 Lightning II, we rank America's best combat aircraft based on performance, stealth, and air superiority capabilities.
Read article - technology
Philo in 2026: Pricing, Lineup & How It Compares to Sling TV
As we head into 2026, Philo continues to position itself as an affordable streaming alternative for cable TV lovers. Discover what Philo offers, how its pricing stacks up against competitors like Sling TV, and what the Reddit community thinks about its future.
Read article
Explore More
Related comparisons and categories