pldb/PLDB huggingface dataset:
Programming Language for Business (pl, appeared 1972)
Stands for: Programming Language for Business
Origin: Datapoint Corporation
Country: United Kingdom


Programming Language for Business or PL/B is a business-oriented programming language originally called DATABUS and designed by Datapoint in 1972 as an alternative to COBOL because Datapoint's 8-bit computers could not fit COBOL into their limited memory, and because COBOL did not at the time have facilities to deal with Datapoint's built-in keyboard and screen. A version of DATABUS became an ANSI standard, and the name PL/B came about when Datapoint chose not to release its trademark on the DATABUS name.
Please Build (pl, appeared 2016)
Origin: Thought Machine Group
Country: United Kingdom
Website: https://please.build

Language for the please.build cross-language build system. The Please build language is a full programming language.


GitHub description: High-performance extensible build system for reproducible multi-language builds.

# Taken from //src/core/BUILD in the Please repo
go_library(
    name = "core",
    srcs = glob(["*.go"], exclude=["*_test.go", "version.go"]) + [":version"],
    visibility = ["PUBLIC"],
    deps = [
        "//third_party/go:gcfg",
        "//third_party/go:logging",
        "//third_party/go:queue",
    ]
)
PLEX (pl, appeared 1975)
Origin: Telefonaktiebolaget LM Ericsson
Country: Sweden


PLEX (Programming Language for EXchanges) is a special-purpose, concurrent, real-time programming language.  The PLEX language is closely tied to the architecture of Ericsson's AXE telephone exchanges which it was designed to control. PLEX was developed by Göran Hemdahl at Ericsson in the 1970s,  and it has been continuously evolving since then. PLEX was described in 2008 as "a cross between Fortran and a macro assembler."The language has two variants: Plex-C used for the AXE Central Processor (CP) and Plex-M used for Extension Module Regional Processors (EMRP).
pliant (pl, appeared 1999)
Origin: Copliant Société à responsabilité limitée
Country: France
Website: https://www.fullpliant.org/

At the beginning, Pliant is a computing language. It's target is: enable to keep better control on the computing system and better adaptation capabilities thanks to reduced complexity. This has been achieved mostly through enabling to develop everything in a single language that combines high expression power with execution efficiency.
plink-bed-format (binaryDataFormat, appeared 2007)
Origin: https://github.com/samtools
Country: Various
Website: https://www.cog-genomics.org/plink2/formats#bed
File extensions: bed

Primary representation of genotype calls at biallelic variants. Do not confuse this with the UCSC Genome Browser's BED format, which is totally different. Used in plink.



0x6c 0x1b 0x01 0xdc 0x0f 0xe7 0x0f 0x6b 0x01
plink-ped-format (textDataFormat, appeared 2007)
Origin: Kyung Hee University
Country: South Korea
Website: https://www.cog-genomics.org/plink2/formats#ped
File extensions: ped

The "ped" file is a commonly used format for holding pedigree and genotype data. Files in this format usually end in ".ped". There are several variants of the format. Used by plink.



1 1 0 0 1  0  G G  2 2  C C
1 2 0 0 2  0  A A  0 0  A C
1 3 1 2 1  2  0 0  1 2  A C
2 1 0 0 1  0  A A  2 2  0 0
2 2 0 0 2  2  A A  2 2  0 0
2 3 1 2 1  2  A A  2 2  A A
Property list (textMarkup, appeared 2012)
Origin: Apple, Inc
NeXT, Inc
Country: United States
File extensions: plist


In the macOS, iOS, NeXTSTEP, and GNUstep programming frameworks, property list files are files that store serialized objects. Property list files use the filename extension .plist, and thus are often referred to as p-list files. Property list files are often used to store a user's settings. They are also used to store information about bundles and applications, a task served by the resource fork in the old Mac OS.
Plot (pl, appeared 2006)
Stands for: Programming Language for Old Timers
Creators: David A. Moon
Origin: Association of Lisp Users
Country: United States
Website: http://users.rcn.com/david-moon/PLOT/




;; A silly toy program
def response(threat)
  if threat = #severe
    run-in-circles()
    scream-and-shout()
  elseif threat = #moderate
    print("Danger Will Robinson")
  else
    sleep(1)
plot (template, appeared 2019)
Creators: John Sundell
Origin: https://github.com/JohnSundell/Plot/pulls
Country: Poland



