pldb/PLDB huggingface dataset:
J# (pl, appeared 2002)
Origin: Microsoft
Country: United States
Website: http://msdn2.microsoft.com/en-us/vjsharp/default.aspx


Visual J# (pronounced "jay-sharp") is an implementation of the J# programming language that was a transitional language for programmers of Java and Visual J++ languages, so they could use their existing knowledge and applications on .NET Framework. It was introduced in 2002 and discontinued in 2007, with support for the final release of the product continuing until October, 2017. J# worked with Java bytecode as well as source so it could be used to transition applications that used third-party libraries even if their original source code was unavailable. It was developed by the Hyderabad-based Microsoft India Development Center at HITEC City in India.
JSML (xmlFormat, appeared 2001)
Stands for: Java Speech Markup Language
Origin: Sun Microsystems, Inc
Country: United States


Java Speech API Markup Language (JSML) is an XML-based markup language for annotating text input to speech synthesizers.  JSML is used within the Java Speech API. JSML is an XML application and conforms to the requirements of well-formed XML documents. Java Speech API Markup Language is referred to as JSpeech Markup Language when describing the W3C documentation of the standard. Java Speech API Markup Language and JSpeech Markup Language identical apart from the change in name, which is made to protect Sun trademarks. JSML is primarily an XML text format used by Java applications to annotate text input to speech synthesizers. Elements of JSML provide speech synthesizer with detailed information on how to speak text in a naturalized fashion. JSML defines elements which define a document's structure, the pronunciation of certain words and phrases, features of speech such as emphasis and intonation, etc. JSML is designed in the Java fashion to be simple to learn and use, to be portable across different synthesizers and computing platforms, and although designed for use within is also applicable to a wide range of languages. An example of how JSML is defined is set out below:  The W3C has developed a standard markup language called SSML, which is based on JSML but is not identical to it. This became a formal W3C recommendation in 2004.
json-graph-format (jsonFormat, appeared 2014)
Also known as: jgf
Origin: https://github.com/jsongraph
Country: United States
Website: http://jsongraphformat.info/



GitHub description: A proposal for representing graph structure (nodes / edges) in JSON.

{
    "graph": {
        "directed": false,
        "type": "graph type",
        "label": "graph label",
        "metadata": {
            "user-defined": "values"
        },
        "nodes": [
            {
                "id": "0",
                "type": "node type",
                "label": "node label(0)",
                "metadata": {
                    "user-defined": "values"
                }
            },
            {
                "id": "1",
                "type": "node type",
                "label": "node label(1)",
                "metadata": {
                    "user-defined": "values"
                }
            }
        ],
        "edges": [
            {
                "source": "0",
                "relation": "edge relationship",
                "target": "1",
                "directed": false,
                "label": "edge label",
                "metadata": {
                    "user-defined": "values"
                }
            }
        ]
    }
}
JSON Graph Spec (jsonFormat, appeared 2013)
Creators: Byron Ruth
Origin: https://github.com/bruth/json-graph-spec/issues
Country: United States



GitHub description: JSON specification for representing a graph structure

{
    "nodes": [{
        "labels": ["Origin"],
        "props": {
            "name": "file.csv",
            "uri": "csv:///path/to/file.csv"
        },
        "match": ["uri"]
    }, {
        "labels": ["Element"],
        "props": {
            "name": "ArtistId",
            "uri": "csv:///path/to/file.csv/ArtistId"
        },
        "match": ["uri"]
    }],
    "rels": [{
        "start": 0,
        "end": 1,
        "type": "CONTAINS"
    }]
}
JSON lambda (queryLanguage, appeared 2017)
Also known as: jl
Creators: Chris Done
Origin: https://chrisdone.com/
Country: England and Canada

jl ("JSON lambda") is a tiny functional language for querying and manipulating JSON.


GitHub description: Functional sed for JSON

map (\o -> { sha: o.sha, ps: map _.sha o.parents }) | filter (\o -> length o.ps > 1)
JSON-LD (dataValidationLanguage, appeared 2010)
Stands for: JavaScript Object Notation for Linked Data
Creators: Dave Longley
Origin: https://www.w3.org/2018/json-ld-wg/
Country: Various
Website: https://json-ld.org/


JSON-LD (JavaScript Object Notation for Linked Data), is a method of encoding Linked Data using JSON. It was a goal to require as little effort as possible from developers to transform their existing JSON to JSON-LD. This allows data to be serialized in a way that is similar to traditional JSON. It is a World Wide Web Consortium Recommendation. It was initially developed by the JSON for Linking Data Community Group before being transferred to the RDF Working Group for review, improvement, and standardization.

