-
Notifications
You must be signed in to change notification settings - Fork 0
/
1, Jina
83 lines (69 loc) · 4.26 KB
/
1, Jina
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
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 are features of variables (not types)
so they only appear 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>]