GitHub description: A DSL for writing type-safe HTML, XML and RSS in Swift.

let html = HTML(
    .head(
        .title("My website"),
        .stylesheet("styles.css")
    ),
    .body(
        .div(
            .h1("My website"),
            .p("Writing HTML in Swift is pretty great!")
        )
    )
)
PL/pgSQL (pl, appeared 1998)
Creators: Jan Wieck
Origin: The PostgreSQL Global Development Group
Country: United States


PL/pgSQL (Procedural Language/PostgreSQL) is a procedural programming language supported by the PostgreSQL ORDBMS.  It closely resembles Oracle's PL/SQL language. Implemented by Jan Wieck, PL/pgSQL first appeared with PostgreSQL 6.4, released on October 30, 1998. Version 9 also implements some ISO SQL/PSM features, like overloading of SQL-invoked functions and procedures.PL/pgSQL, as a fully featured programming language, allows much more procedural control than SQL, including the ability to use loops and other control structures. SQL statements and triggers can call functions created in the PL/pgSQL language. The design of PL/pgSQL aimed to allow PostgreSQL users to perform more complex operations and computations than SQL, while providing ease of use. The language is able to be defined as trusted by the server.PL/pgSQL is one of the programming languages included in the standard PostgreSQL distribution, the others being PL/Tcl, PL/Perl and PL/Python. In addition many others are available from third parties, including PL/Java, PL/pgPSM, PL/php, PL/R,  PL/Ruby,PL/sh,  PL/Lua and PL/v8.  PostgreSQL uses Bison as its parser, making it easy to port many open-source languages, as well as to reuse code.
Pλ⍵NK (pl, appeared 2020)
Origin: Katholieke Universiteit Leuven
Country: Belgium

This work presents Pλ⍵NK, a functional probabilistic network programming language that extends Probabilistic NetKAT (PNK). Like PNK, it enables probabilistic modelling of network behaviour, by providing probabilistic choice and infinite iteration (to simulate looping network packets). Yet, unlike PNK, it also offers abstraction and higher-order functions to make programming much more convenient.
Plus (pl, appeared 1976)
Origin: University of British Columbia
Country: Canada


Plus is a "Pascal-like" system implementation language from the University of British Columbia (UBC), Canada, based on the SUE system language developed at the University of Toronto, c. 1971.There is another programming language named PLUS, developed at Sperry Univac in Roseville, Minnesota, but the Univac PLUS is not the subject of this article.
PLZ (pl, appeared 1979)
Origin: Zilog, Inc
Country: United States

PLZ/SYS is intended to aid the implementation of system programs for microcomputers. PLZ/SYS is a synthesis of concepts from contemporary programming languages and compilers--the language Pascal has had the most notable influence on the overall design and implementation of PLZ/SYS.



bubble sort MODULE

CONSTANT
 false : .. 0
 true := 1
 
EXTERNAL
 printarray PROCEDURE (first tWORD count BYTE)
 
INTERNAL
 a ARRAY [10 WORD]
  := [33 10 2000 400 410
   3 3 33 500 1999]
 sort PROCEDURE (n BYTE)
  LOCAL
   i j limit BYTE
   temp WORD
   switched BYTE
  ENTRY
  DO
   switched := false
    i := 0
    limit := n-2
    DO
     IF i > limit THEN EXIT FI
     j := i + 1
     IF a[i] > a[j] THEN
      switched := true
      temp :'" a [i)
      a[i] := a[j]
      a [j] : .. temp
     FI
     i +- 1
   OD
   IF switched .. false THEN RETURN FI
  END sort
GLOBAL
 main PROCEDURE
  ENTRY
   sort (10)
   printarray(ta[O] 10)
  END main
END bubble sort
PML (textMarkup, appeared 1986)
Stands for: Practical Markup Language
Creators: Christian Neumanns
Origin: https://github.com/pml-lang
Country: Unknown
Website: https://www.pml-lang.dev/




[doc [title PML Demo]

    [ch [title Introduction]
        This is a [i simple] example.

        You can add images, audio, and videos:
        [image (
            source = images/strawberries.jpg
             width = 300
             align = center
        )]
    ]

    [ch [title Source Code]
        You can show highlighted source code:
        [code (lang=java)
            // Simple Java example
            public static void sayHello ( String name ) {
                System.out.println ( "Hello " + name );
            }        
        code]
    ]
]
Pnuts (pl, appeared 1997)
Origin: Sun Japan
Country: Japan


