pldb/PLDB huggingface dataset:
Hopscotch (pl, appeared 2016)
Origin: Hopscotch Technologies
Country: United States


Hopscotch is a visual programming language developed by Hopscotch Technologies, designed to allow young or beginner programmers to develop simple projects. Its simple UI allows its users to drag and drop blocks to create scripts of which can be played when activated. Although the language is easy to use, to develop more advanced pieces of code is almost impossible and requires more powerful languages. The use of the language is through an iPad or iPhone supporting Hopscotch.
Hotdog (pl, appeared 2001)
Origin: Sausage Software
Country: New Zealand


HotDog is an HTML editor developed by Sausage Software in the mid-1990s. At the time of its development, there were only a small number of HTML editors available on the market (such as HoTMetaL) and HotDog gathered significant interest due to its ease of use. The program was developed by the New Zealand Internet entrepreneur Steve Outtrim. In 2000, the ownership of the product was sold from Sausage Software and, despite still being called Sausage Software, is now run by a company unrelated to the Outtrim-founded Sausage Software.
HP BASIC for OpenVMS (pl, appeared 1982)
Origin: Digital Equipment Corporation
Country: United States


HP BASIC for OpenVMS is the latest name for a dialect of the BASIC programming language created by Digital Equipment Corporation (DEC) and now owned by Hewlett-Packard Enterprise (HPE).  It was originally developed in the 1970s for the RSTS-11 operating system on the PDP-11 minicomputer.  It was later ported to OpenVMS, first on VAX, then Alpha, and most recently Integrity. Past names for the product include: BASIC-PLUS, Basic Plus 2 (BP2 or BASIC-Plus-2), VAX BASIC, DEC BASIC, and Compaq BASIC for OpenVMS.  Multiple variations of the titles noting the hardware platform (VAX, AlphaServer, etc.) also exist.
HP-GL (pl, appeared 1986)
Origin: Hewlett-Packard
Country: United States


HP-GL, short for Hewlett-Packard Graphics Language and often written as HPGL, is a printer control language created by Hewlett-Packard (HP). HP-GL was the primary printer control language used by HP plotters. It later became a standard for almost all plotters. Hewlett-Packard's printers also usually support HP-GL/2 in addition to PCL.
Hspec (pl, appeared 1990)
Origin: https://github.com/hspec
Country: Various
Website: https://hspec.github.io/

Hspec is a testing framework for Haskell.



-- file Spec.hs
import Test.Hspec
import Test.QuickCheck
import Control.Exception (evaluate)

main :: IO ()
main = hspec $ do
  describe "Prelude.head" $ do
    it "returns the first element of a list" $ do
      head [23 ..] `shouldBe` (23 :: Int)

    it "returns the first element of an *arbitrary* list" $
      property $ \x xs -> head (x:xs) == (x :: Int)

    it "throws an exception if used with an empty list" $ do
      evaluate (head []) `shouldThrow` anyException
HTML (textMarkup, appeared 1991)
Creators: Tim Berners-Lee
Origin: Conseil Européen pour la Recherche Nucléaire
Country: Switzerland


Hypertext Markup Language (HTML) is the standard markup language for creating web pages and web applications. With Cascading Style Sheets (CSS) and JavaScript it forms a triad of cornerstone technologies for the World Wide Web. Web browsers receive HTML documents from a web server or from local storage and render them into multimedia web pages. HTML describes the structure of a web page semantically and originally included cues for the appearance of the document. HTML elements are the building blocks of HTML pages. With HTML constructs, images and other objects, such as interactive forms, may be embedded into the rendered page. It provides a means to create structured documents by denoting structural semantics for text such as headings, paragraphs, lists, links, quotes and other items. HTML elements are delineated by tags, written using angle brackets. Tags such as <img /> and <input /> introduce content into the page directly. Others such as <p>...</p> surround and provide information about document text and may include other tags as sub-elements. Browsers do not display the HTML tags, but use them to interpret the content of the page. HTML can embed programs written in a scripting language such as JavaScript which affect the behavior and content of web pages. Inclusion of CSS defines the look and layout of content. The World Wide Web Consortium (W3C), maintainer of both the HTML and the CSS standards, has encouraged the use of CSS over explicit presentational HTML since 1997.
htmx (template, appeared 2020)
Origin: https://github.com/bigskysoftware/
Country: United States
Website: https://htmx.org/

htmx gives you access to AJAX, CSS Transitions, WebSockets and Server Sent Events directly in HTML, using attributes, so you can build modern user interfaces with the simplicity and power of hypertext


