pldb/PLDB huggingface dataset:
p4p (pl, appeared 2010)
Origin: Brown University
Country: United States
Website: https://shriram.github.io/p4p

an alternate syntax for Racket.


GitHub description: An alternate syntax for Racket

defvar: m = 10
defvar: this-better-be-6 = add(1, 2, 3)
defvar: this-better-be-0 = add()
deffun: five() = 5
deffun: trpl(x) = add(x, x, x)
deffun: g(a, b, c) = add(a, b, c)
deffun: d/dx(f) =

  defvar: delta = 0.001

  fun: (x) in:

    div(sub(f(add(x, delta)),

            f(x)),

        delta)
 deffun: fib(n) =
   if: numeq(n, 0)
     1
   elseif: numeq(n, 1)
     1
   else:
     add(fib(sub1(n)), fib(sub(n, 2)))
PACT I (pl, appeared 1955)
Origin: IBM
Country: United States


PACT was a series of compilers for the IBM 701 and IBM 704 scientific computers. Their development was conducted jointly by IBM and a committee of customers starting in 1954. PACT I was developed for the 701, and PACT IA for the 704. The emphasis in that early generation of compilers was minimization of the memory footprint, because memory was a very expensive resource at the time. The word "compiler" was not in widespread use at the time, so most of the 1956 papers described it as an "(automatic) coding system", although the word compiler was also used in some papers.
PALASM (pl, appeared 1980)
Origin: Monolithic Memories, Inc
Country: United States


PALASM is an early hardware description language, used to translate Boolean functions and state transition tables into a fuse map for use with Programmable Array Logic (PAL) devices introduced by Monolithic Memories, Inc. (MMI). The language was developed by John Birkner in the early 1980s. It is not case-sensitive.  The PALASM compiler was written by MMI in FORTRAN IV on an IBM 370/168. MMI made the source code available to users at no cost. By 1983, MMI customers ran versions on the DEC PDP-11, Data General NOVA, Hewlett-Packard HP 2100, MDS800 and others. A widely used MS DOS port was produced by MMI. There was a windows front-end written sometime later.
PALcode (isa, appeared 1996)
Origin: Digital Equipment Corporation
Country: United States


In computing, in the Alpha instruction set architecture, PALcode (Privileged Architecture Library code) is the name used by DEC for a set of functions in the SRM or AlphaBIOS firmware, providing a hardware abstraction layer for system software, covering features such as cache management, translation lookaside buffer (TLB) miss handling, interrupt handling and exception handling. PALcode is Alpha machine code, running in a special mode that also allows access to internal registers specific to the particular Alpha processor implementation. It is thus somewhere between the role of microcode and of a hardware emulator. PALcode is operating system-specific; different versions of PALcode are required by OpenVMS, Tru64 UNIX, and Windows NT. Tru64 UNIX PALcode is also used by NetBSD, FreeBSD, OpenBSD and Linux.
PAMELA (pl, appeared 1992)
Origin: Delft University of Technology
Country: The Netherlands

In this report we present a new methodology for the performance prediction of parallel programs on parallel platforms ranging from shared-memory to distributed-memory (vector) machines. The complete methodology comprises the concurrent language Pamela (PerformAnce ModEling LAnguage), the program and machine modeling paradigm, and a novel performance analysis method, called "serialization analysis". While Pamela models can be directly executed (i.e., simulated), prior to this ultimate evaluation step, serialization analysis allows for (symbolic) model reduction, which often renders simulation superuous. This analysis method extends conventional parallel program analysis technology by explicitly accounting for the performance degrading eects of resource contention, yet at the low evaluation cost, typical for conventional techniques. It is shown that, where application of conventional techniques may yield serious errors, predictions from serialization analysis remain accurate. Apart from the modeling methodology itself, this low-cost/high-reliability analysis potential makes Pamela a particularly suitable candidate for compile-time application in terms of the performance prediction hierarchy often found in parallel programming environments.
Pan (pl, appeared 2011)
Creators: Charles Loomis
Origin: https://github.com/quattor
Country: Various
Website: http://www.quattor.org/


The pan configuration language allows the definition of machine configuration information and an associated schema with a simple, human-accessible syntax. A pan language compiler transforms the configuration information contained within a set of pan templates to a machine-friendly XML or JSON format. The pan language is used within the Quattor toolkit to define the desired configuration for one or more machines. The language is primarily a declarative language where elements in a hierarchical tree are set to particular values. The pan syntax is human-friendly and fairly simple, yet allows system administrators to simultaneously set configuration values, define an overall configuration schema, and validate the final configuration against the schema.

