-
Notifications
You must be signed in to change notification settings - Fork 0
/
scrap.txt
140 lines (98 loc) · 5.43 KB
/
scrap.txt
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
# inspiration
lisp: quote atom eq car cdr cons cond
factor: dup swap drop call
# refs
concatenative https://concatenative.org/wiki/view/Concatenative%20language/Concatenation%20is%20composition
factor cookbook https://docs.factorcode.org/content/article-cookbook.html
factor handbook https://docs.factorcode.org/content/article-handbook.html
lisp bootstrap http://programmingpraxis.codepad.org/8cfeZ3ER
lisp http://www.gigamonkeys.com/book/practical-a-simple-database.html
http://htdp.org/2003-09-26/Book/curriculum-Z-H-5.html
https://github.com/andreaferretti/factor-tutorial#metaprogramming - parsing words
https://www.forth.com/starting-forth/11-forth-compiler-defining-words/
https://crystal-lang.org/reference/syntax_and_semantics/macros/index.html - crystal macros
https://clojure.org/reference/macros
https://concatenative.org/wiki/view/Factor/Optimization
https://concatenative.org/wiki/view/Factor/Optimizing%20compiler
https://en.wikipedia.org/wiki/Static_single_assignment_form
# motivation
provide code examples with comparisons with lisp, ruby, crystal, clojure, haskell, erlang, python, js, go, rust, lua
consiceness - less to type
simplicity - easy to read
interop - use your existing stack, use FOR your existing stack (as lib)
general-purpose - use for anything
exceptions, cooperative threading - https://concatenative.org/wiki/revision/1184
? garbage collection - see https://koka-lang.github.io/koka/doc/book.html#why-perceus for no garbage
naive lexing and parsing, both by humans and machines
extensible with parsing words - similar to lisp macros
refactoring toolset built-in - allows finding common code that can be extracted or reused
effect inference and stack effect checks
homoiconic - code is data
types, objects - specific implementations (e.g. https://docs.factorcode.org/content/word-sum-of-squares,math.statistics.html)
# sneak peek
'music-db namespace
^^^^^^^^^ creates a hashmap of words (functions) in the lexical scope, that can be called locally, and can be imported to a different scope by a handle
'make-cd ( title artist rating -- cd ) [ array:new3 ] def
^^^^^^^^ defined method name - quoted word
^^^^^^^^^^^^^^^^^^^^^^^^^^^ signature - list of consumed words and effect
^^^^^^^^^^^^^^ quoted implementation
^^^ adds method implementation to the namespace
'make-db ( -- db ) [ array:new ] def
'add-record ( db record -- db ) [ array:push ] def
> make-db
()
> "foo biters" "bar buzz" 5.0 make-cd
()
(artist: "foo biters" title: "bar buzz" rating: 5.0)
> add-record
(( artist: "foo biters" title: "bar buzz" rating: 5.0 ))
> dup first 'artist fetch
(( artist: "foo biters" title: "bar buzz" rating: 5.0 ))
"foo biters"
## Memory efficiency vs Computation efficiency dilemma
```
'sum-of-squares ( sequence -- sum )
[ 'sq map sum ]
```
is memory-inefficient, as it would require another the memory for the list
process in-place?
pipeline-like?
Ruby lazy enumerator?
Java-like buffered streams?
endless streams?
or even finite streams: "abc" chars first - makes no sense to split all when we only need first
at times, memory is not a problem, when building a computationally-expensive sequence
if it's not computationally expensive, e.g. `100 [1,b]`, it might be dynamic and lazy
memoizable isn't mutually exclusive with dynamic
sometimes prompt (immediate) output is more important that the overall processing speed, e.g. screen output
## Interesing links
motivating checklist
https://drewdevault.com/2020/12/25/How-to-design-a-new-programming-language.html
design criteria http://jcsites.juniata.edu/faculty/rhodes/lt/plcriteria.htm
book https://www.researchgate.net/publication/220692467_Advanced_programming_language_design
more on homoiconicity
https://docs.racket-lang.org/htdp-langs/intermediate.html#%28def._htdp-intermediate._%28%28lib._lang%2Fhtdp-intermediate..rkt%29._list%29%29
parsing words :point_up: code is just code, not needed to be
immediately represented as data on the stack
racket syntax https://docs.racket-lang.org/htdp-langs/advanced.html
simple: https://docs.racket-lang.org/htdp-langs/index.html
rant http://tomasp.net/blog/2017/design-side-of-pl/
https://medium.com/coinmonks/the-organized-chaos-of-programming-language-design-1e0a95067afb
https://en.wikipedia.org/wiki/Programming_language_theory
https://en.wikipedia.org/wiki/Lambda_calculus
Write compiler in Zig https://ziglang.org/
https://docs.racket-lang.org/eopl/index.html
a random language design decisions http://www.zimbu.org/design/goals
another http://ducklang.org/designing-a-programming-language-i
book https://www.amazon.com/Programming-Language-Design-Concepts-David/dp/0470853204
https://esolangs.org
The Theory of Concatenative Combinators https://web.archive.org/web/20180324230846/https://tunes.org/~iepos/joy.html
# compiling to native code - meh!
https://github.com/factor/factor/blob/master/extra/elf/elf.factor
https://en.wikipedia.org/wiki/Executable_and_Linkable_Format#FatELF:_universal_binaries_for_Linux
https://golang.org/src/syscall/
https://apidock.com/ruby/Kernel/syscall
asm linux http://asm.sourceforge.net/articles/linasm.html
linux syscalls https://linuxhint.com/list_of_linux_syscalls/
https://habr.com/ru/post/347596/
Factor's optimizing compiler generates machine code for x86 (32 and 64-bit), as well as PowerPC (32-bit only). The optimizing compiler is written entirely in Factor. Its implementation can be found in basis/compiler/ and basis/cpu/