GitHub description: </> htmx - high power tools for HTML

<script src="https://unpkg.com/htmx.org@1.7.0"></script>
<!-- have a button POST a click via AJAX -->
<button hx-post="/clicked" hx-swap="outerHTML">
  Click Me
</button>
HTTP/2 (protocol, appeared 2015)
Origin: Google
Mozilla
Country: United States


HTTP/2 (originally named HTTP/2.0) is a major revision of the HTTP network protocol used by the World Wide Web. It was derived from the earlier experimental SPDY protocol, originally developed by Google. HTTP/2 was developed by the Hypertext Transfer Protocol working group httpbis (where bis means "second") of the Internet Engineering Task Force. HTTP/2 is the first new version of HTTP since HTTP 1.1, which was standardized in RFC 2068 in 1997. The Working Group presented HTTP/2 to IESG for consideration as a Proposed Standard in December 2014, and IESG approved it to publish as Proposed Standard on February 17, 2015. The HTTP/2 specification was published as RFC 7540 in May 2015.The standardization effort was supported by Chrome, Opera, Firefox, Internet Explorer 11, Safari, Amazon Silk, and Edge browsers. Most major browsers had added HTTP/2 support by the end of 2015.According to W3Techs, as of  February 2019, 33.1% of the top 10 million websites supported HTTP/2.HTTP/3 is the proposed successor (Internet Draft) to HTTP/2, that builds on it.
HTTP/3 (protocol, appeared 2018)
Origin: Akamai
Country: United States


HTTP/3 is the upcoming third major version of the Hypertext Transfer Protocol used to exchange binary information on the World Wide Web. HTTP/3 is based on previous RFC draft "Hypertext Transfer Protocol (HTTP) over QUIC". QUIC is an experimental transport layer network protocol initially developed by Google. On 28 October 2018 in a mailing list discussion, Mark Nottingham, Chair of the IETF HTTP and QUIC Working Groups, made the official request to rename HTTP-over-QUIC as HTTP/3 to "clearly identify it as another binding of HTTP semantics to the wire protocol ... so people understand its separation from QUIC" and pass its development from the QUIC Working Group to the HTTP Working Group after finalizing and publishing the draft. In the subsequent discussions that followed and stretched over several days, Nottingham's proposal was accepted by fellow IETF members, who in November 2018 gave their official seal of approval that HTTP-over-QUIC become HTTP/3.
HTTP (protocol, appeared 1989)
Origin: The World Wide Web Consortium
Country: United States


The Hypertext Transfer Protocol (HTTP) is an application protocol for distributed, collaborative, and hypermedia information systems. HTTP is the foundation of data communication for the World Wide Web. Hypertext is structured text that uses logical links (hyperlinks) between nodes containing text. HTTP is the protocol to exchange or transfer hypertext. Development of HTTP was initiated by Tim Berners-Lee at CERN in 1989. Standards development of HTTP was coordinated by the Internet Engineering Task Force (IETF) and the World Wide Web Consortium (W3C), culminating in the publication of a series of Requests for Comments (RFCs). The first definition of HTTP/1.1, the version of HTTP in common use, occurred in RFC 2068 in 1997, although this was obsoleted by RFC 2616 in 1999 and then again by the RFC 7230 family of RFCs in 2014. A later version, the successor HTTP/2, was standardized in 2015, and is now supported by major web servers and browsers over TLS using ALPN extension where TLS 1.2 or newer is required.
Hummingbird QuickScript (pl, appeared 1990)
Origin: Hummingbird Ltd
Country: Canada


Hummingbird Ltd. (previously NASDAQ: HUMC, TSX: HUM) is a subsidiary of OpenText and is a provider of enterprise software solutions including Exceed.  Initially founded as a consulting business in 1984, Hummingbird moved into the connectivity market. Its enterprise content management (ECM) solutions focuses on the management of the life cycle of enterprise content. Hummingbird has 40 offices worldwide. Customers include IBM, NASA, Morgan Stanley, Boeing, The Walt Disney Company, and The Government of Canada.
hurl (application, appeared 2020)
Stands for: The name Hurl is a tribute to the awesome curl, with a focus on the HTTP protocol.
Creators: Orange S.A
Origin: https://github.com/Orange-OpenSource
Country: France
Website: https://hurl.dev/

Hurl is a command line tool that runs HTTP requests defined in a simple plain text format. It can perform requests, capture values and evaluate queries on headers and body response. Hurl is very versatile: it can be used for both fetching data and testing HTTP sessions


