Talk:Low-level programming language

Examples

This page could use some examples. Thehotelambush 16:09, 30 July 2007 (UTC)

Example - a function that calculates the nth Fibonacci number.

First, in C [3rd generation]:

unsigned int fib(unsigned int n)
{
    if (n <= 0)
        return 0;
    else if (n <= 2)
        return 1;
    else {
        int a,b,c;
        a = 1;
        b = 1;
        while (1) {
            c = a + b;
            if (n <= 3) return c;
            a = b;
            b = c;
            n--;
        }
    }
}

The same function, but converted to x86 assembly language, specifically MASM, using the __cdecl calling convention [2nd generation]:

fib:
    mov edx, [esp+8]
    cmp edx, 0
    ja @f
    mov eax, 0
    ret
    
    @@:
    cmp edx, 2
    ja @f
    mov eax, 1
    ret
    
    @@:
    push ebx
    mov ebx, 1
    mov ecx, 1
    
    @@:
        lea eax, [ebx+ecx]
        cmp edx, 3
        jbe @f
        mov ebx, ecx
        mov ecx, eax
        dec edx
    jmp @b
    
    @@:
    pop ebx
    ret

Note:

@f refers to the closest following @@: label.

@b refers to the closest preceding @@: label.

I deliberately did not use proc.

And here is the final x86 machine code [1st generation]:

8B542408 83FA0077 06B80000 0000C383
FA027706 B8010000 00C353BB 01000000
B9010000 008D0419 83FA0376 078BD98B
C84AEBF1 5BC3

For comparison purposes, here is a disassembly listing:

00401000                    fib:
00401000 8B542408               mov     edx,[esp+8]
00401004 83FA00                 cmp     edx,0
00401007 7706                   ja      loc_0040100F
00401009 B800000000             mov     eax,0
0040100E C3                     ret
0040100F                    loc_0040100F:
0040100F 83FA02                 cmp     edx,2
00401012 7706                   ja      loc_0040101A
00401014 B801000000             mov     eax,1
00401019 C3                     ret
0040101A                    loc_0040101A:
0040101A 53                     push    ebx
0040101B BB01000000             mov     ebx,1
00401020 B901000000             mov     ecx,1
00401025                    loc_00401025:
00401025 8D0419                 lea     eax,[ecx+ebx]
00401028 83FA03                 cmp     edx,3
0040102B 7607                   jbe     loc_00401034
0040102D 8BD9                   mov     ebx,ecx
0040102F 8BC8                   mov     ecx,eax
00401031 4A                     dec     edx
00401032 EBF1                   jmp     loc_00401025
00401034                    loc_00401034:
00401034 5B                     pop     ebx
00401035 C3                     ret

Alksentrs (talk) 23:57, 16 February 2008 (UTC)

By the way, the Fibonacci sequence breaks at precisely F₄₇.

unsigned int fib(unsigned int n): -1323752223

unsigned long long int fib(unsigned int n): 18446744072385799393

actual F₄₇: 2971215073

Just thought I'd let you know. 174.28.41.236 (talk) 18:24, 2 January 2014 (UTC)

Absolute terms

I've always known low-level and high-level programming languages to be absolute terms. The former refers to programming languages that provide no abstraction from the instructions that the processor implements, this is binary code (maybe written in hexadecimal), and assembler language, which is a mnemonic for the binary code and is assembled. The latter refers to programming languages that can be used independently of the processor because there is a software layer that abstracts that detail (something an assembler does not do), as a compiler or an interpreter.

The crisp and absolute difference between low-level programming languages and high-level programming languages, for what I knew, is that the code is done for a specific hardware (or group of them) as may be the x86 group of processors, or it is done for a software (or group of them) as is the group of C compilers.

Unfortunately I haven't been able to find references as this is more a terminological matter than a informatics matter, that's why I've required the citation (as there may be one). All that I got by now is this a definition in the webopedia[1].

Kind regards. —Preceding unsigned comment added by Trylks (talk • contribs) 23:26, 19 February 2008 (UTC)

Removed two-year old citation tag