Pnuts is a dynamic scripting language for the Java platform. It is designed to be used in a dual language system with the Java programming language. The goals of the Pnuts project are to provide a small, fast scripting language that has tight integration with the Java language. Pnuts uses syntax that is simple and friendly to Java developers, while also being very expressive.
Pod6 (textMarkup, appeared 2019)
Creators: Aliaksandr Zahatski
Origin: https://github.com/zag/js-pod6/issues
Country: Unknown
Website: https://pod6.in



GitHub description: Pod6 is an easy-to-use markup language. It can be used for writing language documentation, for documenting programs and modules, as well as for other types of document composition

=begin pod
 This is an ordinary paragraph

    While this is not
    This is a code block
    
    =head1 Mumble mumble
    
    Suprisingly, this is not a code block
        (with fancy indentation too)

But this is just a text. Again

=end pod
pointless (pl, appeared 2020)
Creators: Avery N. Nortonsmith
Origin: https://github.com/pointless-lang
Country: United States
Website: https://ptls.dev/



GitHub description: Pointless: a scripting language for learning and fun

import "chart.ptls" as chart
 
output =
  iterate(collatzStep, 175)
  |> takeWhile(greaterThan(1))
  |> chart.scale(8)
  |> println

collatzStep(n) =
  if n % 2 == 0 then n / 2 else n * 3 + 1
polymath (textMarkup, appeared 2020)
Creators: JL
Origin: https://github.com/jwmza/polymath/issues
Country: Unknown
Website: https://jwmza.com/polymath/

Polymath is a markup language (like Markdown, LaTeX, or HTML) and a static site generator specialized in aesthetically presenting a wide variety of information: text, mathematics, code, photos, videos, you name it.


GitHub description: Polymath is a human readable, interoperable, long-term focused markup language for information storage and display
Pop-11 (pl, appeared 1999)
Origin: University of Sussex
Country: United Kingdom


POP-11 is a reflective, incrementally compiled programming language with many of the features of an interpreted language. It is the core language of the Poplog programming environment developed originally by the University of Sussex, and recently in the School of Computer Science at the University of Birmingham which hosts the Poplog website. POP-11 is an evolution of the language POP-2, developed in Edinburgh University and features an open stack model (like Forth, among others). It is mainly procedural, but supports declarative language constructs, including a pattern matcher and is mostly used for research and teaching in Artificial Intelligence, although it has features sufficient for many other classes of problems. It is often used to introduce symbolic programming techniques to programmers of more conventional languages like Pascal, who find POP syntax more familiar than that of Lisp. One of POP-11's features is that it supports first-class functions. Pop-11 is the core language of the Poplog system. The fact that the compiler and compiler subroutines are available at run-time (a requirement for incremental compilation) gives it the ability to support a far wider range of extensions than would be possible using only a macro facility. This made it possible for incremental compilers to be added for Prolog, Common Lisp and Standard ML, which could be added as required to support either mixed language development or development in the second language without using any Pop-11 constructs. This made it possible for Poplog to be used by teachers, researchers, or developers who were interested in only one of the languages. The most successful product developed in Pop-11 was the Clementine data-mining system, developed by ISL, as described in the entry on Poplog. After SPSS bought ISL they decided to port Clementine to C++ and Java, and eventually succeeded with great effort (and perhaps some loss of the flexibility provided by the use of an AI language!). As explained in the entries for Poplog and POP-2, Pop-11 was for a time available only as part of an expensive commercial package (Poplog), but since about 1999 it has been freely available as part of the Open Source version of Poplog, including various additional packages and teaching libraries. An online version of ELIZA using Pop-11 is available at Birmingham. At the University of Sussex David Young used Pop-11 in combination with C and Fortran to develop a suite of teaching and interactive development tools for image processing and vision, and has made them available in the Popvision extension to Poplog.
POP-2 (pl, appeared 1967)
Origin: University of Edinburgh
Country: United Kingdom


