pypl.github.io

TIOBE and PYPL are both programming-language popularity rankings, but they measure different signals. TIOBE counts search-engine results that mention a language, while PYPL analyzes how often people search for language tutorials on Google. If you want a rough popularity snapshot, either can help; if you want to gauge learning interest or future adoption, PYPL's tutorial-search method is the more relevant signal. The two often disagree because they are not measuring the same thing.

What the TIOBE Index Measures

TIOBE is commonly described as a ranking based on search-engine query volume for programming languages. In practice, it aggregates how often a language's name appears in search results across major search engines, then converts that into a percentage share and a rank.

Key characteristics:

• Signal: search-engine result counts, not tutorial searches specifically.
• What it captures: general online visibility and mention volume of a language.
• What it does not capture: how many people are actively trying to learn the language, or how much code is written in it.

Because it counts mentions, a language can rank high due to news coverage, job postings, academic references, or legacy discussion — not necessarily because developers are adopting it.

What the PYPL Index Measures

The PYPL (PopularitY of Programming Language) index is built by analyzing how often language tutorials are searched on Google. Its own description states: "The more a language tutorial is searched, the more popular the language is assumed to be. It is a leading indicator. The raw data comes from Google Trends."

Key characteristics:

• Signal: frequency of Google searches for language tutorials.
• What it captures: learning interest and intent to adopt.
• Leading indicator: because people often search for tutorials before using a language, PYPL is positioned as forward-looking rather than a lagging measure of existing code.

PYPL publishes a worldwide ranking plus country filters (for example Worldwide, US, India, Germany, United Kingdom, France) and a 1-year trend column. It also offers companion indices for Top IDE, Top Online IDE, and Top Databases.

How the Two Differ

The practical consequence: a language can be high on TIOBE because it is widely discussed, while ranking lower on PYPL because fewer people are searching for tutorials — or vice versa. Neither is "wrong"; they answer different questions.

How to Read the Ranking Columns

Using PYPL's published table as an example (Worldwide, Oct 2026):

• Rank: position by share.
• Change: movement versus the prior period.
• Language: the language being measured.
• Share: percentage of the index attributed to that language.
• 1-year trend: how the share moved over the past year.

In that snapshot, Python leads with 53.9% share and a +24.9% one-year trend, followed by Java at 12.98% and C/C++ at 7.97%. PYPL also notes that over the last 5 years Python grew the most (25.6%) and JavaScript lost the most (-5.9%).

When reading any such table, treat the share as relative, not absolute — it is a slice of a fixed pie, so one language rising usually means others fall. The trend column is often more informative than the rank itself, because it shows direction.

How to Use These Indices Without Over-Relying on Them

Rankings are a starting point, not a decision rule. A reasonable approach:

1. Match the index to your question. Choosing what to learn? PYPL's tutorial-search signal is closer to learning interest. Assessing general visibility or legacy presence? TIOBE's mention-based view may be more relevant.
2. Check the trend, not just the rank. A high rank with a falling trend tells a different story than a mid rank with a rising trend.
3. Filter by geography if it matters. PYPL lets you switch between Worldwide and specific countries; popularity can differ by market.
4. Cross-check with your actual constraints. Job market in your region, existing team skills, library ecosystem, and project requirements usually outweigh a global ranking.
5. Avoid treating either index as a measure of quality or suitability. Both measure popularity signals, not technical merit.

If you believe in collective wisdom, as PYPL itself frames it, these indices can help you decide which language to study or which to use in a new project — but they should inform the decision, not make it.

The PYPL (PopularitY of Programming Language) Index ranks programming languages by how often their tutorials are searched on Google, using raw data from Google Trends. It is designed as a leading indicator of language interest: the more people search for a language's tutorial, the more popular that language is assumed to be. If you accept the idea of collective wisdom, PYPL can serve as one input when deciding which language to study or use in a new project. It measures search interest, not lines of code written, job postings, or repository activity.

How the Ranking Is Built

PYPL's method is deliberately simple and narrow in scope:

• Input: Google Trends data on searches for language tutorials.
• Assumption: Tutorial searches reflect people learning or adopting a language, so they signal future usage.
• Output: A ranked list of languages with a share percentage and a 1-year trend for each.

Because the signal is search behavior, PYPL is forward-looking rather than a snapshot of what is currently deployed in production. A language can rank high on PYPL while having a smaller installed base, or rank lower while remaining heavily used in existing systems.

Reading the Share and Trend Columns

The index presents each language with a rank, a share (percentage of total tutorial-search interest), and a 1-year trend showing how that share changed over the past year. The worldwide snapshot below illustrates how to read it:

How to interpret the two columns together:

• Share tells you the relative size of search interest right now. Python at 53.9% means it accounts for more than half of the measured tutorial-search interest worldwide.
• Trend tells you the direction and speed of change. Python's +24.9% indicates rapidly growing interest; C/C++ at -5.0% indicates declining search interest over the year.
• A high share with a negative trend (Java, C/C++) suggests a large but cooling base. A smaller share with a positive trend (Objective-C) suggests growing interest from a lower starting point.

