Citrine (programming language): Difference between revisions

Revision as of 14:56, 24 January 2016

Latest revision as of 04:29, 23 February 2024

(63 intermediate revisions by 25 users not shown)

Line 1:

{{short description|Programming language}}

{{distinguish|Citrine, the stone (disambiguation)}}

{{Multiple issues|{{primary sources|date=August 2020}}{{COI|date=September 2020}}}}

{{Infobox programming language

| name = Citrine

| logo = Citrine programming language logo.png

| paradigm = [[object Object-oriented|object programming|Object-oriented]], [[Prototype-based programming|prototype-based]]

| year = 2014

| designer = Gabor de Mooij, Aavesh Jilani

| developer = Gabor de Mooij, Aavesh Jilani

| latest release version = 0.29.6

| latest release date = {{startStart date and age|mf=yes2024|20141|5}}

| typing = [[dynamic typing|dynamic]]

| implementations = C

| influenced by = [[Smalltalk]], [[Self (programming language)|Self]]

| influenced =

| operating system = [[UNIXCross-platform|Cross-platform (multi-platform)]]

| license = [[BSD licenses|BSD]]

| website = http://{{URL|citrine-lang.org}}

| file ext = .ctr

}}

'''Citrine''' is a general-purpose [[programming language]] for [[Cross-platform|various operating systems]]. It focuses on readability and maintainability. Readability is achieved by syntactic and conceptual minimalism. The language is heavily inspired by [[Smalltalk]] and [[Self (programming language)|Self]] but has some very distinctive features. Like Smalltalk, Citrine treats everything as an object and focuses on sending messages to these objects. However, unlike Smalltalk, Citrine lacks the concept of a class. In this regard, Citrine is more like Self and [[JavaScript]] because it uses [[Prototype-based programming|prototypes]]. The combination of Smalltalk-like messages and prototypes is what makes Citrine unique.

In [[computing]], '''Citrine''' is a general purpose programming language for UNIX-like operating systems. The language focuses on readability and maintainability.

Readability is achieved by syntactical and conceptual minimalism. The Citrine programming language is heavily inspired by [[Smalltalk]] and [[Self]] but has some very distinctive

features. Like Smalltalk, the Citrine language treats everything as an object and focuses on sending messages to these objects. However unlike Smalltalk Citrine lacks the concept

of a class. In this regard, Citrine is more like [[Self]] and [[Javascript]] because it uses prototypes. The combination of Smalltalk like messages and prototypes is what makes

Citrine unique.

Since version 0.7, Citrine has focused on using forms based on various natural languages instead of just English, improving usability for users of other languages, thereby reducing programming effort and incidence of bugs. As such, Citrine 0.7 and later include a feature to transform code between natural languages.

== Syntax ==

==Syntax==