POP-2 (also referred to as POP2) is a programming language developed around 1970 from the earlier language POP-1 (developed by Robin Popplestone in 1968, originally named COWSEL) by Robin Popplestone and Rod Burstall at the University of Edinburgh.  It drew roots from many sources: the languages LISP and ALGOL 60, and theoretical ideas from Peter J. Landin. It used an incremental compiler, which gave it some of the flexibility of an interpreted language, including allowing new function definitions at run time and modification of function definitions while a program was running (both of which are features of dynamic compilation), without the overhead of an interpreted language.
Patient-Oriented Prescription Programming Language (pl, appeared 2015)
Origin: Northwestern University
Country: United States
Website: https://users.cs.northwestern.edu/~sfq833/pop-pl/




#lang pop-pl

used by JessieBrownVA

initially
 giveBolus 80 units/kg of: HEParin by: iv

infusion:
 whenever new aPTTResult
  aPTT < 45 | giveBolus 80 units/kg of: HEParin by: iv
popr (pl, appeared 2012)
Origin: https://github.com/HackerFoo/poprc/issues
Country: United States
Website: https://popr.dev

<a href='https://github.com/HackerFoo/poprc'>Popr</a> applies concatenative programming to types as well as values, striving for purity and correctness, and efficient execution.


GitHub description: A Compiler for the Popr Language

1 2 | 3 +
Portable Standard Lisp (pl, appeared 1980)
Origin: University of Utah
Country: United States


Portable Standard Lisp (PSL) is a tail-recursive dynamically bound dialect of Lisp inspired by its predecessor, Standard Lisp and the Portable Lisp Compiler. It was developed by researchers at the University of Utah in 1980, which released PSL 3.1; development was handed over to developers at Hewlett-Packard in 1982 who released PSL 3.3 and up. Portable Standard Lisp was available as a kit containing a screen editor, a compiler, and an interpreter for the 68000 processor architecture, DEC-20s, CRAY-1s, and the VAX architecture (among many others). Today, PSL is mainly developed by and available from Konrad-Zuse-Zentrum für Informationstechnik Berlin.  Its main modern use is as underlying language for implementations of Reduce.Like most older lisps, PSL in the first step compiles Lisp to LAP code, which is a platform independent language in its own.  However, where older lisps mostly compiled LAP directly to assembler or some architecture dependent intermediate,  PSL compiles the LAP to C code, which would run in a virtual machine language; so programs written in it in principle are as portable as C itself, which is very portable. The compiler itself was written in PSL or a more primitive dialect dubbed "System Lisp"/"SYSLISP" as "an experiment in writing a production-quality Lisp in Lisp itself as much as possible, with only minor amounts of code written by hand in assembly language or other systems languages", so the whole ensemble could bootstrap itself, and improvements to the compiler improved the compiler itself as well. Some later releases had a compatibility package for Common Lisp, but this is not sustained in the modern versions.
Post-X (grammarLanguage, appeared 1980)
Creators: P.A.C. Bailes
L.H. Reeker
Origin: University of Queensland
Country: Australia

The Post-X language is designed to provide facilities for pattern-directed processing of strings, sequences and trees in an integrated applicative format.



REPLACE GRAM := "<"^BREAK">"^"> ''
                {$<^((REPLACE GRAM)<
                   SELECT RHS
                   (ALT LTST<
                   (LHS--FIND $2 <GRAM)))
                %>}
                INULL{$$};
PostScript (textMarkup, appeared 1982)
Creators: John Warnock
Chuck Geschke
Doug Brotz
Ed Taft
Bill Paxton
Origin: Adobe
Country: United States

Postscript is a graphical page description language invented by ChuckGetsche and JohnWarnock (the President and CEO of Adobe). Its syntax looks a little bit like Forth, because it is derived from Forth; however, Postscript's internal implementation has nothing to do with Forth.

PostScript (PS) is a page description language in the electronic publishing and desktop publishing business. It is a dynamically typed, concatenative programming language and was created at Adobe Systems by John Warnock, Charles Geschke, Doug Brotz, Ed Taft and Bill Paxton from 1982 to 1984.
PowerQuery M (queryLanguage, appeared 2015)
Also known as: m
powerquery
Origin: Microsoft
Website: https://docs.microsoft.com/en-us/powerquery-m/
Keywords: as
each
else
error
false
if
in
is
let
meta
otherwise
section
shared
then
true
try
type

The Power Query M formula language is optimized for building highly flexible data mashup queries. It's a functional, case sensitive language similar to F#.



"Hello World"             // a text value 
123                       // a number 
1 + 2                     // sum of two numbers 
{1, 2, 3}                 // a list of three numbers 
[ x = 1, y = 2 + 3 ]      // a record containing two fields: 
                          //        x and y 
