pldb/PLDB huggingface dataset:
HCL (dataNotation, appeared 2014)
Stands for: HashiCorp configuration language
Origin: HashiCorp
Keywords: var
local
path
for_each
any
string
number
bool
true
false
null
if
else
endif
for
in
endfor

HCL (HashiCorp Configuration Language) is a configuration language built by HashiCorp. The goal of HCL is to build a structured configuration language that is both human and machine friendly for use with command-line tools, but specifically targeted towards DevOps tools, servers, etc. HCL is also fully JSON compatible. That is, JSON can be used as completely valid input to a system expecting HCL. This helps makes systems interoperable with other systems. HCL is heavily inspired by libucl, nginx configuration, and others similar.


GitHub description: HCL is the HashiCorp configuration language.

variable "ami" {
   description = "the AMI to use"
}
<<FOO
hello
world
FOO
Hierarchical Data Format (binaryDataFormat, appeared 1992)
Stands for: Hierarchical Data Format
Origin: National Center for Supercomputing Applications
Country: United States
Website: https://support.hdfgroup.org/HDF5/
File extensions: hdf
h4
hdf4
he2
h5
hdf5
he5


Hierarchical Data Format (HDF) is a set of file formats (HDF4, HDF5) designed to store and organize large amounts of data. Originally developed at the National Center for Supercomputing Applications, it is supported by The HDF Group, a non-profit corporation whose mission is to ensure continued development of HDF5 technologies and the continued accessibility of data stored in HDF. In keeping with this goal, the HDF libraries and associated tools are available under a liberal, BSD-like license for general use. HDF is supported by many commercial and non-commercial software platforms, including Java, MATLAB, Scilab, Octave, Mathematica, IDL, Python, R, and Julia. The freely available HDF distribution consists of the library, command-line utilities, test suite source, Java interface, and the Java-based HDF Viewer (HDFView).The current version, HDF5, differs significantly in design and API from the major legacy version HDF4.
HDMI (standard, appeared 2002)
Origin: HDMI Founders
HDMI Forum
Country: United States


HDMI (High-Definition Multimedia Interface) is a proprietary audio/video interface for transmitting uncompressed video data and compressed or uncompressed digital audio data from an HDMI-compliant source device, such as a display controller, to a compatible computer monitor, video projector, digital television, or digital audio device. HDMI is a digital replacement for analog video standards. HDMI implements the EIA/CEA-861 standards, which define video formats and waveforms, transport of compressed and uncompressed LPCM audio, auxiliary data, and implementations of the VESA EDID. CEA-861 signals carried by HDMI are electrically compatible with the CEA-861 signals used by the digital visual interface (DVI). No signal conversion is necessary, nor is there a loss of video quality when a DVI-to-HDMI adapter is used. The CEC (Consumer Electronics Control) capability allows HDMI devices to control each other when necessary and allows the user to operate multiple devices with one handheld remote control device.Several versions of HDMI have been developed and deployed since initial release of the technology, but all use the same cable and connector. Other than improved audio and video capacity, performance, resolution and color spaces, newer versions have optional advanced features such as 3D, Ethernet data connection, and CEC (Consumer Electronics Control) extensions. Production of consumer HDMI products started in late 2003. In Europe either DVI-HDCP or HDMI is included in the HD ready in-store labeling specification for TV sets for HDTV, formulated by EICTA with SES Astra in 2005. HDMI began to appear on consumer HDTVs in 2004 and camcorders and digital still cameras in 2006. As of  January 6, 2015 (twelve years after the release of the first HDMI specification), over 4 billion HDMI devices have been sold.
Hedy (pl, appeared 2020)
Origin: https://github.com/hedyorg
Country: Netherlands
Website: https://www.hedy.org/

Hedy is a gradual programming language to teach children programming. Gradual languages use different language levels, where each level adds new concepts and syntactic complexity. At the end of the Hedy level sequence, kids master a subset of syntactically valid Python.


