1, Jina

Jina is a programming language with sane memory management, actors, and a coherent syntax

Mahsa Jina Amini was a 22 years old girl, murdered by the evil regime in Iran
at her funeral, these words were written on a stone above her grave:
	beloved Jina, you will not die, your name will become a code

memory management is done in a sane way, by distinguishing 2 kinds of variables:
, immutable/mutable borrow variables
, immutable/mutable own variables:

note that in Jina, mutability and ownership of a standalone type is meaningless
it's only meaningful in two situations:
, variable types
, function parameters types

immutable borrow var can only be put into immutable borrow var
mutable borrow var can only be put into immutable/mutable borrow var
note that here "put into" means:
, variable assignment
, field assignment
, variable capture in functions

putting immutable own var into immutable/mutable borrow var is/isn't possible
putting mutable own var into immutable/mutable borrow var is possible
putting immutable/mutable own var into immutable/mutable own var:
, if on stack: copy
, if on heap: if reference count is zero and it isn't used in the following code, move,
	otherwise increase reference count
putting immutable/mutable own var into mutable/immutable own var is not possible

numbers are stored on the stack (thus don't need memory management)
lists and dictionaries are stored on the heap
small records will be kept on stack, big ones on the heap

"https://www.toptal.com/software/eliminating-garbage-collector"
"http://blog.skylight.io/rust-means-never-having-to-close-a-socket/"

actors are used to achieve lock'free concurrency
sharing mutable data in concurrent parts of a program is problematic
a data race happens when these three behaviors occur:
, two or more pointers access the same data at the same time
, at least one of the pointers is being used to write to the data
, there's no mechanism being used to synchronize access to the data

to deal with it, programming languages choose different approaches:
, abandon concurrency altogether; make single threaded programs
, implement complicated and error prone lock mechanisms
, abandon mutability like in pure functional programming; but since at the end, mutability is necessary,
	a complicated mechanism like monads, linear types, effects, or Clojure reference types, must be used
	"https://stackoverflow.com/questions/9132346/clojure-differences-between-ref-var-agent-atom-with-examples"
	"https://clojure-doc.org/articles/language/concurrency_and_parallelism/"
	any how, the lack of direct mutability, and the need for aggressive garbage collection,
		means that functional programming is not an efficient method
, use the approach taken by Pony "https://www.ponylang.io/"
	it controls aliasing (sharing) and mutability, using reference capabilities
	Pony's approach introduces many complexities, especially when dealing with generics
	i think the main reason for its complexities is that even class fields have reference capabilities

in Jina, as shown above, mutable variables can't be captured in immutable own functions
messages are sent to actors via immutable own functions
so in Jina, all mutations will be synchronous

immutable functions with null return can be called asynchronously, since they can't affect their environment

types show us what we can do with the data, ie which operations are valid
inheritance is problematic:
"https://en.wikipedia.org/wiki/Covariance_and_contravariance_(computer_science)"
"https://www.tedinski.com/2018/06/26/variance.html"
i feel that this problem was the motivation behind dynamic typing (another bad design)
to avoid this problem, some languages (eg Rust) have two kinds of types:
, concrete types can be instantiated, but cannot have subtypes
, abstract types cannot be instantiated, but can have subtypes
Jina does the same, without actually spliting types into two kinds

Jina compiles to C, and can easily use existing C libraries
the compiled binary will at least need "glib2" and "flint" dynamic libraries to be installed on the system

to install Jina in SPM Linux:
; spm install jina <jina-repo-url> [<public-key>]
in other Unix'like systems, install "gcc gnunet git", download SPM Linux source, then:
; cp spm.sh ~/.local/bin/spm
; chmod +x ~/.local/bin/spm
; spm install jina <jina-repo-url> [<public-key>]