There are no controversial statements of fact in this article, so no citations are needed. Nor is the Utah State Office of Education reference needed. "a low level language is one that does not need a compiler or interpreter to run" is a simple statement of fact. "Mars is a planet" does not need an "according to..." reference. The article may be a stub, but what's there is an example of content which does not need references, besides the one instance with the citation tag. And sometimes, especially in the long-winded Wikipedia, a term can be explained perfectly well with a stub. J M Rice (talk) 13:37, 11 October 2008 (UTC)

Old citation

It's rediculous to require a citation for the statement that programmers rarely code in machine code. That's like requiring a citation to state that Elvis is dead.

"Rediculous" or not, it's Wikipedia policy.Diego (talk) 10:26, 27 October 2008 (UTC)

Low-level programming in high-level languages - needs edit, possible removal

I have moved the C example code out of this section and provided a point by point comparison between it and the assembly language example, to emphasise the difference between high level abstraction and low level architecture specifics. The C example served absolutely no purpose in this section - it is absolutely not an example of low-level programming in a high level language.

I do not think this section is very useful as currently written. It makes no mention of the most pertinent mechanism (inline assembler) and I think causes confustion by mostly refering to systems programming. Systems programming is not by definition low-level programming. UNIX (and UNIX-like) operating systems are written in C but almost all of that code is completely portable. Porting such an operating system to a specific architecture mostly means simply specifying values for operating system constants and in some places choosing implementations which will operate most efficiently on a particular architecture (over implementations which would function poorly but would work). Even those parts which are achitecture-specific are mostly high-level C code written with an awareness of the architecture rather than code which directly manipulates that architecture in a low-level way. Actual low-level programming is a very small part of operating system design. As it stands, this section is as vague in its worning and uncertain in its purpose.

I think this also applies to the "relative meaning" section, which seems equally ill informed. The beginning of the article gives a clear definition of "low level". This is computer-science jargon, where words and phrases which might be ambiguous in general language have specific meanings. Whoever wrote that doesn't realise that C is still considered a high level language. The emergence of more abstract languages hasn't changed that basic fact.

I am going to make the following changes to this section:

• Add mention of inline assembler and other techniques for low-level hardware control by high level programmes.
• Remove mention of Forth (off topic).
• Remove the paragraph which is entirely devoted to systems programming in C, does not contribute to the definition of Low-level programming languages and is off topic.
• Remove the small bullet list of other types of programmig languages. It is not relevant to this section, very limited and entirely redundant given the automatically-generated category-relevant lists at the bottom of the page.

Itsbruce (talk) 17:39, 25 August 2014 (UTC)

I am not sure by now, how well low and high are defined. Seems to me that there needs to be a name for something above assembler, but that still allows for low-level coding at the register level, and other machine specific abilities. PL/360, for example, allows operations on specific machine registers. As well as I know, BLISS and PL/S also allow specification at the hardware level. PL/M does similarly for the 8080 and 8086. I believe some C compilers allow writing interrupt routines, with, for example, proper interrupt enable and disable. While C is still a high-level language, one can cast an integer constant to a pointer, and read or write from specific hardware addresses. On machines with memory-mapped I/O, one can do I/O operations directly. Those are things one normally is not able to do in a high-level language, yet C allows for them. Gah4 (talk) 13:04, 11 July 2019 (UTC)

more examples

Seems to me that languages like PL/360 and PL/M should be described here. They are designed to look like higher-level languages, but operate more like an assembler. In PL/360, variables with names like R1 and R2 represent actual processor registers. Even more, the translation is more direct than for high level languages. In PL/360, for example, R1:=R1+R1+R1; will result in R1 holding four times its previous value, LR R1,R1; AR R1,R1; AR R1,R1, as the modified value is used for the last AR. Gah4 (talk) 18:57, 29 June 2018 (UTC)

C as a low-level language

There is no mentioning of C being used as a low-level language. C could be used as a high-level language, but the modern day go-to low-level programming language is pretty much C.

• People publishing books about "low-level programming" with C in the title.
• Columbia University offering course in Low-level programming with C

Based on my observation, the only people who potentially disagree about C being low level are hardware developers. However if this article only takes their point of view, then it is basically NPOV. --Voidvector (talk) 07:54, 27 December 2019 (UTC)

