Languages

From Things and Stuff Wiki
Jump to navigation Jump to search


Languages

See also Notebooks


to reformat. should be more a graph..?





  • HOPL - An online roster and genealogy of 8945 programming languages from the 18th century to the present, featuring 7,800 influence links and over 11,000 citations.


  • https://en.wikipedia.org/wiki/First-generation_programming_language - a grouping of programming languages that are machine level languages used to program first-generation computers. The instructions were given through the front panel switches of these computers, directly to the CPU. There was originally no compiler or assembler to process the instructions in 1GL.


  • https://en.wikipedia.org/wiki/Second-generation_programming_language - a generational way to categorize assembly languages. The code can be read and written by a programmer. To run on a computer it must be converted into a machine readable form, a process called assembly. The language is specific to a particular processor family and environment.
  • https://en.wikipedia.org/wiki/Third-generation_programming_language - a generational way to categorize high-level computer programming languages. Where assembly languages, categorized as second generation programming languages, are machine-dependent, 3GLs are much more machine independent and more programmer-friendly. This includes features like improved support for aggregate data types, and expressing concepts in a way that favors the programmer, not the computer. A third generation language improves over a second generation language by having the computer take care of non-essential details. 3GLs feature more abstraction than previous generations of languages, and thus can be considered higher level languages than their first and second generation counterparts.

First introduced in the late 1950s, Fortran, ALGOL, and COBOL are early examples of this sort of language. Most popular general-purpose languages today, such as C, C++, C#, Java, BASIC and Pascal, are also third-generation languages, although each of these languages can be further subdivided into other categories based on other contemporary traits.





  • https://rosettacode.org/wiki/Operator_precedence - a list of precedence and associativity of all the operators and constructs that the language utilizes in descending order of precedence such that an operator which is listed on some row will be evaluated prior to any operator that is listed on a row further below it. Operators that are in the same cell (there may be several rows of operators listed in a cell, are evaluated with the same level of precedence, in the given direction.







Plankalkül

1948

Speedcoding

1953

IPL

1954

FLOW-MATIC

1955


FLOW-MATIC

1955

  • Xavier Denis - ПП-BESM- a language implemented for the BESM computer, one of the first large scale soviet computers. Started in 1954, after a lecture on ПП-1 a precursor language, it was finished by 1955. [11]

Fortran

1957

COMTRAN

1957

ALGOL

1958

COBOL

1959

Lisp

1959

See Lisp

See also Emacs

ALGOL 60

1960

JOVIAL

1960

Influenced by ALGOL, SAGE. Influenced CMS-2, Coral 66, and SYMPL.

SNOBOL

CPL

1963

BASIC

1964

  • https://en.wikipedia.org/wiki/Dartmouth_BASIC - the original version of the BASIC programming language. It is so named because it was designed and implemented at Dartmouth College. The language was designed by John Kemeny and Thomas Kurtz as part of the Dartmouth Time Sharing System (DTSS) and was one of the first programming languages intended to be used interactively.

Several versions were produced at Dartmouth over the years, all implemented as compile and go compilers, unlike many of the versions of the language implemented elsewhere, which were interpreters. The first compiler was produced before the time-sharing system was ready. Known as CardBASIC, it was intended for the standard card-reader based batch processing system. Like all the following versions, it was implemented by a team of undergraduate programmers working under the direction of Kemeny and Kurtz. The first interactive version was made available to general users in June 1964; the second in October, 1964; the third in 1966; the fourth in 1969; the fifth in 1970; the sixth in 1971; and the seventh in 1979.


APL

1964

wut









  • APLcart - Find your way in APL. A searchable collection of over two thousand short APL phrases intended for both beginners and professionals, with content provided by the community. Knowledge of basic APL syntax is a prerequisite. [14]





  • Papers from the Lost Culture of Array Languages - 2012 is the 50th anniversary of Ken Iverson's A Programming Language, which described the notation that became APL (even though a machine executable version of APL didn't exist yet). Since then there's been APL2, Nial, A+, K, Q, and other array-oriented languages. Iverson (1920-2004) teamed with Roger Hui to create a modern successor to APL, tersely named J, in the late 1980s. The culture of array languages is a curious one. Though largely functional, array languages represent a separate evolutionary timeline from the lambda calculus languages like Miranda and Haskell. [17]




