The project I'm working on does this -- we define high level semantic entity types, and from that you can:
- Define APIs that take those entities as inputs, automatically validating API arguments for you, automatically generating documentation, and driving API consistency.
- Can represent those entities in memory without writing any custom code beyond the schema.
- As mentioned above, you don't have to write manual code to validate your entities, that's done for you from the schema.
- Automatically generates database tables for those entity types without having to maintain a separate database schema, and can serialize/deserialize entities into or out of the database without having to write SQL. Acts like a document based database but still allows the power of relational SQL matching.
- From git diffs, automatically produce expressions that specify how the entity types have evolved over time, and then have the ability to apply those entity type diffs to a production server & database.
- Automatically maps natural language onto the schema allowing NLU queries like "orders today in Canada" to be turned into a semantic representation that the database can natively understand and execute, with control to override default NLU mappings if the default mapping isn't working right.
- Automatically generates web UIs for viewing and editing entities.
- Supports dynamic applicability to be defined so that whether a property is applicable, and which values are valid, can be defined as a dynamic function of other property values.
- Supports inferred properties to be defined in either an inference rule approach, or a functional approach.
This is really nice. I experimented converting natural language to git log commands this week (https://twitter.com/danielbigham/status/1294461750251839489), but mapping natural language to git sql might be better and more flexible in some cases.
I love this. Yes, there are higher level languages that can be used for accomplishing these things, but people find themselves at the command line a lot, and having the ability to efficiently express your intent using a familiar language, without getting hand-cuffed by a poor underlying representation seems very useful.
One challenge with using things like trees to estimate long-ago temperatures is that you have to build a complex mathematical model to map to temperature, and I'm aware of at least one famous study that got the math wrong, to the point of being potentially suspicious. (But I haven't studied this stuff enough to know whether or not other proper studies exist)
Something that I started doing recently is to create a "30 second summary" of each important concept, consisting of text and diagrams. I then record a 30 second video where I narrate, using good intonation, the 30 second summary. I also create a hyperlink from the summary to my notes of each prerequisite concept.
This serves three purposes:
1) The act of teaching is one of the best ways to solidify a concept in your mind. It forces you to have a good understanding of it, and forces your mind to produce a good internal organization around concept.
2) It usually takes a while to write + diagram a good summary, and takes a number of tries to get a smooth recording of you speaking the summary (Example: https://www.youtube.com/watch?v=rHc-bog1hhE). All of this "repetition" / time spent with the concept makes it easier to remember.
3) Sooner or later we realize that remembering everything is impossible. Given enough time, concepts will decay in your mind. In the long term, one of the most important things for you to optimize is the speed at which you can re-create your mental model of a concept. Having these 30 second summaries, complete with links to prerequisite concepts, allows you to re-build your mental model of a subject area extremely quickly in the future in a just-in-time fashion. Just like a smartphone is an "extension" of your brain, a note system like I've described here is like an extension of your memory.
One of the ways I think about humility is that it is the ability of a person to successfully integrate information that requires some non-trivial refactoring of one's internal model of the world.
Refactoring can be a costly operation, so it makes sense that the mind shouldn't take on that task too often, especially if one's mind is more likely to suffer net harm from an unsuccessful or partial refactoring.
However, if a person is gifted at learning in the broadest sense, then it would make a lot of sense that their mind would undertake this process much more gladly, and as a result, form a very strong model of the world.
There is a wise phrase, "more with less", that people may be familiar with. I think this article fits into that paradigm nicely. Imagine the difference in global outcome if person A ate out each day of the week for lunch, while another followed the pattern of eating the same thing for lunch and took the money saved, putting it towards something like clean water in developing nations. Even a single human being doing this would make a big difference.
This year for whatever reason I keep seeing the concept of "integration" in everything, and have also become interested in what feels like the opposite -- division and separation -- so when I read "Ego is all about division and separation", it really piqued my curiosity. Could you elaborate on that?
- Define APIs that take those entities as inputs, automatically validating API arguments for you, automatically generating documentation, and driving API consistency.
- Can represent those entities in memory without writing any custom code beyond the schema.
- As mentioned above, you don't have to write manual code to validate your entities, that's done for you from the schema.
- Automatically generates database tables for those entity types without having to maintain a separate database schema, and can serialize/deserialize entities into or out of the database without having to write SQL. Acts like a document based database but still allows the power of relational SQL matching.
- From git diffs, automatically produce expressions that specify how the entity types have evolved over time, and then have the ability to apply those entity type diffs to a production server & database.
- Automatically maps natural language onto the schema allowing NLU queries like "orders today in Canada" to be turned into a semantic representation that the database can natively understand and execute, with control to override default NLU mappings if the default mapping isn't working right.
- Automatically generates web UIs for viewing and editing entities.
- Supports dynamic applicability to be defined so that whether a property is applicable, and which values are valid, can be defined as a dynamic function of other property values.
- Supports inferred properties to be defined in either an inference rule approach, or a functional approach.