The index also reports that, worldwide, Python grew the most over the last 5 years (+25.6%) and JavaScript lost the most (-5.9%).

Why the Trend Chart Uses a Logarithmic Scale

The trend chart is plotted on a logarithmic scale. This matters because language shares span a very wide range — from Python's double-digit share down to fractions of a percent for languages like Cobol or Groovy. On a linear scale, the smaller languages would be compressed into an unreadable band at the bottom. A logarithmic scale gives proportional visibility to both large and small languages, so you can compare their relative growth rates rather than just their absolute sizes.

PYPL vs. TIOBE

Both indices are frequently cited, but they answer different questions:

If your question is "what are people trying to learn right now?", PYPL's tutorial-search signal is the more direct fit. If you want a general popularity measure, TIOBE is the more common reference. Neither measures job demand or code volume directly.

Using PYPL as One Input in a Language Decision

PYPL is a single data point, not a decision rule. A practical way to use it:

1. Check the share and trend for your candidate languages. A rising trend suggests growing ecosystem momentum and future tooling, libraries, and community support.
2. Match against your actual constraint. If you need hiring depth, check job markets separately — PYPL does not measure employment demand. If you need a specific domain (data science, mobile, systems), filter by relevance rather than rank.
3. Look at the country view. PYPL lets you switch between Worldwide, US, India, Germany, United Kingdom, and France, so regional interest can differ from the global picture.
4. Treat it as directional. Use it to confirm or challenge a hunch, not to override domain requirements.

The index also offers companion rankings for Top IDE, Top Online IDE, and Top Databases, which can help when you are choosing a full toolchain rather than just a language.

Practical Caveats

• PYPL measures tutorial search interest, so it reflects learners and evaluators more than established production teams.
• A language with a large existing codebase can rank modestly on PYPL while remaining important in practice.
• Shares are relative: when one language's share grows sharply, others' shares can fall even if their absolute interest is stable.
• The index is maintained by Pierre Carbonnelle and has been cited in trade journals including InfoWorld, eWeek, and Techworld.

A++ is an educational programming language built on the lambda calculus, designed for one purpose: helping people who want to learn programming understand the essentials of the art of programming as quickly and thoroughly as possible. It suits learners who want a deep grasp of core concepts and transferable patterns before (or instead of) wrestling with the many convenience features of mainstream languages. It is not aimed at people who need a language for practical, production-style software work.

The core idea: essentials instead of features

Most languages come with what the A++ project describes as "bells and whistles" — many soft features that are genuinely useful for coping with practical programming problems. A++ deliberately strips these away. Being based on the lambda calculus, it is presented as a hard-core language made of elements that cannot be further split up or disintegrated.

The reasoning behind this: learning the art of programming is not accomplished by becoming familiar with all the handy soft features a language offers. It comes from learning how to cope with programming problems by continuously applying three operations from beginning to end.

ARS Based Programming

A++ organizes programming around three concepts, abbreviated ARS:

• Abstraction — capturing a pattern or behavior as a reusable unit.
• Reference — using what has been abstracted.
• Synthesis — combining abstractions into larger constructs.

Programming with the focus on applying Abstraction, Reference and Synthesis is called ARS Based Programming. In A++, the project states, ARS Based Programming becomes "ultimately visible to a programmer" — the language is structured so these three operations are not hidden behind incidental syntax.

The claim for learners is twofold: quick, deep comprehension of programming, and pattern-recognition skills that apply in most other programming languages.

Implementations

A++ has been implemented in Scheme, Java, C++, C, Perl and Python, using ARS based programming techniques. The Perl and C implementations are presented in detail in the book on A++ (see below); the other implementations are covered in Programmierung pur (Undiluted Programming), published in 2003.

That spread matters for the educational argument: the same ARS approach is shown to carry across very different language families, which supports the idea that what you learn in A++ transfers rather than being tied to one tool.

Books and learning entry points

The language is introduced in A++ – The Smallest Programming Language in the World, which covers both the language and its implementation. It was first published in Darmstadt, Germany in October 2004 (ISBN 3-87820-116-8), with a 2nd edition published in April 2018 by tredition GmbH, Hamburg.

The site also lists newer titles (July 2018), including:

Who should consider it

A++ fits you if:

• You want to understand what programming is at a fundamental level before committing to a mainstream language.
• You are interested in the lambda calculus as a practical foundation rather than only as theory.
• You want patterns you can carry into other languages.

It probably does not fit you if:

• You need to build practical applications now and want a language with extensive libraries and convenience features.
• You are looking for a first language chosen for employability rather than conceptual depth.

For a systematic path in, the book A++ – The Smallest Programming Language in the World is the documented starting point, with A++ and the Lambda-Calculus as the natural companion for the theoretical basis.