This repository has been archived by the owner on May 2, 2023. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 3
/
Copy pathphilosophy.ftd
114 lines (81 loc) · 5.21 KB
/
philosophy.ftd
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
\-- ft-core.concept:
-- my-ds.page: Philosophy Behind `ftd`
-- ds.markdown:
FTD is being designed as language for human beings. We believe all humans should
be able to own the digital work they produce. Today that work is lost in
proprietory software and SAAS. Even most open source software treats text as
primarily a text blob, information in text is really hard to extract.
There is no distinction between data and prose. When you write a tweet there is
some prose, but there is also a lot of data, when you tweeted it, what app did
you use, what was your location, what is the URL of the tweet. You own all that
data. You want to be able to edit all that data. Same with Microsoft Word or
Google Docs. You want to be able to extract information from your documents, but
you can not. You can download maybe, but you will lose data in the process. What
you download will not be editable in the same way. The downloaded data offered
by most SAAS as response to regulations and customer demands is done in a
farciscal fashion, Facebook, Twitter, everyone will give you a ZIP file but you
will have very hard time viewing this data, or using it for any reason.
We belive a uniform language must exist to represent data and prose that any
human being can learn easily. We believe all human beings are going to write
and create more and more things. And they must be able to remix that, use
programming facilities, create reusable packages, have dependencies on each
other, etc.
When you are writing you do not want to be limited to dead text. And you do not
want to be at the whims of SAAS and other such software that you have to learn,
where things keeps on changing, company can go away with your data. You also do
not want to do the same thing in every software in slightly different interfaces,
learning a powerful general purpose editor is a worthwhile investment only for
programmers because programmers are not bound to any software and they truly
own the software they write, the entire history etc, in a way you do not own,
when using MS Word of Google Docs, Notion etc.
Further most software are incompatible with others. A graph made in one software
one can not be used with another software. You have to export the graph out as
image, losing the original document, and if you attach the image, the changes to
the original do automatically get reflected, you will have to re-export and
re-attach. Why can't you use any presentaiton in any document? Why can't your
presentation not include the spreadsheet? Why can't your email not contain a
presentation you can view? Without exporting everything and detaching it from
the original source?
Why can you have your document depend on another document like your software
depends on software libraries? Why can't there be a package manager that
downloads all documents your document depend on and create a final documentation
you want to share? A text written in one software is today lost, can barely be
used from another without export step.
-- ds.h1: Markdown
Markdown is brilliant, very soon probably every text input where humans write free
form text will be supporting markdown or a subset of it.
But markdown fails at:
1. capturing data ([frontmatter](https://jekyllrb.com/docs/front-matter/)
is a cop-out, forces yml, which may not be something all humans will be able to
learn) and,
2. more complex UI (in an attempt to chase simplicity, it is too simple).
On the other hand, data files like JSON/XML/ini,TOML etc are either not suitable
for writing free form text, or have too much syntax.
If the vision is for every human to own their data, one must ask, data in what
format? XML? JSON? YML? Markdown? FTD hopes to be that format.
`ftd` is [strongly typed](data-modelling/), with a type system
hopefully superior to many programming languages (we have
[ADT](or-type/)!).
-- ds.h1: Simple Syntax
If our goal is for all humans to learn some syntax, it must be very simple.
With these in mind, we have a syntax that only has `-`, `:` (and `\`) as special
characters. There is no `(`, or `[`, or `{`, or even `"` etc etc.
-- ds.h1: Indentation And Closing Tags
If our goal is to the universal data format, which can be inputted in any text
field humans come across, we can not rely on advanced editor features.
Working with indentation-based grammar is very hard if an indentation-aware editor
is not used. You need an editor that is able to indent and un-indent blocks of
text.
Closing tags or brackets/braces etc are even worse: they require indentation
anyways, but they also force users to keep track of matching special characters,
which is a common stumbling block for programmers that many attempts in
programming language world has been made to get rid of them (Python, one of the
most successful programming languages used "getting rid of closing tags/brackets"
as one of the selling points, at least in the beginning).
-- ds.h2: Hierarchical data and flat structure
This forces us to represent data and UI, both of them are inherently hierarchal
in nature, in a flat format. This is possible to some extent, as we explore with
the design of `ftd`.
Read how we do ["container management"](container/) to attempt this.
What we are trying is very hard. We will have to make compromises somewhere.
-- end: my-ds.page