BCPL

1966

Simula

1967

1967

Forth

1968ish





B

1969


  • Thompson's B Manual - B is a computer language intended for recursive, primarily non-numeric applications typified by system programming. B has a small, unrestrictive syntax that is easy to compile. Because of the unusual freedom of expression and a rich set of operators, B programs are often quite compact.This manual contains a concise definition of the language, sample programs, and instructions for using the PDP-11 version of B. [21]


Pascal

1970



Smalltalk

1972




  • Squeak is an open-source Smalltalk programming system with fast execution environments for all major platforms. It features the Morphic framework, which promotes low effort graphical, interactive application development and maintenance. Many projects have been successfully created with Squeak. They cover a wide range of domains such as education, multimedia, gaming, research, and commerce.


  • Pharo - an open source implementation of the programming language and environment Smalltalk. Pharo offers strong live programming features such as immediate object manipulation, live update, hot recompilation. Live programming environment is in the heart of the system. Pharo emerged as a fork of Squeak.


  • Strongtalk - a major re-thinking of the Smalltalk-80 programming language and system. While retaining the basic Smalltalk syntax and semantics, it contains a number of significant advances




  • Open Cobalt - a free and open-source software platform for constructing, accessing, and sharing virtual worlds both on local area networks or across the Internet, without any requirement for centralized servers. The technology makes it easy to create deeply collaborative and hyperlinked multi-user virtual workspaces, virtual exhibit spaces, and game-based learning and training environments that run on all major software operating systems. By using a peer-based messaging protocol to reduce reliance on server infrastructures for support of basic in world interactions across many participants, Open Cobalt makes it possible for people to hyperlink their virtual worlds via 3D portals to form a large distributed network of interconnected collaboration spaces. It also makes it possible for schools and other organizations to freely set up their own networks of public and private 3D virtual workspaces that feature integrated web browsing, voice chat, text chat and access to remote desktop applications and services.


  • TypeTalk - an attempt to replicate the classic SmallTalk/Lisp paradigm which don’t distinguish between users and programmers: you can, if you wish, take the lid off the application suite you’re currently using and tinker with it, without recompilation, restarts, or even having to save your work.Currently it’s a pile of fairly nasty hacks flying in loose formation, but it does actually work. Mostly. [24]


  • https://github.com/feenkcom/gtoolkit - moldable development environment. It is a live notebook. It is a flexible search interface. It is a fancy code editor. It is a software analysis platform. It is a data visualization engine. All in one. And it is free and open-source under an MIT license.

Prolog

1972



Datalog

1977

  • https://en.wikipedia.org/wiki/Datalog - a declarative logic programming language. While it is syntactically a subset of Prolog, Datalog generally uses a bottom-up rather than top-down evaluation model. This difference yields significantly different behavior and properties from Prolog. It is often used as a query language for deductive databases. Datalog has been applied to problems in data integration, networking, program analysis, and more.


IDL

1977

  • https://en.wikipedia.org/wiki/IDL_(programming_language) - a programming language used for data analysis. It is popular in particular areas of science, such as astronomy, atmospheric physics and medical imaging. IDL shares a common syntax with PV-Wave and originated from the same codebase, though the languages have subsequently diverged in detail. There are also free or costless implementations, such as GNU Data Language (GDL, and Fawlty Language (FL).

C / C++

to sort out!

See C/C++

ML / Standard ML

1973 / 1990 / 1997

CLU

1974

Iterators.

Mesa

1974

Xerox, used on Alto and Star

Influenced Modula-2 and Java

Modula

1975

Scheme

1975




Continuation-passing_style


  • STklos - a free Scheme system compliant with the languages features defined in R5RS. The aim of this implementation is to be fast as well as light. The implementation is based on an ad-hoc Virtual Machine. STklos can also be compiled as a library and embedded in an application.

Icon

1977

FP

1977

Mouse

Rexx

1979

Ada

1980

BBC BASIC

1981

C++

to move

Objective-C

1983

  • Objective-C is a general-purpose, high-level, object-oriented programming language that adds Smalltalk-style messaging to the C programming language. It is the main programming language used by Apple for the OS X and iOS operating systems and their respective APIs, Cocoa and Cocoa Touch. Originally developed in the early 1980s, it was selected as the main language used by NeXT for its NeXTSTEP operating system, from which OS X and iOS are derived.[1] Generic Objective-C programs that do not use the Cocoa or Cocoa Touch libraries can also be compiled for any system supported by GCC or Clang.