GitHub description: Hurl, run and test HTTP requests with plain text.
HXML (application, appeared 2009)
Origin: Haxe Foundation
Country: Unknown

Haxe compiler arguments can be stored in a .hxml file and can be executed with haxe <file.hxml>. In hxml it is possible to use newlines and comments which makes it easier to maintain Haxe build configurations. It is possible to supply more arguments after the hxml file, e.g. haxe build.hxml -debug.



-cp src
-dce full

--each

-js bin/homepage.js
-main website.HomePage

--next  

-js bin/gallery.js
-main website.GalleryPage

--next  

-js bin/contact.js
-main website.ContactPage
Hy (pl, appeared 2013)
Creators: Paul Tagliamonte
Origin: https://github.com/hylang
Country: Various
Website: http://hylang.org/

A dialect of Lisp that's embedded in Python

Hy (alternately, Hylang) is a programming language, a dialect of the language Lisp designed to interact with the language Python by translating expressions into Python's abstract syntax tree (AST). Hy was introduced at Python Conference (PyCon) 2013 by Paul Tagliamonte.Similar to Kawa's and Clojure's mapping of s-expressions onto the Java virtual machine (JVM), Hy is meant to operate as a transparent Lisp front end to Python's abstract syntax. Lisp allows operating on code as data (metaprogramming). Thus, Hy can be used to write domain-specific languages. Hy also allows Python libraries, including the standard library, to be imported and accessed alongside Hy code with a compiling step converting the data structure of both into Python's AST.

GitHub description: A dialect of Lisp that's embedded in Python

(+ "Hyllo " "World" "!")
HyperCard (pl, appeared 1987)
Origin: Apple
Country: United States


HyperCard was a piece of application software and a programming tool for Apple Macintosh and Apple IIGS computers. It was among the first successful hypermedia systems before the World Wide Web. HyperCard combined a flat-file database with a graphical, flexible, user-modifiable interface. HyperCard also included a built-in programming language called HyperTalk for manipulating data and the user interface. This combination of features – a database with simple form layout, flexible support for graphics, and ease of programming – led many people to use HyperCard for many different projects. Some people used HyperCard as a programming tool for rapid application development of applications and databases, others for building interactive applications with no database requirements, command and control systems, and many examples in the demoscene. HyperCard was originally released in 1987 for $49.95 and was included for free with all new Macs sold then. It was withdrawn from sale in March 2004 after its final update in 1998. HyperCard ran in the Classic Environment, but was not ported to Mac OS X.
Hyperscript (pl, appeared 2020)
Also known as: _hyperscript
Origin: https://github.com/bigskysoftware
Country: United States
Website: https://hyperscript.org/

_hyperscript is a small, open scripting language inspired by hypertalk


GitHub description: a small scripting language for the web

<script src="https://unpkg.com/hyperscript.org@0.9.5"></script>


<button _="on click toggle .clicked">
  Toggle the "clicked" class on me
</button>


<div hs="on mouseOver toggle mouse-over on #foo">
</div>

<div data-hs="on click call aJavascriptFunction() then
              wait 10s then
              call anotherJavascriptFunction()">
           Do some stuff
</div>
Hyperscript (template, appeared 2012)
Creators: Dominic Tarr
Origin: https://github.com/hyperhype
Country: United States



GitHub description: Create HyperText with JavaScript.

var h = require('hyperscript')
h('div#page',
  h('div#header',
    h('h1.classy', 'h', { style: {'background-color': '#22f'} })),
  h('div#menu', { style: {'background-color': '#2f2'} },
    h('ul',
      h('li', 'one'),
      h('li', 'two'),
      h('li', 'three'))),
    h('h2', 'content title',  { style: {'background-color': '#f22'} }),
    h('p',
      "so it's just like a templating engine,\n",
      "but easy to use inline with javascript\n"),
    h('p',
      "the intention is for this to be used to create\n",
      "reusable, interactive html widgets. "))
HyperTalk (pl, appeared 1987)
Creators: Dan Winkler
Origin: Apple
Country: United States