(x, y) => x + y           // a function that computes a sum 
if 2 > 1 then 2 else 1    // a conditional expression 
let x = 1 + 1  in x * 2   // a let expression 
error "A"                 // error with message "A"
let Orders = Table.FromRecords({  
    [OrderID = 1, CustomerID = 1, Item = "fishing rod", Price = 100.0],  
    [OrderID = 2, CustomerID = 1, Item = "1 lb. worms", Price = 5.0],  
    [OrderID = 3, CustomerID = 2, Item = "fishing net", Price = 25.0]}),  
    #"Capitalized Each Word" = Table.TransformColumns(Orders, {"Item", Text.Proper})  
in  
    #"Capitalized Each Word"
PowerBASIC (pl, appeared 1989)
Origin: PowerBASIC Inc
Country: United States


PowerBASIC, formerly Turbo Basic, is the brand of several commercial compilers by PowerBASIC Inc. that compile a dialect of the BASIC programming language. There are both MS-DOS and Windows versions, and two kinds of the latter:  Console and Windows.  The MS-DOS version has a syntax similar to that of QBasic and QuickBASIC.  The Windows versions use a BASIC syntax expanded to include many Windows functions, and the statements can be combined with calls to the Windows API.
PowerBuilder (pl, appeared 2010)
Origin: SAP SE
Country: Germany


PowerBuilder is an integrated development environment owned by SAP since the acquisition of Sybase in 2010.  On July 5, 2016, SAP and Appeon entered into an agreement whereby Appeon would be responsible for developing, selling, and supporting PowerBuilder.PowerBuilder has been in use since 1991, peaking around 1998 with around 100,000 users. While PowerBuilder's market share has declined over the years, many applications created with it are still in use today.  Over the years, PowerBuilder has been updated with new standards.  In 2010, a major upgrade of PowerBuilder was released to provide support for the Microsoft .NET Framework.  In 2014, support was added for OData, dockable windows, and 64-bit native applications.  In 2017, support was added for iOS and Android app development.PowerBuilder 2018 provides new targets to enable developers to rapidly create RESTful Web APIs and non-visual .NET assemblies, in a test-driven manner, with the native PowerBuilder IDE and C#. A preview version is currently available for select customers.


// The MIT License (MIT)

// Copyright (c) 2016 dario ureña

// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:

// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

// Source: https://github.com/darioaxel/PowerScriptToKDMTransformer/blob/173c3949d5684150c34f7405f0689310eade0362/resources/basics/TestPBT.pbt

Save Format v3.0(19990112)
@begin Projects
 0 "myproject\\myprojectlib.pbl";
@end;
appname "myproject";
applib "myproject\\myproject.pbl";
LibList "myproject\\myproject.pbl;myproject\\lib\\logger\\logger.pbl;myproject\\lib\\payroll\\payroll.pbl;myproject\\lib\\contract\\contract.pbl;myproject\\lib\\common\\common.pbl;";
type "pb";
PowerHouse (pl, appeared 1988)
Origin: UNICOM Systems
Country: United States


PowerHouse is a trademarked name for a byte-compiled fourth-generation programming language (or 4GL) originally produced by Quasar Corporation (later renamed Cognos Incorporated) for the Hewlett-Packard HP3000 mini-computer. It was initially composed of five components:  QDD, or Quasar Data Dictionary: for building a central data dictionary used by all other components QDesign: a character-based screen generator Quick: an interactive, character-based screen processor (running screens generated by QDesign) Quiz: a report writer QTP: a batch transaction processor.
IBM POWER Instruction Set Architecture (isa, appeared 1998)
Origin: IBM
Country: United States


The IBM POWER ISA is a reduced instruction set computer (RISC) instruction set architecture (ISA) developed by IBM. The name is an acronym for Performance Optimization With Enhanced RISC. The ISA is used as base for high end microprocessors from IBM during the 1990s and were used in many of IBM's servers, minicomputers, workstations, and supercomputers. These processors are called POWER1 (RIOS-1, RIOS.9, RSC, RAD6000) and POWER2 (POWER2, POWER2+ and P2SC). The ISA evolved into the PowerPC instruction set architecture and was deprecated in 1998 when IBM introduced the POWER3 processor that was mainly a 32/64 bit PowerPC processor but included the POWER ISA for backwards compatibility. The POWER ISA was then abandoned.