GitHub description: A JSON-LD Processor and API implementation in JavaScript
JSON Schema (dataValidationLanguage, appeared 2010)
Creators: Kris Zyp
Origin: https://github.com/json-schema-org
Country: Various
Website: http://json-schema.org/

JSON Schema is a vocabulary that allows you to annotate and validate JSON documents.


GitHub description: The JSON Schema I-D sources

{
  "$id": "https://example.com/calendar.schema.json",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "description": "A representation of an event",
  "type": "object",
  "required": [ "dtstart", "summary" ],
  "properties": {
    "dtstart": {
      "type": "string",
      "description": "Event starting time"
    },
    "dtend": {
      "type": "string",
      "description": "Event ending time"
    },
    "summary": {
      "type": "string"
    },
    "location": {
      "type": "string"
    },
    "url": {
      "type": "string"
    },
    "duration": {
      "type": "string",
      "description": "Event duration"
    },
    "rdate": {
      "type": "string",
      "description": "Recurrence date"
    },
    "rrule": {
      "type": "string",
      "description": "Recurrence rule"
    },
    "category": {
      "type": "string"
    },
    "description": {
      "type": "string"
    },
    "geo": {
      "$ref": "https://example.com/geographical-location.schema.json"
    }
  }
}
json->url (jsonFormat, appeared 2017)
Creators: Tim Bray
Origin: Textuality Services, Inc.
Country: Canada
Website: https://jsonurl.org

JSON→URL is a language-independent data interchange format for the JSON data model suitable for use within a URL/URI query string. It is defined by an open specification, though not through a standards body.


GitHub description: JSON->URL defines a text format for the JSON data model suitable for use within a URL/URI (as described by RFC3986). This repository holds the JavaScript reference implementation of JSON->URL.
JSON with Comments (dataNotation, appeared 2001)
Also known as: jsonc
Creators: Muhammad Muzzammil
Origin: https://github.com/muhammadmuzzammil1998/jsonc/issues
Country: India



GitHub description: JSON with comments for Go!

/*
 * JSLint's implementation of JSHint
 * The JSLint options and makeup of this file were created based on the documentation of JSLint by
 * Douglas Crockford: http://www.jslint.com/lint.html
 */

{
  "foobar" : true,       // Not checked in JSHint
}
JSON (dataNotation, appeared 2001)
Creators: Douglas Crockford
Origin: State Software
Country: United States
Website: https://www.json.org/


In computing, JavaScript Object Notation or JSON ( JAY-sən), is an open-standard file format that uses human-readable text to transmit data objects consisting of attribute–value pairs and array data types (or any other serializable value). It is a very common data format used for asynchronous browser–server communication, including as a replacement for XML in some AJAX-style systems. JSON is a language-independent data format. It was derived from JavaScript, but as of 2017 many programming languages include code to generate and parse JSON-format data. The official Internet media type for JSON is application/json. JSON filenames use the extension .json. Douglas Crockford originally specified the JSON format in the early 2000s; two competing standards, RFC 7159 and ECMA-404, defined it in 2013. The ECMA standard describes only the allowed syntax, whereas the RFC covers some security and interoperability considerations. A restricted profile of JSON, known as I-JSON (short for "Internet JSON"), seeks to overcome some of the interoperability problems with JSON. It is defined in RFC 7493..
JSON5 (dataNotation, appeared 2012)
Creators: Aseem Kishore
Origin: https://github.com/json5
Country: United States
Website: https://json5.org/

The JSON5 Data Interchange Format (JSON5) is a superset of JSON that aims to alleviate some of the limitations of JSON by expanding its syntax to include some productions from ECMAScript 5.1.


GitHub description: JSON5 — JSON for humans

{
  // comments
  unquoted: 'and you can quote me on that',
  singleQuotes: 'I can use "double quotes" here',
  lineBreaks: "Look, Mom! \
No \\n's!",
  hexadecimal: 0xdecaf,
  leadingDecimalPoint: .8675309, andTrailing: 8675309.,
  positiveSign: +1,
  trailingComma: 'in objects', andIn: ['arrays',],
  "backwardsCompatible": "with JSON",
}
JSONiq (queryLanguage, appeared 2011)
Origin: https://groups.google.com/g/zorba-io-user
Country: Unknown
Website: http://www.jsoniq.org/


