2015-04-16 17:35:49 +00:00
//: Containers contain a fixed number of elements of different types.
2015-04-17 18:22:59 +00:00
2015-03-17 03:26:59 +00:00
: ( before " End Mu Types Initialization " )
2016-09-07 05:11:03 +00:00
//: We'll use this container as a running example in scenarios below.
2015-11-06 19:06:58 +00:00
type_ordinal point = put ( Type_ordinal , " point " , Next_type_ordinal + + ) ;
2016-03-28 17:11:23 +00:00
get_or_insert ( Type , point ) ; // initialize
2015-11-06 19:06:58 +00:00
get ( Type , point ) . kind = CONTAINER ;
get ( Type , point ) . name = " point " ;
2016-09-17 17:22:56 +00:00
get ( Type , point ) . elements . push_back ( reagent ( " x:number " ) ) ;
get ( Type , point ) . elements . push_back ( reagent ( " y:number " ) ) ;
2015-02-20 07:49:13 +00:00
2015-05-07 22:06:53 +00:00
//: Containers can be copied around with a single instruction just like
2015-05-13 17:03:26 +00:00
//: numbers, no matter how large they are.
2015-05-07 22:06:53 +00:00
2016-05-07 17:33:53 +00:00
//: Tests in this layer often explicitly set up memory before reading it as a
2018-06-16 05:16:09 +00:00
//: container. Don't do this in general. I'm tagging such cases with /unsafe;
//: they'll be exceptions to later checks.
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
: ( code )
void test_copy_multiple_locations ( ) {
run (
" def main [ \n "
" 1:num <- copy 34 \n "
" 2:num <- copy 35 \n "
" 3:point <- copy 1:point/unsafe \n "
" ] \n "
) ;
CHECK_TRACE_CONTENTS (
" mem: storing 34 in location 3 \n "
" mem: storing 35 in location 4 \n "
) ;
}
2015-02-20 08:03:47 +00:00
2015-10-01 20:43:32 +00:00
//: trying to copy to a differently-typed destination will fail
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
void test_copy_checks_size ( ) {
Hide_errors = true ;
run (
" def main [ \n "
" 2:point <- copy 1:num \n "
" ] \n "
) ;
CHECK_TRACE_CONTENTS (
" error: main: can't copy '1:num' to '2:point'; types don't match \n "
) ;
}
2015-08-07 20:01:49 +00:00
2015-03-27 04:06:14 +00:00
: ( before " End Mu Types Initialization " )
2016-09-07 05:11:03 +00:00
// A more complex example container, containing another container as one of
// its elements.
2015-11-06 19:06:58 +00:00
type_ordinal point_number = put ( Type_ordinal , " point-number " , Next_type_ordinal + + ) ;
2016-03-28 17:11:23 +00:00
get_or_insert ( Type , point_number ) ; // initialize
2015-11-06 19:06:58 +00:00
get ( Type , point_number ) . kind = CONTAINER ;
get ( Type , point_number ) . name = " point-number " ;
2016-02-17 18:09:48 +00:00
get ( Type , point_number ) . elements . push_back ( reagent ( " xy:point " ) ) ;
2016-09-17 17:22:56 +00:00
get ( Type , point_number ) . elements . push_back ( reagent ( " z:number " ) ) ;
2015-03-27 04:06:14 +00:00
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
: ( code )
void test_copy_handles_nested_container_elements ( ) {
run (
" def main [ \n "
" 12:num <- copy 34 \n "
" 13:num <- copy 35 \n "
" 14:num <- copy 36 \n "
" 15:point-number <- copy 12:point-number/unsafe \n "
" ] \n "
) ;
CHECK_TRACE_CONTENTS (
" mem: storing 36 in location 17 \n "
) ;
}
2015-03-27 04:06:14 +00:00
2016-04-24 07:36:30 +00:00
//: products of recipes can include containers
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
void test_return_container ( ) {
run (
" def main [ \n "
" 3:point <- f 2 \n "
" ] \n "
" def f [ \n "
" 12:num <- next-ingredient \n "
" 13:num <- copy 35 \n "
" return 12:point/raw \n "
" ] \n "
) ;
CHECK_TRACE_CONTENTS (
" run: result 0 is [2, 35] \n "
" mem: storing 2 in location 3 \n "
" mem: storing 35 in location 4 \n "
) ;
}
2016-04-24 05:11:48 +00:00
2015-05-07 22:06:53 +00:00
//: Containers can be checked for equality with a single instruction just like
2015-05-13 17:03:26 +00:00
//: numbers, no matter how large they are.
2015-05-07 22:06:53 +00:00
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
void test_compare_multiple_locations ( ) {
run (
" def main [ \n "
" 1:num <- copy 34 \n " // first
" 2:num <- copy 35 \n "
" 3:num <- copy 36 \n "
" 4:num <- copy 34 \n " // second
" 5:num <- copy 35 \n "
" 6:num <- copy 36 \n "
" 7:bool <- equal 1:point-number/raw, 4:point-number/unsafe \n "
" ] \n "
) ;
CHECK_TRACE_CONTENTS (
" mem: storing 1 in location 7 \n "
) ;
}
void test_compare_multiple_locations_2 ( ) {
run (
" def main [ \n "
" 1:num <- copy 34 \n " // first
" 2:num <- copy 35 \n "
" 3:num <- copy 36 \n "
" 4:num <- copy 34 \n " // second
" 5:num <- copy 35 \n "
" 6:num <- copy 37 \n " // different
" 7:bool <- equal 1:point-number/raw, 4:point-number/unsafe \n "
" ] \n "
) ;
CHECK_TRACE_CONTENTS (
" mem: storing 0 in location 7 \n "
) ;
}
2015-05-07 22:06:53 +00:00
2016-11-07 17:10:48 +00:00
: ( before " End size_of(type) Special-cases " )
2018-06-09 15:59:33 +00:00
if ( type - > value = = - 1 ) return 1 ; // error value, but we'll raise it elsewhere
if ( type - > value = = 0 ) return 1 ;
if ( ! contains_key ( Type , type - > value ) ) {
raise < < " no such type " < < type - > value < < ' \n ' < < end ( ) ;
2016-02-19 10:21:37 +00:00
return 0 ;
}
2018-06-09 15:59:33 +00:00
type_info t = get ( Type , type - > value ) ;
2015-10-27 03:06:51 +00:00
if ( t . kind = = CONTAINER ) {
2018-06-09 15:59:33 +00:00
// size of a container is the sum of the sizes of its elements
int result = 0 ;
for ( int i = 0 ; i < SIZE ( t . elements ) ; + + i ) {
// todo: strengthen assertion to disallow mutual type recursion
if ( t . elements . at ( i ) . type - > value = = type - > value ) {
raise < < " container " < < t . name < < " can't include itself as a member \n " < < end ( ) ;
return 0 ;
2016-11-08 18:31:48 +00:00
}
2018-06-09 15:59:33 +00:00
result + = size_of ( element_type ( type , i ) ) ;
3309
Rip out everything to fix one failing unit test (commit 3290; type
abbreviations).
This commit does several things at once that I couldn't come up with a
clean way to unpack:
A. It moves to a new representation for type trees without changing
the actual definition of the `type_tree` struct.
B. It adds unit tests for our type metadata precomputation, so that
errors there show up early and in a simpler setting rather than dying
when we try to load Mu code.
C. It fixes a bug, guarding against infinite loops when precomputing
metadata for recursive shape-shifting containers. To do this it uses a
dumb way of comparing type_trees, comparing their string
representations instead. That is likely incredibly inefficient.
Perhaps due to C, this commit has made Mu incredibly slow. Running all
tests for the core and the edit/ app now takes 6.5 minutes rather than
3.5 minutes.
== more notes and details
I've been struggling for the past week now to back out of a bad design
decision, a premature optimization from the early days: storing atoms
directly in the 'value' slot of a cons cell rather than creating a
special 'atom' cons cell and storing it on the 'left' slot. In other
words, if a cons cell looks like this:
o
/ | \
left val right
..then the type_tree (a b c) used to look like this (before this
commit):
o
| \
a o
| \
b o
| \
c null
..rather than like this 'classic' approach to s-expressions which never
mixes val and right (which is what we now have):
o
/ \
o o
| / \
a o o
| / \
b o null
|
c
The old approach made several operations more complicated, most recently
the act of replacing a (possibly atom/leaf) sub-tree with another. That
was the final straw that got me to realize the contortions I was going
through to save a few type_tree nodes (cons cells).
Switching to the new approach was hard partly because I've been using
the old approach for so long and type_tree manipulations had pervaded
everything. Another issue I ran into was the realization that my layers
were not cleanly separated. Key parts of early layers (precomputing type
metadata) existed purely for far later ones (shape-shifting types).
Layers I got repeatedly stuck at:
1. the transform for precomputing type sizes (layer 30)
2. type-checks on merge instructions (layer 31)
3. the transform for precomputing address offsets in types (layer 36)
4. replace operations in supporting shape-shifting recipes (layer 55)
After much thrashing I finally noticed that it wasn't the entirety of
these layers that was giving me trouble, but just the type metadata
precomputation, which had bugs that weren't manifesting until 30 layers
later. Or, worse, when loading .mu files before any tests had had a
chance to run. A common failure mode was running into types at run time
that I hadn't precomputed metadata for at transform time.
Digging into these bugs got me to realize that what I had before wasn't
really very good, but a half-assed heuristic approach that did a whole
lot of extra work precomputing metadata for utterly meaningless types
like `((address number) 3)` which just happened to be part of a larger
type like `(array (address number) 3)`.
So, I redid it all. I switched the representation of types (because the
old representation made unit tests difficult to retrofit) and added unit
tests to the metadata precomputation. I also made layer 30 only do the
minimal metadata precomputation it needs for the concepts introduced
until then. In the process, I also made the precomputation more correct
than before, and added hooks in the right place so that I could augment
the logic when I introduced shape-shifting containers.
== lessons learned
There's several levels of hygiene when it comes to layers:
1. Every layer introduces precisely what it needs and in the simplest
way possible. If I was building an app until just that layer, nothing
would seem over-engineered.
2. Some layers are fore-shadowing features in future layers. Sometimes
this is ok. For example, layer 10 foreshadows containers and arrays and
so on without actually supporting them. That is a net win because it
lets me lay out the core of Mu's data structures out in one place. But
if the fore-shadowing gets too complex things get nasty. Not least
because it can be hard to write unit tests for features before you
provide the plumbing to visualize and manipulate them.
3. A layer is introducing features that are tested only in later layers.
4. A layer is introducing features with tests that are invalidated in
later layers. (This I knew from early on to be an obviously horrendous
idea.)
Summary: avoid Level 2 (foreshadowing layers) as much as possible.
Tolerate it indefinitely for small things where the code stays simple
over time, but become strict again when things start to get more
complex.
Level 3 is mostly a net lose, but sometimes it can be expedient (a real
case of the usually grossly over-applied term "technical debt"), and
it's better than the conventional baseline of no layers and no
scenarios. Just clean it up as soon as possible.
Definitely avoid layer 4 at any time.
== minor lessons
Avoid unit tests for trivial things, write scenarios in context as much as
possible. But within those margins unit tests are fine. Just introduce them
before any scenarios (commit 3297).
Reorganizing layers can be easy. Just merge layers for starters! Punt on
resplitting them in some new way until you've gotten them to work. This is the
wisdom of Refactoring: small steps.
What made it hard was not wanting to merge *everything* between layer 30
and 55. The eventual insight was realizing I just need to move those two
full-strength transforms and nothing else.
2016-09-10 01:32:52 +00:00
}
2016-11-11 05:39:02 +00:00
return result ;
}
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
: ( code )
void test_stash_container ( ) {
run (
" def main [ \n "
" 1:num <- copy 34 \n " // first
" 2:num <- copy 35 \n "
" 3:num <- copy 36 \n "
" stash [foo:], 1:point-number/raw \n "
" ] \n "
) ;
CHECK_TRACE_CONTENTS (
" app: foo: 34 35 36 \n "
) ;
}
2015-08-11 06:15:00 +00:00
2015-04-18 06:24:52 +00:00
//:: To access elements of a container, use 'get'
3309
Rip out everything to fix one failing unit test (commit 3290; type
abbreviations).
This commit does several things at once that I couldn't come up with a
clean way to unpack:
A. It moves to a new representation for type trees without changing
the actual definition of the `type_tree` struct.
B. It adds unit tests for our type metadata precomputation, so that
errors there show up early and in a simpler setting rather than dying
when we try to load Mu code.
C. It fixes a bug, guarding against infinite loops when precomputing
metadata for recursive shape-shifting containers. To do this it uses a
dumb way of comparing type_trees, comparing their string
representations instead. That is likely incredibly inefficient.
Perhaps due to C, this commit has made Mu incredibly slow. Running all
tests for the core and the edit/ app now takes 6.5 minutes rather than
3.5 minutes.
== more notes and details
I've been struggling for the past week now to back out of a bad design
decision, a premature optimization from the early days: storing atoms
directly in the 'value' slot of a cons cell rather than creating a
special 'atom' cons cell and storing it on the 'left' slot. In other
words, if a cons cell looks like this:
o
/ | \
left val right
..then the type_tree (a b c) used to look like this (before this
commit):
o
| \
a o
| \
b o
| \
c null
..rather than like this 'classic' approach to s-expressions which never
mixes val and right (which is what we now have):
o
/ \
o o
| / \
a o o
| / \
b o null
|
c
The old approach made several operations more complicated, most recently
the act of replacing a (possibly atom/leaf) sub-tree with another. That
was the final straw that got me to realize the contortions I was going
through to save a few type_tree nodes (cons cells).
Switching to the new approach was hard partly because I've been using
the old approach for so long and type_tree manipulations had pervaded
everything. Another issue I ran into was the realization that my layers
were not cleanly separated. Key parts of early layers (precomputing type
metadata) existed purely for far later ones (shape-shifting types).
Layers I got repeatedly stuck at:
1. the transform for precomputing type sizes (layer 30)
2. type-checks on merge instructions (layer 31)
3. the transform for precomputing address offsets in types (layer 36)
4. replace operations in supporting shape-shifting recipes (layer 55)
After much thrashing I finally noticed that it wasn't the entirety of
these layers that was giving me trouble, but just the type metadata
precomputation, which had bugs that weren't manifesting until 30 layers
later. Or, worse, when loading .mu files before any tests had had a
chance to run. A common failure mode was running into types at run time
that I hadn't precomputed metadata for at transform time.
Digging into these bugs got me to realize that what I had before wasn't
really very good, but a half-assed heuristic approach that did a whole
lot of extra work precomputing metadata for utterly meaningless types
like `((address number) 3)` which just happened to be part of a larger
type like `(array (address number) 3)`.
So, I redid it all. I switched the representation of types (because the
old representation made unit tests difficult to retrofit) and added unit
tests to the metadata precomputation. I also made layer 30 only do the
minimal metadata precomputation it needs for the concepts introduced
until then. In the process, I also made the precomputation more correct
than before, and added hooks in the right place so that I could augment
the logic when I introduced shape-shifting containers.
== lessons learned
There's several levels of hygiene when it comes to layers:
1. Every layer introduces precisely what it needs and in the simplest
way possible. If I was building an app until just that layer, nothing
would seem over-engineered.
2. Some layers are fore-shadowing features in future layers. Sometimes
this is ok. For example, layer 10 foreshadows containers and arrays and
so on without actually supporting them. That is a net win because it
lets me lay out the core of Mu's data structures out in one place. But
if the fore-shadowing gets too complex things get nasty. Not least
because it can be hard to write unit tests for features before you
provide the plumbing to visualize and manipulate them.
3. A layer is introducing features that are tested only in later layers.
4. A layer is introducing features with tests that are invalidated in
later layers. (This I knew from early on to be an obviously horrendous
idea.)
Summary: avoid Level 2 (foreshadowing layers) as much as possible.
Tolerate it indefinitely for small things where the code stays simple
over time, but become strict again when things start to get more
complex.
Level 3 is mostly a net lose, but sometimes it can be expedient (a real
case of the usually grossly over-applied term "technical debt"), and
it's better than the conventional baseline of no layers and no
scenarios. Just clean it up as soon as possible.
Definitely avoid layer 4 at any time.
== minor lessons
Avoid unit tests for trivial things, write scenarios in context as much as
possible. But within those margins unit tests are fine. Just introduce them
before any scenarios (commit 3297).
Reorganizing layers can be easy. Just merge layers for starters! Punt on
resplitting them in some new way until you've gotten them to work. This is the
wisdom of Refactoring: small steps.
What made it hard was not wanting to merge *everything* between layer 30
and 55. The eventual insight was realizing I just need to move those two
full-strength transforms and nothing else.
2016-09-10 01:32:52 +00:00
//: 'get' takes a 'base' container and an 'offset' into it and returns the
//: appropriate element of the container value.
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
void test_get ( ) {
run (
" def main [ \n "
" 12:num <- copy 34 \n "
" 13:num <- copy 35 \n "
" 15:num <- get 12:point/raw, 1:offset \n " // unsafe
" ] \n "
) ;
CHECK_TRACE_CONTENTS (
" mem: storing 35 in location 15 \n "
) ;
}
2015-03-27 04:06:14 +00:00
2015-04-17 17:31:17 +00:00
: ( before " End Primitive Recipe Declarations " )
GET ,
2015-02-20 08:03:47 +00:00
: ( before " End Primitive Recipe Numbers " )
2015-11-06 19:06:58 +00:00
put ( Recipe_ordinal , " get " , GET ) ;
2015-10-01 20:43:32 +00:00
: ( before " End Primitive Recipe Checks " )
2015-02-20 08:03:47 +00:00
case GET : {
2015-10-01 20:43:32 +00:00
if ( SIZE ( inst . ingredients ) ! = 2 ) {
2017-05-26 23:43:18 +00:00
raise < < maybe ( get ( Recipe , r ) . name ) < < " 'get' expects exactly 2 ingredients in ' " < < to_original_string ( inst ) < < " ' \n " < < end ( ) ;
2015-10-01 20:43:32 +00:00
break ;
}
2016-05-06 07:46:39 +00:00
reagent /*copy*/ base = inst . ingredients . at ( 0 ) ; // new copy for every invocation
2016-04-24 07:36:30 +00:00
// Update GET base in Check
3309
Rip out everything to fix one failing unit test (commit 3290; type
abbreviations).
This commit does several things at once that I couldn't come up with a
clean way to unpack:
A. It moves to a new representation for type trees without changing
the actual definition of the `type_tree` struct.
B. It adds unit tests for our type metadata precomputation, so that
errors there show up early and in a simpler setting rather than dying
when we try to load Mu code.
C. It fixes a bug, guarding against infinite loops when precomputing
metadata for recursive shape-shifting containers. To do this it uses a
dumb way of comparing type_trees, comparing their string
representations instead. That is likely incredibly inefficient.
Perhaps due to C, this commit has made Mu incredibly slow. Running all
tests for the core and the edit/ app now takes 6.5 minutes rather than
3.5 minutes.
== more notes and details
I've been struggling for the past week now to back out of a bad design
decision, a premature optimization from the early days: storing atoms
directly in the 'value' slot of a cons cell rather than creating a
special 'atom' cons cell and storing it on the 'left' slot. In other
words, if a cons cell looks like this:
o
/ | \
left val right
..then the type_tree (a b c) used to look like this (before this
commit):
o
| \
a o
| \
b o
| \
c null
..rather than like this 'classic' approach to s-expressions which never
mixes val and right (which is what we now have):
o
/ \
o o
| / \
a o o
| / \
b o null
|
c
The old approach made several operations more complicated, most recently
the act of replacing a (possibly atom/leaf) sub-tree with another. That
was the final straw that got me to realize the contortions I was going
through to save a few type_tree nodes (cons cells).
Switching to the new approach was hard partly because I've been using
the old approach for so long and type_tree manipulations had pervaded
everything. Another issue I ran into was the realization that my layers
were not cleanly separated. Key parts of early layers (precomputing type
metadata) existed purely for far later ones (shape-shifting types).
Layers I got repeatedly stuck at:
1. the transform for precomputing type sizes (layer 30)
2. type-checks on merge instructions (layer 31)
3. the transform for precomputing address offsets in types (layer 36)
4. replace operations in supporting shape-shifting recipes (layer 55)
After much thrashing I finally noticed that it wasn't the entirety of
these layers that was giving me trouble, but just the type metadata
precomputation, which had bugs that weren't manifesting until 30 layers
later. Or, worse, when loading .mu files before any tests had had a
chance to run. A common failure mode was running into types at run time
that I hadn't precomputed metadata for at transform time.
Digging into these bugs got me to realize that what I had before wasn't
really very good, but a half-assed heuristic approach that did a whole
lot of extra work precomputing metadata for utterly meaningless types
like `((address number) 3)` which just happened to be part of a larger
type like `(array (address number) 3)`.
So, I redid it all. I switched the representation of types (because the
old representation made unit tests difficult to retrofit) and added unit
tests to the metadata precomputation. I also made layer 30 only do the
minimal metadata precomputation it needs for the concepts introduced
until then. In the process, I also made the precomputation more correct
than before, and added hooks in the right place so that I could augment
the logic when I introduced shape-shifting containers.
== lessons learned
There's several levels of hygiene when it comes to layers:
1. Every layer introduces precisely what it needs and in the simplest
way possible. If I was building an app until just that layer, nothing
would seem over-engineered.
2. Some layers are fore-shadowing features in future layers. Sometimes
this is ok. For example, layer 10 foreshadows containers and arrays and
so on without actually supporting them. That is a net win because it
lets me lay out the core of Mu's data structures out in one place. But
if the fore-shadowing gets too complex things get nasty. Not least
because it can be hard to write unit tests for features before you
provide the plumbing to visualize and manipulate them.
3. A layer is introducing features that are tested only in later layers.
4. A layer is introducing features with tests that are invalidated in
later layers. (This I knew from early on to be an obviously horrendous
idea.)
Summary: avoid Level 2 (foreshadowing layers) as much as possible.
Tolerate it indefinitely for small things where the code stays simple
over time, but become strict again when things start to get more
complex.
Level 3 is mostly a net lose, but sometimes it can be expedient (a real
case of the usually grossly over-applied term "technical debt"), and
it's better than the conventional baseline of no layers and no
scenarios. Just clean it up as soon as possible.
Definitely avoid layer 4 at any time.
== minor lessons
Avoid unit tests for trivial things, write scenarios in context as much as
possible. But within those margins unit tests are fine. Just introduce them
before any scenarios (commit 3297).
Reorganizing layers can be easy. Just merge layers for starters! Punt on
resplitting them in some new way until you've gotten them to work. This is the
wisdom of Refactoring: small steps.
What made it hard was not wanting to merge *everything* between layer 30
and 55. The eventual insight was realizing I just need to move those two
full-strength transforms and nothing else.
2016-09-10 01:32:52 +00:00
if ( ! base . type ) {
raise < < maybe ( get ( Recipe , r ) . name ) < < " first ingredient of 'get' should be a container, but got ' " < < inst . ingredients . at ( 0 ) . original_string < < " ' \n " < < end ( ) ;
break ;
}
2016-09-10 23:47:17 +00:00
const type_tree * base_type = base . type ;
// Update GET base_type in Check
if ( ! base_type - > atom | | base_type - > value = = 0 | | ! contains_key ( Type , base_type - > value ) | | get ( Type , base_type - > value ) . kind ! = CONTAINER ) {
2016-05-21 05:09:06 +00:00
raise < < maybe ( get ( Recipe , r ) . name ) < < " first ingredient of 'get' should be a container, but got ' " < < inst . ingredients . at ( 0 ) . original_string < < " ' \n " < < end ( ) ;
2015-10-01 20:43:32 +00:00
break ;
}
2016-05-06 07:46:39 +00:00
const reagent & offset = inst . ingredients . at ( 1 ) ;
2015-10-01 20:43:32 +00:00
if ( ! is_literal ( offset ) | | ! is_mu_scalar ( offset ) ) {
2016-05-21 05:09:06 +00:00
raise < < maybe ( get ( Recipe , r ) . name ) < < " second ingredient of 'get' should have type 'offset', but got ' " < < inst . ingredients . at ( 1 ) . original_string < < " ' \n " < < end ( ) ;
2015-07-24 08:05:59 +00:00
break ;
}
2016-03-14 03:26:47 +00:00
int offset_value = 0 ;
2016-12-28 02:09:30 +00:00
if ( is_integer ( offset . name ) ) {
2015-10-02 07:28:08 +00:00
offset_value = to_integer ( offset . name ) ;
2016-12-28 02:09:30 +00:00
}
// End update GET offset_value in Check
2016-09-10 23:47:17 +00:00
if ( offset_value < 0 | | offset_value > = SIZE ( get ( Type , base_type - > value ) . elements ) ) {
raise < < maybe ( get ( Recipe , r ) . name ) < < " invalid offset ' " < < offset_value < < " ' for ' " < < get ( Type , base_type - > value ) . name < < " ' \n " < < end ( ) ;
2015-11-02 02:24:17 +00:00
break ;
2015-10-02 07:28:08 +00:00
}
2015-11-16 02:36:34 +00:00
if ( inst . products . empty ( ) ) break ;
2016-05-06 07:46:39 +00:00
reagent /*copy*/ product = inst . products . at ( 0 ) ;
2016-04-24 07:36:30 +00:00
// Update GET product in Check
2016-12-12 18:01:12 +00:00
//: use base.type rather than base_type because later layers will introduce compound types
const reagent /*copy*/ element = element_type ( base . type , offset_value ) ;
2015-11-27 18:32:34 +00:00
if ( ! types_coercible ( product , element ) ) {
2016-05-21 05:09:06 +00:00
raise < < maybe ( get ( Recipe , r ) . name ) < < " 'get " < < base . original_string < < " , " < < offset . original_string < < " ' should write to " < < names_to_string_without_quotes ( element . type ) < < " but ' " < < product . name < < " ' has type " < < names_to_string_without_quotes ( product . type ) < < ' \n ' < < end ( ) ;
2015-10-06 00:02:32 +00:00
break ;
2015-10-02 07:28:08 +00:00
}
2015-10-01 20:43:32 +00:00
break ;
}
: ( before " End Primitive Recipe Implementations " )
case GET : {
2016-05-06 07:46:39 +00:00
reagent /*copy*/ base = current_instruction ( ) . ingredients . at ( 0 ) ;
2016-04-24 07:36:30 +00:00
// Update GET base in Run
2016-03-14 03:26:47 +00:00
int base_address = base . value ;
2015-08-01 00:06:38 +00:00
if ( base_address = = 0 ) {
2017-05-26 23:43:18 +00:00
raise < < maybe ( current_recipe_name ( ) ) < < " tried to access location 0 in ' " < < to_original_string ( current_instruction ( ) ) < < " ' \n " < < end ( ) ;
2015-08-01 00:06:38 +00:00
break ;
}
2016-09-10 23:47:17 +00:00
const type_tree * base_type = base . type ;
// Update GET base_type in Run
2016-03-14 03:26:47 +00:00
int offset = ingredients . at ( 1 ) . at ( 0 ) ;
2016-09-10 23:47:17 +00:00
if ( offset < 0 | | offset > = SIZE ( get ( Type , base_type - > value ) . elements ) ) break ; // copied from Check above
2018-06-16 05:16:09 +00:00
int src = base_address ;
for ( int i = 0 ; i < offset ; + + i )
src + = size_of ( element_type ( base . type , i ) ) ;
2019-02-25 08:17:46 +00:00
trace ( Callstack_depth + 1 , " run " ) < < " address to copy is " < < src < < end ( ) ;
2016-12-12 18:01:12 +00:00
//: use base.type rather than base_type because later layers will introduce compound types
reagent /*copy*/ element = element_type ( base . type , offset ) ;
2016-04-20 16:58:07 +00:00
element . set_value ( src ) ;
2019-02-25 08:17:46 +00:00
trace ( Callstack_depth + 1 , " run " ) < < " its type is " < < names_to_string ( element . type ) < < end ( ) ;
2016-04-20 16:58:07 +00:00
// Read element
products . push_back ( read_memory ( element ) ) ;
2015-02-20 08:03:47 +00:00
break ;
}
2015-11-02 03:38:30 +00:00
: ( code )
2016-04-30 17:09:38 +00:00
const reagent element_type ( const type_tree * type , int offset_value ) {
2015-11-02 03:38:30 +00:00
assert ( offset_value > = 0 ) ;
2016-11-08 19:46:04 +00:00
const type_tree * base_type = type ;
// Update base_type in element_type
assert ( contains_key ( Type , base_type - > value ) ) ;
assert ( ! get ( Type , base_type - > value ) . name . empty ( ) ) ;
const type_info & info = get ( Type , base_type - > value ) ;
2015-11-02 03:38:30 +00:00
assert ( info . kind = = CONTAINER ) ;
2016-06-18 00:22:15 +00:00
if ( offset_value > = SIZE ( info . elements ) ) return reagent ( ) ; // error handled elsewhere
2016-05-06 07:46:39 +00:00
reagent /*copy*/ element = info . elements . at ( offset_value ) ;
2015-11-02 03:38:30 +00:00
// End element_type Special-cases
return element ;
}
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
void test_get_handles_nested_container_elements ( ) {
run (
" def main [ \n "
" 12:num <- copy 34 \n "
" 13:num <- copy 35 \n "
" 14:num <- copy 36 \n "
" 15:num <- get 12:point-number/raw, 1:offset \n " // unsafe
" ] \n "
) ;
CHECK_TRACE_CONTENTS (
" mem: storing 36 in location 15 \n "
) ;
}
void test_get_out_of_bounds ( ) {
Hide_errors = true ;
run (
" def main [ \n "
" 12:num <- copy 34 \n "
" 13:num <- copy 35 \n "
" 14:num <- copy 36 \n "
" get 12:point-number/raw, 2:offset \n " // point-number occupies 3 locations but has only 2 fields; out of bounds
" ] \n "
) ;
CHECK_TRACE_CONTENTS (
" error: main: invalid offset '2' for 'point-number' \n "
) ;
}
void test_get_out_of_bounds_2 ( ) {
Hide_errors = true ;
run (
" def main [ \n "
" 12:num <- copy 34 \n "
" 13:num <- copy 35 \n "
" 14:num <- copy 36 \n "
" get 12:point-number/raw, -1:offset \n "
" ] \n "
) ;
CHECK_TRACE_CONTENTS (
" error: main: invalid offset '-1' for 'point-number' \n "
) ;
}
void test_get_product_type_mismatch ( ) {
Hide_errors = true ;
run (
" def main [ \n "
" 12:num <- copy 34 \n "
" 13:num <- copy 35 \n "
" 14:num <- copy 36 \n "
" 15:&:num <- get 12:point-number/raw, 1:offset \n "
" ] \n "
) ;
CHECK_TRACE_CONTENTS (
" error: main: 'get 12:point-number/raw, 1:offset' should write to number but '15' has type (address number) \n "
) ;
}
2015-10-02 07:28:08 +00:00
2015-11-16 02:36:34 +00:00
//: we might want to call 'get' without saving the results, say in a sandbox
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
void test_get_without_product ( ) {
run (
" def main [ \n "
" 12:num <- copy 34 \n "
" 13:num <- copy 35 \n "
" get 12:point/raw, 1:offset \n " // unsafe
" ] \n "
) ;
// just don't die
}
2015-11-16 02:36:34 +00:00
2016-04-11 02:26:37 +00:00
//:: To write to elements of containers, use 'put'.
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
void test_put ( ) {
run (
" def main [ \n "
" 12:num <- copy 34 \n "
" 13:num <- copy 35 \n "
" $clear-trace \n "
" 12:point <- put 12:point, 1:offset, 36 \n "
" ] \n "
) ;
CHECK_TRACE_CONTENTS (
" mem: storing 36 in location 13 "
) ;
CHECK_TRACE_DOESNT_CONTAIN ( " mem: storing 34 in location 12 " ) ;
}
2016-04-11 02:26:37 +00:00
: ( before " End Primitive Recipe Declarations " )
PUT ,
: ( before " End Primitive Recipe Numbers " )
put ( Recipe_ordinal , " put " , PUT ) ;
: ( before " End Primitive Recipe Checks " )
case PUT : {
if ( SIZE ( inst . ingredients ) ! = 3 ) {
2017-05-26 23:43:18 +00:00
raise < < maybe ( get ( Recipe , r ) . name ) < < " 'put' expects exactly 3 ingredients in ' " < < to_original_string ( inst ) < < " ' \n " < < end ( ) ;
2016-04-11 02:26:37 +00:00
break ;
}
2016-05-06 07:46:39 +00:00
reagent /*copy*/ base = inst . ingredients . at ( 0 ) ;
2016-04-24 07:36:30 +00:00
// Update PUT base in Check
3309
Rip out everything to fix one failing unit test (commit 3290; type
abbreviations).
This commit does several things at once that I couldn't come up with a
clean way to unpack:
A. It moves to a new representation for type trees without changing
the actual definition of the `type_tree` struct.
B. It adds unit tests for our type metadata precomputation, so that
errors there show up early and in a simpler setting rather than dying
when we try to load Mu code.
C. It fixes a bug, guarding against infinite loops when precomputing
metadata for recursive shape-shifting containers. To do this it uses a
dumb way of comparing type_trees, comparing their string
representations instead. That is likely incredibly inefficient.
Perhaps due to C, this commit has made Mu incredibly slow. Running all
tests for the core and the edit/ app now takes 6.5 minutes rather than
3.5 minutes.
== more notes and details
I've been struggling for the past week now to back out of a bad design
decision, a premature optimization from the early days: storing atoms
directly in the 'value' slot of a cons cell rather than creating a
special 'atom' cons cell and storing it on the 'left' slot. In other
words, if a cons cell looks like this:
o
/ | \
left val right
..then the type_tree (a b c) used to look like this (before this
commit):
o
| \
a o
| \
b o
| \
c null
..rather than like this 'classic' approach to s-expressions which never
mixes val and right (which is what we now have):
o
/ \
o o
| / \
a o o
| / \
b o null
|
c
The old approach made several operations more complicated, most recently
the act of replacing a (possibly atom/leaf) sub-tree with another. That
was the final straw that got me to realize the contortions I was going
through to save a few type_tree nodes (cons cells).
Switching to the new approach was hard partly because I've been using
the old approach for so long and type_tree manipulations had pervaded
everything. Another issue I ran into was the realization that my layers
were not cleanly separated. Key parts of early layers (precomputing type
metadata) existed purely for far later ones (shape-shifting types).
Layers I got repeatedly stuck at:
1. the transform for precomputing type sizes (layer 30)
2. type-checks on merge instructions (layer 31)
3. the transform for precomputing address offsets in types (layer 36)
4. replace operations in supporting shape-shifting recipes (layer 55)
After much thrashing I finally noticed that it wasn't the entirety of
these layers that was giving me trouble, but just the type metadata
precomputation, which had bugs that weren't manifesting until 30 layers
later. Or, worse, when loading .mu files before any tests had had a
chance to run. A common failure mode was running into types at run time
that I hadn't precomputed metadata for at transform time.
Digging into these bugs got me to realize that what I had before wasn't
really very good, but a half-assed heuristic approach that did a whole
lot of extra work precomputing metadata for utterly meaningless types
like `((address number) 3)` which just happened to be part of a larger
type like `(array (address number) 3)`.
So, I redid it all. I switched the representation of types (because the
old representation made unit tests difficult to retrofit) and added unit
tests to the metadata precomputation. I also made layer 30 only do the
minimal metadata precomputation it needs for the concepts introduced
until then. In the process, I also made the precomputation more correct
than before, and added hooks in the right place so that I could augment
the logic when I introduced shape-shifting containers.
== lessons learned
There's several levels of hygiene when it comes to layers:
1. Every layer introduces precisely what it needs and in the simplest
way possible. If I was building an app until just that layer, nothing
would seem over-engineered.
2. Some layers are fore-shadowing features in future layers. Sometimes
this is ok. For example, layer 10 foreshadows containers and arrays and
so on without actually supporting them. That is a net win because it
lets me lay out the core of Mu's data structures out in one place. But
if the fore-shadowing gets too complex things get nasty. Not least
because it can be hard to write unit tests for features before you
provide the plumbing to visualize and manipulate them.
3. A layer is introducing features that are tested only in later layers.
4. A layer is introducing features with tests that are invalidated in
later layers. (This I knew from early on to be an obviously horrendous
idea.)
Summary: avoid Level 2 (foreshadowing layers) as much as possible.
Tolerate it indefinitely for small things where the code stays simple
over time, but become strict again when things start to get more
complex.
Level 3 is mostly a net lose, but sometimes it can be expedient (a real
case of the usually grossly over-applied term "technical debt"), and
it's better than the conventional baseline of no layers and no
scenarios. Just clean it up as soon as possible.
Definitely avoid layer 4 at any time.
== minor lessons
Avoid unit tests for trivial things, write scenarios in context as much as
possible. But within those margins unit tests are fine. Just introduce them
before any scenarios (commit 3297).
Reorganizing layers can be easy. Just merge layers for starters! Punt on
resplitting them in some new way until you've gotten them to work. This is the
wisdom of Refactoring: small steps.
What made it hard was not wanting to merge *everything* between layer 30
and 55. The eventual insight was realizing I just need to move those two
full-strength transforms and nothing else.
2016-09-10 01:32:52 +00:00
if ( ! base . type ) {
raise < < maybe ( get ( Recipe , r ) . name ) < < " first ingredient of 'put' should be a container, but got ' " < < inst . ingredients . at ( 0 ) . original_string < < " ' \n " < < end ( ) ;
break ;
}
2016-09-10 23:47:17 +00:00
const type_tree * base_type = base . type ;
// Update PUT base_type in Check
if ( ! base_type - > atom | | base_type - > value = = 0 | | ! contains_key ( Type , base_type - > value ) | | get ( Type , base_type - > value ) . kind ! = CONTAINER ) {
2016-05-21 05:09:06 +00:00
raise < < maybe ( get ( Recipe , r ) . name ) < < " first ingredient of 'put' should be a container, but got ' " < < inst . ingredients . at ( 0 ) . original_string < < " ' \n " < < end ( ) ;
2016-04-11 02:26:37 +00:00
break ;
}
2016-05-06 07:46:39 +00:00
reagent /*copy*/ offset = inst . ingredients . at ( 1 ) ;
2016-04-24 07:36:30 +00:00
// Update PUT offset in Check
2016-04-11 02:26:37 +00:00
if ( ! is_literal ( offset ) | | ! is_mu_scalar ( offset ) ) {
2016-05-21 05:09:06 +00:00
raise < < maybe ( get ( Recipe , r ) . name ) < < " second ingredient of 'put' should have type 'offset', but got ' " < < inst . ingredients . at ( 1 ) . original_string < < " ' \n " < < end ( ) ;
2016-04-11 02:26:37 +00:00
break ;
}
int offset_value = 0 ;
2016-12-12 18:01:12 +00:00
//: later layers will permit non-integer offsets
if ( is_integer ( offset . name ) ) {
2016-04-11 02:26:37 +00:00
offset_value = to_integer ( offset . name ) ;
2016-09-10 23:47:17 +00:00
if ( offset_value < 0 | | offset_value > = SIZE ( get ( Type , base_type - > value ) . elements ) ) {
raise < < maybe ( get ( Recipe , r ) . name ) < < " invalid offset ' " < < offset_value < < " ' for ' " < < get ( Type , base_type - > value ) . name < < " ' \n " < < end ( ) ;
2016-04-11 02:26:37 +00:00
break ;
}
}
else {
offset_value = offset . value ;
}
2016-05-06 07:46:39 +00:00
const reagent & value = inst . ingredients . at ( 2 ) ;
2016-12-12 18:01:12 +00:00
//: use base.type rather than base_type because later layers will introduce compound types
const reagent & element = element_type ( base . type , offset_value ) ;
2016-04-11 02:26:37 +00:00
if ( ! types_coercible ( element , value ) ) {
2016-05-21 05:09:06 +00:00
raise < < maybe ( get ( Recipe , r ) . name ) < < " 'put " < < base . original_string < < " , " < < offset . original_string < < " ' should write to " < < names_to_string_without_quotes ( element . type ) < < " but ' " < < value . name < < " ' has type " < < names_to_string_without_quotes ( value . type ) < < ' \n ' < < end ( ) ;
2016-04-11 02:26:37 +00:00
break ;
}
2016-07-21 18:56:27 +00:00
if ( inst . products . empty ( ) ) break ; // no more checks necessary
if ( inst . products . at ( 0 ) . name ! = inst . ingredients . at ( 0 ) . name ) {
2016-05-21 06:45:03 +00:00
raise < < maybe ( get ( Recipe , r ) . name ) < < " product of 'put' must be first ingredient ' " < < inst . ingredients . at ( 0 ) . original_string < < " ', but got ' " < < inst . products . at ( 0 ) . original_string < < " ' \n " < < end ( ) ;
break ;
}
2016-07-21 18:56:27 +00:00
// End PUT Product Checks
2016-04-11 02:26:37 +00:00
break ;
}
: ( before " End Primitive Recipe Implementations " )
case PUT : {
2016-05-06 07:46:39 +00:00
reagent /*copy*/ base = current_instruction ( ) . ingredients . at ( 0 ) ;
2016-04-24 07:36:30 +00:00
// Update PUT base in Run
2016-04-11 02:26:37 +00:00
int base_address = base . value ;
if ( base_address = = 0 ) {
2017-05-26 23:43:18 +00:00
raise < < maybe ( current_recipe_name ( ) ) < < " tried to access location 0 in ' " < < to_original_string ( current_instruction ( ) ) < < " ' \n " < < end ( ) ;
2016-04-11 02:26:37 +00:00
break ;
}
2016-09-10 23:47:17 +00:00
const type_tree * base_type = base . type ;
// Update PUT base_type in Run
2016-04-11 02:26:37 +00:00
int offset = ingredients . at ( 1 ) . at ( 0 ) ;
2016-09-10 23:47:17 +00:00
if ( offset < 0 | | offset > = SIZE ( get ( Type , base_type - > value ) . elements ) ) break ; // copied from Check above
2018-06-16 05:16:09 +00:00
int address = base_address ;
for ( int i = 0 ; i < offset ; + + i )
address + = size_of ( element_type ( base . type , i ) ) ;
2019-02-25 08:17:46 +00:00
trace ( Callstack_depth + 1 , " run " ) < < " address to copy to is " < < address < < end ( ) ;
2016-04-11 02:26:37 +00:00
// optimization: directly write the element rather than updating 'product'
// and writing the entire container
2016-05-04 00:38:33 +00:00
// Write Memory in PUT in Run
2017-05-28 21:28:07 +00:00
write_products = false ;
2016-10-20 05:10:35 +00:00
for ( int i = 0 ; i < SIZE ( ingredients . at ( 2 ) ) ; + + i ) {
2019-02-25 08:17:46 +00:00
trace ( Callstack_depth + 1 , " mem " ) < < " storing " < < no_scientific ( ingredients . at ( 2 ) . at ( i ) ) < < " in location " < < address + i < < end ( ) ;
2016-04-11 02:26:37 +00:00
put ( Memory , address + i , ingredients . at ( 2 ) . at ( i ) ) ;
}
2017-05-28 21:28:07 +00:00
break ;
2016-04-11 02:26:37 +00:00
}
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
: ( code )
void test_put_product_error ( ) {
Hide_errors = true ;
run (
" def main [ \n "
" local-scope \n "
" load-ingredients \n "
" 1:point <- merge 34, 35 \n "
" 3:point <- put 1:point, x:offset, 36 \n "
" ] \n "
) ;
CHECK_TRACE_CONTENTS (
" error: main: product of 'put' must be first ingredient '1:point', but got '3:point' \n "
) ;
}
2016-05-21 06:45:03 +00:00
2016-10-22 23:56:07 +00:00
//:: Allow containers to be defined in Mu code.
2015-05-14 17:30:01 +00:00
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
void test_container ( ) {
load (
" container foo [ \n "
" x:num \n "
" y:num \n "
" ] \n "
) ;
CHECK_TRACE_CONTENTS (
" parse: --- defining container foo \n "
" parse: element: {x: \" number \" } \n "
" parse: element: {y: \" number \" } \n "
) ;
}
void test_container_use_before_definition ( ) {
load (
" container foo [ \n "
" x:num \n "
" y:bar \n "
" ] \n "
" container bar [ \n "
" x:num \n "
" y:num \n "
" ] \n "
) ;
CHECK_TRACE_CONTENTS (
" parse: --- defining container foo \n "
" parse: type number: 1000 \n "
" parse: element: {x: \" number \" } \n "
// todo: brittle
// type bar is unknown at this point, but we assign it a number
" parse: element: {y: \" bar \" } \n "
// later type bar gets a definition
" parse: --- defining container bar \n "
" parse: type number: 1001 \n "
" parse: element: {x: \" number \" } \n "
" parse: element: {y: \" number \" } \n "
) ;
}
2015-05-18 23:09:09 +00:00
2016-04-29 00:23:50 +00:00
//: if a container is defined again, the new fields add to the original definition
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
void test_container_extend ( ) {
run (
" container foo [ \n "
" x:num \n "
" ] \n "
" container foo [ \n " // add to previous definition
" y:num \n "
" ] \n "
" def main [ \n "
" 1:num <- copy 34 \n "
" 2:num <- copy 35 \n "
" 3:num <- get 1:foo, 0:offset \n "
" 4:num <- get 1:foo, 1:offset \n "
" ] \n "
) ;
CHECK_TRACE_CONTENTS (
" mem: storing 34 in location 3 \n "
" mem: storing 35 in location 4 \n "
) ;
}
2016-04-29 00:23:50 +00:00
2015-05-14 17:30:01 +00:00
: ( before " End Command Handlers " )
else if ( command = = " container " ) {
2015-10-27 03:06:51 +00:00
insert_container ( command , CONTAINER , in ) ;
2015-05-14 17:30:01 +00:00
}
2016-04-29 00:23:50 +00:00
//: Even though we allow containers to be extended, we don't allow this after
//: a call to transform_all. But we do want to detect this situation and raise
//: an error. This field will help us raise such errors.
: ( before " End type_info Fields " )
int Num_calls_to_transform_all_at_first_definition ;
: ( before " End type_info Constructor " )
Num_calls_to_transform_all_at_first_definition = - 1 ;
2015-05-14 17:30:01 +00:00
: ( code )
void insert_container ( const string & command , kind_of_type kind , istream & in ) {
2015-12-03 01:11:58 +00:00
skip_whitespace_but_not_newline ( in ) ;
2015-05-14 17:30:01 +00:00
string name = next_word ( in ) ;
2016-10-21 08:08:09 +00:00
if ( name . empty ( ) ) {
assert ( ! has_data ( in ) ) ;
raise < < " incomplete container definition at end of file (0) \n " < < end ( ) ;
return ;
}
2015-10-30 20:00:16 +00:00
// End container Name Refinements
2019-02-25 08:17:46 +00:00
trace ( 101 , " parse " ) < < " --- defining " < < command < < ' ' < < name < < end ( ) ;
2015-11-06 21:22:16 +00:00
if ( ! contains_key ( Type_ordinal , name )
2015-11-06 19:06:58 +00:00
| | get ( Type_ordinal , name ) = = 0 ) {
put ( Type_ordinal , name , Next_type_ordinal + + ) ;
2015-05-14 17:30:01 +00:00
}
2019-02-25 08:17:46 +00:00
trace ( 102 , " parse " ) < < " type number: " < < get ( Type_ordinal , name ) < < end ( ) ;
2016-06-18 00:22:15 +00:00
skip_bracket ( in , " ' " + command + " ' must begin with '[' " ) ;
2015-11-06 19:31:37 +00:00
type_info & info = get_or_insert ( Type , get ( Type_ordinal , name ) ) ;
2016-04-29 00:23:50 +00:00
if ( info . Num_calls_to_transform_all_at_first_definition = = - 1 ) {
// initial definition of this container
info . Num_calls_to_transform_all_at_first_definition = Num_calls_to_transform_all ;
}
else if ( info . Num_calls_to_transform_all_at_first_definition ! = Num_calls_to_transform_all ) {
// extension after transform_all
2016-05-21 05:09:06 +00:00
raise < < " there was a call to transform_all() between the definition of container ' " < < name < < " ' and a subsequent extension. This is not supported, since any recipes that used ' " < < name < < " ' values have already been transformed and \" frozen \" . \n " < < end ( ) ;
2016-04-29 00:23:50 +00:00
return ;
}
2015-10-06 02:49:43 +00:00
info . name = name ;
info . kind = kind ;
2015-11-17 09:21:00 +00:00
while ( has_data ( in ) ) {
2015-05-14 17:30:01 +00:00
skip_whitespace_and_comments ( in ) ;
string element = next_word ( in ) ;
2016-10-21 08:08:09 +00:00
if ( element . empty ( ) ) {
assert ( ! has_data ( in ) ) ;
raise < < " incomplete container definition at end of file (1) \n " < < end ( ) ;
return ;
}
2015-05-14 17:30:01 +00:00
if ( element = = " ] " ) break ;
2016-06-18 00:22:15 +00:00
if ( in . peek ( ) ! = ' \n ' ) {
raise < < command < < " ' " < < name < < " ' contains multiple elements on a single line. Containers and exclusive containers must only contain elements, one to a line, no code. \n " < < end ( ) ;
// skip rest of container declaration
while ( has_data ( in ) ) {
skip_whitespace_and_comments ( in ) ;
if ( next_word ( in ) = = " ] " ) break ;
}
break ;
}
2016-02-17 18:09:48 +00:00
info . elements . push_back ( reagent ( element ) ) ;
2016-09-17 07:43:13 +00:00
expand_type_abbreviations ( info . elements . back ( ) . type ) ; // todo: use abbreviation before declaration
2016-02-22 04:30:02 +00:00
replace_unknown_types_with_unique_ordinals ( info . elements . back ( ) . type , info ) ;
2019-02-25 08:17:46 +00:00
trace ( 103 , " parse " ) < < " element: " < < to_string ( info . elements . back ( ) ) < < end ( ) ;
2016-02-15 20:25:13 +00:00
// End Load Container Element Definition
2015-05-14 17:30:01 +00:00
}
}
2016-02-22 04:30:02 +00:00
void replace_unknown_types_with_unique_ordinals ( type_tree * type , const type_info & info ) {
if ( ! type ) return ;
3309
Rip out everything to fix one failing unit test (commit 3290; type
abbreviations).
This commit does several things at once that I couldn't come up with a
clean way to unpack:
A. It moves to a new representation for type trees without changing
the actual definition of the `type_tree` struct.
B. It adds unit tests for our type metadata precomputation, so that
errors there show up early and in a simpler setting rather than dying
when we try to load Mu code.
C. It fixes a bug, guarding against infinite loops when precomputing
metadata for recursive shape-shifting containers. To do this it uses a
dumb way of comparing type_trees, comparing their string
representations instead. That is likely incredibly inefficient.
Perhaps due to C, this commit has made Mu incredibly slow. Running all
tests for the core and the edit/ app now takes 6.5 minutes rather than
3.5 minutes.
== more notes and details
I've been struggling for the past week now to back out of a bad design
decision, a premature optimization from the early days: storing atoms
directly in the 'value' slot of a cons cell rather than creating a
special 'atom' cons cell and storing it on the 'left' slot. In other
words, if a cons cell looks like this:
o
/ | \
left val right
..then the type_tree (a b c) used to look like this (before this
commit):
o
| \
a o
| \
b o
| \
c null
..rather than like this 'classic' approach to s-expressions which never
mixes val and right (which is what we now have):
o
/ \
o o
| / \
a o o
| / \
b o null
|
c
The old approach made several operations more complicated, most recently
the act of replacing a (possibly atom/leaf) sub-tree with another. That
was the final straw that got me to realize the contortions I was going
through to save a few type_tree nodes (cons cells).
Switching to the new approach was hard partly because I've been using
the old approach for so long and type_tree manipulations had pervaded
everything. Another issue I ran into was the realization that my layers
were not cleanly separated. Key parts of early layers (precomputing type
metadata) existed purely for far later ones (shape-shifting types).
Layers I got repeatedly stuck at:
1. the transform for precomputing type sizes (layer 30)
2. type-checks on merge instructions (layer 31)
3. the transform for precomputing address offsets in types (layer 36)
4. replace operations in supporting shape-shifting recipes (layer 55)
After much thrashing I finally noticed that it wasn't the entirety of
these layers that was giving me trouble, but just the type metadata
precomputation, which had bugs that weren't manifesting until 30 layers
later. Or, worse, when loading .mu files before any tests had had a
chance to run. A common failure mode was running into types at run time
that I hadn't precomputed metadata for at transform time.
Digging into these bugs got me to realize that what I had before wasn't
really very good, but a half-assed heuristic approach that did a whole
lot of extra work precomputing metadata for utterly meaningless types
like `((address number) 3)` which just happened to be part of a larger
type like `(array (address number) 3)`.
So, I redid it all. I switched the representation of types (because the
old representation made unit tests difficult to retrofit) and added unit
tests to the metadata precomputation. I also made layer 30 only do the
minimal metadata precomputation it needs for the concepts introduced
until then. In the process, I also made the precomputation more correct
than before, and added hooks in the right place so that I could augment
the logic when I introduced shape-shifting containers.
== lessons learned
There's several levels of hygiene when it comes to layers:
1. Every layer introduces precisely what it needs and in the simplest
way possible. If I was building an app until just that layer, nothing
would seem over-engineered.
2. Some layers are fore-shadowing features in future layers. Sometimes
this is ok. For example, layer 10 foreshadows containers and arrays and
so on without actually supporting them. That is a net win because it
lets me lay out the core of Mu's data structures out in one place. But
if the fore-shadowing gets too complex things get nasty. Not least
because it can be hard to write unit tests for features before you
provide the plumbing to visualize and manipulate them.
3. A layer is introducing features that are tested only in later layers.
4. A layer is introducing features with tests that are invalidated in
later layers. (This I knew from early on to be an obviously horrendous
idea.)
Summary: avoid Level 2 (foreshadowing layers) as much as possible.
Tolerate it indefinitely for small things where the code stays simple
over time, but become strict again when things start to get more
complex.
Level 3 is mostly a net lose, but sometimes it can be expedient (a real
case of the usually grossly over-applied term "technical debt"), and
it's better than the conventional baseline of no layers and no
scenarios. Just clean it up as soon as possible.
Definitely avoid layer 4 at any time.
== minor lessons
Avoid unit tests for trivial things, write scenarios in context as much as
possible. But within those margins unit tests are fine. Just introduce them
before any scenarios (commit 3297).
Reorganizing layers can be easy. Just merge layers for starters! Punt on
resplitting them in some new way until you've gotten them to work. This is the
wisdom of Refactoring: small steps.
What made it hard was not wanting to merge *everything* between layer 30
and 55. The eventual insight was realizing I just need to move those two
full-strength transforms and nothing else.
2016-09-10 01:32:52 +00:00
if ( ! type - > atom ) {
replace_unknown_types_with_unique_ordinals ( type - > left , info ) ;
replace_unknown_types_with_unique_ordinals ( type - > right , info ) ;
return ;
}
assert ( ! type - > name . empty ( ) ) ;
if ( contains_key ( Type_ordinal , type - > name ) ) {
type - > value = get ( Type_ordinal , type - > name ) ;
}
// End insert_container Special-cases
else if ( type - > name ! = " -> " ) { // used in recipe types
put ( Type_ordinal , type - > name , Next_type_ordinal + + ) ;
type - > value = get ( Type_ordinal , type - > name ) ;
2016-02-07 00:47:10 +00:00
}
}
2015-10-06 01:49:21 +00:00
void skip_bracket ( istream & in , string message ) {
skip_whitespace_and_comments ( in ) ;
if ( in . get ( ) ! = ' [ ' )
2016-02-26 21:04:55 +00:00
raise < < message < < ' \n ' < < end ( ) ;
2015-10-06 01:49:21 +00:00
}
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
void test_multi_word_line_in_container_declaration ( ) {
Hide_errors = true ;
run (
" container foo [ \n "
" x:num y:num \n "
" ] \n "
) ;
CHECK_TRACE_CONTENTS (
" error: container 'foo' contains multiple elements on a single line. Containers and exclusive containers must only contain elements, one to a line, no code. \n "
) ;
}
2016-06-18 00:22:15 +00:00
2016-09-12 07:47:44 +00:00
//: support type abbreviations in container definitions
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
void test_type_abbreviations_in_containers ( ) {
run (
" type foo = number \n "
" container bar [ \n "
" x:foo \n "
" ] \n "
" def main [ \n "
" 1:num <- copy 34 \n "
" 2:foo <- get 1:bar/unsafe, 0:offset \n "
" ] \n "
) ;
CHECK_TRACE_CONTENTS (
" mem: storing 34 in location 2 \n "
) ;
}
2016-09-12 07:47:44 +00:00
: ( after " Transform.push_back(expand_type_abbreviations) " )
2016-10-22 19:16:02 +00:00
Transform . push_back ( expand_type_abbreviations_in_containers ) ; // idempotent
2016-09-12 07:47:44 +00:00
: ( code )
// extremely inefficient; we process all types over and over again, once for every single recipe
// but it doesn't seem to cause any noticeable slowdown
2018-07-26 03:47:41 +00:00
void expand_type_abbreviations_in_containers ( const recipe_ordinal /*unused*/ ) {
2016-10-20 05:10:35 +00:00
for ( map < type_ordinal , type_info > : : iterator p = Type . begin ( ) ; p ! = Type . end ( ) ; + + p ) {
for ( int i = 0 ; i < SIZE ( p - > second . elements ) ; + + i )
2016-09-12 07:47:44 +00:00
expand_type_abbreviations ( p - > second . elements . at ( i ) . type ) ;
}
}
2016-09-12 02:55:28 +00:00
//: ensure scenarios are consistent by always starting new container
//: declarations at the same type number
2017-07-09 21:34:17 +00:00
: ( before " End Reset " ) //: for tests
2015-07-04 16:40:50 +00:00
Next_type_ordinal = 1000 ;
2015-05-14 17:30:01 +00:00
: ( before " End Test Run Initialization " )
2015-07-04 16:40:50 +00:00
assert ( Next_type_ordinal < 1000 ) ;
2015-05-14 17:30:01 +00:00
2016-04-29 00:23:50 +00:00
: ( code )
void test_error_on_transform_all_between_container_definition_and_extension ( ) {
// define a container
run ( " container foo [ \n "
2016-09-17 07:43:13 +00:00
" a:num \n "
2016-04-29 00:23:50 +00:00
" ] \n " ) ;
// try to extend the container after transform
transform_all ( ) ;
2016-11-16 05:55:56 +00:00
CHECK_TRACE_DOESNT_CONTAIN_ERRORS ( ) ;
2016-04-29 00:23:50 +00:00
Hide_errors = true ;
run ( " container foo [ \n "
2016-09-17 07:43:13 +00:00
" b:num \n "
2016-04-29 00:23:50 +00:00
" ] \n " ) ;
2016-11-16 05:55:56 +00:00
CHECK_TRACE_CONTAINS_ERRORS ( ) ;
2016-04-29 00:23:50 +00:00
}
2015-10-07 05:15:45 +00:00
//:: Allow container definitions anywhere in the codebase, but complain if you
//:: can't find a definition at the end.
2015-05-19 01:40:58 +00:00
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
void test_run_complains_on_unknown_types ( ) {
Hide_errors = true ;
run (
" def main [ \n "
" 1:integer <- copy 0 \n "
" ] \n "
) ;
CHECK_TRACE_CONTENTS (
" error: main: unknown type integer in '1:integer <- copy 0' \n "
) ;
}
void test_run_allows_type_definition_after_use ( ) {
run (
" def main [ \n "
" 1:bar <- copy 0/unsafe \n "
" ] \n "
" container bar [ \n "
" x:num \n "
" ] \n "
) ;
CHECK_TRACE_COUNT ( " error " , 0 ) ;
}
2015-05-19 01:40:58 +00:00
2016-09-12 00:14:48 +00:00
: ( before " End Type Modifying Transforms " )
2015-11-07 01:29:52 +00:00
Transform . push_back ( check_or_set_invalid_types ) ; // idempotent
2015-05-19 01:40:58 +00:00
: ( code )
2015-11-07 01:03:02 +00:00
void check_or_set_invalid_types ( const recipe_ordinal r ) {
2015-11-19 18:29:55 +00:00
recipe & caller = get ( Recipe , r ) ;
2019-02-25 08:17:46 +00:00
trace ( 101 , " transform " ) < < " --- check for invalid types in recipe " < < caller . name < < end ( ) ;
2016-10-20 05:10:35 +00:00
for ( int index = 0 ; index < SIZE ( caller . steps ) ; + + index ) {
2015-11-19 18:29:55 +00:00
instruction & inst = caller . steps . at ( index ) ;
2016-10-20 05:10:35 +00:00
for ( int i = 0 ; i < SIZE ( inst . ingredients ) ; + + i )
2016-10-16 04:12:30 +00:00
check_or_set_invalid_types ( inst . ingredients . at ( i ) , caller , inst ) ;
2016-10-20 05:10:35 +00:00
for ( int i = 0 ; i < SIZE ( inst . products ) ; + + i )
2016-10-16 04:12:30 +00:00
check_or_set_invalid_types ( inst . products . at ( i ) , caller , inst ) ;
2015-05-19 01:40:58 +00:00
}
2015-11-19 18:29:55 +00:00
// End check_or_set_invalid_types
2015-05-19 01:40:58 +00:00
}
2016-10-16 04:12:30 +00:00
void check_or_set_invalid_types ( reagent & r , const recipe & caller , const instruction & inst ) {
// Begin check_or_set_invalid_types(r)
2017-05-26 23:43:18 +00:00
check_or_set_invalid_types ( r . type , maybe ( caller . name ) , " ' " + to_original_string ( inst ) + " ' " ) ;
2016-10-16 04:12:30 +00:00
}
2016-11-06 19:59:50 +00:00
void check_or_set_invalid_types ( type_tree * type , const string & location_for_error_messages , const string & name_for_error_messages ) {
2016-10-16 04:12:30 +00:00
if ( ! type ) return ;
2015-10-30 20:00:16 +00:00
// End Container Type Checks
3309
Rip out everything to fix one failing unit test (commit 3290; type
abbreviations).
This commit does several things at once that I couldn't come up with a
clean way to unpack:
A. It moves to a new representation for type trees without changing
the actual definition of the `type_tree` struct.
B. It adds unit tests for our type metadata precomputation, so that
errors there show up early and in a simpler setting rather than dying
when we try to load Mu code.
C. It fixes a bug, guarding against infinite loops when precomputing
metadata for recursive shape-shifting containers. To do this it uses a
dumb way of comparing type_trees, comparing their string
representations instead. That is likely incredibly inefficient.
Perhaps due to C, this commit has made Mu incredibly slow. Running all
tests for the core and the edit/ app now takes 6.5 minutes rather than
3.5 minutes.
== more notes and details
I've been struggling for the past week now to back out of a bad design
decision, a premature optimization from the early days: storing atoms
directly in the 'value' slot of a cons cell rather than creating a
special 'atom' cons cell and storing it on the 'left' slot. In other
words, if a cons cell looks like this:
o
/ | \
left val right
..then the type_tree (a b c) used to look like this (before this
commit):
o
| \
a o
| \
b o
| \
c null
..rather than like this 'classic' approach to s-expressions which never
mixes val and right (which is what we now have):
o
/ \
o o
| / \
a o o
| / \
b o null
|
c
The old approach made several operations more complicated, most recently
the act of replacing a (possibly atom/leaf) sub-tree with another. That
was the final straw that got me to realize the contortions I was going
through to save a few type_tree nodes (cons cells).
Switching to the new approach was hard partly because I've been using
the old approach for so long and type_tree manipulations had pervaded
everything. Another issue I ran into was the realization that my layers
were not cleanly separated. Key parts of early layers (precomputing type
metadata) existed purely for far later ones (shape-shifting types).
Layers I got repeatedly stuck at:
1. the transform for precomputing type sizes (layer 30)
2. type-checks on merge instructions (layer 31)
3. the transform for precomputing address offsets in types (layer 36)
4. replace operations in supporting shape-shifting recipes (layer 55)
After much thrashing I finally noticed that it wasn't the entirety of
these layers that was giving me trouble, but just the type metadata
precomputation, which had bugs that weren't manifesting until 30 layers
later. Or, worse, when loading .mu files before any tests had had a
chance to run. A common failure mode was running into types at run time
that I hadn't precomputed metadata for at transform time.
Digging into these bugs got me to realize that what I had before wasn't
really very good, but a half-assed heuristic approach that did a whole
lot of extra work precomputing metadata for utterly meaningless types
like `((address number) 3)` which just happened to be part of a larger
type like `(array (address number) 3)`.
So, I redid it all. I switched the representation of types (because the
old representation made unit tests difficult to retrofit) and added unit
tests to the metadata precomputation. I also made layer 30 only do the
minimal metadata precomputation it needs for the concepts introduced
until then. In the process, I also made the precomputation more correct
than before, and added hooks in the right place so that I could augment
the logic when I introduced shape-shifting containers.
== lessons learned
There's several levels of hygiene when it comes to layers:
1. Every layer introduces precisely what it needs and in the simplest
way possible. If I was building an app until just that layer, nothing
would seem over-engineered.
2. Some layers are fore-shadowing features in future layers. Sometimes
this is ok. For example, layer 10 foreshadows containers and arrays and
so on without actually supporting them. That is a net win because it
lets me lay out the core of Mu's data structures out in one place. But
if the fore-shadowing gets too complex things get nasty. Not least
because it can be hard to write unit tests for features before you
provide the plumbing to visualize and manipulate them.
3. A layer is introducing features that are tested only in later layers.
4. A layer is introducing features with tests that are invalidated in
later layers. (This I knew from early on to be an obviously horrendous
idea.)
Summary: avoid Level 2 (foreshadowing layers) as much as possible.
Tolerate it indefinitely for small things where the code stays simple
over time, but become strict again when things start to get more
complex.
Level 3 is mostly a net lose, but sometimes it can be expedient (a real
case of the usually grossly over-applied term "technical debt"), and
it's better than the conventional baseline of no layers and no
scenarios. Just clean it up as soon as possible.
Definitely avoid layer 4 at any time.
== minor lessons
Avoid unit tests for trivial things, write scenarios in context as much as
possible. But within those margins unit tests are fine. Just introduce them
before any scenarios (commit 3297).
Reorganizing layers can be easy. Just merge layers for starters! Punt on
resplitting them in some new way until you've gotten them to work. This is the
wisdom of Refactoring: small steps.
What made it hard was not wanting to merge *everything* between layer 30
and 55. The eventual insight was realizing I just need to move those two
full-strength transforms and nothing else.
2016-09-10 01:32:52 +00:00
if ( ! type - > atom ) {
2016-11-06 19:59:50 +00:00
check_or_set_invalid_types ( type - > left , location_for_error_messages , name_for_error_messages ) ;
check_or_set_invalid_types ( type - > right , location_for_error_messages , name_for_error_messages ) ;
3309
Rip out everything to fix one failing unit test (commit 3290; type
abbreviations).
This commit does several things at once that I couldn't come up with a
clean way to unpack:
A. It moves to a new representation for type trees without changing
the actual definition of the `type_tree` struct.
B. It adds unit tests for our type metadata precomputation, so that
errors there show up early and in a simpler setting rather than dying
when we try to load Mu code.
C. It fixes a bug, guarding against infinite loops when precomputing
metadata for recursive shape-shifting containers. To do this it uses a
dumb way of comparing type_trees, comparing their string
representations instead. That is likely incredibly inefficient.
Perhaps due to C, this commit has made Mu incredibly slow. Running all
tests for the core and the edit/ app now takes 6.5 minutes rather than
3.5 minutes.
== more notes and details
I've been struggling for the past week now to back out of a bad design
decision, a premature optimization from the early days: storing atoms
directly in the 'value' slot of a cons cell rather than creating a
special 'atom' cons cell and storing it on the 'left' slot. In other
words, if a cons cell looks like this:
o
/ | \
left val right
..then the type_tree (a b c) used to look like this (before this
commit):
o
| \
a o
| \
b o
| \
c null
..rather than like this 'classic' approach to s-expressions which never
mixes val and right (which is what we now have):
o
/ \
o o
| / \
a o o
| / \
b o null
|
c
The old approach made several operations more complicated, most recently
the act of replacing a (possibly atom/leaf) sub-tree with another. That
was the final straw that got me to realize the contortions I was going
through to save a few type_tree nodes (cons cells).
Switching to the new approach was hard partly because I've been using
the old approach for so long and type_tree manipulations had pervaded
everything. Another issue I ran into was the realization that my layers
were not cleanly separated. Key parts of early layers (precomputing type
metadata) existed purely for far later ones (shape-shifting types).
Layers I got repeatedly stuck at:
1. the transform for precomputing type sizes (layer 30)
2. type-checks on merge instructions (layer 31)
3. the transform for precomputing address offsets in types (layer 36)
4. replace operations in supporting shape-shifting recipes (layer 55)
After much thrashing I finally noticed that it wasn't the entirety of
these layers that was giving me trouble, but just the type metadata
precomputation, which had bugs that weren't manifesting until 30 layers
later. Or, worse, when loading .mu files before any tests had had a
chance to run. A common failure mode was running into types at run time
that I hadn't precomputed metadata for at transform time.
Digging into these bugs got me to realize that what I had before wasn't
really very good, but a half-assed heuristic approach that did a whole
lot of extra work precomputing metadata for utterly meaningless types
like `((address number) 3)` which just happened to be part of a larger
type like `(array (address number) 3)`.
So, I redid it all. I switched the representation of types (because the
old representation made unit tests difficult to retrofit) and added unit
tests to the metadata precomputation. I also made layer 30 only do the
minimal metadata precomputation it needs for the concepts introduced
until then. In the process, I also made the precomputation more correct
than before, and added hooks in the right place so that I could augment
the logic when I introduced shape-shifting containers.
== lessons learned
There's several levels of hygiene when it comes to layers:
1. Every layer introduces precisely what it needs and in the simplest
way possible. If I was building an app until just that layer, nothing
would seem over-engineered.
2. Some layers are fore-shadowing features in future layers. Sometimes
this is ok. For example, layer 10 foreshadows containers and arrays and
so on without actually supporting them. That is a net win because it
lets me lay out the core of Mu's data structures out in one place. But
if the fore-shadowing gets too complex things get nasty. Not least
because it can be hard to write unit tests for features before you
provide the plumbing to visualize and manipulate them.
3. A layer is introducing features that are tested only in later layers.
4. A layer is introducing features with tests that are invalidated in
later layers. (This I knew from early on to be an obviously horrendous
idea.)
Summary: avoid Level 2 (foreshadowing layers) as much as possible.
Tolerate it indefinitely for small things where the code stays simple
over time, but become strict again when things start to get more
complex.
Level 3 is mostly a net lose, but sometimes it can be expedient (a real
case of the usually grossly over-applied term "technical debt"), and
it's better than the conventional baseline of no layers and no
scenarios. Just clean it up as soon as possible.
Definitely avoid layer 4 at any time.
== minor lessons
Avoid unit tests for trivial things, write scenarios in context as much as
possible. But within those margins unit tests are fine. Just introduce them
before any scenarios (commit 3297).
Reorganizing layers can be easy. Just merge layers for starters! Punt on
resplitting them in some new way until you've gotten them to work. This is the
wisdom of Refactoring: small steps.
What made it hard was not wanting to merge *everything* between layer 30
and 55. The eventual insight was realizing I just need to move those two
full-strength transforms and nothing else.
2016-09-10 01:32:52 +00:00
return ;
}
2016-01-19 00:46:07 +00:00
if ( type - > value = = 0 ) return ;
2015-11-07 01:03:02 +00:00
if ( ! contains_key ( Type , type - > value ) ) {
2016-02-22 04:30:02 +00:00
assert ( ! type - > name . empty ( ) ) ;
if ( contains_key ( Type_ordinal , type - > name ) )
type - > value = get ( Type_ordinal , type - > name ) ;
2015-11-07 01:03:02 +00:00
else
2016-11-06 19:59:50 +00:00
raise < < location_for_error_messages < < " unknown type " < < type - > name < < " in " < < name_for_error_messages < < ' \n ' < < end ( ) ;
2015-11-07 01:03:02 +00:00
}
2015-05-19 01:40:58 +00:00
}
5001 - drop the :(scenario) DSL
I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.
[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2
The implementation of the DSL was also highly hacky:
a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.
b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?
On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.
Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.
---
This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.
2019-03-13 01:56:55 +00:00
void test_container_unknown_field ( ) {
Hide_errors = true ;
run (
" container foo [ \n "
" x:num \n "
" y:bar \n "
" ] \n "
) ;
CHECK_TRACE_CONTENTS (
" error: foo: unknown type in y \n "
) ;
}
void test_read_container_with_bracket_in_comment ( ) {
run (
" container foo [ \n "
" x:num \n "
" # ']' in comment \n "
" y:num \n "
" ] \n "
) ;
CHECK_TRACE_CONTENTS (
" parse: --- defining container foo \n "
" parse: element: {x: \" number \" } \n "
" parse: element: {y: \" number \" } \n "
) ;
}
void test_container_with_compound_field_type ( ) {
run (
" container foo [ \n "
" {x: (address array (address array character))} \n "
" ] \n "
) ;
CHECK_TRACE_COUNT ( " error " , 0 ) ;
}
2016-07-24 08:12:20 +00:00
2016-03-28 05:03:13 +00:00
: ( before " End transform_all " )
2015-05-19 01:40:58 +00:00
check_container_field_types ( ) ;
: ( code )
void check_container_field_types ( ) {
2016-10-20 05:10:35 +00:00
for ( map < type_ordinal , type_info > : : iterator p = Type . begin ( ) ; p ! = Type . end ( ) ; + + p ) {
2015-05-19 01:40:58 +00:00
const type_info & info = p - > second ;
2015-11-05 07:44:46 +00:00
// Check Container Field Types(info)
2016-10-20 05:10:35 +00:00
for ( int i = 0 ; i < SIZE ( info . elements ) ; + + i )
2016-02-17 18:09:48 +00:00
check_invalid_types ( info . elements . at ( i ) . type , maybe ( info . name ) , info . elements . at ( i ) . name ) ;
2015-05-19 01:40:58 +00:00
}
}
2016-11-06 19:59:50 +00:00
void check_invalid_types ( const type_tree * type , const string & location_for_error_messages , const string & name_for_error_messages ) {
2015-11-07 01:03:02 +00:00
if ( ! type ) return ; // will throw a more precise error elsewhere
3309
Rip out everything to fix one failing unit test (commit 3290; type
abbreviations).
This commit does several things at once that I couldn't come up with a
clean way to unpack:
A. It moves to a new representation for type trees without changing
the actual definition of the `type_tree` struct.
B. It adds unit tests for our type metadata precomputation, so that
errors there show up early and in a simpler setting rather than dying
when we try to load Mu code.
C. It fixes a bug, guarding against infinite loops when precomputing
metadata for recursive shape-shifting containers. To do this it uses a
dumb way of comparing type_trees, comparing their string
representations instead. That is likely incredibly inefficient.
Perhaps due to C, this commit has made Mu incredibly slow. Running all
tests for the core and the edit/ app now takes 6.5 minutes rather than
3.5 minutes.
== more notes and details
I've been struggling for the past week now to back out of a bad design
decision, a premature optimization from the early days: storing atoms
directly in the 'value' slot of a cons cell rather than creating a
special 'atom' cons cell and storing it on the 'left' slot. In other
words, if a cons cell looks like this:
o
/ | \
left val right
..then the type_tree (a b c) used to look like this (before this
commit):
o
| \
a o
| \
b o
| \
c null
..rather than like this 'classic' approach to s-expressions which never
mixes val and right (which is what we now have):
o
/ \
o o
| / \
a o o
| / \
b o null
|
c
The old approach made several operations more complicated, most recently
the act of replacing a (possibly atom/leaf) sub-tree with another. That
was the final straw that got me to realize the contortions I was going
through to save a few type_tree nodes (cons cells).
Switching to the new approach was hard partly because I've been using
the old approach for so long and type_tree manipulations had pervaded
everything. Another issue I ran into was the realization that my layers
were not cleanly separated. Key parts of early layers (precomputing type
metadata) existed purely for far later ones (shape-shifting types).
Layers I got repeatedly stuck at:
1. the transform for precomputing type sizes (layer 30)
2. type-checks on merge instructions (layer 31)
3. the transform for precomputing address offsets in types (layer 36)
4. replace operations in supporting shape-shifting recipes (layer 55)
After much thrashing I finally noticed that it wasn't the entirety of
these layers that was giving me trouble, but just the type metadata
precomputation, which had bugs that weren't manifesting until 30 layers
later. Or, worse, when loading .mu files before any tests had had a
chance to run. A common failure mode was running into types at run time
that I hadn't precomputed metadata for at transform time.
Digging into these bugs got me to realize that what I had before wasn't
really very good, but a half-assed heuristic approach that did a whole
lot of extra work precomputing metadata for utterly meaningless types
like `((address number) 3)` which just happened to be part of a larger
type like `(array (address number) 3)`.
So, I redid it all. I switched the representation of types (because the
old representation made unit tests difficult to retrofit) and added unit
tests to the metadata precomputation. I also made layer 30 only do the
minimal metadata precomputation it needs for the concepts introduced
until then. In the process, I also made the precomputation more correct
than before, and added hooks in the right place so that I could augment
the logic when I introduced shape-shifting containers.
== lessons learned
There's several levels of hygiene when it comes to layers:
1. Every layer introduces precisely what it needs and in the simplest
way possible. If I was building an app until just that layer, nothing
would seem over-engineered.
2. Some layers are fore-shadowing features in future layers. Sometimes
this is ok. For example, layer 10 foreshadows containers and arrays and
so on without actually supporting them. That is a net win because it
lets me lay out the core of Mu's data structures out in one place. But
if the fore-shadowing gets too complex things get nasty. Not least
because it can be hard to write unit tests for features before you
provide the plumbing to visualize and manipulate them.
3. A layer is introducing features that are tested only in later layers.
4. A layer is introducing features with tests that are invalidated in
later layers. (This I knew from early on to be an obviously horrendous
idea.)
Summary: avoid Level 2 (foreshadowing layers) as much as possible.
Tolerate it indefinitely for small things where the code stays simple
over time, but become strict again when things start to get more
complex.
Level 3 is mostly a net lose, but sometimes it can be expedient (a real
case of the usually grossly over-applied term "technical debt"), and
it's better than the conventional baseline of no layers and no
scenarios. Just clean it up as soon as possible.
Definitely avoid layer 4 at any time.
== minor lessons
Avoid unit tests for trivial things, write scenarios in context as much as
possible. But within those margins unit tests are fine. Just introduce them
before any scenarios (commit 3297).
Reorganizing layers can be easy. Just merge layers for starters! Punt on
resplitting them in some new way until you've gotten them to work. This is the
wisdom of Refactoring: small steps.
What made it hard was not wanting to merge *everything* between layer 30
and 55. The eventual insight was realizing I just need to move those two
full-strength transforms and nothing else.
2016-09-10 01:32:52 +00:00
if ( ! type - > atom ) {
2016-11-06 19:59:50 +00:00
check_invalid_types ( type - > left , location_for_error_messages , name_for_error_messages ) ;
check_invalid_types ( type - > right , location_for_error_messages , name_for_error_messages ) ;
3309
Rip out everything to fix one failing unit test (commit 3290; type
abbreviations).
This commit does several things at once that I couldn't come up with a
clean way to unpack:
A. It moves to a new representation for type trees without changing
the actual definition of the `type_tree` struct.
B. It adds unit tests for our type metadata precomputation, so that
errors there show up early and in a simpler setting rather than dying
when we try to load Mu code.
C. It fixes a bug, guarding against infinite loops when precomputing
metadata for recursive shape-shifting containers. To do this it uses a
dumb way of comparing type_trees, comparing their string
representations instead. That is likely incredibly inefficient.
Perhaps due to C, this commit has made Mu incredibly slow. Running all
tests for the core and the edit/ app now takes 6.5 minutes rather than
3.5 minutes.
== more notes and details
I've been struggling for the past week now to back out of a bad design
decision, a premature optimization from the early days: storing atoms
directly in the 'value' slot of a cons cell rather than creating a
special 'atom' cons cell and storing it on the 'left' slot. In other
words, if a cons cell looks like this:
o
/ | \
left val right
..then the type_tree (a b c) used to look like this (before this
commit):
o
| \
a o
| \
b o
| \
c null
..rather than like this 'classic' approach to s-expressions which never
mixes val and right (which is what we now have):
o
/ \
o o
| / \
a o o
| / \
b o null
|
c
The old approach made several operations more complicated, most recently
the act of replacing a (possibly atom/leaf) sub-tree with another. That
was the final straw that got me to realize the contortions I was going
through to save a few type_tree nodes (cons cells).
Switching to the new approach was hard partly because I've been using
the old approach for so long and type_tree manipulations had pervaded
everything. Another issue I ran into was the realization that my layers
were not cleanly separated. Key parts of early layers (precomputing type
metadata) existed purely for far later ones (shape-shifting types).
Layers I got repeatedly stuck at:
1. the transform for precomputing type sizes (layer 30)
2. type-checks on merge instructions (layer 31)
3. the transform for precomputing address offsets in types (layer 36)
4. replace operations in supporting shape-shifting recipes (layer 55)
After much thrashing I finally noticed that it wasn't the entirety of
these layers that was giving me trouble, but just the type metadata
precomputation, which had bugs that weren't manifesting until 30 layers
later. Or, worse, when loading .mu files before any tests had had a
chance to run. A common failure mode was running into types at run time
that I hadn't precomputed metadata for at transform time.
Digging into these bugs got me to realize that what I had before wasn't
really very good, but a half-assed heuristic approach that did a whole
lot of extra work precomputing metadata for utterly meaningless types
like `((address number) 3)` which just happened to be part of a larger
type like `(array (address number) 3)`.
So, I redid it all. I switched the representation of types (because the
old representation made unit tests difficult to retrofit) and added unit
tests to the metadata precomputation. I also made layer 30 only do the
minimal metadata precomputation it needs for the concepts introduced
until then. In the process, I also made the precomputation more correct
than before, and added hooks in the right place so that I could augment
the logic when I introduced shape-shifting containers.
== lessons learned
There's several levels of hygiene when it comes to layers:
1. Every layer introduces precisely what it needs and in the simplest
way possible. If I was building an app until just that layer, nothing
would seem over-engineered.
2. Some layers are fore-shadowing features in future layers. Sometimes
this is ok. For example, layer 10 foreshadows containers and arrays and
so on without actually supporting them. That is a net win because it
lets me lay out the core of Mu's data structures out in one place. But
if the fore-shadowing gets too complex things get nasty. Not least
because it can be hard to write unit tests for features before you
provide the plumbing to visualize and manipulate them.
3. A layer is introducing features that are tested only in later layers.
4. A layer is introducing features with tests that are invalidated in
later layers. (This I knew from early on to be an obviously horrendous
idea.)
Summary: avoid Level 2 (foreshadowing layers) as much as possible.
Tolerate it indefinitely for small things where the code stays simple
over time, but become strict again when things start to get more
complex.
Level 3 is mostly a net lose, but sometimes it can be expedient (a real
case of the usually grossly over-applied term "technical debt"), and
it's better than the conventional baseline of no layers and no
scenarios. Just clean it up as soon as possible.
Definitely avoid layer 4 at any time.
== minor lessons
Avoid unit tests for trivial things, write scenarios in context as much as
possible. But within those margins unit tests are fine. Just introduce them
before any scenarios (commit 3297).
Reorganizing layers can be easy. Just merge layers for starters! Punt on
resplitting them in some new way until you've gotten them to work. This is the
wisdom of Refactoring: small steps.
What made it hard was not wanting to merge *everything* between layer 30
and 55. The eventual insight was realizing I just need to move those two
full-strength transforms and nothing else.
2016-09-10 01:32:52 +00:00
return ;
}
2016-07-24 08:12:20 +00:00
if ( type - > value ! = 0 ) { // value 0 = compound types (layer parse_tree) or type ingredients (layer shape_shifting_container)
if ( ! contains_key ( Type , type - > value ) )
2016-11-06 19:59:50 +00:00
raise < < location_for_error_messages < < " unknown type in " < < name_for_error_messages < < ' \n ' < < end ( ) ;
2015-11-07 01:03:02 +00:00
}
}
2017-06-11 06:56:37 +00:00
string to_original_string ( const type_ordinal t ) {
ostringstream out ;
if ( ! contains_key ( Type , t ) ) return out . str ( ) ;
const type_info & info = get ( Type , t ) ;
if ( info . kind = = PRIMITIVE ) return out . str ( ) ;
out < < ( info . kind = = CONTAINER ? " container " : " exclusive-container " ) < < " " < < info . name < < " [ \n " ;
for ( int i = 0 ; i < SIZE ( info . elements ) ; + + i ) {
out < < " " < < info . elements . at ( i ) . original_string < < " \n " ;
}
out < < " ] \n " ;
return out . str ( ) ;
}