GitHub description: Hedy is a gradual programming language to teach children programming. Gradual languages use different language levels, where each level adds new concepts and syntactic complexity. At the end of the Hedy level sequence, kids master a subset of syntactically valid Python.
Heron (pl, appeared 2016)
Creators: Christopher Diggins
Origin: https://github.com/cdiggins/heron-language/issues
Country: Canada
Website: https://cdiggins.github.io/heron-language



GitHub description: A pure functional type-inferred language based on JavaScript

// Named function with statement body
function sum(xs) {
    var result = 0;
    for (var x in xs)
        result += x;
    return result;
}
Qualcomm Hexagon (assembly, appeared 2006)
Origin: Qualcomm


Hexagon (QDSP6) is the brand for a family of 32-bit multi-threaded microarchitectures implementing the same instruction set for a digital signal processor (DSP) developed by Qualcomm. According to 2012 estimation, Qualcomm shipped 1.2 billion DSP cores inside its system on a chip (SoCs) (average 2.3 DSP core per SoC) in 2011 year, and 1.5 billion cores were planned for 2012, making the QDSP6 the most shipped architecture of DSP (CEVA had around 1 billion of DSP cores shipped in 2011 with 90% of IP-licenseable DSP market). The Hexagon architecture is designed to deliver performance with low power over a variety of applications. It has features such as hardware assisted multithreading, privilege levels, Very Long Instruction Word (VLIW), Single Instruction, Multiple Data (SIMD), and instructions geared toward efficient signal processing. The CPU is capable of in-order dispatching up to 4 instructions (the packet) to 4 Execution Units every clock. Hardware multithreading is implemented as barrel temporal multithreading - threads are switched in round-robin fashion each cycle, so the 600 MHz physical core is presented as three logical 200 MHz cores before V5. Hexagon V5 switched to dynamic multithreading (DMT) with thread switch on L2 misses, interrupt waiting or on special instructions.
HFS Plus (filesystem, appeared 1998)
Origin: Apple
Country: United States


HFS Plus or HFS+ is a file system developed by Apple Inc.  It replaced the Hierarchical File System (HFS) as the primary file system of Apple computers with the 1998 release of Mac OS 8.1.  HFS+ continued as the primary Mac OS X file system until it was itself replaced with the release of the Apple File System (APFS) with macOS High Sierra in 2017. HFS+ is also one of the formats used by the iPod digital music player. It is also referred to as Mac OS Extended or HFS Extended, where its predecessor, HFS, is also referred to as Mac OS Standard or HFS Standard. During development, Apple referred to this file system with the codename Sequoia.HFS Plus is an improved version of HFS, supporting much larger files (block addresses are 32-bit length instead of 16-bit) and using Unicode (instead of Mac OS Roman or any of several other character sets) for naming items. Like HFS, HFS Plus uses B-trees to store most volume metadata, but unlike most other file systems, HFS Plus supports hard links to directories. HFS Plus permits filenames up to 255 characters in length, and n-forked files similar to NTFS, though until 2005 almost no system software took advantage of forks other than the data fork and resource fork. HFS Plus also uses a full 32-bit allocation mapping table rather than HFS's 16 bits, significantly improving space utilization with large disks.
Hierarchical File System (filesystem, appeared 1985)
Stands for: Hierarchical File System
Origin: Apple
Country: United States


Hierarchical File System (HFS) is a proprietary file system developed by Apple Inc. for use in computer systems running Mac OS. Originally designed for use on floppy and hard disks, it can also be found on read-only media such as CD-ROMs. HFS is also referred to as Mac OS Standard (or, erroneously, "HFS Standard"), while its successor, HFS Plus, is also called Mac OS Extended (or, erroneously, "HFS Extended"). With the introduction of Mac OS X 10.6, Apple dropped support for formatting or writing HFS disks and images, which remain supported as read-only volumes.
HHVM (vm, appeared 2011)
Origin: Facebook
Country: United States
Website: https://hhvm.com