GitHub description: Pan Language Compiler and Tools
Pandas (library, appeared 2008)
Origin: https://github.com/pandas-dev
Country: Various
Website: https://pandas.pydata.org


In computer programming, pandas is a software library written for the Python programming language for data manipulation and analysis. In particular, it offers data structures and operations for manipulating numerical tables and time series. It is free software released under the three-clause BSD license. The name is derived from the term "panel data", an econometrics term for multidimensional, structured data sets.
Pandoc (application, appeared 2006)
Origin: https://github.com/jgm/pandoc/issues
Country: United States
Website: http://pandoc.org/

If you need to convert files from one markup format into another, pandoc is your swiss-army knife.

Pandoc is a free and open-source software document converter, widely used as a writing tool (especially by scholars) and as a basis for publishing workflows. It was created by John MacFarlane, a philosophy professor at the University of California, Berkeley.
Papyrus (pl, appeared 2015)
Origin: Bethesda Softworks LLC
Country: United States

Papyrus is an entirely new scripting system created specifically for the Creation Kit. If you've never used a Bethesda toolset before, consider some basic tutorials to get your footing with the Creation Kit in general.

Papyrus  is a material similar to thick paper that was used in ancient times as a writing surface. It was made from the pith of the papyrus plant, Cyperus papyrus, a wetland sedge. Papyrus (plural: papyri) can also refer to a document written on sheets of such material, joined together side by side and rolled up into a scroll, an early form of a book.   Papyrus is first known to have been used in Egypt (at least as far back as the First Dynasty), as the papyrus plant was once abundant across the Nile Delta. It was also used throughout the Mediterranean region and in the Kingdom of Kush. Apart from a writing material, ancient Egyptians employed papyrus in the construction of other artifacts, such as reed boats, mats, rope, sandals, and baskets.
Parallax Propeller (isa, appeared 2006)
Origin: Parallax, Inc
Country: United States


The Parallax P8X32A Propeller is a multi-core processor parallel computer architecture microcontroller chip with eight 32-bit reduced instruction set computer (RISC) central processing unit (CPU) cores. Introduced in 2006, it is designed and sold by Parallax, Inc. The Propeller microcontroller, Propeller assembly language, and Spin interpreter were designed by one person, Parallax's cofounder and president, Chip Gracey. The Spin programming language and Propeller Tool integrated development environment (IDE) were designed by Chip Gracey and Parallax's software engineer Jeff Martin. On August 6, 2014, Parallax Inc., released all of the Propeller 1 P8X32A hardware and tools as open-source hardware and software under the GNU General Public License (GPL) 3.0. This included the Verilog code, top-level hardware description language (HDL) files, Spin interpreter, PropellerIDE and SimpleIDE programming tools, and compilers.
parasail (pl, appeared 2009)
Creators: Seth Tucker Taft
Origin: Ada Core Technologies
Country: United States
Website: http://parasail-lang.org
File extensions: .psi
.psl

ParaSail is a new parallel programming language designed to support the development of inherently safe and secure, highly parallel applications that can be mapped to multicore, manycore, heterogeneous, or distributed architectures.

Parallel Specification and Implementation Language (ParaSail) is an object-oriented parallel programming language. Its design and ongoing implementation is described in a blog and on its official website.
Parenscript (pl, appeared 2009)
Creators: Manuel Odendahl
Edward Marco Baringer
Origin: https://gitlab.common-lisp.net/parenscript/parenscript/-/issues
Country: United States and Italy
Website: https://common-lisp.net/project/parenscript/



GitHub description: MOVED TO C-L.NET GITLAB. THIS REPOSITORY WILL BE DELETED
PARI/GP (pl, appeared 1985)
Also known as: parigp
PARI/GP
Origin: Université Bordeaux
Country: France
Website: http://pari.math.u-bordeaux.fr/


PARI/GP is a computer algebra system with the main aim of facilitating number theory computations. Versions 2.1.0 and higher are distributed under the GNU General Public License. It runs on most common operating systems.
Parlog (pl, appeared 1983)
Creators: Steve Gregory
Keith L. Clark
Origin: Imperial College, London
Country: United Kingdom


