pldb/PLDB huggingface dataset:
PowerPC (isa, appeared 1992)
Origin: Apple
IBM
Motorola


PowerPC (a backronym for Performance Optimization With Enhanced RISC – Performance Computing, sometimes abbreviated as PPC) is a reduced instruction set computer instruction set architecture created by the 1991 Apple–IBM–Motorola alliance, known as AIM. PowerPC, as an evolving instruction set, has since 2006 been named Power ISA, while the old name lives on as a trademark for some implementations of Power Architecture-based processors. PowerPC was the cornerstone of AIM's PReP and Common Hardware Reference Platform initiatives in the 1990s. Originally intended for personal computers, the architecture is well known for being used by Apple's Power Macintosh, PowerBook, iMac, iBook, and Xserve lines from 1994 until 2006, when Apple migrated to Intel's x86. It has since become niche in personal computers, but remain popular as embedded and high-performance processors. Its use in video game consoles and embedded applications provided an array of uses. In addition, PowerPC CPUs are still used in AmigaOne and third party AmigaOS 4 personal computers. PowerPC is largely based on IBM's earlier POWER instruction set architecture, and retains a high level of compatibility with it; the architectures have remained close enough that the same programs and operating systems will run on both if some care is taken in preparation; newer chips in the POWER series use the Power ISA.
PowerShell (pl, appeared 2006)
Creators: Jeffrey Snover
Origin: Microsoft
Website: http://microsoft.com/powershell
Keywords: begin
break
catch
class
continue
data
define
do
dynamicparam
else
elseif
end
exit
filter
finally
for
foreach
from
function
if
in
param
process
return
switch
throw
trap
try
until
using
var
while
workflow
parallel
sequence
inlinescript
configuration


PowerShell is a task automation and configuration management framework from Microsoft, consisting of a command-line shell and associated scripting language. Initially a Windows component only, known as Windows PowerShell, it was made open-source and cross-platform on 18 August 2016 with the introduction of PowerShell Core. The former is built on .NET Framework while the latter on .NET Core. In PowerShell, administrative tasks are generally performed by cmdlets (pronounced command-lets), which are specialized .NET classes implementing a particular operation. These work by accessing data in different data stores, like the file system or registry, which are made available to PowerShell via providers. Third-party developers can develop their own cmdlets and add them to PowerShell. Sets of cmdlets may be combined into scripts. PowerShell provides full access to COM and WMI, enabling administrators to perform administrative tasks on both local and remote Windows systems as well as WS-Management and CIM enabling management of remote Linux systems and network devices. PowerShell also provides a hosting API with which the PowerShell runtime can be embedded inside other applications. These applications can then use PowerShell functionality to implement certain operations, including those exposed via the graphical interface. This capability has been used by Microsoft Exchange Server 2007 to expose its management functionality as PowerShell cmdlets and providers and implement the graphical management tools as PowerShell hosts which invoke the necessary cmdlets. Other Microsoft applications including Microsoft SQL Server 2008 also expose their management interface via PowerShell cmdlets. PowerShell includes its own extensive, console-based help (similar to man pages in Unix shells) accessible via the Get-Help cmdlet. Local help contents can be retrieved from the Internet via Update-Help cmdlet. Alternatively, help from the web can be acquired on a case-by-case basis via the -online switch to Get-Help.
ppm-format (textDataFormat, appeared 1988)
Origin: https://netpbm.sourceforge.net/index.html#support
Country: United States

The PPM format is a lowest common denominator color image file format. It should be noted that this format is egregiously inefficient. It is highly redundant, while containing a lot of information that the human eye can't even discern. Furthermore, the format allows very little information about the image besides basic color, which means you may have to couple a file in this format with other independent information to get any decent use out of it. However, it is very easy to write and analyze programs to process this format, and that is the point.



P3
# feep.ppm
4 4
15
 0  0  0    0  0  0    0  0  0   15  0 15
 0  0  0    0 15  7    0  0  0    0  0  0
 0  0  0    0  0  0    0 15  7    0  0  0
