pldb/PLDB huggingface dataset:
PIC (textMarkup, appeared 1988)
Origin: Bell labs
Country: United States


In computing, Pic is a domain-specific programming language by Brian Kernighan for specifying diagrams in terms of objects such as boxes with arrows between them.  The pic compiler translates this description into concrete drawing commands.  Pic is a procedural programming language, with variable assignment, macros, conditionals, and looping. The language is an example of a little language originally intended for the comfort of non-programmers in the Unix environment (Bentley 1988). Pic was first implemented, and is still most typically used, as a preprocessor in the troff document processing system.  The pic preprocessor filters a troff document, replacing diagram descriptions by concrete drawing commands, and passing the rest of the document through without change. A version of pic is included in groff, the GNU version of troff.  GNU pic can also act as a preprocessor for TeX documents, emitting its own tpic DVI specials, which aren't as widely supported as those of other TeX drivers (like PostScript).  Arbitrary diagram text can be included for formatting by the word processor to which the pic output is directed, and arbitrary post-processor commands can also be included. Dwight Aplevich's implementation, DPIC, can also generate postscript or svg images by itself, as well as act as a preprocessor. The three principal sources of pic processors are GNU pic, found on many Linux systems, and dpic, both of which are free, and the original AT&T pic. Pic has some similarity with MetaPost and the DOT language.
Picat (pl, appeared 2012)
Creators: Neng-Fa Zhou
Jonathan Fruhman
Website: http://www.picat-lang.org/




import util.

input_data(Tri) => 
    Lines = read_file_lines("triangle.txt"),
    Tri = new_array(Lines.length),
    I = 1,
    foreach(Line in Lines)
        Tri[I] = Line.split().map(to_integer).to_array(),
 I := I+1
    end.
piccola (pl, appeared 2002)
Origin: RUniversitat ̈at Bern
Country: Switzerland
Website: http://scg.unibe.ch/research/piccola/

Piccola is a small, pure language for building applications from software components. Piccola is small in the sense that its syntax is tiny, and it is pure in the sense that it provides only compositional features — computation is performed entirely by components of the host programming language. The semantics of Piccola is defined in terms of a process calculus, an extension of Milner’s pi calculus in which values communicated are forms, rather than tuples. A "form" is essentially an extensible nested record which also serves as a namespace in which expressions may be evaluated. This simple mechanism is responsible for much of the expressive power of Piccola.
Pick operating system (os, appeared 1970)
Origin: TRW Inc
Country: United States


The Pick operating system (often called just "the Pick system" or simply "Pick") is a demand-paged, multiuser, virtual memory, time-sharing computer operating system based around a unique MultiValue database. Pick is used primarily for business data processing. It is named after one of its developers, Dick Pick. The term "Pick system" has also come to be used as the general name of all operating environments which employ this multivalued database and have some implementation of Pick/BASIC and ENGLISH/Access queries. Although Pick started on a variety of minicomputers, the system and its various implementations eventually spread to a large assortment of microcomputers, personal computers and mainframe computers.
Pickle (binaryDataFormat, appeared 1995)
Origin: The Python Software Foundation
Country: United States
Website: https://docs.python.org/3/library/pickle.html