DRAKON

1986

Eiffel

1986

Caml / OCaml

1985

1996

  • http://en.wikipedia.org/wiki/OCaml - originally known as Objective Caml, is the main implementation of the Caml programming language, created by Xavier Leroy, Jérôme Vouillon, Damien Doligez, Didier Rémy, Ascánder Suárez and others in 1996. OCaml extends the core Caml language with object-oriented constructs. OCaml's toolset includes an interactive top level interpreter, a bytecode compiler, a reversible debugger, a package manager (OPAM), and an optimizing native code compiler. It has a large standard library that makes it useful for many of the same applications as Python or Perl, as well as robust modular and object-oriented programming constructs that make it applicable for large-scale software engineering. OCaml is the successor to Caml Light. The acronym CAML originally stood for Categorical Abstract Machine Language, although OCaml abandons this abstract machine. OCaml is a free open source project managed and principally maintained by INRIA. In recent years, many new languages have drawn elements from OCaml, most notably F# and Scala.


2016

  • Facebook: Reason is a new interface to OCaml - a highly expressive dialect of the ML language featuring type inference and static type checking.Reason provides a new syntax and toolchain for editing, building, and sharing code, and will evolve in the open as a community collaboration. Reason already has contributers across several organizations/companies. Much of Reason’s core syntax should be familiar to anyone who has ever used modern JavaScript / Flow or Rust. The examples in this document give an overview of the most important language constructs and their respective syntax. [33]

OCaml is a great tool for writing highly expressive, functional or imperative code, with type inference and fast runtime performance. Because of these properties, OCaml has helped Facebook quickly build scalable infrastructure such as Hack, Flow, and Infer. It is also used for other performance sensitive applications in the financial industry (Jane Street, Bloomberg). At the same time, OCaml has a very mature (and still growing) ecosystem for targeting browser and JavaScript environments with a focus on language interoperability and integration with existing JavaScript code.Reason‘s non-invasive approach to the OCaml compiler allows Reason code to take advantage of all of the existing OCaml compiler optimizations/backends such as bare metal ARM, x86, and even JavaScript compilation.

Fabrik

1985

Object Pascal

1986

Modula-3

1986/1989

Oberon

1986

Self

1987






Perl

1987

See Perl

HyperTalk

1987

for hypercard

Tcl

1988

  • Dodekalogue - the common name for the twelve rules that define the syntax and semantics of Tcl.









  • PS/Tk - provides an interface to the Tk toolkit, and is an effective tool for creating graphical interfaces. A detailed guide to using Tk from Scheme is in progress.


  • AndroWish - allows to run desktop Tcl and Tk programs almost unaltered on the Android Platform while it opens the door to script a rich feature set of a mobile platform. It's sibling undroidwish uses the same code base and offers a similar feature set on various desktop and embedded platforms.

Mathematica

1988

A+

1988

  • A+: a programming language for actual programmers - a powerful and efficient programming language. It is freely available under the GNU General Public License. It embodies a rich set of functions and operators, a modern graphical user interface with many widgets and automatic synchronization of widgets and variables, asynchronous execution of functions associated with variables and events, dynamic loading of user compiled subroutines, and many other features. Execution is by a rather efficient interpreter. A+ was created at Morgan Stanley. Primarily used in a computationally-intensive business environment, many critical applications written in A+ have withstood the demands of real world developers over many years. Written in an interpreted language, A+ applications tend to be portable.

FL

1989

Haskell

1990

  • Haskell is an advanced purely-functional programming language. An open-source product of more than twenty years of cutting-edge research, it allows rapid development of robust, concise, correct software. With strong support for integration with other languages, built-in concurrency and parallelism, debuggers, profilers, rich libraries and an active community, Haskell makes it easier to produce flexible, maintainable, high-quality software.



  • GHC - a state-of-the-art, open source, compiler and interactive environment for the functional language Haskell. Highlights:



Packages

A package is a library of Haskell modules known to the compiler. GHC comes with several packages: see the accompanying library documentation. More packages to install can be obtained from HackageDB.

