Go! (programming language)

Last updated
Go!
Paradigm Multi-paradigm: concurrent, logic, functional, imperative (object-based)
Designed by Francis McCabe, Keith Clark
First appeared2003;20 years ago (2003)
Preview release
9-30-07 / September 30, 2007;15 years ago (2007-09-30)
Typing discipline strong
OS Unix-like
License GPLv2
Influenced by
Prolog [1]

Go! is an agent-based programming language in the tradition of logic-based programming languages like Prolog. [1] It was introduced in a 2003 paper by Francis McCabe and Keith Clark. [2]

Contents

Design

The authors of Go! describe it as "a multi-paradigm programming language that is oriented to the needs of programming secure, production quality and agent-based applications. It is multi-threaded, strongly typed and higher order (in the functional programming sense). It has relation, function and action procedure definitions. Threads execute action procedures, calling functions and querying relations as needed. Threads in different agents communicate and coordinate using asynchronous messages. Threads within the same agent can also use shared dynamic relations acting as Linda-style tuple stores." [2]

The authors also propose that the language is suitable for representing ontologies due to its integration of logic, functional and imperative styles of programming. [3]

Example

The following example illustrates the "ontology-oriented" type and declarations style of Go!: [3] 

Sex ::= male | female.  person <~ {dayOfBirth:[] =>day.            age:[] =>integer.            sex:[] => Sex.            name:[] =>string.            home:[] =>string.            lives:[string]{}}.    person:[string, day, Sex, string] $= person.    person(Nm, Born, Sx, Hm)..{   dayOfBirth() => Born.   age() => yearsBetween(now(), Born).   sex() => Sx.   name() => Nm.   home() => Hm.   lives(Pl) :- Pl = home().   yearsBetween:[integer, day] => integer.   yearsBetween(...) => .. }.    newPerson:[string, day, Sex, string] => person.    newPerson(Nm, Born, Sx, Hm) => $person(Nm, Born, Sx, Hm).

The ::= rule defines a new algebraic data type, a data type with only data constructors.

The <~ rule defines an interface type - it indicates what properties are characteristic of a person and also gives type constraints on these properties. It documents that age is a functional property with an integer value, that lives is a unary relation over strings, and that dayOfBirth is a functional property with a value that is an object of type day.

The $= type rule indicates that there is also a theory label, with the functor person, for a theory that defines the characteristic properties of the person type - implements the person interface - in terms of four given parameters of types string, day , Sex, and string.

Conflict with Google

In November 2009, Google released a similarly named Go programming language (with no exclamation point). McCabe asked Google to change the name of their language as he was concerned they were "steam-rolling over us". [1] [4] The issue received attention among technology news websites, with some of them characterizing Go! as "obscure". [5] The issue thread opened on the subject was closed by a Google developer on 12 October 2010 with the custom status "Unfortunate" and with the following comment: "there are many computing products and services named Go. In the 11 months since our release, there has been minimal confusion of the two languages." [6]

Related Research Articles

Eiffel is an object-oriented programming language designed by Bertrand Meyer and Eiffel Software. Meyer conceived the language in 1985 with the goal of increasing the reliability of commercial software development; the first version becoming available in 1986. In 2005, Eiffel became an ISO-standardized language.

<span class="mw-page-title-main">Java (programming language)</span> Object-oriented programming language

Java is a high-level, class-based, object-oriented programming language that is designed to have as few implementation dependencies as possible. It is a general-purpose programming language intended to let programmers write once, run anywhere (WORA), meaning that compiled Java code can run on all platforms that support Java without the need to recompile. Java applications are typically compiled to bytecode that can run on any Java virtual machine (JVM) regardless of the underlying computer architecture. The syntax of Java is similar to C and C++, but has fewer low-level facilities than either of them. The Java runtime provides dynamic capabilities that are typically not available in traditional compiled languages. As of 2019, Java was one of the most popular programming languages in use according to GitHub, particularly for client–server web applications, with a reported 9 million developers.

Mercury is a functional logic programming language made for real-world uses. The first version was developed at the University of Melbourne, Computer Science department, by Fergus Henderson, Thomas Conway, and Zoltan Somogyi, under Somogyi's supervision, and released on April 8, 1995.

<span class="mw-page-title-main">Programming language</span> Language for communicating instructions to a machine

A programming language is a system of notation for writing computer programs. Most programming languages are text-based formal languages, but they may also be graphical. They are a kind of computer language.

OCaml is a general-purpose, high-level multi-paradigm programming language which extends the Caml dialect of ML with object-oriented features. OCaml was created in 1996 by Xavier Leroy, Jérôme Vouillon, Damien Doligez, Didier Rémy, Ascánder Suárez, and others.

<span class="mw-page-title-main">F Sharp (programming language)</span> Microsoft programming language

F# is a functional-first, general-purpose, strongly typed, multi-paradigm programming language that encompasses functional, imperative, and object-oriented programming methods. It is most often used as a cross-platform Common Language Infrastructure (CLI) language on .NET, but can also generate JavaScript and graphics processing unit (GPU) code.

<span class="mw-page-title-main">Modula-3</span>