JSONiq is a query and functional programming language that is designed to declaratively query and transform collections of hierarchical and heterogeneous data in format of JSON, XML, as well as unstructured, textual data. JSONiq is an open specification published under the Creative Commons Attribution-ShareAlike 3.0 license. It is based on the XQuery language, with which it shares the same core expressions and operations on atomic types. JSONiq comes in two syntactical flavors, which both support JSON and XML natively.  The JSONiq syntax (a superset of JSON) extended with XML support through a compatible subset of XQuery. The XQuery syntax (native XML support) extended with JSON support through a compatible subset (the JSONiq extension to XQuery) of the above JSONiq syntax.
Jsonnet (dataNotation, appeared 2014)
Creators: Dave Cunningham
Origin: Google
Country: United States
Website: https://jsonnet.org/




// A function that returns an object.
local Person(name='Alice') = {
  name: name,
  welcome: 'Hello ' + name + '!',
};
{
  person1: Person(),
  person2: Person('Bob'),
}
JS++ (pl, appeared 2011)
Creators: Roger Poon
Anton Rapetov
Origin: Onux
Country: United Kingdom
Website: https://onux.com/jspp/
File extensions: jspp
Keywords: abstract
auto
break
bool
byte
catch
char
class
continue
debugger
delete
do
double
else
enum
external
false
final
finally
float
for
foreach
function
if
import
in
instanceof
int
interface
long
module
new
null
override
overwrite
private
protected
property
public
return
short
signed
string
super
switch
static
this
true
try
typeid
typeof
undefined
unsigned
var
virtual
void
while
with
yield
juicy (pl, appeared 2017)
Creators: Jonathan Avery
Origin: https://github.com/GordianNaught/Juicy/issues
Country: New Zealand

<a href='https://github.com/GordianNaught/Juicy'>Juicy</a> is a low-level, compiled, purely functional, highly generic language with inferred types and tail recursion.


GitHub description: Juicy Language Compiler
Jule (pl, appeared 2021)
Creators: Mertcan Davulcu
Origin: Beykoz Okan University
Country: Turkey
Website: https://jule.dev
File extensions: .jule
Keywords: fn
pub
struct
enum
unsafe
const
let
mut
self
match
if
else
for
in
impl
trait
break
continue
goto
cpp
i8
i16
i32
i64
u8
u16
u32
u64
f32
f64
str
int
uint
type
any
true
false
bool
ret
fall
nil
uintptr
co

Jule is the simple, efficient, statically typed and compiled system programming language.


GitHub description: Jule is the simple, efficient, statically typed and compiled system programming language.

fn quicksort(mut s: []int) {
    if s.len <= 1 {
        ret
    }
    let mut i = 0
    for i < s.len-1; i++ {
        let (mut x, mut y) = &s[i], &s[i+1]
        unsafe {
            if *x > *y {
                *x, *y = *y, *x
            }
        }
    }
    quicksort(s[:i])
    quicksort(s[i+1:])
}

fn main() {
    let mut s = [1, 9, -2, 25, -24, 4623, 0, -1, 0xFD2]
    outln(s)
    quicksort(s)
    outln(s)
}
fn main() {
    outln("Hello World")
}
use std::math::{PI}

trait Shape {
    fn area(self): int
}

struct Rectangle {
    width: int
    height: int
}

impl Shape for Rectangle {
    fn area(self): int {
        ret self.width * self.height
    }
}

struct Circle {
    r: f32
}

impl Shape for Circle {
    fn area(self): int {
        ret PI * self.r * self.r
    }
}

fn main() {
    let rect: Shape = Rectangle{90, 5}
    let circ: Shape = Circle{90.5}
    outln(rect.area())
    outln(circ.area())
}
Joyfully Universal Language for (Inline) Assembly (pl, appeared 2016)
Origin: https://github.com/ethereum
Country: United States

JULIA is an intermediate language that can compile to various different backends (EVM 1.0, EVM 1.5 and eWASM are planned). Because of that, it is designed to be a usable common denominator of all three platforms. It can already be used for “inline assembly” inside Solidity and future versions of the Solidity compiler will even use JULIA as intermediate language. It should also be easy to build high-level optimizer stages for JULIA.



