pldb/PLDB huggingface dataset:
JavaCC (grammarLanguage, appeared 1996)
Origin: Sun Microsystems, Inc
Country: United States
Website: https://javacc.org/


JavaCC (Java Compiler Compiler) is an open source parser generator and lexical analyzer generator written in the Java programming language. JavaCC is similar to yacc in that it generates a parser from a formal grammar written in EBNF notation. Unlike yacc, however, JavaCC generates top-down parsers. JavaCC can resolve choices based on the next k input tokens, and so can handle LL(k) grammars automatically; by use of "lookahead specifications", it can also resolve choices requiring unbounded look ahead. JavaCC also generates lexical analyzers in a fashion similar to lex. The tree builder that accompanies it, JJTree, constructs its trees from the bottom up. JavaCC is licensed under a BSD license.
JavaFX Script (pl, appeared 2005)
Origin: Oracle
Website: http://javafx.com/


JavaFX Script is a scripting language designed by Sun Microsystems, forming part of the JavaFX family of technologies on the Java Platform. JavaFX targets the Rich Internet Application domain (competing with Adobe Flex and Microsoft Silverlight), specializing in rapid development of visually rich applications for the desktop and mobile markets. JavaFX Script works with integrated development environments such as NetBeans, Eclipse and IntelliJ IDEA. JavaFX is released under the GNU General Public License, via the Sun sponsored OpenJFX project.
JavaScript (pl, appeared 1995)
Also known as: ECMAScript
es6
es5
Creators: Brendan Eich
Origin: Netscape
Country: United States
Keywords: abstract
arguments
await
boolean
break
byte
case
catch
char
class
const
continue
debugger
default
delete
do
double
else
enum
eval
export
extends
false
final
finally
float
for
function
goto
if
implements
import
in
instanceof
int
interface
let
long
native
new
null
package
private
protected
public
return
short
static
super
switch
synchronized
this
throw
throws
transient
true
try
typeof
var
void
volatile
while
with
yield


JavaScript (), often abbreviated as JS, is a high-level, dynamic, weakly typed, prototype-based, multi-paradigm, and interpreted programming language. Alongside HTML and CSS, JavaScript is one of the three core technologies of World Wide Web content production. It is used to make webpages interactive and provide online programs, including video games. The majority of websites employ it, and all modern web browsers support it without the need for plug-ins by means of a built-in JavaScript engine. Each of the many JavaScript engines represent a different implementation of JavaScript, all based on the ECMAScript specification, with some engines not supporting the spec fully, and with many engines supporting additional features beyond ECMA. As a multi-paradigm language, JavaScript supports event-driven, functional, and imperative (including object-oriented and prototype-based) programming styles. It has an API for working with text, arrays, dates, regular expressions, and basic manipulation of the DOM, but the language itself does not include any I/O, such as networking, storage, or graphics facilities, relying for these upon the host environment in which it is embedded. Initially only implemented client-side in web browsers, JavaScript engines are now embedded in many other types of host software, including server-side in web servers and databases, and in non-web programs such as word processors and PDF software, and in runtime environments that make JavaScript available for writing mobile and desktop applications, including desktop widgets. Although there are strong outward similarities between JavaScript and Java, including language name, syntax, and respective standard libraries, the two languages are distinct and differ greatly in design; JavaScript was influenced by programming languages such as Self and Scheme.
JAWS Scripting Language (pl, appeared 2008)
Also known as: JSL
Origin: Freedom Scientific Inc
Country: United States


JAWS Scripting Language is a proprietary programming language that facilitates the interoperability of the JAWS for Windows screen reading program with practically any application–both proprietary and off-the-shelf.  The JAWS Scripting Language, or JSL is a compiled language, allowing for source code protection.  "JAWS scripting" commonly also cumulatively refers to customization of JAWS through use of its built-in, user-editable utilities (called "Managers") or editing the configuration files directly, in combination with writing actual scripts.  The scripting language is an API that exposes functionality including a combination of traditional JAWS scripting, MSAA Server direct scripting, and document object model scripting to ensure optimal performance of JAWS to end-users.
jcard (jsonFormat, appeared 2014)
Origin: Versit Consortium
Country: United States




