pldb/PLDB huggingface dataset:
QBasic (pl, appeared 1991)
Stands for: Quick Beginners All purpose Symbolic Instruction Code
Origin: Microsoft
Country: United States
Keywords: ACCESS
ALIAS
ANY
APPEND
AS
BASE
BINARY
BYVAL
CASE
CDECL
DOUBLE
ELSE
ELSEIF
ENDIF
INTEGER
IS
LIST
LOCAL
LONG
LOOP
MOD
NEXT
OFF
ON
OUTPUT
RANDOM
SIGNAL
SINGLE
STEP
STRING
THEN
TO
UNTIL
USING
WEND


QBasic (Quick Beginners All purpose Symbolic Instruction Code) is an IDE and interpreter for a variety of the BASIC programming language which is based on QuickBASIC. Code entered into the IDE is compiled to an intermediate representation, and this IR is immediately interpreted on demand within the IDE. It can run under nearly all versions of DOS and 32-bit versions of Windows, or through emulation via DOSBox/DOSEMU on Linux, FreeBSD, and 64-bit versions of Windows. (QBasic is a DOS program and requires DOS or a DOS emulator. Windows XP comes with an emulator called DOS Virtual Machine, subsequent versions of Windows require an emulator such as DosBox.) For its time, QBasic provided a state-of-the-art IDE, including a debugger with features such as on-the-fly expression evaluation and code modification. It supports various inbuilt functions. Like QuickBASIC, but unlike earlier versions of Microsoft BASIC, QBasic is a structured programming language, supporting constructs such as subroutines and while loops. Line numbers, a concept often associated with BASIC, are supported for compatibility, but are not considered good form, having been replaced by descriptive line labels. QBasic has limited support for user-defined data types (structures), and several primitive types used to contain strings of text or numeric data.
qbe (pl, appeared 2015)
Origin: https://lists.sr.ht/~mpu/qbe
Country: Unknown
Website: https://c9x.me/compile/

QBE aims to be a pure C embeddable backend that provides 70% of the performance of advanced compilers in 10% of the code. Its small size serves both its aspirations of correctness and our ability to understand, fix, and improve it. It also serves its users by providing trivial integration and great flexibility.
qed-lang (pl, appeared 2015)
Origin: University of Washington
Country: United States
Website: https://qed-lang.org




void Button(string text) {
    int col = 0xC0C0C0; @out("  " + text + "  ")
} @out(rect()) @bgcol(col) @onpress(col = 0x808080) @onrelease([col = 0xC0C0C0, return()])
Button("Form 1");
println("Form 1 clicked");
Button("Form 2");
println("Form 2 clicked");
Button("Quit");
return(0);
QMake (pl, appeared 2002)
Origin: Qt Group plc
Country: Finland


qmake is an utility that automates the generation of makefiles. Makefiles are used by the program make to build executable programs from source code; therefore qmake is a make-makefile tool, or makemake for short. The makefiles that qmake produces are tailored to the particular platform where it is run from based on qmake project files. This way one set of build instructions can be used to create build instructions on different operating systems. qmake supports code generation for the following operating systems: Linux, Apple Mac OS X, Symbian, Microsoft Windows and Microsoft Windows CE. qmake was created by Trolltech (now The Qt Company). It is distributed and integrated with the Qt application framework, and automates the creation of moc (meta object compiler) and rcc (resource compiler) sources, which are used in Qt's meta-object system and in the integration of binary resources (e.g., pictures). The qmake tool helps simplify the build process for development projects across different platforms. It automates the generation of Makefiles so that only a few lines of information are needed to create each Makefile. You can use qmake for any software project, whether it is written with Qt or not.


CONFIG += qt debug
HEADERS += hello.h
SOURCES += hello.cpp
SOURCES += main.cpp
win32 {
    SOURCES += hellowin.cpp
}
unix {
    SOURCES += hellounix.cpp
}
!exists( main.cpp ) {
    error( "No main.cpp file found" )
}
win32:debug {
    CONFIG += console
}
QML (pl, appeared 2009)
Stands for: Qt Modeling Language
Origin: Qt Group plc
Country: Finland
Website: http://qt-project.org/doc/qt-5/qmlapplications.html