No idea about the WP:NPOV, but I do agree that C is commonly used as a low-level language. One common example is assigning addresses (often of memory-mapped I/O devices) to pointers, and then dereferencing them. While the standard is meant to be used as a high-level language, that doesn't mean that people do it. Gah4 (talk) 00:32, 31 December 2019 (UTC)

C is often used to control low-level machine details, however that statement does not imply that C is a low-level programming language. For instance, many languages uncontroversially considered high-level (e.g. Haskell, Java) can also perform low-level operations if suitable abstractions are provided. As evidence, House is an operating system written in Haksell. I argue the correct way to think about C is as a high-level language with implementations that often provide out-of-the-box support for low-level operations. I suggest that this article can be improved by mentioning very high-level languages so as to distinguish C from languages like Java and Haskell. — Preceding unsigned comment added by 65.60.139.183 (talk) 14:00, 27 March 2020 (UTC)

computer languages

low level languageItalic text A low-level programming language is a programming language that provides little or no abstraction from a computer's instruction set architecture—commands or functions in the language map that are structurally similar to processor's instructions. Generally, this refers to either machine code or assembly language. Because of the low (hence the word) abstraction between the language and machine language, low-level languages are sometimes described as being "close to the hardware". Programs written in low-level languages tend to be relatively non-portable, due to being optimized for a certain type of system architecture.

Low-level languages can convert to machine code without a compiler or interpreter – second-generation programming languages use a simpler processor called an assembler – and the resulting code runs directly on the processor. A program written in a low-level language can be made to run very quickly, with a small memory footprint. An equivalent program in a high-level language can be less efficient and use more memory. Low-level languages are simple, but considered difficult to use, due to numerous technical details that the programmer must remember. By comparison, a high-level programming language isolates execution semantics of a computer architecture from the specification of the program, which simplifies development. First - generation programming language

(high level language)

A first-generation programming language (1GL) is a machine-level programming language. A first generation (programming) language (1GL) is a grouping of programming languages that are machine level languages used to program first-generation computers. Originally, no translator was used to compile or assemble the first-generation language. The first-generation programming instructions were entered through the front panel switches of the computer system. The instructions in 1GL are made of binary numbers, represented by 1s and 0s. This makes the language suitable for the understanding of the machine but far more difficult to interpret and learn by the human programmer. The main advantage of programming in 1GL is that the code can run very fast and very efficiently, precisely because the instructions are executed directly by the central processing unit (CPU). One of the main disadvantages of programming in a low level language is that when an error occurs, the code is not as easy to fix. First generation languages are very much adapted to a specific computer and CPU, and code portability is therefore significantly reduced in comparison to higher level languages. Modern day programmers still occasionally use machine level code, especially when programming lower level functions of the system, such as drivers, interfaces with firmware and hardware devices. Modern tools such as native-code compilers are used to produce machine level from a higher-level language.

Second - generation programming language

(Assembly language)

Second-generation programming language (2GL) is a generational way to categorize assembly languages. The term was coined to provide a distinction from higher level machine independent third-generation programming languages (3GL) such as COBOL and earlier first-generation programming languages (machine code) Second-generation programming languages have the properties: Lines within a program correspond directly to processor commands, essentially acting as a mnemonic device overlaying a first generation programming language. The code can be read and written by a programmer. To run on a computer it must be converted into a machine readable form, a process called assembly. The language is specific to a particular processor family and environment. Second-generation languages are sometimes used for parts of kernels or device drivers, and are sometimes used in video games, graphics programs, and other intensive programs. In modern programs, second generation assembly languages are rarely used.Programming in second generation languages may yield speed benefits, but several disadvantages have led to its decline: Programming is expressed in terms of individual processor instructions, rather than higher level logic. Low-level memory and hardware details must be manually managed which is often bug-prone. Programs are machine-dependent, so different versions must be written for every target machine architecture. The vast majority of programs are written in a third-generation programming language or a fourth-generation programming language. Assembly's main advantage, speed, has degraded by the fact that well written C code can often be as fast or even faster than hand written assembly Second generation languages are perhaps most significant in their place in computing history. For a long time, Second generation assembly languages were the only good option for development for many machines, such as the NES or the Commodore 64. Second generation languages represented a massive step away from the tradition of programmers conforming to the needs of a machine, and the first step towards the machine accommodating for the programmer, a phenomenon that would be repeated in all subsequent programming language generations.

