Take twelve programming languages. Rate each one on seven criteria, from one to five stars. Then lay it all out in the table below: options as rows, criteria as columns, ratings in the cells. Everyone has been handed a table like this one right before having to decide.
| Programming Language | Performance | Ease of Learning | Ecosystem | Concurrency | Type Safety | Job Market | Tooling |
|---|---|---|---|---|---|---|---|
| Python | ⭐️⭐️ | ⭐️⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️⭐️ | ⭐️⭐️ | ⭐️⭐️ | ⭐️⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️ |
| Rust | ⭐️⭐️⭐️⭐️⭐️ | ⭐️⭐️ | ⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️ |
| Go | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️ |
| JavaScript | ⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️ | ⭐️⭐️ | ⭐️⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️ |
| TypeScript | ⭐️⭐️⭐️ | ⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️ |
| Java | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️⭐️ |
| C++ | ⭐️⭐️⭐️⭐️⭐️ | ⭐️ | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️ |
| C# | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️⭐️ |
| Ruby | ⭐️⭐️ | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️ | ⭐️⭐️ | ⭐️⭐️ | ⭐️⭐️⭐️ | ⭐️⭐️⭐️ |
| Kotlin | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️ |
| Swift | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️ | ⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️ | ⭐️⭐️⭐️⭐️ |
| Elixir | ⭐️⭐️⭐️ | ⭐️⭐️⭐️ | ⭐️⭐️ | ⭐️⭐️⭐️⭐️⭐️ | ⭐️⭐️⭐️ | ⭐️⭐️ | ⭐️⭐️⭐️ |
The input table, as you would fill it in: twelve options, seven criteria, one rating per cell. Standpoint reads this file as it stands.
So which language? Twelve rows times seven columns makes eighty-four cells of stars to compare in your head and seven columns to weigh against one another. Somewhere around Kotlin your eye probably gave up. The table tells no lies: everything is there and every star can be checked. The trouble is that nobody can read it. So the choice falls back on gut feeling, the very thing the table was meant to prevent. And two people acting in good faith read the same stars and pick two different winners.
Standpoint makes a map of that table. Each option becomes a dot on a plane and two dots close together are two similar profiles. The ends of the axes show plain words, in the language of your columns. That leaves the question you opened the table with, the one the map settles at a glance: where do you stand?
The same table, seen from above: the twelve languages placed relative to one another, the leader at the top right, challengers along each axis.
The questions that call for a map
You recognize these questions quickly: several options, several criteria, then the duty to say where each one stands against the rest. Which cloud provider should you settle on for the next three years? Which language will a team write in for the next five? Where does your product stand against six competitors, before a board meeting? How do you cut fifteen applications down to a shortlist and still say why those ones?
The repository holds four demonstration tables, which show what the tool accepts:
- One compares cloud providers.
- Another rates laptops, with price and weight marked as columns where less is better.
- A third covers French electric cars and comes back with a French title and French axis names.
- The last is the programming languages from the introduction.
Four unrelated subjects, then, sharing only the shape of the file: names in the first column, numbers everywhere else.
With one or two columns, skip the map: an ordinary chart beats it. To rank on a single criterion, sort the column. If you only need the numbers as one step inside a machine-learning program, with no figure at the end, use the PCA in scikit-learn. Above all, Standpoint maps a table that already exists. No data gets fetched and no rating gets checked. Is your table badly filled in? It will never know.
A computation from 1901, two families of tools
Positioning maps are a staple of marketing and consulting: people sketch them on whiteboards to place brands, products, competitors. The method that computes them is called Principal Component Analysis, or PCA. Karl Pearson set down its geometry in 1901 and Harold Hotelling gave it its form in 1933.
Take a school report card. It lines up eight marks, one per subject, yet two numbers often place the student: more of a science type, more of a humanities type. PCA runs the same reasoning on your table. It hunts for the two or three directions along which the options truly differ. Then it reduces each row of ratings to two numbers, which keep most of what sets that row apart from the rest.
This method is a hundred and twenty-five years old and it is still the right one in 2026, when today's reflex is to throw a large model at everything. Yet look at the size of our problem: twelve rows and seven columns. A few milliseconds settle it, with no training and no data from anywhere else. Anyone who doubts it can redo the arithmetic by hand. For flattening a small table of numbers, nothing has improved on it.
Since the computation was settled long ago, the time goes into everything around it. The map has to be turned so it reads the right way, the axes named in words a management committee understands, the dots colored, the labels kept from overlapping, the whole exported at print quality. Standpoint automates that work. You give it your table in CSV or Markdown. A single command hands back the figure as SVG and PNG, plus a YAML file listing every coordinate and every coefficient.
Two families of tools already share this work and neither ever finishes it. The first gathers the statistical toolkits: prince or the PCA in scikit-learn for Python, FactoMineR and factoextra for R, the statisticians' language. Their computation is impeccable and you can run it again. But their output stops at raw axes and numbers. Naming the axes, turning the map and making it presentable are left to you.
The second family, the layout tools, heads straight for the result: a four-box slide, a Canva template or the famous magic quadrant from the firm Gartner. It looks finished immediately. But who placed the dots? A hand. None of them comes from the data, none can be run again. The axes say whatever their author decided to make them say.
The square that moves money
One member of that second family is worth a stop, because it is the most looked-at positioning map in the world. Gartner is an American firm that analyzes software markets for the companies that buy. Each year, across dozens of markets, it publishes a figure called the Magic Quadrant. The horizontal axis measures vision: what the software vendor has understood about the market and where it is going. The vertical axis measures execution: what that vendor can ship today. Two axes make four boxes, whose names have entered everyday speech:
- The Leaders stand at the top right.
- The Challengers, top left, ship well but see the market badly.
- The Visionaries, bottom right, see correctly but cannot yet ship.
- The Niche Players fill the bottom left.
Making it into that square is already an achievement, because Gartner places there only the companies it judges important enough to follow. Many work for years to get in. Once they are inside, the money follows. A chief information officer defending a purchase of a million or more to a board can point to it, a reference everyone grasps at a glance. Some tenders go as far as copying it out.
How is that square built? The question went to court. In 2009 the vendor ZL Technologies sued Gartner for defamation. Gartner argued that the quadrant is an opinion. A statement of fact can be proved false, an opinion cannot. The American courts sided with Gartner in 2010, then again on appeal.
An expert who owns an opinion beats an invented measurement. Gartner's opinion rests on a year of interviews, vendor briefings and calls to their customers, work no computation replaces. You only have to know what you are looking at: the position of a dot there is a judgment, which cannot be redone identically.
Standpoint promises far less and does not replace that expertise. But what it promises can be checked. A dot's position comes from a table you can read and from a computation you can run again. Does a dot surprise you? Go back to its row, then to its ratings.
That promise has a price. A map is worth what the ratings in the table are worth. Filling in eighty-four cells by instinct, then flattening them with care, creates no knowledge. The computation makes what you put in visible and arguable. That counts for a lot. It is not knowing.
So Standpoint does both: the statisticians' computation and the layout tools' finish. One new idea comes on top, handed to a language model. These programs, ChatGPT among them, are trained to continue text. Standpoint's reads the axes that came out of the computation and gives them names in plain words. PCA has often been used for a positioning map. Far less often has a machine been left to name its axes.
Other people can use it too. The package installs from PyPI, like any Python library. Every change to the code runs the tests again with nobody lifting a finger. Four example sets ship in the repository with their figures and the documentation exists in English and in French. Finally, the engine can be reached in several ways, described at the end of this article.
One choice matters to me, even though it gives up the comfort of online services: everything runs on your machine. That covers the computation, the drawing and even the names of the axes, which come from an open language model that Ollama runs on your own computer.
From the blank cell to the names on the axes
One quiet decision protects you before the computation even starts. A cell you leave blank gets the lowest rating in its column. A gap therefore never gets to flatter an option. Conveniently forgetting to rate yourself on the awkward criterion earns you nothing.
First step, even out the criteria. Take a comfort rating out of 5 and a price in thousands of euros. As they stand they cannot be compared: the column with the biggest numbers would crush all the others. So from each column \(j\) we take away its mean \(\mu_j\), then divide by its standard deviation \(\sigma_j\), which says how far its values usually stray from that mean:
Once rescaled, every criterion weighs the same. In any column, a difference of one now means one standard deviation above average.
Second step, the computation itself. Picture the options as a cloud of points in a seven-dimensional space, one dimension per criterion. Nobody sees seven dimensions, but the cloud remains a good picture: each language is a point, placed by its ratings. Now light that cloud with a very distant lamp: each point casts its shadow on a wall. Depending on how the wall is turned, the shadows bunch up or spread out. PCA looks for the angle where they spread out the most. That wall is a plane, resting on two directions \(v_1, v_2\), the ones along which the options pull apart the most. The position of an option on the map is then its shadow on that plane:
The angle brackets \(\langle\cdot,\cdot\rangle\) denote the scalar product, which measures how far a point advances along a direction. Squashing seven dimensions onto a plane inevitably loses something, since the map summarizes a richer space. Standpoint measures the share of information kept and prints it on the figure:
Around 80%, the map tells the table's story faithfully. Below that, read it as a sketch.
Third step, orientation. PCA spits out its map facing any which way and nothing forces the "good" corner to land at the top right. So Standpoint turns the plane to bring your reference option there, the one whose position you want to tell. One edge case gets a fix. A reference rated top marks on everything would drift far from everyone else. Standpoint then sets it just past the best competitor, where the map stays legible.
Geometry alone picks the four options the map singles out. The leader, top right, is your reference. The weakest loses on both axes. That leaves two challengers, once the leader is set aside: one climbs highest on the vertical axis, the other reaches furthest along the horizontal. Those two deserve a look, because each embodies one extreme better than anyone, without winning.
Color obeys the same rule. Each competitor takes its hue from its direction, seen from the center of the map, and the hues run all the way around the color wheel. Two neighbors on the map therefore get neighboring colors, which the eye reads without thinking. The legend follows the map's order, from the top-right corner downwards.
Last step, words on the axes. PCA axes are blends of your columns and those blends can be read. One axis might lean mostly on performance and concurrency, the other on ease of learning and job market. A model installed at your end reads those weights and christens the four ends, always with a quality. The column names tell it which language to write in: English, French or Spanish. A column marked "(↓)", as in Price (↓), means less is better. The name chosen then states the benefit: "Affordable," for instance. A guard stops acronyms, negations and opposite words before they reach a label.
What does "model" mean here? The word covers very different objects. ChatGPT is an enormous language model. Its size is measured in parameters, the internal dials learned during training. The biggest models count hundreds of billions and run only in data centers. To distill is to teach a small model the answers of a large one, on one precise task.
Ours is tiny: a Qwen3 of 0.6 billion parameters. Against the hundreds of billions of the biggest, do the division: it is at least a hundred times smaller. It was distilled for three very limited tasks:
- It names the four ends of the axes.
- It puts words in the right number, singular or plural, so the labels sound right in both languages, English and French.
- It proposes a rating from one to five for a blank cell, when you ask it to fill one.
That third task touches the position of the dots. The proposed ratings enter the computation like any other and so they move the dot on the map. They appear on screen so that you correct them. By this project's measurements they land within three quarters of a point of what a large model would propose, on a one-to-five scale that stays subjective.
Why so small? Because the PCA has already computed everything computable. The model steps in where there is nothing to compute: putting a word on a blend of columns that already have names, proposing a number where the cell is empty. It never sees your ratings. It sees weights, column names and, for the filling, the row names. This work calls for none of the very large models of the moment. It calls for one that fits on a laptop and does not leave the room.
One training result runs against intuition. First came two distilled models, one per language. Then a third, trained on both languages together, was added to see what specializing brought. The bilingual model won, everywhere. For naming the axes, the two specialists stopped at 90%. The bilingual one reaches 100% in each language. For a model this small, the weak spot is the exact shape of the answer: four names in a fixed structure, the same in English and in French. Training in two languages therefore shows that structure twice as often. So a single model ships, better everywhere and half as much to maintain.
The same habit of checking led to removing a model. Standpoint inspects its own figure with three questions. Is the leader really at the top right? Can the labels be read? Is the legend visible? A model that reads images used to answer them. Its answers were counted across the 1,480 examples recorded during distillation: two of the three questions came back "yes" all 1,480 times. Two times 1,480 makes 2,960 answers and not a single "no"! The third question turns on the sign of a coordinate, which the program already knows to the digit. A model was being made to look at a picture for numbers already at hand. The program now does that check itself, with no model, instantly and offline.
The next map places Standpoint among the other ways of drawing a positioning map, on seven criteria. Standpoint drew it itself, from a table of ratings I filled in. It lands at the top right. Hold your applause: Standpoint is the reference row, so it ends up there by construction. And the ratings in the table are mine. Change the reference and the same map rearranges itself around another tool.
The tool judges itself: statistical toolkits on one side, layout tools on the other and the targeted corner where the two meet.
The same engine is reached through seven paths:
- A Python library goes into your code (
import standpoint). - Two twin commands are typed in a terminal and count as two paths.
- A graphical interface opens in the browser.
- An HTTP API is a door through which other programs call the tool over the network.
- A server talks to AI agents, speaking the Model Context Protocol (MCP).
- A fully static build translates the engine into WebAssembly, a format every browser knows how to run. It therefore runs at the visitor's end, with no server.
That static build is the one online at deraison.ai/standpoint. Paste your table, get the map, with nothing to install. The version installed on your machine and the online one do not name the axes the same way. On your machine, Standpoint picks the best local model your computer can run. In the browser, the page loads the small distilled model described above, once. It names the axes and fills the empty cells when you ask it to. The figure itself is hand-written SVG, with no drawing library. Every stroke is chosen.
Taken one by one, the pieces impress nobody. Pearson did the computation by hand in 1901. The pocket model knows its three small tasks and nothing else. The rest is a drawing with no library, a table format anyone can type and a browser tab. The whole interest comes from the assembly, where each piece passes to the next what it cannot do itself.
The whole thing runs in a tab because every piece is small. Your notes on your competitors stay with you with no contract needed to promise it, because no server exists to receive them. Gartner spends a year of interviews and teams of analysts placing a market. Standpoint claims no such thing, granted. But it runs inside the page you are reading, where everything checks out row by row.
Try it on your own table
An honest table deserves better than a gut reading. The map leaves the table in place and adds the overview, the one that tells you which rows to reread closely. Its axes stay blends of your own criteria. So every position traces back to the original figures, kept in the output YAML file.
To form an opinion, try it: deraison.ai/standpoint runs the engine in your browser, with no install and no upload.
The code is open source under the BSD license: pip install standpoint, then one command on your CSV. The code, the examples and the documentation live at github.com/warith-harchaoui/standpoint. All it needs now is your table, to show you where you stand.