HyperTalk is a high-level, procedural programming language created in 1987 by Dan Winkler and used in conjunction with Apple Computer's HyperCard hypermedia program by Bill Atkinson. The main target audience of HyperTalk was beginning programmers, hence HyperTalk programmers were usually called authors, and the process of writing programs was called "scripting". HyperTalk scripts are fairly similar to written English, and use a logic structure similar to that of the Pascal programming language. It supports the basic control structures of procedural languages: repeat for/while/until, if/then/else, as well as function and message "handler" calls (a handler is a subroutine, a message handler is a procedure). Data types are transparent to the user, conversion happens transparently in the background between strings and numbers. There are no classes or data structures in the traditional sense; their place was taken by special string literals, or rather "lists" of "items" delimited by commas (in later versions the "itemDelimiter" property allowed choosing an arbitrary character). In the late 1980s Apple considered using HyperCard's HyperTalk scripting language as the standard language across the company and within its classic Mac OS operating system, and for interprocess communication between Apple and non-Apple products. The company did not oppose the development of imitations like SuperCard, and created a HyperTalk Standards Committee to avoid incompatibility between language variants. The case-insensitive language was interpreted at first, but gained just-in-time compilation with HyperCard 2.0.
HyPhy (pl, appeared 2008)
Origin: University of California San Diego
North Carolina State University
Country: United States
Website: http://hyphy.org/w/index.php/HyPhy_Batch_Language



GitHub description: HyPhy: Hypothesis testing using Phylogenies

#profile START;s = 0;m = {5,1};for (k=0; k<250000; k=k+1){	s = s + k;	t = Random (0,5);	m [t] = m [t] + 1;}#profile PAUSE;s2 = 0;for (k=1; k<10000; k=k+1){	s2 = s2+1/k;}#profile _hyphy_profile_dump;stats  			= _hyphy_profile_dump["STATS"];_profile_summer	= {1,Rows(stats)};_profile_summer = _profile_summer["1"] * stats;_instructions   = _hyphy_profile_dump["INSTRUCTION"];_indices	    = _hyphy_profile_dump["INSTRUCTION INDEX"];fprintf (stdout, "\nTotal run time (seconds)      : ", Format(_profile_summer[1]/1000000,15,6),				 "\nTotal number of steps         : ", Format(_profile_summer[0],15,0), "\n\n");				 for (k=0; k<Columns(_instructions); k=k+1){	fprintf (stdout, Format (_indices[k],6,0), " : ", _instructions[k], "\n\tCall count: ", stats[k][0], 												   "\n\tTime (seconds): ", stats[k][1]/1000000, "\n");}
HyTime (pl, appeared 1991)
Origin: International Organization for Standardization
International Electrotechnical Commission
Country: Switzerland and United Kingdom


HyTime (Hypermedia/Time-based Structuring Language) is a markup language that is an application of SGML. HyTime defines a set of hypertext-oriented element types that, in effect, supplement SGML and allow SGML document authors to build hypertext and multimedia presentations in a standardized way. HyTime is an international standard published by the ISO and IEC. The first edition was published in 1992, and the second edition was published in 1997.
I-expressions (dataNotation, appeared 2003)
Creators: Egil Möller
Origin: https://srfi.schemers.org
Country: Sweden

This SRFI descibes a new syntax for Scheme, called I-expressions, whith equal descriptive power as S-expressions. The syntax uses indentation to group expressions, and has no special cases for semantic constructs of the language. It can be used both for program and data input.



define
  fac x
  if
   = x 0
   1
   * x
     fac
      - x 1
 let
  group
   foo
    + 1 2
   bar
    + 3 4
  + foo bar
IA-32 (isa, appeared 1985)
Origin: Intel Corporation
Country: United States


IA-32 (short for "Intel Architecture, 32-bit", sometimes also called i386) is the 32-bit version of the x86 instruction set architecture, first implemented in the Intel 80386 microprocessors in 1985. IA-32 is the first incarnation of x86 that supports 32-bit computing; as a result, the "IA-32" term may be used as a metonym to refer to all x86 versions that support 32-bit computing. The IA-32 instruction set was introduced in the Intel 80386 microprocessor in 1985 and, as of 2017, remains supported by contemporary PC microprocessors. Even though the instruction set has remained intact, the successive generations of microprocessors that run it have become much faster. Within various programming language directives, IA-32 is still sometimes referred to as the "i386" architecture. Intel is the inventor and the biggest supplier of IA-32 processors, and the second biggest supplier is AMD. For a while, VIA, Transmeta and others also produced IA-32 processors, but since the 2000s all manufacturers moved to the 64-bit variant of x86, x86-64.
IBM 1401 Symbolic Programming System (compiler, appeared 1959)
Origin: IBM
Country: United States