{
    function power(base:u256, exponent:u256) -> result:u256
    {
        switch exponent
        case 0:u256 { result := 1:u256 }
        case 1:u256 { result := base }
        default:
        {
            result := power(mul(base, base), div(exponent, 2:u256))
            switch mod(exponent, 2:u256)
                case 1:u256 { result := mul(base, result) }
        }
    }
}
Julia (pl, appeared 2012)
Creators: Jeff Bezanson
Alan Edelman
Stefan Karpinski
Viral B. Shah
Origin: https://github.com/JuliaLang
Country: Various
Website: http://julialang.org/
File extensions: jl
Keywords: begin
while
if
for
try
return
break
continue
function
macro
quote
let
local
global
const
do
struct
abstract
typealias
bitstype
type
immutable
module
baremodule
using
import
export
importall
end
else
catch
finally
true
false


Julia is a high-level dynamic programming language designed to address the needs of high-performance numerical analysis and computational science, without the typical need of separate compilation to be fast, while also being effective for general-purpose programming, web use or as a specification language. Distinctive aspects of Julia's design include a type system with parametric polymorphism and types in a fully dynamic programming language and multiple dispatch as its core programming paradigm. It allows concurrent, parallel and distributed computing, and direct calling of C and Fortran libraries without glue code. Julia is garbage-collected, uses eager evaluation and includes efficient libraries for floating-point calculations, linear algebra, random number generation, fast Fourier transforms and regular expression matching.

GitHub description: The Julia Programming Language
juniper (pl, appeared 2016)
Creators: Caleb Helbling
Origin: https://github.com/calebh/Juniper/issues
Country: United States
Website: http://www.juniper-lang.org/

<a href='http://www.juniper-lang.org/'>Juniper</a> is a functional reactive programming language for the Arduino and other related platforms.


GitHub description: FRP (Functional Reactive Programming) for the Arduino and other microcontrollers
Project Jupyter (editor, appeared 2014)
Origin: https://github.com/jupyter/
Country: Various
Website: https://jupyter.org/


Project Jupyter ( ( listen)) is a nonprofit organization created to "develop open-source software, open-standards, and services for interactive computing across dozens of programming languages."  Spun-off from IPython in 2014 by Fernando Pérez, Project Jupyter supports execution environments in several dozen languages.  Project Jupyter's name is a reference to the three core programming languages supported by Jupyter, which are Julia, Python and R, and also an homage to Galileo's notebooks recording the discovery of the moons of Jupiter. Project Jupyter has developed and supported the interactive computing products Jupyter Notebook, Jupyter Hub, and Jupyter Lab, the next-generation version of Jupyter Notebook.
JVM (vm, appeared 1994)
Stands for: Java Virtual Machine
Origin: Sun Microsystems


A Java virtual machine (JVM) is a virtual machine that enables a computer to run Java programs as well as programs written in other languages and compiled to Java bytecode.  The JVM is detailed by a specification that formally describes what is required of a JVM implementation.  Having a specification ensures interoperability of Java programs across different implementations so that program authors using the Java Development Kit (JDK) need not worry about idiosyncrasies of the underlying hardware platform. The JVM reference implementation is developed by the OpenJDK project as open source code and includes a JIT compiler called HotSpot.  The commercially supported Java releases available from Oracle Corporation are based on the OpenJDK runtime.
K (pl, appeared 1993)
Creators: Arthur Whitney
Origin: Kx Systems
Country: United States

K is like APL, but K restricts itself to the ASCII character set.

K is a proprietary array processing language developed by Arthur Whitney and commercialized by Kx Systems. Since then, an open-source implementation known as Kona has also been developed. The language serves as the foundation for kdb+, an in-memory, column-based database, and other related financial products. The language, originally developed in 1993, is a variant of APL and contains elements of Scheme. Advocates of the language emphasize its speed, facility in handling arrays, and expressive syntax.
Kaggle (application, appeared 2010)
Origin: Google
Country: Unknown
Website: https://www.kaggle.com/


Kaggle is an online community of data scientists and machine learners, owned by Google LLC. Kaggle allows users to find and publish data sets, explore and build models in a web-based data-science environment, work with other data scientists and machine learning engineers, and enter competitions to solve data science challenges. Kaggle got its start by offering machine learning competitions and now also offers a public data platform, a cloud-based workbench for data science, and short form AI education. On 8 March 2017, Google announced that they were acquiring Kaggle.
kai (pl, appeared 2016)
Origin: https://github.com/kai-language
Country: The Netherlands
Website: http://docs.kai-lang.org

An expressive low level programming language


GitHub description: An expressive low level programming language