Using a package couldn't be simpler: if you're using ––make or GHCi, then most of the installed packages will be automatically available to your program without any further options. The exceptions to this rule are covered below in Section 4.9.1, “Using Packages ”.

Building your own packages is also quite straightforward: we provide the Cabal infrastructure which automates the process of configuring, building, installing and distributing a package. All you need to do is write a simple configuration file, put a few files in the right places, and you have a package. See the Cabal documentation for details, and also the Cabal libraries (Distribution.Simple, for example).

  • Cabal (Common Architecture for Building Applications and Libraries) is a system for building and packaging Haskell libraries and programs. It defines a common interface for package authors and distributors to easily build their applications in a portable way. Cabal is part of a larger infrastructure for distributing, organizing, and cataloging Haskell libraries and programs. Specifically, the Cabal describes what a Haskell package is, how these packages interact with the language, and what Haskell implementations must to do to support packages. The Cabal also specifies some infrastructure (code) that makes it easy for tool authors to build and distribute conforming packages.
  • HackageDB (or just Hackage) is a collection of releases of Haskell packages. Each package is in the Cabal format, a standard way of packaging Haskell source code that makes it easy to build and install. These pages are a basic web interface to the Hackage package database.
  • cabal-install package provides the cabal command-line tool which simplifies the process of managing Haskell software by automating the fetching, configuration, compilation and installation of Haskell libraries and programs. Those packages must be prepared using Cabal and should be present at Hackage.
  • Gtk2Hs - A GUI Library for Haskell based on Gtk

Arch

pacman -Rncs ghc
  remove all haskell..

Web

  • Yesod is a Haskell web framework for productive development of type-safe, RESTful, high performance web applications.
  • Snap is a simple web development framework for unix systems, written in the Haskell programming language. Snap has a high level of test coverage and is well-documented. Features include: a fast HTTP server library, a sensible and clean monad for web programming, an HTML-based templating system for generating pages

JS

  • Fay - A proper subset of Haskell that compiles to JavaScript. Fay is a small programming language which has the following properties: A proper syntactic and semantic subset of Haskell, Statically typed, Lazy, Pure by default, Compiles to JavaScript, Has fundamental data types (Double, String, etc.) based upon what JS can support, Outputs minifier-aware code for small compressed size, Has a trivial foreign function interface to JavaScript

Erlang

1990

J

1990


Piet

1990

Esoteric, image based.

Python

1991

See Python

Q

1991

Oz

1991

Guile

1993

  • GNU Guile - designed to help programmers create flexible applications that can be extended by users or other programmers with plug-ins, modules, or scripts.

Lua

1993

See Lua

R

1993

Good for stats, etc.




  • R Package Documentation - A comprehensive index of R packages and documentation from CRAN, Bioconductor, GitHub and R-Forge.


  • R packages - This is the book site for “R packages”. It was published with O’Reilly in April 2015. Packages are the fundamental units of reproducible R code. They include reusable R functions, the documentation that describes how to use them, and sample data. In this section you’ll learn how to turn your code into packages that others can easily download and use. Writing a package can seem overwhelming at first. So start with the basics and improve it over time. It doesn’t matter if your first version isn’t perfect as long as the next version is better.


sudo Rscript -e "install.packages('devtools', repos='https://www.stats.bris.ac.uk/R/')"

devtools::load_all("directory/for/my/package")



  • R Markdown - documents are fully reproducible. Use a productive notebook interface to weave together narrative text and code to produce elegantly formatted output. Use multiple languages including R, Python, and SQL.


[43]


OpenDylan

1993

K

1993




Brainfuck

1993




  • yabfig - a BF interpreter written in Go. It has also been extended to lint code (by removing un-interpreted characters) and to include a gdb-style interpreter.


Racket

1994

SAC

1994

PHP

1995

See PHP

Java

1995

Java syntax seems unwieldy.



Apache Tomcat

Jetty

JavaScript

1995

See JavaScript

Ruby

1995

See Ruby

Rebol

1997

Dylan

Mid 90s

Slate

1999

C#

2000

D

2001

Processing

2001

.NET

2002

Io

2002

Scala

2003

Squirrel

2003


Factor

2003

  • Factor - a concatenative, stack-based programming language with high-level features including dynamic types, extensible syntax, macros, and garbage collection. On a practical side, Factor has a full-featured library, supports many different platforms, and has been extensively documented. The implementation is fully compiled for performance, while still supporting interactive development. Factor applications are portable between all common platforms. Factor can deploy stand-alone applications on all platforms. Full source code for the Factor project is available under a BSD license.