Third - generation programming language

A third-generation programming language (3GL) is a high-level computer programming language that tends to be more machine-independent and programmer-friendly than the machine code of the first-generation and assembly languages of the second-generation, while having a less specific focus to the fourth and fifth generations.Examples of common and historical third-generation programming languages are ALGOL, BASIC, C, COBOL, Fortran, Java, and Pascal.

3GLs are much more machine-independent and more programmer-friendly. This includes features like improved support for aggregate data types, and expressing concepts in a way that favors the programmer, not the computer. A third generation language improves over a second-generation language by having the computer take care of non-essential details. 3GLs are more abstract than previous generations of languages, and thus can be considered higher-level languages than their first- and second-generation counterparts. First introduced in the late 1950s, Fortran, ALGOL, and COBOL are examples of early 3GLs. Most popular general-purpose languages today, such as C, C++, C#, Java, BASIC and Pascal, are also third-generation languages, although each of these languages can be further subdivided into other categories based on other contemporary traits. Most 3GLs support structured programming. Many support object-oriented programming. Traits like these are more often used to describe a language rather than just being a 3GL. A programming language such as C, FORTRAN, or Pascal enables a programmer to write programs that are more or less independent from a particular type of computer. Such languages are considered high-level because they are closer to human languages and further from machine languages, and hence require compilation or interpretation. In contrast, machine languages are considered as low-level because they are designed for and executed by physical hardware without further translation required. The main advantage of high-level languages over low-level languages is that they are easier to read, write, and maintain. Ultimately, programs written in a high-level language must be translated into machine language by a compiler or directly into behaviour by an interpreter. These programs could run on different machines so they were machine-independent. As new, more abstract languages have been developed, however, the concept of high- and low-level languages have become rather relative. Many of the early "high-level" languages are now considered relatively low-level in comparison to languages such as Python, Ruby, and Common Lisp, which have some features of fourth-generation programming languages.

Fourth - generation programming language

A fourth-generation programming language (4GL) is any computer programming language that belongs to a class of languages envisioned as an advancement upon third-generation programming languages (3GL). Each of the programming language generations aims to provide a higher level of abstraction of the internal computer hardware details, making the language more programmer-friendly, powerful, and versatile. While the definition of 4GL has changed over time, it can be typified by operating more with large collections of information at once rather than focusing on just bits and bytes. Languages claimed to be 4GL may include support for database management, report generation, mathematical optimization, GUI development, or web development. Some researchers state that 4GLs are a subset of domain-specific languages. The concept of 4GL was developed from the 1970s through the 1990s, overlapping most of the development of 3GL, with 4GLs identified as "non-procedural" or "program-generating" languages, contrasted with 3GLs being algorithmic or procedural languages. While 3GLs like C, C++, C#, Java, and JavaScript remain popular for a wide variety of uses, 4GLs as originally defined found uses focused on databases, reports, and websites.Some advanced 3GLs like Python, Ruby, and Perl combine some 4GL abilities within a general-purpose 3GL environment, and libraries with 4GL-like features have been developed as add-ons for most popular 3GLs, producing languages that are a mix of 3GL and 4GL, blurring the distinction.

Fifth- generation programming language

A fifth-generation programming language (5GL) is any programming language based on problem-solving using constraints given to the program, rather than using an algorithm written by a programmer. Most constraint-based and logic programming languages and some other declarative languages are fifth-generation languages. While fourth-generation programming languages are designed to build specific programs, fifth-generation languages are designed to make the computer solve a given problem without the programmer. This way, the user only needs to worry about what problems need to be solved and what conditions need to be met, without worrying about how to implement a routine or algorithm to solve them. Fifth-generation languages are used mainly in artificial intelligence research. OPS5 and Mercury are examples of fifth-generation languages as is ICAD, which was built upon Lisp. KL-ONE is an example of a related idea, a frame language. In the 1980s, fifth-generation languages were considered to be the way of the future, and some predicted that they would replace procedural programming with constraint based programming for all tasks that could be framed as a series of logical constraints. Most notably, from 1982 to 1993, Japan put much research and money into their fifth-generation computer systems project, hoping to design a massive computer network of machines using these tools. However, as larger programs were built, the flaws of the approach became more apparent. It turns out that, given a set of constraints defining a particular problem, deriving an efficient algorithm to solve it is a very difficult problem in itself. This crucial step cannot yet be automated and still requires the insight of a human programmer. Vendors have been known on occasion to advertise their languages as 5GL. Most of the time they actually sell 4GLs with a higher level of automation and knowledge base. Because the hype of the 1980s faded away and the projects were eventually all dropped, 5GL awareness has also dropped; this has opened doors to the vendors to re-use the term in marketing their new tools, without causing much controversy among the current generations of programmers.