The IBM 1401 Symbolic Programming System (SPS) was an assembler that was developed by Gary Mokotoff, IBM Applied Programming Department, for the IBM 1401 computer, the first of the IBM 1400 series.  One source indicates that "This programming system was announced by IBM with the machine."SPS-1 could run on a low-end machine with 1.4K memory, SPS-2 required at least 4K memory.  SPS-1 punched one card for each input instruction in its first pass and this deck had to be read during pass 2. At the University of Chicago and many other locations, SPS-1 was replaced by assemblers taking advantage of the commonly available 4K memory configuration to pack the output of pass one into several instructions per card.  Other assemblers were written which placed the pass one output into memory for small programs.As the 1400 series matured additional assemblers, programming languages and report generators became available, replacing SPS in most sites.
IBM BASIC (pl, appeared 1981)
Origin: IBM
Country: United States


The IBM Personal Computer Basic, commonly shortened to IBM BASIC, is a programming language first released by IBM with the IBM Personal Computer (model 5150) in 1981. IBM released four different versions of the Microsoft BASIC interpreter, licensed from Microsoft for the PC and PCjr. They are known as Cassette BASIC, Disk BASIC, Advanced BASIC (BASICA), and Cartridge BASIC. Versions of Disk BASIC and Advanced BASIC were included with IBM PC DOS up to PC DOS 4. In addition to the features of an ANSI standard BASIC, the IBM versions offered support for the graphics and sound hardware of the IBM PC line. Source code could be typed in with a full screen editor, and very limited facilities were provided for rudimentary program debugging. IBM also released a version of the Microsoft BASIC compiler for the PC, concurrently with the release of PC DOS 1.10 in 1982.
IBM BASICA (pl, appeared 1981)
Origin: IBM
Country: United States


The IBM Personal Computer Basic, commonly shortened to IBM BASIC, is a programming language first released by IBM with the IBM Personal Computer (model 5150) in 1981. IBM released four different versions of the Microsoft BASIC interpreter, licensed from Microsoft for the PC and PCjr. They are known as Cassette BASIC, Disk BASIC, Advanced BASIC (BASICA), and Cartridge BASIC. Versions of Disk BASIC and Advanced BASIC were included with IBM PC DOS up to PC DOS 4. In addition to the features of an ANSI standard BASIC, the IBM versions offered support for the graphics and sound hardware of the IBM PC line. Source code could be typed in with a full screen editor, and very limited facilities were provided for rudimentary program debugging. IBM also released a version of the Microsoft BASIC compiler for the PC, concurrently with the release of PC DOS 1.10 in 1982.
GML (xmlFormat, appeared 1969)
Stands for: IBM Generalised Markup Language
Creators: Charles Goldfarb
Edward Mosher
Raymond Lorie
Origin: IBM
Country: United States


Generalized Markup Language (GML) is a set of macros that implement intent-based (procedural) markup tags for the IBM text formatter, SCRIPT.  SCRIPT/VS is the main component of IBM's Document Composition Facility (DCF). A starter set of tags in GML is provided with the DCF product.
IBM i Control Language (pl, appeared 1993)
Origin: IBM


The IBM i Control Language (CL) is a scripting language for the IBM's IBM i platform (previously called OS/400 when running on AS/400 systems) bearing a resemblance to the IBM Job Control Language and consisting of an ever-expanding set of command objects (*CMD) used to invoke traditional AS/400 programs and/or get help on what those programs do. CL can also be used to create CL programs (congruent to shell scripts) where there are additional commands that provide program-like functionality (IF/ELSE, variable declaration, file input, etc.) Although CL is a scripting language for system administration, it is used mainly to create compiled programs. The use of interpreted CL scripts through the SBMDBJOB command  is in fact extremely limited. While thousands of commands were written by IBM developers to perform system level tasks like compiling programs, backing up data, changing system configurations, displaying system object details, or deleting them, commands are not limited to systems level concerns and can be drafted for user applications as well.
RPG (pl, appeared 1959)
Stands for: Report Program Generator
Origin: IBM


RPG is a high-level programming language (HLL) for business applications. RPG is an IBM proprietary programming language and its later versions are available only on IBM i- or OS/400-based systems. It has a long history, having been developed by IBM in 1959 as the Report Program Generator - a tool to replicate punched card processing on the IBM 1401 then updated to RPG II for the IBM System/3 in the late 1960s, and since evolved into an HLL equivalent to COBOL and PL/I. It remains a popular programming language on the IBM i operating system, which runs on IBM Power i platform hardware. The current version, RPG IV (a.k.a. ILE RPG), provides a modern programming environment.