["vcard",
  [
    ["version", {}, "text", "4.0"],
    ["n", {}, "text", ["Gump", "Forrest", "", "Mr.", ""]],
    ["fn", {}, "text", "Forrest Gump"],
    ["org", {}, "text", "Bubba Gump Shrimp Co."],
    ["title", {} ,"text", "Shrimp Man"],
    ["photo", {"mediatype":"image/gif"}, "uri", "http://www.example.com/dir_photos/my_photo.gif"],
    ["tel", {"type":["work", "voice"]}, "uri", "tel:+1-111-555-1212"],
    ["tel", {"type":["home", "voice"]}, "uri", "tel:+1-404-555-1212"],
    ["adr",
      {"label":"100 Waters Edge\nBaytown, LA 30314\nUnited States of America", "type":"work", "pref":"1"},
      "text",
      ["", "", "100 Waters Edge", "Baytown", "LA", "50505", "United States of America"]
    ],
    ["adr",
      {"label":"42 Plantation St.\nBaytown, LA 30314\nUnited States of America", "type":"home"},
      "text",
      ["", "", "42 Plantation St.", "Baytown", "LA", "30314", "United States of America"]
    ],
    ["email", {}, "text", "forrestgump@example.com"],
    ["rev", {}, "timestamp", "2008-04-24T19:52:43Z"]
  ]
]
JCL (pl, appeared 1964)
Stands for: Job Control Language
Origin: IBM
Country: United States


Job Control Language (JCL) is a name for scripting languages used on IBM mainframe operating systems to instruct the system on how to run a batch job or start a subsystem. More specifically, the purpose of JCL is to say which programs to run, using which files or devices  for input or output, and at times to also indicate under what conditions to skip a step. There are two distinct IBM Job Control languages: one for the operating system lineage that begins with DOS/360 and whose latest member is z/VSE; and the other for the lineage from OS/360 to z/OS, the latter now including JES extensions, Job Entry Control Language (JECL). They share some basic syntax rules and a few basic concepts, but are otherwise very different.
JCOF (dataNotation, appeared 2022)
Stands for: JSON-like Compact Object Format
Creators: Martin Dørum
Origin: https://github.com/mortie/jcof/issues
Country: Norway



GitHub description: An efficient drop-in replacement for JSON.

Programmer;"age""first-name""full-time""occupation";
{"people"[(0,iw"Bob"b"Plumber")(0,is"Alice"b,s0)(0,iA"Bernard"n,n)(0,iV"El"B,s0)]}
JOSS Extended and Adapted for Nineteen-hundred (pl, appeared 1960)
Stands for: JOSS Extended and Adapted for Nineteen-hundred
Origin: University of Southampton
Country: United Kingdom


JEAN was a dialect of the JOSS programming language developed for and used on ICT 1900 series computers in the late 1960s and early 1970s; it was implemented under the MINIMOP operating system. It was used at the University of Southampton. JEAN was an acronym derived from "JOSS Extended and Adapted for Nineteen-hundred". It was operated from a Teletype terminal.
Jevko (dataNotation, appeared 2021)
Origin: https://github.com/jevko
Country: Poland
Website: https://jevko.org/




first name [John]
last name [Smith]
is alive [true]
age [27]
address [
  street address [21 2nd Street]
  city [New York]
  state [NY]
  postal code [10021-3100]
]
phone numbers [
  [
    type [home]
    number [212 555-1234]
  ]
  [
    type [office]
    number [646 555-4567]
  ]
]
children []
spouse []
Jinja (template, appeared 2006)
Creators: Armin Ronacher
Origin: https://github.com/pallets/jinja/issues/
Country: Various
Website: http://jinja.pocoo.org/


Jinja is a template engine for the Python programming language and is licensed under a BSD License created by Armin Ronacher. It is similar to the Django template engine but provides Python-like expressions while ensuring that the templates are evaluated in a sandbox. It is a text-based template language and thus can be used to generate any markup as well as sourcecode. The Jinja template engine allows customization of tags, filters, tests, and globals. Also, unlike the Django template engine, Jinja allows the template designer to call functions with arguments on objects. Jinja is Flask's default template engine.

GitHub description: A very fast and expressive template engine.
JIS X 0201 (characterEncoding, appeared 1969)
Origin: The National Institute of Advanced Industrial Science and Technology
Country: Japan