15  0 15    0  0  0    0  0  0    0  0  0
Praat Script (pl, appeared 1997)
Origin: Universiteit van Amsterdam
Country: The Netherlands
Website: https://www.fon.hum.uva.nl/praat/manual/Praat_script.html

The language is bundled with Praat, a speech analysis tool, to execute menu and action commands.


GitHub description: Praat: Doing Phonetics By Computer

clearinfo
# print fizzbuzz result
procedure fizzbuzz: .i
	if .i mod 15 == 0
		appendInfoLine: "fizzbuzz"
	elsif .i mod 3 == 0
		appendInfoLine: "fizz"
	elsif .i mod 5 == 0
		appendInfoLine: "buzz"
	else
		appendInfoLine: .i
	endif
endproc

for i from 1 to 100
	@fizzbuzz: i
endfor
praxis-lang (pl, appeared 2011)
Also known as: praxis
Creators: Richard Evans
Origin: Imperial College
Country: United Kingdom




insert data.scene_data.linus_wakes_up
 {
 noun!”Linus wakes up”
 set_location.jordan_fischer!anonymous_room
 set_location.linus_bergstrom!anonymous_room
 establish_relationship.linus_bergstrom.jordan_fischer!
friends!”{A}We get along really well”
 movement_restricted
 timeout_conclusion.null_scene!”The story has ended due
to inactivity.”!10000
 setup!stocker_for_linus_wakes_up
 }
Preferred Executable Format (pl, appeared 1994)
Origin: Apple
Country: United States


The Preferred Executable Format is a file format that specifies the format of executable files and other object code. PEF executables are also called Code Fragment Manager files (CFM). PEF was developed by Apple Computer for use in its classic Mac OS operating system. It was optimised for RISC processors. In macOS, the Mach-O file format is the native executable format. However, PEF is still supported on PowerPC-based Macintoshes running Mac OS X and is used by some Carbon applications ported from earlier versions for classic Mac OS, so that the same binary can be run on classic Mac OS and Mac OS X. BeOS on PowerPC systems also uses PEF, although x86 systems do not.
Prism (library, appeared 2012)
Creators: Lea Verou
Origin: https://github.com/PrismJS
Country: United States and Germany
Website: https://prismjs.com/

Prism is a lightweight, extensible syntax highlighter, built with modern web standards in mind. It’s used in millions of websites, including some of those you visit daily.


GitHub description: Lightweight, robust, elegant syntax highlighting.
Pro*C (pl, appeared 1996)
Origin: Oracle Corporation
Country: United States


Pro*C (also known as Pro*C/C++) is an embedded SQL programming language used by Oracle Database database management systems.  Pro*C uses either C or C++ as its host language.  During compilation, the embedded SQL statements are interpreted by a precompiler and replaced by C or C++ function calls to their respective SQL library.  The output from the Pro*C precompiler is standard C or C++ code that is then compiled by any one of several C or C++ compilers into an executable.
ProbeVue (pl, appeared 2008)
Origin: http://www.tablespace.net
Country: United States


ProbeVue is IBM's implementation of a lightweight dynamic tracing environment introduced in AIX version 6.1. ProbeVue provides the ability to probe running processes in order to provide statistical analysis as well as retrieve data from the probed process. The dynamic nature of ProbeVue allows it to be used as a global system performance tool while retaining the ability to drill into very specific events on a single process or thread. Because modifications are not required of a probed process or system and the lightweight design of ProbeVue as a tracing tool, it is suitable for use in a production environment where previous tracing tools would have been performance prohibitive.


@@syscall:*:read:entry
when ( __pid == 123456)
{
   /* This is a comment: The process with a PID of 123456 has called read(); */
   printf("read() system call entered.\n");
}
Processing (pl, appeared 2001)
Origin: Massachusetts Institute of Technology
Country: United States
Website: http://processing.org
File extensions: pde