\x80\x03cpandas.core.frame\nDataFrame\nq\x00)\x81q\x01}q\x02(X\x05\x00\x00\x00_dataq\x03cpandas.core.internals\nBlockManager\nq\x04)\x81q\x05(]q\x06(cpandas.core.indexes.base\n_new_Index\nq\x07cpandas.core.indexes.base\nIndex\nq\x08}q\t(X\x04\x00\x00\x00dataq\ncnumpy.core.multiarray\n_reconstruct\nq\x0bcnumpy\nndarray\nq\x0cK\x00\x85q\rC\x01bq\x0e\x87q\x0fRq\x10(K\x01K\x02\x85q\x11cnumpy\ndtype\nq\x12X\x02\x00\x00\x00O8q\x13K\x00K\x01\x87q\x14Rq\x15(K\x03X\x01\x00\x00\x00|q\x16NNNJ\xff\xff\xff\xffJ\xff\xff\xff\xffK?tq\x17b\x89]q\x18(X\x03\x00\x00\x00Catq\x19X\x03\x00\x00\x00Dogq\x1aetq\x1bbX\x04\x00\x00\x00nameq\x1cNu\x86q\x1dRq\x1eh\x07cpandas.core.indexes.range\nRangeIndex\nq\x1f}q (h\x1cNX\x05\x00\x00\x00startq!K\x00X\x04\x00\x00\x00stopq"K\x02X\x04\x00\x00\x00stepq#K\x01u\x86q$Rq%e]q&h\x0bh\x0cK\x00\x85q\'h\x0e\x87q(Rq)(K\x01K\x02K\x02\x86q*h\x12X\x02\x00\x00\x00f8q+K\x00K\x01\x87q,Rq-(K\x03X\x01\x00\x00\x00<q.NNNJ\xff\xff\xff\xffJ\xff\xff\xff\xffK\x00tq/b\x88C HE\xe2\xc96\xaf\xd6?-\xccrn\xf7\xe4\xf7\xbfo\x02g\x03x\x8e\xea\xbf\xbb~o\xef}\xe6\xff?q0tq1ba]q2h\x07h\x08}q3(h\nh\x0bh\x0cK\x00\x85q4h\x0e\x87q5Rq6(K\x01K\x02\x85q7h\x15\x89]q8(h\x19h\x1aetq9bh\x1cNu\x86q:Rq;a}q<X\x06\x00\x00\x000.14.1q=}q>(X\x04\x00\x00\x00axesq?h\x06X\x06\x00\x00\x00blocksq@]qA}qB(X\x06\x00\x00\x00valuesqCh)X\x08\x00\x00\x00mgr_locsqDcbuiltins\nslice\nqEK\x00K\x02K\x01\x87qFRqGuaustqHbX\x04\x00\x00\x00_typqIX\t\x00\x00\x00dataframeqJX\t\x00\x00\x00_metadataqK]qLub.
PICO (pl, appeared 1997)
Origin: Vrije Universiteit Brussel
Country: Belgium
Website: http://pico.vub.ac.be


See also Pico (disambiguation).Pico is a programming language developed at the Software Languages Lab at Vrije Universiteit Brussel. The language was created to introduce the essentials of programming to non-computer science students. Pico can be seen as an effort to generate a palatable and enjoyable language for people who do not want to study hard for the elegance and power of a language. They have done it by adapting Scheme's semantics. While designing Pico, the Software Languages Lab was inspired by the Abelson and Sussman's book "Structure and Interpretation of Computer Programs". Furthermore, they were influenced by the teaching of programming at high school or academic level. Pico should be interpreted as 'small', the idea was to create a small language for educational purposes.
pie-lang (pl, appeared 2018)
Creators: David Christiansen
Origin: https://github.com/the-little-typer
Country: Denmark
Website: http://thelittletyper.com/

Pie: A Little Language with Dependent Types. Pie is a Racket language, requiring Racket version 6.5 or newer.


GitHub description: The Pie language, which accompanies The Little Typer by Friedman and Christiansen
Piet (esolang, appeared 1990)
Origin: https://www.dangermouse.net/esoteric/piet.html
Country: Australia


An esoteric programming language (sometimes shortened to esolang) is a programming language designed to test the boundaries of computer programming language design, as a proof of concept, as software art, as a hacking interface to another language (particularly functional programming or procedural programming languages), or as a joke.  The use of esoteric distinguishes these languages from programming languages that working developers use to write software. Usually, an esolang's creators do not intend the language to be used for mainstream programming, although some esoteric features, such as visuospatial syntax,  have inspired practical applications in the arts.  Such languages are often popular among hackers and hobbyists. Usability is rarely a goal for esoteric programming language designers—often it is quite the opposite.  Their usual aim is to remove or replace conventional language features while still maintaining a language that is Turing-complete, or even one for which the computational class is unknown.
Pig Latin (queryLanguage, appeared 2008)
Also known as: piglatin
Origin: Apache
Website: https://pig.apache.org/


Apache Pig is a high-level platform for creating programs that run on Apache Hadoop. The language for this platform is called Pig Latin.  Pig can execute its Hadoop jobs in MapReduce, Apache Tez, or Apache Spark.  Pig Latin abstracts the programming from the Java MapReduce idiom into a notation which makes MapReduce programming high level, similar to that of SQL for relational database management systems. Pig Latin can be extended using user-defined functions (UDFs) which the user can write in Java, Python, JavaScript, Ruby or Groovy and then call directly from the language.


input_lines = LOAD '/tmp/word.txt' AS (line:chararray);
words = FOREACH input_lines GENERATE FLATTEN(TOKENIZE(line)) AS word;
filtered_words = FILTER words BY word MATCHES '\\w+';
word_groups = GROUP filtered_words BY word;
word_count = FOREACH word_groups GENERATE COUNT(filtered_words) AS count, group AS word;
ordered_word_count = ORDER word_count BY count DESC;
STORE ordered_word_count INTO '/tmp/results.txt';
Pike (pl, appeared 1994)
Creators: Fredrik Hübinette
Origin: Chalmers Datorförening
Country: Sweden
Website: https://pike.lysator.liu.se/


Pike is an interpreted, general-purpose, high-level, cross-platform, dynamic programming language, with a syntax similar to that of C. Unlike many other dynamic languages, Pike is both statically and dynamically typed, and requires explicit type definitions. It features a flexible type system that allows the rapid development and flexible code of dynamically typed languages, while still providing some of the benefits of a statically typed language. Pike features garbage collection, advanced data types, and first-class anonymous functions, with support for many programming paradigms, including object-oriented, functional and imperative programming. Pike is free software, released under the GPL, LGPL and MPL licenses.
pikelet (pl, appeared 2017)
Creators: Brendan Zabarauskas
Origin: https://github.com/pikelet-lang
Country: Australia
Website: https://pikelet-lang.github.io/pikelet/

Pikelet is a small, functional, dependently typed programming language.


GitHub description: A friendly little systems language with first-class types. Very WIP! 🚧 🚧 🚧
PIKT (pl, appeared 1998)
Origin: University of Chicago
Country: United States


PIKT is cross-categorical, multi-purpose software for global-view, site-at-a-time system and network administration.  Applicability includes system monitoring, configuration management, server and network administration, system security, and many other uses. PIKT consists of a feature-rich file preprocessor; a scripting language; a flexible, centrally directed process scheduler; a customizing file installer; a collection of command-line extensions; and other useful tools. The PIKT binaries are written using a combination of C, lex (flex), and yacc (bison).  PIKT's configuration combines free-form text files, Pikt scripts, and programs written in other popular scripting languages. PIKT is in widespread use at thousands of sites around the world, although its popularity is diminished by the perception that it is complicated to set up and difficult to administer.  Recent changes have mitigated the complexity and difficulty somewhat.  PIKT's user community is low-profile and not very active. PIKT was first released publicly on October 17, 1998, and has undergone numerous revisions since then.  As of 2008, it is still being actively maintained.
pisc (pl, appeared 2017)
Origin: https://pisc.junglecoder.com/home/apps/fossil/PISC.fossil/ticket
Country: United States
Website: https://pisc.junglecoder.com/

<a href='https://pisc.junglecoder.com/'>PISC</a> attempts to make concatenative programming less mind-bendy via pervasive use of locals, closures, the smallest set of syntax hacks to make code look nice. PISC is a stack-based programming language that is primarily inspired by factor, TCL, bash and a little bit of python, written in go.
Pizza (pl, appeared 2001)
Origin: https://sourceforge.net/p/pizzacompiler/_list/tickets
Country: United Kingdom
Website: https://pizzacompiler.sourceforge.net


Pizza is an open-source superset of Java 1.4, prior to the introduction of generics for the Java programming language.  In addition to its own solution for adding generics to the language, Pizza also added function pointers and algebraic types with case classes and pattern matching. In August 2001, the developers made a compiler capable of working with Java.  Most Pizza applications can run in a Java environment, but certain cases will cause problems. Work on Pizza has more or less stopped since 2002.  Its main developers have concentrated instead on the Generic Java project, another attempt to add generics to Java which was eventually adopted into the official language version 1.5. The pattern matching and other functional programming-like features have been further developed in the Scala programming language.  Martin Odersky remarked, "we wanted to integrate the functional and object-oriented parts in a cleaner way than what we were able to achieve before with the Pizza language. [...] In Pizza we did a clunkier attempt, and in Scala I think we achieved a much smoother integration between the two."
PL/0 (pl, appeared 1976)
Creators: Niklaus Wirth
Origin: Eidgenössische Technische Hochschule Zürich
Country: Switzerland


PL/0 is a programming language, intended as an educational programming language, that is similar to but much simpler than Pascal, a general-purpose programming language. It serves as an example of how to construct a compiler. It was originally introduced in the book, Algorithms + Data Structures = Programs, by Niklaus Wirth in 1976. It features quite limited language constructs: there are no real numbers, very few basic arithmetic operations and no control-flow constructs other than "if" and "while" blocks. While these limitations make writing real applications in this language impractical, it helps the compiler remain compact and simple.
PL-11 (pl, appeared 1971)
Origin: Conseil Européen pour la Recherche Nucléaire
Country: Switzerland


PL-11 is a high-level machine-oriented programming language for the PDP-11, developed by R.D. Russell of CERN in 1971. Written in Fortran IV, it is similar to PL360 and is cross-compiled on other machines. PL-11 was originally developed as part of the Omega project, a particle physics facility operational at CERN (Geneva, Switzerland) during the 1970s. The first version was written for the CII 10070, a clone of the XDS Sigma 7 built in France. Towards the end of the 1970s it was ported to the IBM 370/168, then part of CERN's computer centre. A report describing the language is available from CERN.
PL/C (pl, appeared 1973)
Origin: Cornell University
Country: United States


PL/C is a computer programming language developed at Cornell University with the specific goal of being used for teaching programming.  It is based on  IBM's PL/I language, and was designed in the early 1970s.  Cornell also developed a compiler for the language that was based on its earlier CUPL compiler, and it was widely used in college-level programming courses.  The two researchers and academic teachers who designed PL/C were Richard W. Conway and Thomas R. Wilcox. They submitted the famous article "Design and implementation of a diagnostic compiler for PL/I" published in the Communications of ACM in March 1973, pages 169-179.   PL/C eliminated some of the more complex features of PL/I, and added extensive debugging and error recovery facilities. PL/C is a subset of PL/I.   A program that runs without error under the PL/C compiler should run under PL/I and produce the  same results, unless certain incompatible diagnostic features, such as a  macro section (begun by a $MACRO statement and finished by a $MEND statement), were used.The PL/C compiler had the unusual capability of never failing to compile any program, through the use of extensive automatic correction of many syntax errors and by converting any remaining syntax errors to output statements.
PL/I (pl, appeared 1964)
Stands for: Programming Language One
Origin: IBM


PL/I (Programming Language One, pronounced ) is a procedural, imperative computer programming language designed for scientific, engineering, business and system programming uses. It has been used by various academic, commercial and industrial organizations since it was introduced in the 1960s, and continues to be actively used. PL/I's main domains are data processing, numerical computation, scientific computing, and system programming; it supports recursion, structured programming, linked data structure handling, fixed-point, floating-point, complex, character string handling, and bit string handling. The language syntax is English-like and suited for describing complex data formats, with a wide set of functions available to verify and manipulate them.
PL/M (pl, appeared 1973)
Stands for: Programming Language for Microcomputers
Origin: Microcomputer Applications Associates
Country: United States


The PL/M programming language  (an acronym of Programming Language for Microcomputers) is a high-level language conceived and developed by  Gary Kildall in 1973  for Hank Smith at Intel for its microprocessors. The language incorporated ideas from PL/I, ALGOL and XPL, and had an integrated macro processor. Unlike other contemporary languages such as Pascal, C or BASIC, PL/M had no standard input or output routines.  It included features targeted at the low-level hardware specific to the target microprocessors, and as such, it could support direct access to any location in memory, I/O ports and the processor interrupt flags in a very efficient manner. PL/M was the first higher level programming language for microprocessor-based computers and was the original implementation language for the CP/M operating system. Many Intel and Zilog Z80 based embedded systems were programmed in PL/M during the 1970s and 1980s. For instance, the firmware of the Service Processor component of CISC AS/400 was written in PL/M. The original PL/M compiler targeted the Intel 8008. An updated version generated code for the 8080 processor, which would also run on the newer Intel 8085 as well as on the Zilog Z80 family (as it is backward-compatible with the 8080). Later followed compilers for the Intel 8048 and Intel 8051-microcontroller family as well as for the 8086 (8088), 80186 (80188) and subsequent 8086-based processors, including the advanced 80286 and the 32-bit 80386. There were also PL/M compilers developed for later microcontrollers, such as the Intel 8061 and 8096 / MCS-96 architecture family.  While some PL/M compilers were "native", meaning that they ran on systems using that same microprocessor, e.g. for the Intel ISIS operating system, there were also "cross compilers", for instance PLMX, which ran on other operating environments such as CP/M, Microsoft's DOS, and Digital Equipment Corporation's VAX/VMS. PL/M is no longer supported by Intel, but aftermarket tools like PL/M-to-C translators exist (for examples, see External links, below).
PL/P (pl, appeared 1978)
Origin: Prime Computer, Inc
Country: United States


The PL/P programming language (an acronym of Programming Language for Prime (computers)) is a mid-level programming language developed by Prime Computer to serve as their second primary system programming language after Fortran IV.  PL/P was a subset of PL/I. Additions to the PRIMOS operating system for Prime 50 Series computers were written mostly in PL/P in later years.  Certain PRIMOS modules written in Fortran IV during PRIMOS's early years were rewritten in PL/P.  PL/P was the most widespread compiled programming language used for commercial PRIMOS applications, outpacing the use of the Prime C compiler, the CPL (PRIMOS) scripting language, and the Fortran IV compiler in commercial applications.
PL/SQL (pl, appeared 1991)
Also known as: PLSQL
Origin: Oracle
Country: United States


PL/SQL (Procedural Language/Structured Query Language) is Oracle Corporation's procedural extension for SQL and the Oracle relational database. PL/SQL is available in Oracle Database (since version 6 - stored pl/sql procedures/functions/packages/triggers since version 7), TimesTen in-memory database (since version 11.2.1), and IBM DB2 (since version 9.7). Oracle Corporation usually extends PL/SQL functionality with each successive release of the Oracle Database. PL/SQL includes procedural language elements such as conditions and loops. It allows declaration of constants and variables, procedures and functions, types and variables of those types, and triggers. It can handle exceptions (runtime errors). Arrays are supported involving the use of PL/SQL collections. Implementations from version 8 of Oracle Database onwards have included features associated with object-orientation. One can create PL/SQL units such as procedures, functions, packages, types, and triggers, which are stored in the database for reuse by applications that use any of the Oracle Database programmatic interfaces.
PL-X (pl, appeared 1994)
Origin: IBM
Country: United States

IBM internal systems programming language (Programming Language/Cross Systems). There has been a progression from the original PL/S to the current PL/X. The language looks like and was originally based on PL/1 but it has picked up modern features along the way as well as features specifically for writing system software. AFAIK code exists written in all of the PL/* dialects and that the current PL/X compiler can handle all of them. Mark knows a lot better and may feel like commenting.
PL360 (pl, appeared 1967)
Creators: Niklaus Wirth
Origin: Stanford University
Country: United States


PL360 (or PL/360) is a programming language designed by Niklaus Wirth and written by Niklaus Wirth, Joseph  W.  Wells, Jr., and Edwin Satterthwaite, Jr. for the IBM System/360 computer at Stanford University. A description of PL360 was published in early 1968, although the implementation was probably completed before Wirth left Stanford in 1967.
Planguage (dataNotation, appeared 2001)
Origin: Gilb International
Country: Norway
Website: http://www.syque.com/quality_tools/tools/Tools104.htm

Planguage is a keyword-driven language whose name is derived from a contraction of the words planning and language1. Planguage can be used in requirements specifications, design documents, plans, and other places where qualitative statements are common. Its primary benefits are quantifying the qualitative and improving communication about complex ideas



PLAN [01-Sep 2012]: Full product release
GIST : Develop XYZ product ready for product release
STAKEHOLDER [planning, final signoff]: Product Quality Manager
AUTHORITY [final signoff]: Marketing Manager
METER [Product]: Signed off acceptance by <those with final signoff>
MUST [01-Sep 2012]: Partial product release
WISH [01-Aug 2012]: Full product release
Plankalkul (pl, appeared 1948)
Creators: Konrad Zuse
Origin: Zuse-Ingenieurbüro Hopferau
Country: Germany


Plankalkül (German pronunciation: [ˈplaːnkalkyːl], "Plan Calculus") is a programming language designed for engineering purposes by Konrad Zuse between 1942 and 1945. It was the first high-level (non-von Neumann) programming language to be designed for a computer. "Kalkül" means formal system – the Hilbert-style deduction system is for example originally called "Hilbert-Kalkül", so Plankalkül means "formal system for planning".
PLANNER (pl, appeared 1969)
Creators: Carl Hewitt
Origin: Massachusetts Institute of Technology
Country: United States


Planner (often seen in publications as "PLANNER" although it is not an acronym) is a programming language designed by Carl Hewitt at MIT, and first published in 1969. First, subsets such as Micro-Planner and Pico-Planner were implemented, and then essentially the whole language was implemented as Popler by Julian Davies at the University of Edinburgh in the POP-2 programming language. Derivations such as QA4, Conniver, QLISP and Ether (see Scientific Community Metaphor) were important tools in Artificial Intelligence research in the 1970s, which influenced commercial developments such as KEE and ART.
plasma (pl, appeared 2015)
Origin: https://github.com/PlasmaLang
Country: Australia
Website: http://plasmalang.org/

<a href='http://plasmalang.org/'>Plasma</a>, which aims to strike a balance between functional and imperative programming, include state-of-the-art concurrent programming features and feature <a href='http://plasmalang.org/about.html#goal-conc-and-par'> automatic parallelisation</a>. Boney previously worked on <a href='http://mercurylang.org/'>Mercury</a> a logic language.</dd>