QML (Qt Modeling Language) is a user interface markup language. It is a declarative language (similar to CSS and JSON) for designing user interface–centric applications. Inline JavaScript code handles imperative aspects. It is associated with Qt Quick, the UI creation kit originally developed by Nokia within the Qt framework. Qt Quick is often used for mobile applications where touch input, fluid animations (60 FPS) and user experience are crucial. QML is also used with Qt3D to describe a 3D scene and a "frame graph" rendering methodology. A QML document describes a hierarchical object tree. QML modules shipped with Qt include primitive graphical building blocks (e.g., Rectangle, Image), modeling components (e.g., FolderListModel, XmlListModel), behavioral components (e.g., TapHandler, DragHandler, State, Transition, Animation), and more complex controls (e.g., Button, Slider, Drawer, Menu). These elements can be combined to build components ranging in complexity from simple buttons and sliders, to complete internet-enabled programs. QML elements can be augmented by standard JavaScript both inline and via included .js files.  Elements can also be seamlessly integrated and extended by C++ components using the Qt framework. QML is the language; its JavaScript runtime is the custom V4 engine, since Qt 5.2; and Qt Quick is the 2D scene graph and the UI framework based on it. These are all part of the Qt Declarative module, while the technology is no longer called Qt Declarative. QML and JavaScript code can be compiled into native C++ binaries with the Qt Quick Compiler.  Alternatively there is a QML cache file format which stores a compiled version of QML dynamically for faster startup the next time it is run.


Item {
    Rectangle {
        id: myRect
        width: 120
        height: 100
    }
    Rectangle {
        width: myRect.width
        height: 200
    }
}
QOIR (binaryDataFormat, appeared 2022)
Creators: Nigel Tao
Origin: https://github.com/nigeltao/qoir/issues
Country: Australia
Website: https://nigeltao.github.io
File extensions: qoir