Spec# / Sing#

2004

F#

2005

Agda

2005

Vala

2006

Sage

2006

  • Sage is a prototype functional programming language designed to provide high-coverage checking of expressive program specifications (types).

Little

2006

  • Little (L) is a compiled-to-byte-code language that draws heavily from C and Perl. From C, Little gets C syntax, simple types (int, float, string), and complex types (arrays, structs). From Perl, Little gets associative arrays and regular expressions (PCRE). And from neither, Little gets its own simplistic form of classes. [55]

Clojure

2007








  • Cursive - The IDE for beautiful Clojure(Script) code

Gambit Scheme

2007

  • Gambit Scheme - integrates three decades of programming language research into a unique blend of speed, portability and power. Approach the compatibility and performance of C in one of the most elegant and expressive languages ever designed.

LOLCODE

2007

Arc

2008

Lisp dialect by PG etc. Developed in Racket.

Pure

2008

Go

2009 


go get ./...
  # run in go project directory to install dependencies

go build project.go
  # compile a project


  • Glide - Package Management For Go. Semantic Versions and Ranges. Git, Bzr, Hg, Svn. Works with Go toolchain. Leverages vendor directory. Imports from Godep, GB, GPM, Gom. Private Repos and Forks.








  • https://github.com/spf13/cobra - both a library for creating powerful modern CLI applications as well as a program to generate applications and command files.Many of the most widely used Go projects are built using Cobra, such as: Kubernetes, Hugo, rkt, etcd, Moby (former Docker), Docker (distribution), OpenShift, Delve, GopherJS, CockroachDB, Bleve, ProjectAtomic (enterprise), Giant Swarm's gsctl, Nanobox/Nanopack, rclone, nehm, Pouch, Istio, Prototool, mattermost-server, etc.






  • gokrazy - a pure-Go userland for your Raspberry Pi 3 appliances. For a long time, we were unhappy with having to care about security issues and Linux distribution maintenance on our various Raspberry Pis.Then, we had a crazy idea: what if we got rid of memory-unsafe languages and all software we don’t strictly need?Turns out this is feasible. gokrazy is the result.


Dao

2009

Zimbu

2009

  • Zimbu is an experimental programming language. It is a very practical, no-nonsense kind of language. It mixes the good things of many existing languages and avoids their deficiencies. And then throws in a few brand new ideas.

Potion

2009

Rust

2010




  • https://github.com/willcrichton/lia - a dynamically typed and garbage collected programming language that seamlessly interoperates with Rust by using Rust as a compile target. This enables Lia users to drop down into efficient Rust code when necessary, but work with a high-level Javascript-esque language for the majority of their application.


  • https://github.com/Dhghomon/easy_rust - Rust is a new language that already has good textbooks. But sometimes its textbooks are difficult because they are for native English speakers. Many companies and people now learn Rust, and could learn faster with a book that has easy English. This textbook is for these companies and people to learn Rust with simple English. [66]


  • https://github.com/DanielKeep/tlborm - an attempt to distil the Rust community's collective knowledge of Rust macros. As such, both additions (in the form of pull requests) and requests (in the form of issues) are welcome.


  • https://github.com/emilk/egui - a simple, fast, and highly portable immediate mode GUI library for Rust. egui runs on the web, natively, and in your favorite game engine (or will soon).




Crack

2010

Ur

2010?

Dart

2011

Elm

2011


Kotlin

2011


  • https://en.wikipedia.org/wiki/Kotlin_(programming_language) - a statically typed programming language that runs on the Java virtual machine and also can be compiled to JavaScript source code or use the LLVM compiler infrastructure. Its primary development is from a team of JetBrains programmers based in Saint Petersburg, Russia. While the syntax is not compatible with Java, the JVM implementation of Kotlin's standard library is designed to interoperate with Java code and is reliant on Java code from the existing Java Class Library, such as the collections framework[3]. Kotlin uses aggressive type inference to determine the type of values and expressions for which type has been left unstated. This reduces language verbosity relative to Java, which demands often entirely redundant type specifications prior to version 10.