JIS X 0201, a Japanese Industrial Standard developed in 1969 (then called JIS C 6220 until the JIS category reform), was the first Japanese electronic character set to become widely used.  It is either 7-bit encoding or 8-bit encoding, although 8-bit encoding is dominant for modern use. The full name of this standard is 7-bit and 8-bit coded character sets for information interchange (7ビット及び8ビットの情報交換用符号化文字集合). The first 96 codes comprise an ISO 646 variant, mostly following ASCII with some differences, while the second 96 character codes represent the phonetic Japanese katakana signs. Since the encoding does not provide any way to express hiragana or kanji, it is only capable of expressing simplified written Japanese. Nevertheless, it is possible to express, at least phonetically, the full range of sounds in the language.  In the 1980s, this was acceptable for media such as text mode computer terminals, telegrams, receipts or other electronically handled data. JIS X 0201 was supplanted by subsequent encodings such as Shift JIS (which combines this standard and JIS X 0208) and later Unicode.
Jisp (pl, appeared 2014)
Creators: Nelo Mitranim
Origin: https://github.com/mitranim/jisp/issues
Country: Unknown
Website: https://mitranim.com/jisp/
File extensions: jisp
Keywords: car
head
cdr
tail
init
last
let
isa
insta
any
prn



GitHub description: Lisp-style language that compiles to JavaScript
jiyu (pl, appeared 2019)
Creators: Josh Huelsman
Origin: https://handmade.network/p/114/jiyu/forums
Country: Unknown
Website: https://jiyu.handmade.network/



GitHub description: A compiler and programming language for fun.

#clang_import
"""
#include <stdio.h>
""";

func @metaprogram main(argc: int32, argv: **uint8) {
    printf("Hello, Sailor!\n");

    var file = fopen("myfile.txt", "wb");
    fwrite("Hello, Pilot!\n".data, 1, 14, file);
    fclose(file);
}
JLang (pl, appeared 2016)
Creators: Joao Marcelo Brito
Origin: https://github.com/jmbrito01/jlang/issues
Country: Brazil
Website: https://github.com/jmbrito01/jlang



GitHub description: Just another programming language

func test param {
    this.id = 0;
    ret this;
}
var testObj = test();
i = testObj.id;
JMP (application, appeared 1989)
Origin: SAS Institute Inc
Country: United States


JMP (pronounced "jump") is a suite of computer programs for statistical analysis developed by the JMP business unit of SAS Institute. It was launched in 1989 to take advantage of the graphical user interface introduced by the Macintosh. It has since been significantly rewritten and made available for the Windows operating system. JMP is used in applications such as Six Sigma, quality control, and engineering, design of experiments, as well as for research in science, engineering, and social sciences. The software can be purchased in any of five configurations: JMP, JMP Pro, JMP Clinical, JMP Genomics and the JMP Graph Builder App for the iPad. JMP can be automated with its proprietary scripting language, JSL. The software is focused on exploratory visual analytics, where users investigate and explore data. These explorations can also be verified by hypothesis testing, data mining, or other analytic methods. In addition, discoveries made through graphical exploration can lead to a designed experiment that can be both designed and analyzed with JMP.
Joe-E (pl, appeared 2004)
Creators: David A. Wagner
Origin: https://github.com/davidwagner/joe-e/issues
Country: United States


Joe-E is a subset of the Java programming language intended to support programming according to object-capability discipline.The language is notable for being an early object-capability subset language.  It has influenced later subset languages, such as ADsafe and Caja/Cajita, subsets of Javascript. It is also notable for allowing methods to be verified as functionally pure, based on their method signatures.The restrictions imposed by the Joe-E verifier include:  Classes may not have mutable static fields, because these create global state. Catching out-of-memory exceptions is prohibited, because doing so allows non-deterministic execution.  For the same reason, finally clauses are not allowed. Methods in the standard library may be blocked if they are deemed unsafe according to taming rules.  For example, the constructor new File(filename) is blocked because it allows unrestricted access to the filesystem.Cup of Joe is slang for coffee, and so serves as a trademark-avoiding reference to Java. Thus, the name Joe-E is intended to suggest an adaptation of ideas from the E programming language to create a variant of the Java language.  Waterken Server is written in Joe-E.
Jolie (pl, appeared 2006)
Stands for: Java Orchestration Language Interpreter Engine
Creators: Claudio Guidi
Fabrizio Montesi
Origin: University of Bologna
Country: Italy
Website: http://jolie-lang.org/