Citrine has a very limited syntax and it's very closely related to Smalltalk. Everything in Citrine is an '''Object''', there are 5 literals:

Citrine has a very limited syntax very closely related to Smalltalk. Everything in Citrine is an ''object''. There are 5 literals:

* {{code|Nil}}

<source lang="citrine">

* {{code|True, False}}

* Nil

* {{code|0,1,2,3}}

* True False

* {{code|'String'}}

* 0,1,2,3

* <code>{ ...params.. ...block of code... }</code>

* 'String'

* { param | ...block of code... }

</source>

The code block literal uses a '''pipe''' symbol ⟨|⟩ to separate the parameters from the logic '|',; if there are no

parameters, the backslash should be used instead '\'.

Citrine only supports full -line comments, commentswhich start with a '⟨#'⟩.

A Citrine program is basically a sequence of messages sent to objects,. forFor instance, to calculatedetermine whether 5 is an even number, the factorialmessage of'even?' is sent to the number 5 one has.

to send the message 'factorial' to number 5.

<sourcesyntaxhighlight lang="citrinesmalltalk">

5 even?

5 factorial.

</syntaxhighlight>

</source>

This is called a '''unary''' message, becausbecause it doestakes not take anyno arguments. A '''binary''' message is always a single UTF-8 character; (this differs from Smalltalk, where there is differenta fixed set of binary messages. Here is an example:

from Smalltalk where there is a fix set of binary messages), here is an example:

<sourcesyntaxhighlight lang="citrinesmalltalk">

6 + 7.

</syntaxhighlight>

</source>

Here a binary message '+' is sendsent to number 6, with the argument of thisthe binary message isbeing '7',. this willThis resultresults in athe new number object '13'. Assigning the outcome of this operation to a variable uses the assignment operator: :=.

To assign the outcome of this operation to a variable one uses the assignment operator: :=.

<sourcesyntaxhighlight lang="citrinesmalltalk">

total := money + debt.

</syntaxhighlight>

</source>

Also note thatAdditionally, each line in a Citrine program ends with a dot, just likeas in Smalltalk. BesidesAlong with unary and binary messages, Citrine offers ''keyword messages'', which take arguments interspersed with the message itself just like Smalltalk and [[Objective-C]].

also offers '''keyword messages''', these messages take arguments interspersed with the message itself just like Smalltalk and [[Objective-C]].

<sourcesyntaxhighlight lang="citrinesmalltalk">

3☞ x := Number between: 1 and: 5.

</syntaxhighlight>

</source>

The code snippet above will return a boolean object '''True'''.

== Control Flow flow==

Just like Smalltalk, control flow in Citrine is implemented by strategic use of messages. For instance, writing a conditional statement requires sending a block of code to a boolean.

<syntaxhighlight lang="smalltalk">

Just like Smalltalk, control flow in Citrine is implemented by strategic use of messages. For instance to write a conditional statement, one has to send a block of code

(money > price) true: { ✎ write: 'Yes, you can afford this'. }.

to a boolean.

</syntaxhighlight>

<source lang="citrine">

(money >= price) ifTrue: {\ Pen write: 'Yes, you can afford this'. }.

</source>

Likewise, a for-loop is written as:

<sourcesyntaxhighlight lang="citrinesmalltalk">

1{ to: 10 by: 1 do: { step | Pen✎ write: 'this is step:' + step. } × 10.

</syntaxhighlight>

</source>

Besides for-loops, Citrine features each-loops, while-loops and a simple times loop, the latter uses the binary message '*'.

<source lang="citrine">

7 * { step | Pen write: 'this is step:' + step. }.

</source>

To break out of a loop in Citrine, one has tomust send the message 'break' to a boolean,. thisThis allows a conditional break from a loop without having to factor out the break conditions:

without having to factor out the break conditions:

<sourcesyntaxhighlight lang="citrinesmalltalk">

{ :i

#0-4

(i = 3) break.

0 to: 10 by: 1 do: { i |

Pen ✎ write: 'iteration #' + i, brk.

} * 5.

(i = 4) break.

</syntaxhighlight>

}.

</source>

== Pipelines ==

Unlike Smalltalk, Citrine has no semi-colon to send a message to the original receiver. Instead, Citrine has a comma token ',' used to chain keyword messages, which allows writing Unix-like ''[[Pipeline (Unix)|pipelines]]''. The following code uses a pipeline-like syntax to replace all the 'o' characters with zeroes, the resulting string would be something like: '1010101...'.

<syntaxhighlight lang="smalltalk">

Unlike Smalltalk, Citrine has no semi-colon to send a message to the original receiver. Instead Citrine has a comma token ',' used

to chain keyword messages, this allows developers to write UNIX-like '''pipelines'''. The following code uses a pipeline-like syntax

to replace all the 'o' characters with zeroes, the resulting string would be something like: '1010101...'.

<source lang="citrine">

onesAndZeroes := '1o1o1o1o1o1' split: 'o', map: mapUp, join: '0'.

</syntaxhighlight>

</source>

== Prototypes ==

==Prototypes==

The biggest difference from Smalltalk is the use of prototypes. Citrine does not have a concept of a class, it only knows

The biggest difference from Smalltalk is the use of prototypes. Citrine does not have a concept of a class, but only knows about objects. An object is created using the new message:

<sourcesyntaxhighlight lang="citrinesmalltalk">

cat := Object new.

</syntaxhighlight>

</source>

OneThis object can makebe thismade objectto respond to messages by ordering the object to listen to events, thissimilar isto kindadding ofmethods similarin tolanguages like [[Java (programming language)|Java]]:

adding methods in languages like [[Java programming language|Java]]:

<sourcesyntaxhighlight lang="citrinesmalltalk">

cat on: 'meow' do: {\

Pen write: 'meow!'.

}.

</syntaxhighlight>

</source>

As hasstated been mentioned in this articleabove, inheritance is based on prototypes. To derive an object from another object, the new message must be sent to the object to be extended:

To derive an object from another object one has to send the new message to the object

one wishes to extend:

<sourcesyntaxhighlight lang="citrinesmalltalk">

☞ Animal := Object new.

Animal on: 'makeSound' do: {\

Pen✎ write: '?'.

}.

☞ Cat := Animal new.

Cat on: 'makeSound' do: {\

Pen✎ write: 'meow!'.

}.

☞ Tom := Cat new.

Tom makeSound.

</syntaxhighlight>

</source>

== Unicode ==

Citrine uses UTF-8 unicode extensively, both objects and messages can consist of unicode symbols. All string length are calculated using UTF-8. Citrine distinguishes string length and size in bytes:

<syntaxhighlight lang="smalltalk">

Citrine uses '''UTF-8''' unicode extensively, both objects and messages can consist

of unicode symbols. All string length are calculated using UTF-8. Citrine distinguishes

string length and size in bytes:

<source lang="citrine">

'text' length.

</syntaxhighlight>

</source>

returns the length of the string in UTF-8 code pointes, while:

returns the length of the string in UTF-8 code points, while:

<sourcesyntaxhighlight lang="citrinesmalltalk">

'text' bytes.

</syntaxhighlight>

</source>

returns the number of bytes.

==Scoping==

Citrine uses [[dynamic scoping]] instead of [[lexical scoping]]. Thus, there is no need for [[dependency injection]] or global variables, but it might be harder to reason about than lexical scope. This is similar in programming languages like [[Emacs Lisp]] and [[BASIC]]. In code blocks the ''var'' keyword needs to be used to declare a local variable.

The following demonstration makes the Mailer object available in the module:

Citrine uses [[dynamic scoping]] instead of [[lexical scoping]], this means there is no need

for [[Dependency Injection]] or global variables but it might be harder to reason about than

lexical scope. This is similar as in programming language like

[[EMACS Lisp]] and [[BASIC]]. In code blocks the '''var''' keyword needs to be used to declare

a local variable.

<syntaxhighlight lang="smalltalk">

Demonstration:

Application := {

☞ mailer := Mailer new.

<source lang="citrine">

module run.

Application := {\

var mailer := Mailer new. #make mailer available to all modules

module run. #mailer is now available in module

}.

</syntaxhighlight>

</source>

==See also==

* [[Smalltalk (programming language)|Smalltalk]] - Smalltalk programming language

==References==

* [http://fll.presidentbeef.com/lang/citrine/ demo in new programming languages community]

* [https://jaxenter.com/citrine-a-new-all-purpose-programming-language-for-unixoid-systems-123558.html Citrine Review Jaxenter]

* [https://www.reddit.com/r/programming/comments/42gqu4/new_programming_language_citrine/ Announcement on Reddit]

* [http://www.infoworld.com/article/3028559/application-development/citrine-borrows-from-ruby-javascript-c-for-object-oriented-programming.html InfoWorld interview]

* [https://web.archive.org/web/20221108082728/https://www.tiobe.com/tiobe-index/ Tiobe Index]

==External links==

* [http://{{Official website|citrine-lang.org Citrine homepage], Citrine homepage}}

* [https://github.com/gabordemooij/citrine source code], Source code on githubGitHub

<!--Interwikies-->

<!--Categories-->

[[Category:Smalltalk programming language family]]

[[Category:Procedural programming languages]]