HipHop Virtual Machine (HHVM) is an open-source virtual machine based on just-in-time (JIT) compilation that serves as an execution engine for the PHP and Hack programming languages.  By using the principle of JIT compilation, executed PHP or Hack code is first transformed into intermediate HipHop bytecode (HHBC), which is then dynamically translated into x86-64 machine code, optimized, and natively executed.  This contrasts with PHP's usual interpreted execution, in which the Zend Engine transforms PHP source code into opcodes that serve as a form of bytecode, and executes the opcodes directly on the Zend Engine's virtual CPU.HHVM is developed by Facebook, with the project's source code hosted on GitHub; it is licensed under the terms of the PHP License and Zend License.

GitHub description: A virtual machine for executing programs written in Hack.
High Tech BASIC (pl, appeared 1988)
Origin: Hewlett-Packard
Country: United States


Rocky Mountain BASIC (also RMB or RM-BASIC) is a dialect of the BASIC programming language created by Hewlett-Packard.  It was especially popular for control of automatic test equipment using GPIB.  It has several features which are or were unusual in BASIC dialects, such as event-driven operation, extensive external I/O support, complex number support, and matrix manipulation functions.  Today, RMB is mainly used in environments where an investment in RMB software, hardware, or expertise already exists.
hilvl (pl, appeared 2015)
Creators: Holger Ludvigsen
Origin: https://github.com/holgerl/hilvl/issues
Country: Unknown

Hilvl is a programming language that is versatile but with a very small syntax. All code in hilvl are single-argument invocations of actions that belong to services. Services are the fundamental building blocks of a hilvl program. And the name hilvl reflects how this is a higher level of abstraction than objects and functions.


GitHub description: The hilvl programming language

@ var foo = 42
@ var bar = (2 + 40)
 
@ . foo == (@ . bar) then
 @ set foo = 0
 
@ var myList = 
 1
 2
 3
 
@ . myList loop
 @ set foo = (@ . foo + (@ . element))

@ var myMap =
 Map of
   "firstname" , "Ola"
   "lastname" , "Nordmann"

@ var MyService := 
 @ var myAction :
   @ . argument + 10
   
MyService myAction (@ . foo) // foo is now 6, and this returns 16
HiveQL (queryLanguage, appeared 2011)
Website: https://hive.apache.org

SQL-like query language interface called the Hive query language. While based on SQL, HiveQL does not strictly follow the full SQL-92 standard. Internally, a compiler translates HiveQL statements into a directed acyclic graph of MapReduce, Tez, or Spark jobs, which are submitted to Hadoop for execution.



4 CREATE TABLE word_counts AS
5 SELECT word, count(1) AS count FROM
6 (SELECT explode(split(line, '\s')) AS word FROM docs) temp
7 GROUP BY word
8 ORDER BY word;
Hjson (dataNotation, appeared 2014)
Creators: Christian Zangl
Origin: https://github.com/hjson
Country: Austria
Website: https://hjson.org/

Hjson is a syntax extension to JSON. It's NOT a proposal to replace JSON or to incorporate it into the JSON spec itself. It's intended to be used like a user interface for humans, to read and edit before passing the JSON data to the machine.


GitHub description: Hjson, a user interface for JSON

{
 # hash style comments
 # (because it's just one character)

 // line style comments
 // (because it's like C/JavaScript/...)

 /* block style comments because
    it allows you to comment out a block */

 # Everything you do in comments,
 # stays in comments ;-}
}
HL7 (pl, appeared 1989)
Origin: Health Level Seven International
Country: United States
Website: http://www.hl7.org/