Jolie (Java Orchestration Language Interpreter Engine) is an open-source programming language for developing distributed applications based on microservices. In the programming paradigm proposed with Jolie, each program is a service that can communicate with other programs by sending and receiving messages over a network. Jolie supports an abstraction layer that allows services to communicate using different mediums, ranging from TCP/IP sockets to local in-memory communications between processes.Jolie is currently supported by an interpreter implemented in the Java language, which can be run in multiple operating systems including Linux-based operating systems, OS X, and Windows. The language comes with formal semantics, meaning that the execution of Jolie programs is mathematically defined. For this reason, Jolie is used in research for the investigation of language-based techniques for the development of distributed systems, and it is also used for teaching at some Universities.The Jolie open source project was started by Fabrizio Montesi in 2006, as part of his studies at the University of Bologna. The project initially began as an implementation of the SOCK process calculus, a formal model proposed by Claudio Guidi et al. at the University of Bologna inspired by the CCS process calculus and the WS-BPEL programming language. Jolie extends SOCK with support for, e.g., tree-like data structures (inspired by XML, but with a syntax resembling that of C and Java), message types, typed session programming, integration with Java and JavaScript, code mobility, application containment, and web programming. A complete list of the project contributors is available at.The project is currently maintained by Fabrizio Montesi and its evolution is driven by Fabrizio Montesi and Claudio Guidi. Since it supports the orchestration of web services, Jolie is an alternative to XML-based orchestration languages such as WS-BPEL as it offers a concise (C-like) syntax for accessing XML-like data structures.
jonprl (pl, appeared 2015)
Creators: Jonathan Sterling
Origin: https://github.com/jonsterling/JonPRL/issues
Country: Denmark and United Kingdom and Australia and United States
Website: https://www.jonprl.org/