/* // github.com/kai-language/issues/116
#test "bitcast to struct" {
    A :: struct {
        a: rawptr
    }
    x : rawptr = nil
    a := bitcast(A) x
} */
kaitai (idl, appeared 2016)
Creators: Mikhail Yakshin
Origin: http://kaitai.io/
Country: Various
Website: http://kaitai.io/
File extensions: ksy

Kaitai Struct is a YAML-based declarative language used to describe various binary data structures, laid out in files or in memory: i.e. binary file formats, network stream packet formats, etc. The main idea is that a particular format is described in Kaitai Struct language (.ksy file) and then can be compiled with ksc into source files in one of the supported programming languages. These modules will include a generated code for a parser that can read described data structure from a file / stream and give access to it in a nice, easy-to-comprehend API.


GitHub description: Kaitai Struct: declarative language to generate binary data parsers in C++ / C# / Go / Java / JavaScript / Lua / Perl / PHP / Python / Ruby

meta:
  id: tcp_segment
  endian: be
seq:
  - id: src_port
    type: u2
  - id: dst_port
    type: u2
  - id: seq_num
    type: u4
  - id: ack_num
    type: u4
Kal (pl, appeared 2012)
Origin: https://github.com/rzimmerman/kal/issues
Country: United States
Website: http://rzimmerman.github.io/kal

Kal is a highly readable, easy-to-use language that compiles to JavaScript.


GitHub description: A powerful, easy-to-use, and easy-to-read programming language for the future.

task getUserFriends (userName)
 wait for user from db.users.findOne {name:userName}
 wait for friends from db.friends.find {userId:user.id}
 return friends
Kaleidoscope (pl, appeared 1994)
Origin: University of Washington
Country: United States


The Kaleidoscope programming language is a constraint programming language embedding constraints into an imperative object-oriented language.  It adds keywords always, once, and assert..during (formerly while..assert) to make statements about relational invariants. Objects have constraint constructors, which are not methods, to enforce the meanings of user-defined datatypes. There are three versions of Kaleidoscope which show an evolution from declarative to an increasingly imperative style. Differences between them are as follows.
Kamby (pl, appeared 2022)
Creators: Henrique Gogó
Origin: https://github.com/henriquegogo/kamby/issues
Country: Brazil
Website: https://kamby.org/

A small, embeddable and convenient language for who want to use and understand what is happening behind the scenes. The core is just ~400LOC and binary has just 20kb


GitHub description: Kamby Language

planet = [
  name := 'World'
  nick := 'Earth'
]

'Hello, ' + (planet :: {name})
KAML (dataNotation, appeared 2018)
Stands for: KAML ain't markup language
Origin: https://github.com/ISLEcode
Country: Switzerland



GitHub description: KAML ain't markup language

title="KAML Example"                    # A simple string
author=Jean-Michel\ Marcastel           # Alternate string representation with escaped whitespaces
number=1234                             # Numeric value handled as a string
Karel (pl, appeared 1981)
Creators: Richard E. Pattis
Origin: University of California, Irvine
Country: United States


Karel is an educational programming language for beginners, created by Richard E. Pattis in his book Karel The Robot: A Gentle Introduction to the Art of Programming. Pattis used the language in his courses at Stanford University, California. The language is named after Karel Čapek, a Czech writer who introduced the word robot.
kate-editor (editor, appeared 2000)
Origin: KDE e.V.
Country: Germany
Website: https://kate-editor.org/

Kate is a multi-document editor part of KDE since release 2.2. Being a KDE application, Kate ships with network transparency, as well as integration with the outstanding features of KDE. Choose it for viewing HTML sources from konqueror, editing configuration files, writing new applications or any other text editing task. You still need just one running instance of Kate.
KaTeX (textMarkup, appeared 2013)
Creators: Emily Eisenberg
Origin: https://github.com/KaTeX
Country: United States
Website: https://katex.org

The fastest math typesetting library for the web.


GitHub description: Fast math typesetting for the web.

% \f is defined as #1f(#2) using the macro
\f\relax{x} = \int_{-\infty}^\infty
    \f\hat\xi\,e^{2 \pi i \xi x}
    \,d\xi
kaukatcr (pl, appeared 2018)
Origin: https://www.lord-enki.net/
Country: United States

Kaukatcr (pronounced “cowcatcher”[3]) is a stack-based language modeled loosely on Forth. It avoids tokenization by treating cell boundaries as word boundaries. Like Forth, any word that is neither a built-in nor found in the dictionary of defined functions will be treated as data and pushed onto the stack.