Health Level Seven or HL7 refers to a set of international standards for transfer of clinical and administrative data between software applications used by various healthcare providers. These standards focus on the application layer, which is "layer 7" in the OSI model. The HL7 standards are produced by Health Level Seven International, an international standards organization, and are adopted by other standards issuing bodies such as American National Standards Institute and International Organization for Standardization. Hospitals and other healthcare provider organizations typically have many different computer systems used for everything from billing records to patient tracking.  All of these systems should communicate with each other (or "interface") when they receive new information, or when they wish to retrieve information, but not all do so. HL7 International specifies a number of flexible standards, guidelines, and methodologies by which various healthcare systems can communicate with each other. Such guidelines or data standards are a set of rules that allow information to be shared and processed in a uniform and consistent manner. These data standards are meant to allow healthcare organizations to easily share clinical information. Theoretically, this ability to exchange information should help to minimize the tendency for medical care to be geographically isolated and highly variable.HL7 International considers the following standards to be its primary standards – those standards that are most commonly used and implemented: Version 2.x Messaging Standard – an interoperability specification for health and medical transactions Version 3 Messaging Standard – an interoperability specification for health and medical transactions Clinical Document Architecture (CDA) – an exchange model for clinical documents, based on HL7 Version 3 Continuity of Care Document (CCD) – a US specification for the exchange of medical summaries, based on CDA. Structured Product Labeling (SPL) – the published information that accompanies a medicine, based on HL7 Version 3 Clinical Context Object Workgroup (CCOW) – an interoperability specification for the visual integration of user applicationsOther HL7 standards/methodologies include: Fast Healthcare Interoperability Resources (FHIR) – a standard for the exchange of resources Arden Syntax – a grammar for representing medical conditions and recommendations as a Medical Logic Module (MLM) Claims Attachments – a Standard Healthcare Attachment to augment another healthcare transaction Functional Specification of Electronic Health Record (EHR) / Personal Health Record (PHR) systems – a standardized description of health and medical functions sought for or available in such software applications GELLO – a standard expression language used for clinical decision support
High Level Assembly (assembly, appeared 2011)
Stands for: High Level Assembly
Creators: Randall Hyde
Origin: Plantation Productions, Inc
Country: United States
Website: https://plantation-productions.com/Webster/HighLevelAsm/index.html


High Level Assembly (HLA) is an high-level assembly language developed by Randall Hyde. It allows the use of higher-level language constructs to aid both beginners and advanced assembly developers. It fully supports advanced data types and object-oriented programming. It uses a syntax loosely based on several high-level programming languages (HLLs), such as Pascal, Ada, Modula-2, and C++, to allow creating readable assembly language programs, and to allow HLL programmers to learn HLA as fast as possible.


procedure SetFormat;

static
    chr     :w.CHARRANGE;
    chr2    :w.CHARRANGE;
    cf      :w.CHARFORMAT;

begin SetFormat;
    
    w.SendMessage(hwnd, w.EM_GETMODIFY,0,0);
    push    (eax);
    
    w.SendMessage(hwnd, w.EM_EXGETSEL,0, &chr);
    w.SendMessage(hwnd, w.EM_HIDESELECTION, true,0);
    mov (0, chr2.cpMin);
    mov (-1,chr2.cpMax);
    w.SendMessage(hwnd, w.EM_EXSETSEL,0,&chr2);
    mov (@size(cf), cf.cbSize);
    mov (w.CFM_CHARSET | w.CFM_FACE | w.CFM_SIZE | w.CFM_COLOR, cf.dwMask);
    mov (logfont.lfCharSet, al);
    mov (al,cf.bCharSet);
    mov (logfont.lfPitchAndFamily, al);
    mov (al, cf.bPitchAndFamily);
    w.lstrcpyn(cf.szFaceName,&logfont.lfFaceName,w.LF_FACESIZE);
    mov (logfont.lfHeight, eax);
    neg (eax);
    mov (15,ecx);
    mul     (ecx);
    mov (eax, cf.yHeight);
    mov (rgb, cf.crTextColor);
    w.SendMessage(hwnd, w.EM_SETCHARFORMAT, w.SCF_SELECTION,&cf);
    w.SendMessage(hREd, w.WM_SETFONT, hFont, true);
    w.SendMessage(hREd, w.EM_SETMARGINS, w.EC_LEFTMARGIN,5); 
    pop (eax);
    w.SendMessage(hwnd, w.EM_SETMODIFY, eax,0);
    w.SendMessage(hwnd, w.EM_EXSETSEL,0,&chr);
    w.SendMessage(hwnd,w.EM_HIDESELECTION, false, 0);