A Fast, Simple, Lossless Image File Format based on QOI ( http://qoiformat.org )


GitHub description: A fast, simple, lossless image file format.
Qore (pl, appeared 2006)
Creators: David Nichols
Origin: https://github.com/qorelanguage
Country: Czech Republic
Website: http://qore.org/
File extensions: q
qm
qtest


Qore is an interpreted, high-level, general-purpose, garbage collected  dynamic programming language, featuring support for code embedding and sandboxing with optional strong typing and a focus on fundamental support for multithreading and SMP scalability. Qore is unique because it is an interpreted scripting language with fundamental support for multithreading (meaning more than one part of the same code can run at the same time), and additionally because it features automatic memory management (meaning programmers do not have to allocate and free memory explicitly) while also supporting the RAII idiom with destructors for scope-based resource management and exception-safe programming.  This is due to Qore's unique prompt collection implementation for garbage collection.

GitHub description: Qore Programming Language
QR code (barCodeFormat, appeared 1994)
Origin: DENSO Corporation
Country: Japan


QR code (abbreviated from Quick Response code) is the trademark for a type of matrix barcode (or two-dimensional barcode) first designed in 1994 for the automotive industry in Japan. A barcode is a machine-readable optical label that contains information about the item to which it is attached. In practice, QR codes often contain data for a locator, identifier, or tracker that points to a website or application. A QR code uses four standardized encoding modes (numeric, alphanumeric, byte/binary, and kanji) to store data efficiently; extensions may also be used.The Quick Response system became popular outside the automotive industry due to its fast readability and greater storage capacity compared to standard UPC barcodes. Applications include product tracking, item identification, time tracking, document management, and general marketing.A QR code consists of black squares arranged in a square grid on a white background, which can be read by an imaging device such as a camera, and processed using Reed–Solomon error correction until the image can be appropriately interpreted. The required data is then extracted from patterns that are present in both horizontal and vertical components of the image.
Qt (framework, appeared 1995)
Origin: Qt Group plc
Country: Finland
Website: https://www.qt.io/


Qt ( "cute") is a cross-platform application framework that is used for developing application software that can be run on various software and hardware platforms with little or no change in the underlying codebase, while still being a native application with native capabilities and speed. Qt is currently being developed both by The Qt Company, a publicly listed company, and the Qt Project under open-source governance, involving individual developers and firms working to advance Qt. Qt is available with both proprietary and open source GPL 2.0, GPL 3.0, and LGPL 3.0 licenses.
QtScript (pl, appeared 2008)


QtScript is a scripting engine that has been part of the Qt cross-platform application framework since version 4.3.0. The scripting language is based on the ECMAScript standard with a few extensions, such as QObject-style signal and slot connections. The library contains the engine, and a C++ API for evaluating QtScript code and exposing custom QObject-derived C++ classes to QtScript. The QtScript Binding Generator provides bindings for the Qt API to access directly from ECMAScript. QtScript and the binding generator are used for Amarok 2's scripting system. The current (as of Qt 4.7) implementation uses JavaScriptCore and will not be further developed. The module is deprecated as of Qt 5.5.
Quaint (textMarkup, appeared 2014)
Creators: Olivier Breuleux
Origin: https://github.com/breuleux/quaint/issues
Country: Canada
Website: http://breuleux.github.io/quaint/

Quaint is a markup language that you can use to write documents. It is similar to Markdown, but it is more powerful and more extensible.


GitHub description: The Quaint markup language

;; Edit me!

meta ::
  title = My Resume
  author = My Name

= meta::title

Hello, my name is __meta::author and this is meta::title~! I have many skills:

* Pirate skills
  * Eye patch
  * Peg leg
* _Ninja skills
  css ::
    .invisible { color: transparent; }
  # span.invisible % Stealth!
  # Nunchakus
* Robot skills
  * Beep! Boop!
* I can also cook!
  + Meal       + Can I cook it? + How good?
  | Potatoes   | Yes            | Delicious
  | Steak      | Yes            | Rare
  | Egg salad  | You bet!       | Decadent
  | Cheesecake | Yes!!!         | Oh my god

My website is @@{web}. Find me on Google@@http://google.com~! It's easy as 2 + 2 = {2 + 2}!

web => http://my.amazing.website.com

Please embed my `code on your website:

javascript &
  function virus() { alert("AAAAAAAAHHH"); }

@@image:assets/quaint-small.png
Quake (pl, appeared 2001)
Origin: Digital Equipment Corporation
Country: United States

Quake is a simple, specialized language and its interpreter drawing on elements of the C language, the Bourne shell, and the C pre-processor. The cm3 compiler includes a quake interpreter as its extension language. In fact, the configuration file, cm3.cfg, and m3makefiles are quake scripts. Quake was designed to be a simple extension language for the builder. Building a complete, general-purpose language was not one of the goals. Cm3 calls out to quake every time it needs to do something that needs to be specialized such as compiling C files or linking.



proc simple(prefix, suffix) is
   q = prefix & "." & suffix
 end
QuakeC (pl, appeared 1996)
Creators: John Carmack
Origin: id Software LLC
Country: United States


QuakeC is an interpreted language developed in 1996 by John Carmack of id Software to program parts of the video game Quake. Using QuakeC, a programmer is able to customize Quake to great extents by adding weapons, changing game logic and physics, and programming complex scenarios. It can be used to control many aspects of the game itself, such as parts of the AI, triggers, or changes in the level. The Quake engine was the only game engine to use QuakeC. Following engines used DLL game modules for customization written in C and C++ from id Tech 4 on.
QUEL (queryLanguage, appeared 1976)
Creators: Michael Stonebraker
Origin: University of California, Berkeley
Country: United States


QUEL is a relational database query language, based on tuple relational calculus, with some similarities to SQL.  It was created as a part of the Ingres DBMS effort at University of California, Berkeley, based on Codd's earlier suggested but not implemented Data Sub-Language ALPHA.  QUEL was used for a short time in most products based on the freely available Ingres source code, most notably in an implementation called POSTQUEL supported by POSTGRES. As Oracle and DB2 gained market share in the early 1980s, most companies then supporting QUEL moved to SQL instead. QUEL continues to be available as a part of the Ingres DBMS, although no QUEL-specific language enhancements have been added for many years.


range of E is EMPLOYEE
retrieve into W
(COMP = E.Salary / (E.Age - 18))
where E.Name = "Jones"
Query by Example (pl, appeared 1969)
Origin: IBM
Country: United States


Query by Example (QBE) is a database query language for relational databases. It was devised by Moshé M. Zloof at IBM Research during the mid-1970s, in parallel to the development of SQL. It is the first graphical query language, using visual tables where the user would enter commands, example elements and conditions. Many graphical front-ends for databases use the ideas from QBE today. Originally limited only for the purpose of retrieving data, QBE was later extended to allow other operations, such as inserts, deletes and updates, as well as creation of temporary tables. The motivation behind QBE is that a parser can convert the user's actions into statements expressed in a database manipulation language, such as SQL.  Behind the scenes, it is this statement that is actually executed. A suitably comprehensive front-end can minimize the burden on the user to remember the finer details of SQL, and it is easier and more productive for end-users (and even programmers) to select tables and columns by selecting them rather than typing in their names, In the context of information retrieval, QBE has a somewhat different meaning. The user can submit a document, or several documents, and ask for "similar" documents to be retrieved from a document database [see search by multiple examples]. Similarity search is based comparing document vectors (see Vector Space Model). QBE is a seminal work in end-user development, frequently cited in research papers as an early example of this topic. Currently, QBE is supported in several relational database front ends, notably Microsoft Access, which implements "Visual Query by Example", as well as Microsoft SQL Server Enterprise Manager. It is also implemented in several object-oriented databases (e.g. in db4o). QBE is based on the logical formalism called tableau query, although QBE adds some extensions to that, much like SQL is based on the relational algebra.
QuickBASIC (pl, appeared 1985)
Origin: Microsoft
Country: United States


Microsoft QuickBASIC (also QB) is an Integrated Development Environment (or IDE) and compiler for the BASIC programming language that was developed by Microsoft. QuickBASIC runs mainly on DOS, though there was a short-lived version for the classic Mac OS. It is loosely based on GW-BASIC but adds user-defined types, improved programming structures, better graphics and disk support and a compiler in addition to the interpreter.  Microsoft marketed QuickBASIC as the introductory level for their BASIC Professional Development System.  Microsoft marketed two other similar IDEs for C and Pascal, viz QuickC and QuickPascal.
R (pl, appeared 1993)
Creators: Ross Ihaka
Robert Gentleman
Origin: University of Auckland
Country: United States
Website: https://www.r-project.org
File extensions: r
R
RData
rds
rda
Keywords: if
else
repeat
while
function
for
in
next
break
TRUE
FALSE
NULL
Inf
NaN
NA
NA_integer_
NA_real_
NA_complex_
NA_character_
...


R is an open source programming language and software environment for statistical computing and graphics that is supported by the R Foundation for Statistical Computing. The R language is widely used among statisticians and data miners for developing statistical software and data analysis. Polls, surveys of data miners, and studies of scholarly literature databases show that R's popularity has increased substantially in recent years. R is a GNU package. The source code for the R software environment is written primarily in C, Fortran, and R. R is freely available under the GNU General Public License, and pre-compiled binary versions are provided for various operating systems. While R has a command line interface, there are several graphical front-ends available.
Racket (pl, appeared 1994)
Creators: Matthias Felleisen
Matthew Flatt
Robert Bruce Findler
Shriram Krishnamurthi
Origin: PLT Inc.
Website: http://racket-lang.org
File extensions: rkt
rktl
rktd
scrbl
plt
ss
scm


Racket is a general purpose, multi-paradigm programming language in the Lisp-Scheme family. One of its design goals is to serve as a platform for language creation, design, and implementation. The language is used in a variety of contexts such as scripting, general-purpose programming, computer science education, and research. The platform provides an implementation of the Racket language (including a sophisticated run-time system, various libraries, JIT compiler, and more) along with a development environment called DrRacket (formerly named DrScheme) written in Racket itself. The IDE and an accompanying programming curriculum is used in the ProgramByDesign outreach program, an attempt to turn computing and programming into "an indispensable part of the liberal arts curriculum". The core language is known for its extensive macro system which enables the creation of embedded and domain-specific languages, language constructs such as classes or modules, and separate dialects of Racket with different semantics. The platform distribution is free and open-source software distributed under the GNU Lesser General Public License (LGPL) license. Extensions and packages written by the community are uploaded to Racket's centralized package catalog. While the Racket distribution continues to support Scheme variants, the new Racket language was launched on 7 June 2010, Racket was launched. https://racket-lang.org/new-name.html
Ragel (pl, appeared 2007)
Origin: https://github.com/bnoordhuis/ragel/issues
Country: The Netherlands
Website: http://complang.org/ragel/


Ragel is a finite-state machine compiler and a parser generator. Initially Ragel supported output for C, C++ and Assembly source code,. Although subsequently extended to support several other languages (said to be Objective C, D, Go, Ruby, and Java) this support of other languages was withdrawn .  It supports the generation of table or control flow driven state machines from regular expressions and/or state charts and can also build lexical analysers via the longest-match method. Ragel specifically targets text parsing and input validation.

GitHub description: Ragel State Machine Compiler - http://www.complang.org/ragel/

=begin
%%{
  machine simple_scanner;

  action Emit {
    emit data[(ts+8)..(te-7)].pack('c*')
  }

  foo = 'STARTFOO' any+ :>> 'ENDFOO';
  
  main := |*
    foo => Emit;
    any;
  *|;
}%%
=end


# Scans a file for "STARTFOO[...]ENDFOO" blocks and outputs their contents.
#
# ENV['CHUNK_SIZE'] determines how much of the file to read in at a time, allowing you to control memory usage.
#
# Uses ragel's scanner functionality even though it's not strictly necessary.
class SimpleScanner
  attr_reader :path

  def initialize(path)
    @path = path
    %% write data;
    # % (this fixes syntax highlighting)
  end

  def emit(foo)
    $stdout.puts foo
  end
  
  def perform
    # So that ragel doesn't try to get it from data.length
    pe = :ignored
    eof = :ignored

    %% write init;
    # % (this fixes syntax highlighting)

    leftover = []
    
    File.open(path) do |f|
      while chunk = f.read(ENV['CHUNK_SIZE'].to_i)
        data = leftover + chunk.unpack('c*')
        p ||= 0
        pe = data.length

        %% write exec;
        # % (this fixes syntax highlighting)
        if ts
          leftover = data[ts..pe]
          p = p - ts
          ts = 0
        else
          leftover = []
          p = 0
        end
      end
    end
  end
end

s = SimpleScanner.new ARGV[0]
s.perform
Ruby on Rails (framework, appeared 2005)
Origin: https://github.com/rails
Country: Denmark
Website: http://rubyonrails.org


Ruby on Rails, or Rails, is a server-side web application framework written in Ruby under the MIT License. Rails is a model–view–controller (MVC) framework, providing default structures for a database, a web service, and web pages. It encourages and facilitates the use of web standards such as JSON or XML for data transfer, and HTML, CSS and JavaScript for display and user interfacing. In addition to MVC, Rails emphasizes the use of other well-known software engineering patterns and paradigms, including convention over configuration (CoC), don't repeat yourself (DRY), and the active record pattern.
Raku (pl, appeared 2019)
Creators: Larry Wall
Origin: https://www.raku.org/community
Country: United States
Website: https://www.raku.org/


Raku is a member of the Perl family of programming languages. Formerly known as Perl 6, it was renamed in October 2019.While historically several interpreter and compiler implementations were being written, today only the Rakudo implementation is in active development. Raku introduces elements of many modern and historical languages. Compatibility with Perl is not a goal, though a compatibility mode is part of the specification. The design process for Raku began in 2000. In February 2015 a post on The Perl Foundation blog stated that "The Perl6 team will attempt to get a development release of version 1.0 available for Larry's birthday in September and a Version 1.0 release by Christmas", and on 25 December 2015, the first stable version of the specification was announced.Development on Pugs, the first high-traction implementation, began in 2005, and there have been multiple Raku implementation projects. Rakudo is based on NQP (Not Quite Perl) and can use MoarVM or the Java Virtual Machine as a runtime environment, and releases a new version every month (including precompiled Linux packages); in July 2010, the project released the first Rakudo Star distribution, a collection of a Raku implementation and related materials. Larry Wall maintains a reference grammar known as STD.pm6, written in Raku and bootstrapped with Perl.


grammar Parser {
    rule  TOP  { I <love> <lang> }
    token love { '♥' | love }
    token lang { < Raku Perl Rust Go Python Ruby > }
 }
 
 say Parser.parse: 'I ♥ Raku';
 # OUTPUT: ｢I ♥ Raku｣ love => ｢♥｣ lang => ｢Raku｣
 
 say Parser.parse: 'I love Perl';
 # OUTPUT: ｢I love Perl｣ love => ｢love｣ lang => ｢Perl｣
 start { sleep 1.5; print "hi" }
 await Supply.from-list(<A B C D E F>).throttle: 2, {
     sleep 0.5;
     .print
 }
 # OUTPUT: ABCDhiEF
 # No floating point noise:
 say 0.1 + 0.2 == 0.3;        # OUTPUT: True
 say (1/13 + 3/7 + 3/8).perl; # OUTPUT:  <641/728>
 # Infinite list of primes:
 my @primes = ^∞ .grep: *.is-prime;
 say "1001ˢᵗ prime is @primes[1000]";
 
 # Lazily read words from a file
 .say for '50TB.file.txt'.IO.words;