GitHub description: An proof refinement logic for computational type theory. Inspired by Nuprl. [For up-to-date development, see JonPRL's successor, RedPRL: https://github.com/redprl/sml-redprl]
JOSS (pl, appeared 1966)
Stands for: JOHNNIAC Open Shop System
Creators: Cliff Shaw
Origin: RAND Corporation
Country: United States


JOSS (an acronym for JOHNNIAC Open Shop System) was one of the very first interactive, time-sharing programming languages. JOSS I, developed by J. Clifford Shaw at RAND was first implemented, in beta form, on the JOHNNIAC computer in May 1963.  The full implementation was deployed in January 1964, supporting five terminals and the final version, supporting ten terminals, was deployed in January 1965.JOSS was written in a symbolic assembly language called EasyFox (E and F in the US military's phonetic alphabet of that time).  EasyFox was also developed by Cliff Shaw. JOSS was dubbed "The Helpful Assistant" for its conversational user interface.  Originally green/black typewriter ribbons were used in its terminals with green being used for user input and black for the computer's response. Mathematically, JOSS was interesting because it stored all numbers as an integer and a decimal exponent. This means calculations were exact decimal values, as opposed to floating point calculations. One third plus one third plus one third was exactly one. Any command that was not understood elicited the response "Eh?" or "SORRY". JOSS II, was developed by Charles L. Baker, Joseph W. Smith, Irwin D. Greenwald, and G. Edward Bryan for the PDP-6 computer between 1964 and February 1966. Many variants of JOSS were developed and implemented on a variety of platforms.  Some of these variants remained very similar to the original: TELCOMP, FOCAL, CAL, CITRAN, ISIS, PIL/I, JEAN (ICT 1900 series), AID (PDP-10); while others, such as MUMPS, developed in distinctive directions.
Joule (pl, appeared 1996)
Creators: E. Dean Tribble
Origin: Agorics
Country: United States


Joule is a concurrent dataflow programming language, designed for building distributed applications. It is so concurrent that the order of statements within a block is irrelevant to the operation of the block. Statements are executed whenever possible, based on their inputs. Everything in Joule happens by sending messages. There is no control flow. Instead, the programmer describes the flow of data, making it a dataflow programming language.   It is considered the precursor to the E programming language.
Joy (pl, appeared 2001)
Creators: Manfred von Thun
Origin: La Trobe University
Country: Australia


The Joy programming language in computer science is a purely functional programming language that was produced by Manfred von Thun of La Trobe University in Melbourne, Australia. Joy is based on composition of functions rather than lambda calculus. It has turned out to have many similarities to Forth, due not to design but to a sort of parallel evolution and convergence. It was also inspired by the function-level programming style of Backus's FP.
jplace (jsonFormat, appeared 2012)
Origin: Fred Hutchinson Cancer Research Center
University of Washington
Heidelberg Institute for Theoretical Studies
Country: United States and Germany

We have developed a unified format for phylogenetic placements, that is, mappings of environmental sequence data (e.g., short reads) into a phylogenetic tree. We are motivated to do so by the growing number of tools for computing and post-processing phylogenetic placements, and the lack of an established standard for storing them. The format is lightweight, versatile, extensible, and is based on the JSON format, which can be parsed by most modern programming languages.



{
“tree”: “((A:0.2{0},B:0.09{1}):0.7{2},C:0.5{3}){4};”,
“placements”:
[
   {“p”:
       [[1, −2578.16, 0.777385, 0.004132, 0.0006],
       [0, −2580.15, 0.107065, 0.000009, 0.0153]
       ],
   “n”: [“fragment1”, “fragment2”]
   },
   {“p”: [[2, −2576.46, 1.0, 0.003555, 0.000006]],
       “nm”: [[“fragment3”, 1.5], [“fragment4”, 2]]}
],
“metadata”:
{“invocation”:
   “pplacer -c tiny.refpkg frags.fasta”
},
“version”: 3,“fields”:
[“edge_num”, “likelihood”, “like_weight_ratio”,
           “distal_length”, “pendant_length”]
}
JQuery (library, appeared 2006)
Origin: https://jquery.org/team/
Country: Various
Website: https://jquery.com


jQuery is a cross-platform JavaScript library designed to simplify the client-side scripting of HTML. It is free, open-source software using the permissive MIT License. Web analysis indicates that it is the most widely deployed JavaScript library by a large margin. jQuery's syntax is designed to make it easier to navigate a document, select DOM elements, create animations, handle events, and develop Ajax applications. jQuery also provides capabilities for developers to create plug-ins on top of the JavaScript library. This enables developers to create abstractions for low-level interaction and animation, advanced effects and high-level, themeable widgets. The modular approach to the jQuery library allows the creation of powerful dynamic web pages and Web applications. The set of jQuery core features—DOM element selections, traversal and manipulation—enabled by its selector engine (named "Sizzle" from v1.3), created a new "programming style", fusing algorithms and DOM data structures. This style influenced the architecture of other JavaScript frameworks like YUI v3 and Dojo, later stimulating the creation of the standard Selectors API. Microsoft and Nokia bundle jQuery on their platforms. Microsoft includes it with Visual Studio for use within Microsoft's ASP.NET AJAX and ASP.NET MVC frameworks while Nokia has integrated it into the Web Run-Time widget development platform.

GitHub description: jQuery JavaScript Library
JRuby (pl, appeared 2001)
Origin: https://github.com/jruby
Country: Various


JRuby is an implementation of the Ruby programming language atop the Java Virtual Machine, written largely in Java. It is free software released under a three-way EPL/GPL/LGPL license. JRuby is tightly integrated with Java to allow the embedding of the interpreter into any Java application with full two-way access between the Java and the Ruby code (similar to Jython for the Python language). JRuby's lead developers are Charles Oliver Nutter and Thomas Enebo, with many current and past contributors including Ola Bini and Nick Sieger. In September 2006, Sun Microsystems hired Enebo and Nutter to work on JRuby full-time. In June 2007, ThoughtWorks hired Ola Bini to work on Ruby and JRuby.In July 2009, the JRuby developers left Sun to continue JRuby development at Engine Yard. In May 2012, Nutter and Enebo left Engine Yard to work on JRuby at Red Hat.
JScript (pl, appeared 1996)
Origin: Microsoft
Website: https://msdn.microsoft.com/library/hbxc2t98.aspx
File extensions: js
jse
wsf
wsc


JScript is Microsoft's dialect of the ECMAScript standard that is used in Microsoft's Internet Explorer. JScript is implemented as an Active Scripting engine. This means that it can be "plugged in" to OLE Automation applications that support Active Scripting, such as Internet Explorer, Active Server Pages, and Windows Script Host. It also means such applications can use multiple Active Scripting languages, e.g., JScript, VBScript or PerlScript. JScript was first supported in the Internet Explorer 3.0 browser released in August 1996. Its most recent version is JScript 9.0, included in Internet Explorer 9. JScript 10.0 is a separate dialect, also known as JScript .NET, which adds several new features from the abandoned fourth edition of the ECMAScript standard. It must be compiled for .NET Framework version 2 or version 4, but static type annotations are optional.