end SetFormat;
HLSL (pl, appeared 2002)
Origin: Microsoft
Country: United States


The High-Level Shader Language or High-Level Shading Language (HLSL) is a proprietary shading language developed by Microsoft for the Direct3D 9 API to augment the shader assembly language, and went on to become the required shading language for the unified shader model of Direct3D 10 and higher. HLSL is analogous to the GLSL shading language used with the OpenGL standard. It is very similar to the Nvidia Cg shading language, as it was developed alongside it.  HLSL shaders can enable profound speed and detail increases as well as many special effects in both 2d and 3d computer graphics.HLSL programs come in five forms: pixel shaders (fragment in GLSL), vertex shaders, geometry shaders, compute shaders and tessellation shaders (Hull and Domain shaders). A vertex shader is executed for each vertex that is submitted by the application, and is primarily responsible for transforming the vertex from object space to view space, generating texture coordinates, and calculating lighting coefficients such as the vertex's tangent, binormal and normal vectors. When a group of vertices (normally 3, to form a triangle) come through the vertex shader, their output position is interpolated to form pixels within its area; this process is known as rasterisation. Each of these pixels comes through the pixel shader, whereby the resultant screen colour is calculated. Optionally, an application using a Direct3D 10/11/12 interface and Direct3D 10/11/12 hardware may also specify a geometry shader. This shader takes as its input some vertices of a primitive (triangle/line/point) and uses this data to generate/degenerate (or tessellate) additional primitives or to change the type of primitives, which are each then sent to the rasterizer. D3D11.3 and D3D12 introduced Shader Model 5.1 and later 6.0.
High-Level Virtual Machine (vm, appeared 2009)
Stands for: High-Level Virtual Machine
Origin: https://github.com/ocaml-forge
Country: United Kingdom
Website: http://www.ffconsultancy.com/ocaml/hlvm/

HLVM is a cross-platform open-source high-level virtual machine. The virtual machine is written in OCaml and uses the excellent LLVM library for efficient high-performance native code generation.
Hocon (dataNotation, appeared 2011)
Stands for: Human-Optimized Config Object Notation
Origin: https://github.com/lightbend
Country: United States
Website: https://github.com/lightbend/config/blob/master/HOCON.md


HOCON, or Human-Optimized Config Object Notation is a format for human-readable data, and a superset of JSON and .properties. It is primarily used in conjunction with the Play framework, and is developed by Lightbend. It is also supported as a configuration format for .NET projects via Akka.NET and Puppet.


// one array
a : [ 1, 2, 3, 4 ]
// two arrays that are concatenated
a : [ 1, 2 ] [ 3, 4 ]
// a later definition referring to an earlier
// (see "self-referential substitutions" below)
a : [ 1, 2 ]
a : ${a} [ 3, 4 ]
Hodor (esolang, appeared 2015)
Creators: Drew Morris
Origin: https://github.com/hummingbirdtech
Country: United States
Website: http://www.hodor-lang.org/

Using jumbled permutations of the word "hodor" over and over again we have simplified programming syntax to make it easier than ever before.


GitHub description: Official repo for the hodor-lang.org programming language

$HODOR: hhodor? Hodor!? Hodor!? oHooodorrhodor orHodor!? d = HoDoRHoDoR () {
 hodor.hod('Hhodor? Hodor!? Hodor!? o HODOR!? orHodor!? d!');
};