Modula-3 is a programming language conceived as a successor to an upgraded version of Modula-2 known as Modula-2+. While it has been influential in research circles it has not been adopted widely in industry. It was designed by Luca Cardelli, James Donahue, Lucille Glassman, Mick Jordan, Bill Kalsow and Greg Nelson at the Digital Equipment Corporation (DEC) Systems Research Center (SRC) and the Olivetti Research Center (ORC) in the late 1980s.

The Web Ontology Language (OWL) is a family of knowledge representation languages for authoring ontologies. Ontologies are a formal way to describe taxonomies and classification networks, essentially defining the structure of knowledge for various domains: the nouns representing classes of objects and the verbs representing relations between the objects.

errno.h is a header file in the standard library of the C programming language. It defines macros for reporting and retrieving error conditions using the symbol errno.

<span class="mw-page-title-main">Apache Groovy</span> Programming language

Apache Groovy is a Java-syntax-compatible object-oriented programming language for the Java platform. It is both a static and dynamic language with features similar to those of Python, Ruby, and Smalltalk. It can be used as both a programming language and a scripting language for the Java Platform, is compiled to Java virtual machine (JVM) bytecode, and interoperates seamlessly with other Java code and libraries. Groovy uses a curly-bracket syntax similar to Java's. Groovy supports closures, multiline strings, and expressions embedded in strings. Much of Groovy's power lies in its AST transformations, triggered through annotations.

In functional programming, a monad is a structure that combines program fragments (functions) and wraps their return values in a type with additional computation. In addition to defining a wrapping monadic type, monads define two operators: one to wrap a value in the monad type, and another to compose together functions that output values of the monad type. General-purpose languages use monads to reduce boilerplate code needed for common operations. Functional languages use monads to turn complicated sequences of functions into succinct pipelines that abstract away control flow, and side-effects.

Semantic similarity is a metric defined over a set of documents or terms, where the idea of distance between items is based on the likeness of their meaning or semantic content as opposed to lexicographical similarity. These are mathematical tools used to estimate the strength of the semantic relationship between units of language, concepts or instances, through a numerical description obtained according to the comparison of information supporting their meaning or describing their nature. The term semantic similarity is often confused with semantic relatedness. Semantic relatedness includes any relation between two terms, while semantic similarity only includes "is a" relations. For example, "car" is similar to "bus", but is also related to "road" and "driving".

In computer science, object composition and object aggregation are closely related ways to combine objects or data types into more complex ones. In conversation the distinction between composition and aggregation is often ignored. Common kinds of compositions are objects used in object-oriented programming, tagged unions, sets, sequences, and various graph structures. Object compositions relate to, but are not the same as, data structures.

This is an alphabetical list of articles pertaining specifically to software engineering.

<span class="mw-page-title-main">Oxygene (programming language)</span> Object Pascal-based programming language

Oxygene is a programming language developed by RemObjects Software for Microsoft's Common Language Infrastructure, the Java Platform and Cocoa. Oxygene is based on Delphi's Object Pascal, but also has influences from C#, Eiffel, Java, F# and other languages.

The following outline is provided as an overview of and topical guide to computer programming:

Keith Leonard Clark is an Emeritus Professor in the Department of Computing at Imperial College London, England.

<span class="mw-page-title-main">Go (programming language)</span> Programming language

Go is a statically typed, compiled high-level programming language designed at Google by Robert Griesemer, Rob Pike, and Ken Thompson. It is syntactically similar to C, but also has memory safety, garbage collection, structural typing, and CSP-style concurrency. It is often referred to as Golang because of its former domain name, golang.org, but its proper name is Go.

This article describes the features in the programming language Haskell.

Join-patterns provides a way to write concurrent, parallel and distributed computer programs by message passing. Compared to the use of threads and locks, this is a high level programming model using communication constructs model to abstract the complexity of concurrent environment and to allow scalability. Its focus is on the execution of a chord between messages atomically consumed from a group of channels.

References

  1. 1 2 3 Claburn, Thomas (2009-11-11). "Google 'Go' Name Brings Accusations Of 'Evil'". InformationWeek. Archived from the original on 2010-07-22. Retrieved 2009-11-14.
  2. 1 2 Clark, K.L.; McCabe, F.G. (2003). "Go! For multi-threaded deliberative agents". Proceedings of the second international joint conference on Autonomous agents and multiagent systems. pp. 964–965. CiteSeerX   10.1.1.117.184 . doi:10.1145/860575.860747. ISBN   978-1581136838. S2CID   2047545.{{cite book}}: CS1 maint: date and year (link)
  3. 1 2 Clark, K.L.; McCabe, F.G. (2006). "Ontology oriented programming in go!". Applied Intelligence. 24 (3): 189–204. CiteSeerX   10.1.1.117.184 . doi:10.1145/860575.860747. S2CID   2047545.
  4. ↑ "Issue 9 - go - I have already used the name for *MY* programming language". 2009-11-10. Retrieved 2009-11-14.
  5. ↑ Brownlee, John (2009-11-13). "Google didn't google "Go" before naming their programming language". Geek.com. Archived from the original on 2012-05-06. Retrieved 2010-01-18.
  6. ↑ "I have already used the name for *MY* programming language · Issue #9 · golang/go". GitHub. Retrieved 2019-07-04.

Further reading

This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.