Processing is an open source computer programming language and integrated development environment (IDE) built for the electronic arts, new media art, and visual design communities with the purpose of teaching the fundamentals of computer programming in a visual context, and to serve as the foundation for electronic sketchbooks. The project was initiated in 2001 by Casey Reas and Benjamin Fry, both formerly of the Aesthetics and Computation Group at the MIT Media Lab. In 2012, they started the Processing Foundation along with Daniel Shiffman, who joined as a third project lead. Johanna Hedva joined the Foundation in 2014 as Director of Advocacy. One of the aims of Processing is to allow non-programmers to start computer programming aided by visual feedback. The Processing language builds on the Java language, but uses a simplified syntax and a graphics user interface.
Processor Technology (pl, appeared 1975)
Origin: Processor Technology Corporation
Country: United States


Processor Technology Corporation was a personal computer company founded in April 1975 by Gary Ingram and Bob Marsh in Berkeley, California. Their first product was a 4K byte RAM board that was compatible with the MITS Altair 8800 computer but more reliable than the MITS board. This was followed by a series of memory and I/O boards including a video display module.Popular Electronics magazine wanted a feature article on an intelligent computer terminal and Technical Editor Les Solomon asked Marsh and Lee Felsenstein to design one. It was featured on the July 1976 cover and became the Sol-20 Personal Computer.  The first units were shipped in December 1976 and the Sol-20 was a very successful product. The company failed to develop next generation products and ceased operations in May 1979.
Prograph (pl, appeared 1983)
Origin: Acadia University
Country: Canada


Prograph is a visual, object-oriented, dataflow, multiparadigm programming language that uses iconic symbols to represent actions to be taken on data. Commercial Prograph software development environments such as Prograph Classic and Prograph CPX were available for the Apple Macintosh and Windows platforms for many years but were eventually withdrawn from the market in the late 1990s. Support for the Prograph language on macOS has recently reappeared with the release of the Marten software development environment.
PROIV (pl, appeared 1976)
Origin: McDonnell Information Systems
Country: United Kingdom


PROIV is a low code development platform, developed and sold by NorthgateArinso, part of the Northgate Information Solutions Group. It has an active community of around 2500 developers and end-users worldwide, ranging from consultants to large multinationals, finance institutions, tax authorities, retailers, engineering companies, media operators and software houses. PROIV's usual application domain is database-centric business applications. PROIV has some similarities to languages such as ABAP, FOCUS and RPG. PROIV programs consist of declarative/non-procedural specifications that control the overall structure of the program and database access and that have an implicit sequence of execution (which PROIV programmers refer to as the timing cycle).  Procedural subroutines can be added by the programmer; these are written in a 3GL-like language which PROIV calls "Logic". Note that in PROIV programs are referred to as "functions", which can be confusing as it differs from the more usual use of that term in programming languages.
Project Mentat (queryLanguage, appeared 2016)
Creators: Richard Newman
Origin: Mozilla Foundation
Country: United States
Website: https://mentat.rs/

Project Mentat is a persistent, embedded knowledge base. It draws heavily on DataScript and Datomic. This project was started by Mozilla, but is no longer being developed or actively maintained by them.


GitHub description: A persistent, relational store inspired by Datomic and DataScript.

{:db/id          :person/email
 :db/valueType   :db.type/string
 :db/cardinality :db.cardinality/many     ; People can have multiple email addresses.
 :db/unique      :db.unique/identity      ; For our purposes, each email identifies one person.
 :db/index       true}                    ; We want fast lookups by email.
{:db/id          :person/friend
 :db/valueType   :db.type/ref
 :db/cardinality :db.cardinality/many}    ; People can have many friends.
Prolog (pl, appeared 1972)
Creators: Alain Colmerauer
Origin: University of Edinburgh
Aix-Marseille University
Country: United Kingdom and France
File extensions: pl
pro
P