As of Android Studio 3.0 (October 2017) Kotlin is a fully supported programming language by Google on the Android Operating System, and is directly included in the Android Studio 3.0 IDE package as an alternative to the standard Java compiler. The Android Kotlin compiler lets the user choose between targeting Java 6- or Java 8-compatible bytecode.


Elixier

2011

  • Elixir is a functional meta-programming aware language built on top of the Erlang VM. It is a dynamic language with flexible syntax with macros support that leverages Erlang's abilities to build concurrent, distributed, fault-tolerant applications with hot code upgrades. Elixir also provides first-class support for pattern matching, polymorphism via protocols (similar to Clojure's), aliases and associative data structures (usually known as dicts or hashes in other programming languages). Finally, Elixir and Erlang share the same bytecode and data types. This means you can invoke Erlang code from Elixir (and vice-versa) without any conversion or performance hit. This allows a developer to mix the expressiveness of Elixir with the robustness and performance of Erlang.


Shen

2011

Red

2011

Gosu

2011

Julia

2012

Typescript

2012

From Microsoft, compiles to JS.


Nim

  • Nim - systems and applications programming language. Statically typed and compiled, it provides unparalleled performance in an elegant package. High-performance garbage-collected language. Compiles to C, C++ or JavaScript. Produces dependency-free binaries. Runs on Windows, macOS, Linux, and more.



Slash

2012

Idris

2012

  • Idris - Idris is a general purpose pure functional programming language with dependent types. Dependent types allow types to be predicated on values, meaning that some aspects of a program’s behaviour can be specified precisely in the type. It is compiled, with eager evaluation. Its features are influenced by Haskell and ML, and include:
  • Full dependent types with dependent pattern matching
  • Simple foreign function interface (to C)
  • Compiler-supported interactive editing: the compiler helps you write code using the types
  • where clauses, with rule, simple case expressions, pattern matching let and lambda bindings
  • Dependent records with projection and update
  • Interfaces (similar to type classes in Haskell)
  • Type-driven overloading resolution
  • do notation and idiom brackets
  • Indentation significant syntax
  • Extensible syntax
  • Cumulative universes
  • Totality checking
  • Hugs style interactive environment


Clay

Babar

2013

Lobster

2013

Z

2013

Urbit

2013

Ioke

2013

Pyret

2013

Crystal

2013

Egison

Ceylon

Lobster

Cosmos

Mochi

Wren

Lasp

Swift

2014

Eve

2014

SPARK

2014

Mu

Luna

klisp

ATS

2015


Spry

2015

Full Metal Jacket

2015

Logic Production Systems

2015

Hivemind

2016

Zig

2016



L.B. Stanza

Nit

Gravity

  • Gravity Documentation - a powerful, dynamically typed, lightweight, embeddable programming language written in C without any external dependencies (except for stdlib). It is a class-based concurrent scripting language with a modern Swift like syntax. Gravity supports procedural programming, object-oriented programming, functional programming and data-driven programming. Thanks to special built-in methods, it can also be used as a prototype-based programming language. Gravity has been developed from scratch for the Creo project in order to offer an easy way to write portable code for the iOS and Android platforms. It is written in portable C code that can be compiled on any platform using a C99 compiler. The VM code is about 2K lines long, the multipass compiler code is about 3K lines and the shared code is about 2K lines long. The compiler and virtual machine combined add less than 200KB to the executable on a 64 bit system. [93]

V

WysiScript

  • WysiScript - Programming via direct syntax highlighting. The efficiency of programming is often hampered by the need to type the right text in order to obtain the syntax highlighting that will produce the desired program behavior. The programmer can control the colors and formatting of the code only indirectly, through arcane textual incantations. In this paper we introduce WysiScript, a new language which frees the programmer from this antiquated dependence on text by allowing program semantics to be expressed through direct application of colors and formatting. We give a description of the main ideas of the language and demonstrate its power and ease of use with some example programs. We end by proposing a novel technique for understanding the structure of a program, which is made possible only by the fresh approach taken by WysiScript. [95]

Fetlang

2018

  • https://github.com/fetlang/fetlang - a statically typed, procedural, esoteric programming language and reference implementation. It is designed such that source code looks like poorly written fetish erotica.

KPL

  • https://github.com/lokedhs/array - KAP - Array Language (not the final name)An implementation of an APL-like language in Kotlin. The implementation is a Kotlin Multiplatform project, and can be compiled to both Java and natively. It should also be possible to compile to Javascript but this has not been tested.[96]