Parlog is a logic programming language designed for efficient utilization of parallel computer architectures. Its semantics is based on first order predicate logic. It expresses concurrency, interprocess communication, indeterminacy and synchronization within the declarative language framework.It was designed at Imperial College, London by Steve Gregory and Keith L. Clark, as a descendant of IC Prolog and Relational Language.


mode qsort(list?,sorted_list^).
qsort([N|Rest],Sorted) <-
partition(N,Rest,LessN,MoreN),
qsort(LessN,SortedLess),
qsort(MoreN,SortedMore),
append(SortedLess,[N|SortedMore],Sorted).
qsort([],[]).
parquet (binaryDataFormat, appeared 2014)
Creators: Doug Cutting
Julien Le Dem
Origin: Twitter Inc
Cloudera, Inc
Country: United States
Website: http://parquet.apache.org/


Apache Parquet is a free and open-source column-oriented data storage format in the Apache Hadoop ecosystem. It is similar to RCFile and ORC, the other columnar-storage file formats in Hadoop, and is compatible with most of the data processing frameworks around Hadoop. It provides efficient data compression and encoding schemes with enhanced performance to handle complex data in bulk.
Parrot Assembly (assembly, appeared 2003)
Origin: https://www.perl.org
Country: United States


The Parrot assembly language (PASM) is the basic assembly language used by the Parrot virtual machine. PASM is the lowest level assembly language in the Parrot stack. The Parrot intermediate representation (PIR) is PASM extended to simplify development of compilers. The hello world program in PASM is simply:  print "Hello world!\n" end  Although it appears similar to source code in some high-level programming languages, more complex PASM programs will resemble other assembly languages. The main exceptions to this low level programming in PASM are string handling and, as shown above, input and output. Additionally, PASM has automatic garbage collection from the virtual machine, and it does not allow pointer arithmetic. Parrot assembly language has more instructions than hardware assembly languages, even  CISC processors. This is because the marginal cost of creating a new instruction in Parrot is low compared to the marginal cost of doing so in hardware, and the creators of Parrot had no particular goal of minimalism.


#!/usr/bin/env parrot

.pcc_sub :main main:
    say "Hello!"
    end
Parrot BASIC (pl, appeared 2009)
Origin: https://www.perl.org
Country: United States


Parrot is a register-based process virtual machine designed to run dynamic languages efficiently. It is possible to compile Parrot assembly language and PIR (an intermediate language) to Parrot bytecode and execute it. Parrot is free and open source software.Parrot was started by the Perl community and is developed with help from the open source and free software communities. As a result, it is focused on license compatibility with Perl (Artistic License 2.0), platform compatibility across a broad array of systems, processor architecture compatibility across most modern processors, speed of execution, small size (around 700k depending on platform), and the flexibility to handle the varying demands made by Perl 6 and other modern dynamic languages. Version 1.0, with a stable API for development, was released on March 17, 2009.The current version is release 8.1.0 "Andean Parakeet"
PIR (pl, appeared 2006)
Origin: https://www.perl.org
Country: United States


The Parrot intermediate representation (PIR), previously called Intermediate code (IMC), is one of the two assembly languages for the Parrot virtual machine. The other is Parrot assembly language or PASM. Compared to PASM, PIR exists at a slightly higher abstraction layer, and provides temporary registers and named registers, simplifying code generation. While Parrot is still evolving, it is currently being used in many different capacities, and has undergone several releases.
Parrot (vm, appeared 2002)
Origin: https://www.perl.org
Country: United States


Parrot is a register-based process virtual machine designed to run dynamic languages efficiently. It is possible to compile Parrot assembly language and PIR (an intermediate language) to Parrot bytecode and execute it. Parrot is free and open source software.Parrot was started by the Perl community and is developed with help from the open source and free software communities. As a result, it is focused on license compatibility with Perl (Artistic License 2.0), platform compatibility across a broad array of systems, processor architecture compatibility across most modern processors, speed of execution, small size (around 700k depending on platform), and the flexibility to handle the varying demands made by Perl 6 and other modern dynamic languages. Version 1.0, with a stable API for development, was released on March 17, 2009.The current version is release 8.1.0 "Andean Parakeet"
Parser 3 (pl, appeared 1997)
Also known as: parser3
Creators: Konstantin Morshnev
Origin: Art. Lebedev Studio
Country: Russia
Website: http://www.parser.ru/