The other programming languages are: A • A.NET (A#/A sharp) • A-0 System • A+ (A (plus) • ABAP • ABC • ABC ALGOL • ACC • Accent (Rational Synergy) • Ace DASL (Distributed Application Specification Language) • Action! • ActionScript • Actor • Ada • Adenine (Haystack) • AdvPL • Agda • Agilent VEE (Keysight VEE) • Agora • AIMMS • Aldor • Alef • ALF • ALGOL 58 • ALGOL 60 • ALGOL 68 • ALGOL W • Alice (Alice ML) • Alma-0 • AmbientTalk • Amiga E • AMOS (AMOS BASIC) • AMPL • AngelScript • Apache Pig latin • Apex (Salesforce.com, Inc) • APL • App Inventor for Android's visual block language (MIT App Inventor) • AppleScript • APT • Arc • ARexx • Argus • Assembly language (ASM) • AutoIt • AutoLISP / Visual LISP • Averest • AWK • Axum B • B • Babbage • Ballerina • Bash • BASIC • Batch file (Windows/MS-DOS) • bc (basic calculator) • BCPL • BeanShell • Bertrand • BETA • BLISS • Blockly • BlooP • Boo • Boomerang • Bosque C • C – ISO/IEC 9899 • C-- (C minus minus) • C++ (C plus plus) – ISO/IEC 14882 • C* • C# (C sharp) – ISO/IEC 23270 • C/AL • Caché ObjectScript • C Shell (csh) • Caml • Cayenne (Lennart Augustsson) • CDuce • Cecil • Cesil (Computer Education in Schools Instruction Language) • Céu • Ceylon • CFEngine • Cg (High-Level Shader/Shading Language [HLSL]) • Ch • Chapel (Cascade High Productivity Language) • Charm • CHILL • CHIP-8 • ChucK • Cilk (also Cilk++ and Cilk plus) • Control Language • Claire • Clarion • Clean • Clipper • CLIPS • CLIST • Clojure • CLU • CMS-2 • COBOL – ISO/IEC 1989 • CobolScript – COBOL Scripting language • Cobra • CoffeeScript • ColdFusion • COMAL • Combined Programming Language (CPL) • COMIT • Common Intermediate Language (CIL) • Common Lisp (also known as CL) • COMPASS • Component Pascal • Constraint Handling Rules (CHR) • COMTRAN • Cool • Coq • Coral 66 • CorVision • COWSEL • CPL • Cryptol • Crystal • Csound • Cuneiform • Curl • Curry • Cybil • Cyclone • Cypher Query Language • Cython • CEEMAC D • D • Dart • Darwin • DataFlex • Datalog • DATATRIEVE • dBase • dc • DCL (DIGITAL Command Language) • Delphi • DinkC • DIBOL • Dog • Draco • DRAKON • Dylan • DYNAMO • DAX (Data Analysis Expressions) E • E • Ease • Easy PL/I • EASYTRIEVE PLUS • eC • ECMAScript • Edinburgh IMP • EGL • Eiffel • ELAN • Elixir • Elm • Emacs Lisp • Emerald • Epigram • EPL (Easy Programming Language) • EPL (Eltron Programming Language) • Erlang • es • Escher • ESPOL • Esterel • Etoys • Euclid • Euler • Euphoria • EusLisp Robot Programming Language • CMS EXEC (EXEC) • EXEC 2 • Executable UML • Ezhil F • F • F# (F sharp) • F* • Factor • Fantom • FAUST • FFP • fish • Fjölnir • FL • Flavors • Flex • Flix • FlooP • FLOW-MASTIC (B0) • FOCAL (Formulating On-Line Calculations in Algebraic Language/FOrmula CALculator) • FOCUS • FOIL • FORMAC (FORMula MAnipulation Compiler) • @Formula • Forth • Fortran – ISO/IEC 1539 • Fortress • FP • Franz Lisp • Futhark • F-Script G • Game Maker Language (Scripting language) • GameMonkey Script • GAMS (General Algebraic Modeling System) • GAP • G-code • GDScript (Godot) • Genie • GDL (Geometric Description Language) • GEORGE • GLSL (OpenGL Shading Language) • GNU E • GNU Guile (GNU Ubiquitous Intelligent Language for Extensions) • Go • Go! • GOAL (Game Oriented Assembly Lisp) • Gödel • Golo • GOM (Good Old Mad) • Google Apps Script • Gosu • GOTRAN (IBM 1620) • GPSS (General Purpose Simulation System) • GraphTalk (Computer Sciences Corporation) • GRASS • Grasshopper • Groovy (programming language)|Groovy (Apache Groovy) H • Hack • HAGGIS • HAL/S • Halide (programming language) • Hamilton C shell • Harbour • Hartmann pipelines • Haskell • Haxe • Hermes • High Level Assembly (HLA) • HLSL • Hollywood • HolyC (TempleOS) • Hop • Hopscotch • Hope • Hugo (Interactive Fiction/IF) • Hume • HyperTalk I • Io • Icon • IBM Basic assembly language • IBM HAScript • IBM Informix-4GL • IBM RPG • IDL • Idris • Inform J • J • J# (J sharp) • J++ (J plus plus) • JADE • Jai • JAL • Janus (concurrent constraint programming language) • Janus (time-reversible computing programming language) • JASS • Java • JavaFX Script • JavaScript(Scripting language) • Jess (programming language) • JCL • JEAN • Join Java • JOSS • Joule • JOVIAL • Joy • JScript • JScript .NET • Julia • Jython K • K • Kaleidoscope • Karel • KEE • Kixtart • Klerer-May System • KIF (Knowledge Interchange Format) • Kojo • Kotlin • KRC • KRL • KRL (KUKA Robot Language) • KRYPTON • KornShell (ksh) • Kodu • Kv (Kivy) L • LabVIEW • Ladder • LANSA • Lasso • Lava • LC-3 • Lean • Legoscript • LIL • LilyPond • Limbo • Limnor • LINC • Lingo • LINQ • LIS • LISA • Language H • Lisp – ISO/IEC 13816 • Lite-C • Lithe • Little b • LLL • Logo • Logtalk • LotusScript • LPC • LSE • LSL • LiveCode • LiveScript • Lua • Lucid • Lustre • LYaPAS • Lynx M • M2001 • M4 • M# • Machine code • MAD (Michigan Algorithm Decoder) • MAD/I • Magik • Magma • Máni • Maple • MAPPER (now part of BIS) • MARK-IV (now VISION:BUILDER) • Mary • MATLAB • MASM Microsoft Assembly x86 • MATH-MATIC • Maude system • Maxima (see also Macsyma) • Max (Max Msp – Graphical Programming Environment) • MaxScript internal language 3D Studio Max • Maya (MEL) • MDL • Mercury • Mesa • MHEG-5 (Interactive TV programming language) • Microcode • MicroScript • Microsoft Power Fx • MIIS • Milk (programming language) • MIMIC • Mirah • Miranda • MIVA Script • ML • Model 204 • Modelica • Modula • Modula-2 • Modula-3 • Mohol • MOO • Mortran • Mouse • MPD • MSL • MUMPS • MuPAD • Mutan • Mystic Programming Language (MPL) N • NASM • Napier88 • Neko • Nemerle • NESL • Net.Data • NetLogo • NetRexx • NewLISP • NEWP • Newspeak • NewtonScript • Nial • Nickle (NITIN) • Nim • Nix (Systems configuration language) • NPL • Not eXactly C (NXC) • Not Quite C (NQC) • NSIS • Nu • NWScript • NXT-G O • o:XML • Oak • Oberon • OBJ2 • Object Lisp • ObjectLOGO • Object REXX • Object Pascal • Objective-C • Objective-J • Obliq • OCaml • occam • occam-π • Octave • OmniMark • Opa • Opal • OpenCL • OpenEdge ABL • OPL • OpenVera • OPS5 • OptimJ • Orc • ORCA/Modula-2 • Oriel • Orwell • Oxygene • Oz P • P • P4 • P′′ • ParaSail (programming language) • PARI/GP • Pascal – ISO 7185 • Pascal Script • PCASTL • PCF • PEARL • PeopleCode • Perl • PDL • Pharo • PHP • Pico • Picolisp • Pict • Pike • PILOT • Pipelines • Pizza • PL-11 • PL/0 • PL/B • PL/C • PL/I – ISO 6160 • PL/M • PL/P • PL/SQL • PL360 • PLANC • Plankalkül • Planner • PLEX • PLEXIL • Plus • POP-11 • POP-2 • PostScript • PortablE • POV-Ray SDL • Powerhouse • PowerBuilder – 4GL GUI application generator from Sybase • PowerShell • PPL • Processing • Processing.js • Prograph • PROIV • Project Verona • Prolog • PROMAL • Promela • PROSE modeling language • PROTEL • ProvideX • Pro*C • Pure • Pure Data • PureScript • Python Q • Q (programming language from Kx Systems) • Q# (Microsoft programming language) • Qalb • Quantum Computation Language • QtScript • QuakeC • QPL • .QL R • R • R++ • Racket • Raku • RAPID • Rapira • Ratfiv • Ratfor • RemObjects Mercury • rc • Reason • REBOL • Red • Redcode • REFAL • REXX • Rlab • ROOP • RPG • RPL • RSL • RTL/2 • Ruby • Rust S • S • S2 • S3 • S-Lang • S-PLUS • SA-C • SabreTalk • SAIL • SAS • SASL • Sather • Sawzall • Scala • Scheme • Scilab • Scratch • Script.NET • Sed • Seed7 • Self • SenseTalk • SequenceL • Serpent • SETL • SIMPOL • SIGNAL • SiMPLE • SIMSCRIPT • Simula • Simulink • Singularity • SISAL • SLIP • SMALL • Smalltalk • SML • Strongtalk • Snap! • SNOBOL (SPITBOL) • Snowball • SOL • Solidity • SOPHAEROS • Source • SPARK • Speakeasy • Speedcode • SPIN • SP/k • SPS • SQL • SQR • Squeak • Squirrel • SR • S/SL • Starlogo • Strand • Stata • Stateflow • Subtext • SBL • SuperCollider • SuperTalk • Swift (Apple programming language) • Swift (parallel scripting language) • SYMPL • SystemVerilog T • T • TACL • TACPOL • TADS (Text Adventure Development System) • TAL • Tcl • Tea • TECO (text Editor and Corrector) • TELCOMP • TeX • TEX (Text Executive Programming Language) • TIE • TMG (TransMo Griffer), compiler-compiler • Tom • Toi • Topspeed (Clarion) • TPU (text Processing Utility) • Trac • TTM • T-SQL (Transact-SQL) • Transcript (LiveCode) • TTCN (Tree and Tabular Combined Notation) • Turing • TUTOR (PLATO Author Language) • TXL • TypeScript • Tynker U • Ubercode • UCSD Pascal • Umple • Unicon • Uniface • UNITY • Unix shell • UnrealScript V • Vala • Verilog • VHDL • Vim script • Viper (Ethereum/Ether (ETH)) • Visual DataFlex • Visual DialogScript • Visual FoxPro • Visual J++ (Visual J plus plus) • Visual LISP • Visual Objects • Visual Prolog W • WATFIV, WATFOR (WATerloo FORtran IV) • WebAssembly • WebDNA • Whiley • Winbatch • Wolfram Language • Wyvern X • X++ (X plus plus/Microsoft Dynamics AX) • X10 • xBase • xBase++ (xBase plus plus) • XBL • XC (targets XMOS architecture) • xHarbour • XL • Xojo • XOTcl • Xod • XPL • XPL0 • XQuery • XSB • XSharp (X#) • XSLT • Xtend Y • Yorick • YQL • Yoix • YUI Z • Z notation • Zebra, ZPL, ZPL2 • Zeno • ZetaLisp • Zig • ZOPL • ZPL • Z++