BFN

Ring

  • The Ring Programming Language - a practical general-purpose multi-paradigm language. The supported programming paradigms are imperative, procedural, object-oriented, declarative using nested structures, functional, meta programming and natural programming. The language is portable (Windows, Linux, macOS, Android, WebAssembly, etc.) and can be used to create Console, GUI, Web, Games and Mobile applications. The language is designed to be simple, small and flexible.

to sort


  • kayia



Ć

  • https://github.com/pfusik/cito - Ć programming language. Translated automatically to C, C++, C#, Java, JavaScript, Python, Swift, TypeScript and OpenCL C.


Uxntal

  • XXIIVV — uxntal - The programming language for creating Uxn-compatible applications is called Uxntal or simply Tal, it is a unique flavor of assembly designed for this unique stack-machine. The program that transforms Tal files, into Uxn-compatible roms, is the Uxn Assembler.

Icarus

2020

  • https://github.com/asoffer/Icarus - Icarus is an experimental general-purpose programming language, designed to be fast to compile, fast to run, and easy to migrate. Learn more here.

Onyx

  • Onyx - a data-oriented, safe, and modern programming language for application development. By targetting WASM, Onyx can be used in the browser, or natively with a custom runtime. Ditch complicated classes and inheritance. Just focus on modeling the data for your application. With a C binding generation library, a useful C library is just one-step away. Onyx enables programmer expressiveness, while making it easy to write bug-free code.

Letscape

2023


Birb

Inko

Gravity

  • Gravity - An embeddable programming language. Simple and lightweight No external dependencies Register based virtual machine

portcullis

Other

See Dataflow



  • Try It Online - a family of online interpreters for an evergrowing list of practical and recreational programming languages.To use TIO, simply click the arrow below, pick a programming language, and start typing. Once you click the run button, your code is sent to a TIO arena, executed in a sandboxed environment, and the results are sent back to your browser. You can share your code by generating a client-side permalink that encodes code and input directly in the URL.


  • Probabilistic Models of Cognition - 2nd Edition - by Noah D. Goodman & Joshua B. Tenenbaum. This book explores the probabilistic approach to cognitive science, which models learning and reasoning as inference in complex probabilistic models. We examine how a broad range of empirical phenomena, including intuitive physics, concept learning, causal reasoning, social cognition, and language understanding, can be modeled using a functional probabilistic programming language called WebPPL.
  • The Design and Implementation of Probabilistic Programming Languages - Noah D. Goodman and Andreas Stuhlmüller. About: Probabilistic programming languages (PPLs) unify techniques for the formal description of computation and for the representation and use of uncertain knowledge. PPLs have seen recent interest from the artificial intelligence, programming languages, cognitive science, and natural languages communities. This book explains how to implement PPLs by lightweight embedding into a host language. We illustrate this by designing and implementing WebPPL, a small PPL embedded in Javascript. We show how to implement several algorithms for universal probabilistic inference, including priority-based enumeration with caching, particle filtering, and Markov chain Monte Carlo. We use program transformations to expose the information required by these algorithms, including continuations and stack addresses. We illustrate these ideas with examples drawn from semantic parsing, natural language pragmatics, and procedural graphics.


  • Knuth: Programs - "I write lots of CWEB programs, primarily for my own edification. If there is sufficient interest, I'll make a large subset of them available via the Internet. For now, I'm listing only a few. The first two show (by quite different methods) that exactly 2,432,932 knight's tours are unchanged by 180-degree rotation of the chessboard. The third was used to compute some of the tables in Axioms and Hulls that several people have asked about. The fourth was used in one of my otherwise unpublished lectures in the Computer Musings series. The next few were requested by members of the Academy of Recreational Mathematicians in Japan. And so on."



  • cola (aka idst, jolt, etc.) - an ongoing project to create a springboard for investigating new computing paradigms. Everything in it is late-bound, the intention being that any paradigm (existing or yet to be invented, formal complexity notwithstanding) be easily and efficiently mapped to it and made available to the user. It is a small part (the implementation vehicle) of the reinventing computing project.





Language Server Protocol

Retrieved from "https://wiki.thingsandstuff.org/index.php?title=Languages&oldid=64500"