Parser is a free server-side CGI web scripting language developed by Art. Lebedev Studio and released under the GPL. Originally, Parser was merely a simple macro processing language. The latest 3rd revision (March 2006) introduced object-oriented programming features. The compiler for the language was developed in C++ by studio employees Konstantin Morshnev and Alexander Petrosyan to automate often repeated tasks, especially maintenance of already existing websites. It was used in many web projects of the studio. Since revision 3 it was released as free software and it is now used in other websites, mostly in Russia (according to a partial list at the language's website). The language supports technologies needed for common web design tasks: XML, Document Object Model (DOM), Perl Compatible Regular Expressions (PCRE) and others.
PascalABC.NET (pl, appeared 2002)
Creators: S.S. Mikhalkovich
Ivan Bondarev
A.V. Tkachuk
S.O. Ivanov
Origin: http://pascalabc.net/en
Country: Russia
Website: http://pascalabc.net/


PascalABC.NET is a Pascal programming language that implements classic Pascal, most Delphi language features, as well as a number of their own extensions. It is implemented on the .NET Framework platform and contains all the modern language features: classes, operator overloading, interfaces, exception handling, generic classes and routines, garbage collection, lambda expressions, parallel programming tools (OpenMP only as of 2016). PascalABC.NET is also a simple and powerful integrated development environment with integrated debugger, IntelliSense system, form designer, code templates and code auto-formatting. Command-line PascalABC.NET compiler is also available on Linux and MacOS (under Mono).PascalABC.NET is popular in Russian schools and universities. In Southern Federal University, it is used as the main language for teaching students of Information technology in the course "Fundamentals of programming" and for teaching children in one of the largest computer schools in Russia.
PASCAL/MT+ (pl, appeared 1988)
Origin: MT MicroSYSTEMS
Country: United States


Pascal/MT+ was an ISO 7185 compatible Pascal compiler written in 1980 by Michael Lehman, founder of MT MicroSYSTEMS of Solana Beach, California.  The company was acquired by Digital Research in 1981 which subsequently distributed versions that ran on the 8080/Z80 processor under the CP/M operating system. Later versions ran on the 68000 CPU under CP/M-68K, and the 8086 CPU under CP/M-86 and MS-DOS. Pascal/MT+, for the 8086, was available for CP/M-86, PC DOS/MS-DOS as well as RMX-86 (a proprietary OS from Intel). Pascal/MT+86 still runs today on even the latest version of Microsoft Windows and DR-DOS.
Pascal Script (pl, appeared 2000)
Origin: RemObjects Software
Country: United States
Website: https://www.remobjects.com/ps.aspx

Pascal Script is a free scripting engine that allows you to use most of the Object Pascal language within your Delphi or Free Pascal projects at runtime. Written completely in Delphi, it is composed of a set of units that can be compiled into your executable, eliminating the need to distribute any external files. Pascal Script started out as a need for a good working script, when there were none available at the time.

Pascal Script is a scripting language based on the programming language Pascal that facilitates automated runtime control over scriptable applications and server software. It is implemented by a free scripting engine that includes a compiler and an interpreter for byte code. Pascal Script supports the majority of Object Pascal constructs, making it partly compatible to Delphi, Free Pascal and GNU Pascal. Initially developed by Carlo Kok as CajScript and renamed to Innerfuse Pascal Script with version 2.23, the software was taken over by RemObjects, renamed again to RemObjects Pascal Script and offered as open source software for the Delphi IDE. Beginning with version 2.07 CajScript has been ported to Free Pascal. Since 2017 Pascal Script is included as a standard component in the Lazarus IDE.
Pascal (pl, appeared 1970)
Creators: Niklaus Wirth
Origin: ETH Zürich
Country: Switzerland
File extensions: pp
pas
inc
Keywords: *
+
-
/
:=
<
<=
<>
=
>
>=
and
begin
boolean
break
byte
continue
div
do
double
else
end
false
if
integer
longint
mod
not
or
repeat
shl
shortint
shr
single
then
true
until
while
word
xor


Pascal is an imperative and procedural programming language, which Niklaus Wirth designed in 1968–69 and published in 1970, as a small, efficient language intended to encourage good programming practices using structured programming and data structuring. It is named in honor of the French mathematician, philosopher and physicist Blaise Pascal. Pascal was developed on the pattern of the ALGOL 60 language. Wirth had already developed several improvements to this language as part of the ALGOL X proposals, but these were not accepted and Pascal was developed separately and released in 1970. A derivative known as Object Pascal designed for object-oriented programming was developed in 1985; this was used by Apple Computer and Borland in the late 1980s and later developed into Delphi on the Microsoft Windows platform. Extensions to the Pascal concepts led to the Pascal-like languages Modula-2 and Oberon.
pasukon (grammarLanguage, appeared 2020)
Creators: Federico Ramirez
Origin: https://github.com/gosukiwi/Pasukon/issues
Country: Argentina
Website: https://pasukon.rocks



GitHub description: JavaScript practical parser generator library using combinators

lex
  match  NUMBER     /[0-9]+(?:\.[0-9]+)?/
  match  PLUS       '+'
  match  MINUS      '-'
  match  TIMES      '*'
  match  DIV        '/'
  match  POPEN      '('
  match  PCLOSE     ')'
  ignore WHITESPACE /^\s+/
/lex

addition
  | (subtraction as :lhs) then :PLUS then (subtraction as :rhs)
  |> 'return $.lhs + $.rhs'
  | subtraction
  ;

subtraction
  | (multiplication as :lhs) then :MINUS then (multiplication as :rhs)
  |> 'return $.lhs - $.rhs'
  | multiplication
  ;

multiplication
  | (division as :lhs) then :TIMES then (division as :rhs)
  |> 'return $.lhs * $.rhs'
  | division
  ;

division
  | (expression as :lhs) then :DIV then (expression as :rhs)
  |> 'return $.lhs / $.rhs'
  | expression
  ;

expression
  | :POPEN then (addition as :expr) then :PCLOSE
  |> 'return $.expr'
  | number
  ;

number
  | :NUMBER 'return +$1'
  ;

start
  | addition
  ;
Patchwork (pl, appeared 1996)
Creators: Ronen Barzel
David Salesin
Origin: Lucasfilm Computer Graphics Group
Country: United States

We have built a system, Patchwork, that allows programs to be organized according to a dataflow model. In our implementation, application programs use Patchwork to assemble complex microcode programs for a graphics processor from a library of microcode modules. We describe a simple and efficient implementation, in which the only overhead incurred is a single extra level of indirection when invoking a module or when a module accesses inputs, outputs, or local storage. The implementation depends on being able to describe a distinct execution tree for the network, which obviates the need both for run-time monitoring of the execution and for movement of data. Thus, neither dataflow hardware nor a dataflow language is needed for the implementation. Patchwork supports flow-of-control constructs such as looping and branching, the assembly of complex modules from simpler ones, modules written in a variety of languages for a variety of different devices, the interleaved execution of several programs on a single processor, and the execution of a single program on a set of processors in parallel. An analysis showed that Patchwork contributed between 2 and 5% to the total running time of sample microcode programs.
PBASIC (pl, appeared 1988)
Origin: Parallax, Inc
Country: United States


PBASIC is a microcontroller-based version of BASIC created by Parallax, Inc. in 1992.PBASIC was created to bring ease of use to the microcontroller and embedded processor world. It is used for writing code for the BASIC Stamp microcontrollers. After the code is written, it is tokenized and loaded into an EEPROM on the microcontroller. These tokens are fetched by the microcontroller and used to generate instructions for the processor.
Portable Bit Map Format (textDataFormat, appeared 1986)
Origin: https://netpbm.sourceforge.net/history.html
Country: Unknown

The PBM format is a lowest common denominator monochrome file format. It serves as the common language of a large family of bitmap image conversion filters. Because the format pays no heed to efficiency, it is simple and general enough that one can easily develop programs to convert to and from just about any other graphics format, or to manipulate the image. The name "PBM" is an acronym derived from "Portable Bit Map."



P1
# This is an example bitmap of the letter "J"
6 10
0 0 0 0 1 0
0 0 0 0 1 0
0 0 0 0 1 0
0 0 0 0 1 0
0 0 0 0 1 0
0 0 0 0 1 0
1 0 0 0 1 0
0 1 1 1 0 0
0 0 0 0 0 0
0 0 0 0 0 0
Omega (pl, appeared 2019)
Origin: Reasoning Technology, LLC
Country: United States
Website: https://www.pbtomega.com/

Omega is a general purpose problem solving language with an informal conversational interface. Like pure functional programming languages, It is declarative and side-effect free. It is a pure calculus of types where each type characterizes a category of things. Omega expands the range of applications of automated systems by validly characterizing and answering questions about anything that can be imagined including infinite, incompletely knowable and nonexistent things.