hhodor? Hodor!? Hodor!? oHooodorrhodor orHodor!? d();
holyc (pl, appeared 2005)
Creators: Terry A. Davis
Origin: https://github.com/cia-foundation/TempleOS/issues
Country: United States

HolyC is a variation of C developed by Terry A. Davis. HolyC is the official programming language for The Temple Operating System (TempleOS).



U0 Main()
  {
    I16 i1;
    I32 j1;
    j1=i1=0x12345678;           //Resulting i1 is 0x5678 but j1 is 0x12345678
  
    I64 i2=0x8000000000000000;
    Print("%X\n",i2>>1);        //Res is 0xC000000000000000 as expected
  
    U64 u3=0x8000000000000000;
    Print("%X\n",u3>>1);        //Res is 0x4000000000000000 as expected
  
    I32 i4=0x80000000;          //const is loaded into a 64-bit reg var.
    Print("%X\n",i4>>1);        //Res is 0x40000000
  
    I32 i5=-0x80000000;
    Print("%X\n",i5>>1);        //Res is 0xFFFFFFFFC0000000
  }
Homa (protocol, appeared 2018)
Creators: John Ousterhout
Origin: Stanford University
Country: United States
Website: https://web.stanford.edu/~ouster/cgi-bin/home.php

TCP’s problems are too fundamental and interrelated to be fixed; the only way to harness the full performance potential of modern networks is to introduce a new transport protocol into the datacenter.


GitHub description: A Linux kernel module that implements the Homa transport protocol.
hoon (pl, appeared 2011)
Origin: https://github.com/cgyarvin/urbit/issues
Country: Unknown
Website: https://developers.urbit.org/reference/glossary/hoon

Hoon is a high-level, statically typed, functional programming language, custom-designed for use with Urbit. For a functional language it has a surprisingly imperative style, and mastering it doesn't require knowing any advanced mathematics.



::  A message you ping another ship with
::
::::  /===/mar/ping/message/hoon
  ::
/-  ping-message
!:
|_  ping-message
++  grab
  |%
  +=  noun
    ping-message
  --
--
hoot-smalltalk (pl, appeared 2018)
Creators: Nikolas S. Boyd
Origin: https://gitlab.com/hoot-smalltalk/hoot-smalltalk
Country: United States

Hoot is a variation of Smalltalk that integrates the best features of Smalltalk with those of a host language and its virtual machine VM. The initial target platforms include Java (and its JVM), and C# (and its CLR). Hoot is an experimental new programming language which builds on experience and understanding gained during the development of Bistro Smalltalk. Thus, Hoot Smalltalk is the natural and conceptual successor of Bistro Smalltalk.
HOPE (pl, appeared 1978)
Origin: https://github.com/dmbaturin/hope/issues
Country: United Kingdom
Keywords: and
or
not
char
num
div
mod
dec
X
#
:
->
;
---
if
then
else
>
<=
+
(
)
,
infix
-
truval
::
nil
"
<>
==
in
where
data
++
lambda


Hope is a small functional programming language developed in the 1970s at Edinburgh University. It predates Miranda and Haskell and is contemporaneous with ML (also developed at Edinburgh). Hope was derived from NPL, a simple functional language developed by Rod Burstall and John Darlington in their work on program transformation. NPL was, in turn, derived from Kleene Recursion Equations. NPL and Hope are notable for being the first languages with call-by-pattern evaluation and algebraic data types. (Though SNOBOL is even older, and its 'patterns' may qualify as a hybrid between call-by-pattern and regular expression matching.) Hope is an important language in the development of functional programming. Hope was named for Sir Thomas Hope (c. 1681–1771), a Scottish agricultural reformer, after whom Hope Park Square in Edinburgh, the location of the Department of Artificial Intelligence at the time of the development of Hope, was also named.