Prolog is a general-purpose logic programming language associated with artificial intelligence and computational linguistics. Prolog has its roots in first-order logic, a formal logic, and unlike many other programming languages, Prolog is intended as primarily a declarative programming language: the program logic is expressed in terms of relations, represented as facts and rules. A computation is initiated by running a query over these relations. The language was first conceived by a group around Alain Colmerauer in Marseille, France, in the early 1970s and the first Prolog system was developed in 1972 by Colmerauer with Philippe Roussel. Prolog was one of the first logic programming languages, and remains the most popular among such languages today, with several free and commercial implementations available. The language has been used for theorem proving, expert systems, term rewriting, type inference, and automated planning, as well as its original intended field of use, natural language processing. Modern Prolog environments support the creation of graphical user interfaces, as well as administrative and networked applications. Prolog is well-suited for specific tasks that benefit from rule-based logical queries such as searching databases, voice control systems, and filling templates.
PROMAL (pl, appeared 1986)
Origin: Systems Management Associates
Country: United States


PROMAL (PROgrammer's Microapplication Language) is a structured programming language from Systems Management Associates for MS-DOS, Commodore 64, and Apple II. PROMAL features simple syntax, no line numbers, long variable names, functions and procedures with argument passing, real number type, arrays, strings, pointer, and a built-in I/O library. Like ABC and Python, indentation is part of the language syntax. The language uses a single-pass compiler to generate byte code that is interpreted when the program is run. Since the memory is very limited on these early home computers, the compiler can compile to/from disk and memory. The software package for C64 includes a full-screen editor and command shell. See also [Computer Language, Mar 1986, pp. 128–134].
prompter (pl, appeared 2011)
Creators: Graham Nelson
Origin: Little Text People
Country: United Kingdom

“Blood and Laurels”, “Bramble House” and other Versu titles are instead written in a language called Prompter which compiles down to Praxis. Besides making it feasible to write large-scale narratives for Versu, Prompter has two other goals: to enable faster development, and to make Versu content more human-readable. Readability matters. It matters for all soware, in fact, but especially here. In Prompter, the basic unit for grouping code together is the “scene”.



A poor young straight Ancient Roman man. By reputation he is
attractive - “[He] is widely accounted tremendously handsome”,
intelligent - “[He] is known for his poetry, and cannot be
supposed a fool”, but not proper - “[His] misbehaviour, with
various ladies, is the talk of the town”. He is open,
unconscientious, extroverted and &irtatious. He is concerned
with attractiveness, intelligence and friendship
Property Specification Language (pl, appeared 2004)
Origin: Accellera Systems Initiative
Country: United States


Property Specification Language (PSL) is a temporal logic extending Linear temporal logic with a range of operators for both ease of expression and enhancement of expressive power. PSL makes an extensive use of regular expressions and syntactic sugaring. It is widely used in the hardware design and verification industry, where formal verification tools (such as model checking) and/or  logic simulation tools are used to prove or refute that a given PSL formula holds on a given design. PSL was initially developed by Accellera for specifying properties or assertions about hardware designs. Since September 2004 the standardization on the language has been done in IEEE 1850 working group. In September 2005, the IEEE 1850 Standard for Property Specification Language (PSL) was announced.
Protel (pl, appeared 1975)
Origin: Nortel Networks Corporation
Country: Canada


Protel stands for "Procedure Oriented Type Enforcing Language". It is a programming language created by Nortel Networks and used on telecommunications switching systems such as the DMS-100. Protel-2 is the object-oriented version of Protel.PROTEL languages were designed to meet the needs of digital telephony and is the basis of the DMS-100 line of switching systems  PROTEL is a strongly typed, block-structured language which is based heavily on PASCAL and ALGOL 68 with left-to-right style of variable assignment, variable-sized arrays, and extensible structures.  The designers of PROTEL significantly extended PASCAL of the day by adding external compilation and extending the data structures available in the language.
Proteus (pl, appeared 1998)
Origin: http://www.zanella-hifi.com/szp/bugrep.html
Country: Italy


Proteus (PROcessor for TExt Easy to USe) is a fully functional, procedural programming language created in 1998 by Simone Zanella. Proteus incorporates many functions derived from several other languages: C, BASIC, Assembly, Clipper/dBase;  it is especially versatile in dealing with strings, having hundreds of dedicated functions; this makes it one of the richest languages for text manipulation. Proteus owes its name to a Greek god of the sea (Proteus), who took care of Neptune's crowd and gave responses; he was renowned for being able to transform himself, assuming different shapes. Transforming data from one form to another is the main usage of this language.
protium (pl, appeared 2007)
Creators: Diarmuid Pigott
Origin: Strapper
Country: Australia
Website: http://www.protiumblue.com/




<@ DEFAREFLE>pleac</@>
<@ DEFFLELIT>pleac|C:\Documents and Settings\All Users\Documents\Projects\PLEAC\pleac_perl.data</@>
<@ ITEENUFLELIT>pleac|
<@ LETVARELTFLE>aLine|...</@>
<@ TSTRXPVARLIT>aLine|# \^\^PLEAC\^\^_(\d+\.\d+)</@>
<@ IFF><@ LETVARKEY>number|__Reg1</@>
<@ ACTSNKLIT>__Off</@>
<@ ACTSNKEMMLIT>pleac_perl_&number;.p</@>
</@>
<@ SAYVAR>aLine</@>
</@>
Protocol Buffers (idl, appeared 2008)
Origin: Google
Website: https://developers.google.com/protocol-buffers/
Keywords: syntax
import
weak
public
package
option
repeated
oneof
map
reserved
to
max
enum
message
service
rpc
stream
returns
package
optional
true
false


Protocol Buffers is a method of serializing structured data. It is useful in developing programs to communicate with each other over a wire or for storing data. The method involves an interface description language that describes the structure of some data and a program that generates source code from that description for generating or parsing a stream of bytes that represents the structured data. Google developed Protocol Buffers for use internally and has provided a code generator for multiple languages under an open source license (see below). The design goals for Protocol Buffers emphasized simplicity and performance. In particular, it was designed to be smaller and faster than XML. Protocol Buffers is widely used at Google for storing and interchanging all kinds of structured information. The method serves as a basis for a custom remote procedure call (RPC) system that is used for nearly all inter-machine communication at Google. Protocol Buffers are similar to the Apache Thrift (used by Facebook) or Microsoft Bond protocols, offering as well a concrete RPC protocol stack to use for defined services called gRPC. A software developer defines data structures (called messages) and services in a proto definition file (.proto) and compiles it with protoc. This compilation generates code that can be invoked by a sender or recipient of these data structures. For example, example.proto will produce example.pb.cc and example.pb.h, which will define C++ classes for each message and service that example.proto defines. Canonically, messages are serialized into a binary wire format which is compact, forward- and backward-compatible, but not self-describing (that is, there is no way to tell the names, meaning, or full datatypes of fields without an external specification). There is no defined way to include or refer to such an external specification (schema) within a Protocol Buffers file. The officially supported implementation includes an ASCII serialization format, but this format—though self-describing—loses the forward- and backward-compatibility behavior, and is thus not a good choice for applications other than debugging. Though the primary purpose of Protocol Buffers is to facilitate network communication, its simplicity and speed make Protocol Buffers an alternative to data-centric C++ classes and structs, especially where interoperability with other languages or systems might be needed in the future.


message Person {
  required string name = 1;
  required int32 id = 2;
  optional string email = 3;
}
ProvideX (pl, appeared 1992)
Creators: Michael F. King
Origin: Sage Software Canada
Country: Canada


ProvideX is a computer language and development environment derived from Business Basic (a business oriented derivative of BASIC) in the mid-1980s. ProvideX is available on several operating systems (Unix/Linux/Windows/Mac OS X) and includes not only the programming language but also file system, presentation layer interface, and other components.  The language is primarily designed for use in the development of business applications. Over the years since its inception and as the computer industry has changed, ProvideX has added functionality such as a graphical interface, client-server capabilities, access to external databases, web services, and, more recently, object-oriented programming capabilities. On October 8, 2010, PVX Plus Technologies announced that it has assumed all ongoing sales, development, and support of the ProvideX product line for Independent Software Vendors.  This brings the development of the language back under control of the original creator, Mike King and is the end result of almost 2 years of negotiations between Sage, EDIAS, and PVX Plus Technologies.