I am looking for an adjective with regard to computer programming, which says that a program language is not abstract, but very clear and intuitive or even overly "non-computerish".

I saw this word once in a blog post regarding the logo programming language, but cannot find it anymore. By the way, English is not my native language.

For example, C++ would be like:

#include <iostream>

 int main() {
     std::cout << "Hello, world!\n";
     return 0;

While logo would be:

Say "Hello World!"

Maybe it is a term used in programming and someone perhaps know which adjective I mean!?

  • Maybe en.wikipedia.org/wiki/Pseudocode.
    – user2768
    Nov 8, 2017 at 11:45
  • @user2768 That's how the language is written; it's not pseudocode.
    – Laurel
    Nov 8, 2017 at 17:21
  • The OP is looking for a word that "says that a program language is not abstract, but very clear and intuitive or even overly 'non-computerish.'" As discussed (english.stackexchange.com/a/417547/265710), such languages might be termed high-level. But, I'm unconvinced that's what the OP is looking for. Indeed, C++ and logo might well both be termed high-level, hence the term cannot distinguish the two. Although you're right that logo is indeed written as above, I'm not sure we can really call it a programming language. It's language could nonetheless be referred to as pseudocode.
    – user2768
    Nov 8, 2017 at 17:26
  • Do you mean using words rather than symbols? Although such languages are only easy to understand if you are familiar with the human language underlying it; someone with no knowledge of English might understand "<<" more than "say".
    – Stuart F
    Apr 18, 2023 at 16:36

4 Answers 4


Programming languages are usually separated into "levels" based on how close to the machine you really get - see this Stack Exchange article for the real details but most people would instinctively understand that "high-level" languages are declarative and close to human language (e.g. Visual Basic, Python, Perl) and "low-level" languages are closer to the machine and further from human language (e.g. C, C++, Assembler).

Of course there are many graduations (and generations) of languages but sticking to high-level and low-level should be enough in most circumstances.

EDIT: Where I say "most people" above, I mean of course "most programmers/technical people"; I had assumed that the adjective was to be used among people who would understand the concept of levels and that may well have been an unwarranted assumption. If so - sorry.


The adjective high-level is used in this context, because it

may use natural language elements

You're flipping the traditional use of "abstract" in this context. Normally the high-level language is an abstraction from the chip's internal instruction set to a set of human-like commands. So


is the less abstract than

ax = bx;

which is less abstract than

let dinner = "sushi";

This is because AX and BX refer to actual registers in the chip, the stuff of microprocessor design, and as little as a single byte of code specifying which circuit in the chip to run. The latter examples require a compiler, lookup tables for variable names, and other mechanisms to make that abstraction into something concrete the chip can do.

  • High-level doesn't necessarily permit a distinction between C++ and logo.
    – user2768
    Nov 8, 2017 at 12:25
  • @user2768. Yes, these are relative scales, which is the best one can hoep for,. The term "a lot" wouldn't distinguish between $1 million and $1 billion--both are "a lot" to pay for a sandwich, and "not a lot" for a GDP. If I choose a language much higher level than logo, I change the scale and C++ and logo look low level. If I choose machine language and assembly, both are high level.
    – jimm101
    Nov 8, 2017 at 21:19
  • @user it does if logo does not permit low-level accesses, results, or execution. See my answer. Apr 13, 2023 at 22:24
  • @jimm101 in no language is let dinner = "sushi"; an abstraction for ax=bx. You are as wrong to write this as to write Say "We have sushi for dinner" is an abstraction for it in Logo. Apr 13, 2023 at 22:31
  • @HenrikErlandsson I don't assert that one is the abstraction of the other, only that one "is less abstract than" the other. Is this controversial? Wikipedia's opening sentence on the topic is "In computer science, a high-level programming language is a programming language with strong abstraction from the details of the computer". The MOV in MOV AX,BX is an abstraction from machine code. dinner = "shushi" is an abstraction from string copying commands that looks like a simple variable copy. The fact that C++ supports asm{} doesn't make C++ lower level than asm. It's just mixing layers.
    – jimm101
    Apr 13, 2023 at 23:28

High-level programming languages abstract away from "the details of the computer" (quote from Wikipedia). But C++ and logo are both high-level languages, hence they cannot be distinguished using such terminology. Thus, the OP might like to consider the term pseudocode, which

uses structural conventions of programming language, but is written for humans rather than machines. Hence, it omits details that are necessary for machines, e.g., which includes the vast majority of the C++ code listed above. Moreover, pseudocode permits informal natural language descriptions and mathematical notation to aid readability. Thus pseudocode is easier for people to understand than conventional programming language code.

(Adapted from http://en.wikipedia.org/wiki/Pseudocode.)

  • Pseudocode is not a programming language, however. Apr 13, 2023 at 22:49

What constitutes an easy programming language or style?


In Computer Science, the term is, or rather, was high-level. 40 years ago, high-level was for most professional programmers limited to mean 'not Assembler', but today it has a quite different meaning.

If you can still write code to access low-level data, or cause a low-level effect (e.g. control the hardware directly), it must today be viewed as a low-level language - it's simply opposed to all of the levels of abstraction that all languages (including Assembler) support to a smaller or greater extent - see below.


My best fit for an easy programming language, and for an easy programming language style, is educational.

If a language is educational, like Logo, Basic, Lua, or Pascal, it has a clear syntax that lets a student as well as professional programmer produce a result or effect expressing themselves clearly in a readable way - but see below.

Such languages are often as a requirement finalized and documented, so that there is a knowledge base, as opposed to "many schools" or "only one school". See below.

Similarly, a programming style is educational if it's finalized and documented, and relies on a knowledge base. (Educational code can also be pedagogical, if it's purposely written to be understood by anyone who knows the language, and the documentation addresses the context in which the code is executed.)


Some clear and readable languages that can also be educational and high-level, are close to Pseudocode. But this is a plain language description of what is to be executed; it is not (yet) a programming language (i.e. can be executed). For this to be possible, the interpreter or compiler, as well as the result or caused effect must be allowed to be fuzzy, or else a detailed language syntax and implementation must be finalized. (In a way, the latter is in fact what has happened with the educational programming languages.)


You might also like limited, which is true for Logo, Lua, and almost all Basic dialects: they are finalized, in the meaning that they are initially presented with a specification and scope that is limited and not often changed, and you express your thoughts within those limitations. This trait allows them to be educational, but many languages are limited without ever being finalized, e.g. to print Computer Science books or other knowledge bases where answers, methods, and recommendations aren't regularly deprecated, incorrect, or unwanted.


A third alternative is strict: A strict language is not necessarily finalized or limited, but would prevent abuse or mistakes at run-time. This would make it easy to write programs that achieve the intended result without crashing. Such is the case for Pascal and Modula (and its successors). This family of languages is educational and strict, and additionally offers modularity, which provides the benefits of separation of concerns, finalization, documentation, and stability of software at development- and runtime.

Not easy: Levels of Abstraction

All languages that are Turing-complete, and some that are not, support theoretically infinite levels of abstraction. At a handful of abstraction levels up from the language definition already, abstraction can make superficially readable code obtuse to the vast majority of programmers who have learned the language perfectly well. Taken to its extreme, a program would consist of one line of code, which sets up everything the program needs, executes it, and causes its output or effect.

This is the goal and the prize and simultaneously the severe penalty, so that to understand what you can read so clearly makes readability not my primary recommendation; you must dig down many levels to understand the so terse and yet oblivious words that constitute a particular code line that is to deliver the result or effect that you use, test, or must modify.

Not easy: Design Patterns

Sometimes, the language is not high-level enough to provide the necessary abstractions within it. Some current solutions have been suggested to, instead of using a higher-level language, keep using the lower-level language and write design patterns and templates, using ordinary programming statements in the hope that they get adopted and used, and perhaps understood, by other programmers.

This is a different axis from the levels of abstraction. It's a form of structured programming yes, but not one which is supported by language features and which are therefore difficult to provide a knowledge base of documentation for. Each design pattern and template serves a means to an end of this structuring, and depending on what is the current paradigm, style, or need, subject to change.

In short: as you abstract and design in any language, your code displays more superficial readability and more direct incomprehensibility. A language that forces several levels of abstraction above it, or design patterns or templates, then, will inherently be understood by fewer and fewer programmers, and be less easy.

A balance must be struck along these axes, in order to let someone who has learned the language to both read it well and understand it well.

Educational, limited, strict, and modular are properties that are desired in Computer Science for goals such as documentation, comprehension, stability, and deployment.

Not the answer you're looking for? Browse other questions tagged or ask your own question.