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 07:43:13 +00:00
get ( Type , point ) . elements . push_back ( reagent ( " x:num " ) ) ;
get ( Type , point ) . elements . push_back ( reagent ( " y:num " ) ) ;
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
2016-09-07 05:11:03 +00:00
//: container. Don't do this in general. I'm tagging exceptions with /unsafe to
//: skip later checks.
2015-02-20 07:49:13 +00:00
: ( scenario copy_multiple_locations )
2016-03-08 09:30:14 +00:00
def main [
2016-09-17 07:43:13 +00:00
1 : num < - copy 34
2 : num < - copy 35
2016-01-12 06:57:35 +00:00
3 : point < - copy 1 : point / unsafe
2015-02-20 07:49:13 +00:00
]
2015-03-24 06:59:59 +00:00
+ mem : storing 34 in location 3
+ mem : storing 35 in location 4
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
2015-08-07 20:01:49 +00:00
: ( scenario copy_checks_size )
2015-10-07 05:15:45 +00:00
% Hide_errors = true ;
2016-03-08 09:30:14 +00:00
def main [
2016-09-17 07:43:13 +00:00
2 : point < - copy 1 : num
2015-08-07 20:01:49 +00:00
]
2016-09-17 07:43:13 +00:00
+ error : main : can ' t copy ' 1 : num ' to ' 2 : point ' ; types don ' t match
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 07:43:13 +00:00
get ( Type , point_number ) . elements . push_back ( reagent ( " z:num " ) ) ;
2015-03-27 04:06:14 +00:00
2015-04-24 17:19:03 +00:00
: ( scenario copy_handles_nested_container_elements )
2016-03-08 09:30:14 +00:00
def main [
2016-09-17 07:43:13 +00:00
12 : num < - copy 34
13 : num < - copy 35
14 : num < - copy 36
2016-01-12 06:57:35 +00:00
15 : point - number < - copy 12 : point - number / unsafe
2015-03-27 04:06:14 +00:00
]
+ mem : storing 36 in location 17
2016-04-24 07:36:30 +00:00
//: products of recipes can include containers
2016-04-27 22:37:09 +00:00
: ( scenario return_container )
2016-04-24 05:11:48 +00:00
def main [
3 : point < - f 2
]
def f [
2016-09-17 07:43:13 +00:00
12 : num < - next - ingredient
13 : num < - copy 35
2016-04-24 05:11:48 +00:00
return 12 : point / raw
]
+ run : result 0 is [ 2 , 35 ]
+ mem : storing 2 in location 3
+ mem : storing 35 in location 4
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
: ( scenario compare_multiple_locations )
2016-03-08 09:30:14 +00:00
def main [
2016-09-17 07:43:13 +00:00
1 : num < - copy 34 # first
2 : num < - copy 35
3 : num < - copy 36
4 : num < - copy 34 # second
5 : num < - copy 35
6 : num < - copy 36
2016-09-17 07:46:03 +00:00
7 : bool < - equal 1 : point - number / raw , 4 : point - number / unsafe
2015-05-07 22:06:53 +00:00
]
+ mem : storing 1 in location 7
2015-08-09 19:26:31 +00:00
: ( scenario compare_multiple_locations_2 )
2016-03-08 09:30:14 +00:00
def main [
2016-09-17 07:43:13 +00:00
1 : num < - copy 34 # first
2 : num < - copy 35
3 : num < - copy 36
4 : num < - copy 34 # second
5 : num < - copy 35
6 : num < - copy 37 # different
2016-09-17 07:46:03 +00:00
7 : bool < - equal 1 : point - number / raw , 4 : point - number / unsafe
2015-05-07 22:06:53 +00:00
]
+ mem : storing 0 in location 7
2016-05-03 06:11:33 +00:00
//: Can't put this in type_info because later layers will add support for more
2016-05-17 17:44:12 +00:00
//: complex type trees where metadata depends on *combinations* of types.
2016-05-17 19:35:06 +00:00
: ( before " struct reagent " )
2016-05-03 06:11:33 +00:00
struct container_metadata {
int size ;
2016-06-11 16:38:14 +00:00
vector < int > offset ; // not used by exclusive containers
2016-05-03 06:11:33 +00:00
// End container_metadata Fields
container_metadata ( ) : size ( 0 ) {
// End container_metadata Constructor
}
} ;
: ( before " End reagent Fields " )
container_metadata metadata ; // can't be a pointer into Container_metadata because we keep changing the base storage when we save/restore snapshots
: ( before " End reagent Copy Operator " )
2016-05-17 19:13:52 +00:00
metadata = other . metadata ;
2016-05-03 06:11:33 +00:00
: ( before " End reagent Copy Constructor " )
2016-05-17 19:13:52 +00:00
metadata = other . metadata ;
2016-05-03 06:11:33 +00:00
: ( before " End Globals " )
// todo: switch to map after figuring out how to consistently compare type trees
vector < pair < type_tree * , container_metadata > > Container_metadata , Container_metadata_snapshot ;
: ( before " End save_snapshots " )
Container_metadata_snapshot = Container_metadata ;
: ( before " End restore_snapshots " )
2016-05-07 16:45:13 +00:00
restore_container_metadata ( ) ;
: ( before " End One-time Setup " )
atexit ( clear_container_metadata ) ;
: ( code )
// invariant: Container_metadata always contains a superset of Container_metadata_snapshot
void restore_container_metadata ( ) {
for ( int i = 0 ; i < SIZE ( Container_metadata ) ; + + i ) {
assert ( Container_metadata . at ( i ) . first ) ;
if ( i < SIZE ( Container_metadata_snapshot ) ) {
assert ( Container_metadata . at ( i ) . first = = Container_metadata_snapshot . at ( i ) . first ) ;
continue ;
}
delete Container_metadata . at ( i ) . first ;
Container_metadata . at ( i ) . first = NULL ;
}
Container_metadata . resize ( SIZE ( Container_metadata_snapshot ) ) ;
}
void clear_container_metadata ( ) {
Container_metadata_snapshot . clear ( ) ;
for ( int i = 0 ; i < SIZE ( Container_metadata ) ; + + i ) {
delete Container_metadata . at ( i ) . first ;
Container_metadata . at ( i ) . first = NULL ;
}
Container_metadata . clear ( ) ;
}
2016-05-03 06:11:33 +00:00
//: do no work in size_of, simply lookup Container_metadata
2016-05-06 15:33:15 +00:00
: ( before " End size_of(reagent r) Cases " )
2016-05-03 06:11:33 +00:00
if ( r . metadata . size ) return r . metadata . size ;
2015-10-26 04:42:18 +00:00
: ( before " End size_of(type) Cases " )
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 ) {
if ( type - > value = = - 1 ) return 1 ; // error value, but we'll raise it elsewhere
if ( type - > value = = 0 ) return 1 ;
2015-10-26 04:42:18 +00:00
}
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
const type_tree * root = root_type ( type ) ;
if ( ! contains_key ( Type , root - > value ) ) {
raise < < " no such type " < < root - > value < < ' \n ' < < end ( ) ;
2016-02-19 10:21:37 +00:00
return 0 ;
}
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
type_info t = get ( Type , root - > value ) ;
2015-10-27 03:06:51 +00:00
if ( t . kind = = CONTAINER ) {
2016-05-03 06:11:33 +00:00
// Compute size_of Container
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 ( ! contains_key ( Container_metadata , type ) ) return 1 ; // error raised elsewhere
2016-05-03 06:11:33 +00:00
return get ( Container_metadata , type ) . size ;
}
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
: ( code )
const type_tree * root_type ( const type_tree * t ) {
const type_tree * result = t - > atom ? t : t - > left ;
assert ( result - > atom ) ;
return result ;
}
2016-05-03 06:11:33 +00:00
//: precompute Container_metadata before we need size_of
//: also store a copy in each reagent in each instruction in each recipe
2016-09-12 00:14:48 +00:00
: ( after " End Type Modifying Transforms " )
2016-05-12 23:38:59 +00:00
Transform . push_back ( compute_container_sizes ) ;
2016-05-03 06:11:33 +00:00
: ( code )
2016-05-12 23:38:59 +00:00
void compute_container_sizes ( recipe_ordinal r ) {
2016-05-03 06:11:33 +00:00
recipe & caller = get ( Recipe , r ) ;
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
trace ( 9992 , " transform " ) < < " --- compute container sizes for " < < caller . name < < end ( ) ;
2016-05-03 06:11:33 +00:00
for ( int i = 0 ; i < SIZE ( caller . steps ) ; + + i ) {
instruction & inst = caller . steps . at ( 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
trace ( 9993 , " transform " ) < < " - compute container sizes for " < < to_string ( inst ) < < end ( ) ;
2016-05-03 06:11:33 +00:00
for ( int i = 0 ; i < SIZE ( inst . ingredients ) ; + + i )
2016-05-12 23:38:59 +00:00
compute_container_sizes ( inst . ingredients . at ( i ) ) ;
2016-05-03 06:11:33 +00:00
for ( int i = 0 ; i < SIZE ( inst . products ) ; + + i )
2016-05-12 23:38:59 +00:00
compute_container_sizes ( inst . products . at ( i ) ) ;
2016-05-03 06:11:33 +00:00
}
}
2016-05-12 23:38:59 +00:00
void compute_container_sizes ( reagent & r ) {
2016-05-03 06:11:33 +00:00
if ( is_literal ( r ) | | is_dummy ( r ) ) return ;
reagent rcopy = r ;
2016-05-12 23:38:59 +00:00
// Compute Container Size(reagent rcopy)
2016-09-10 16:59:32 +00:00
set < type_tree > pending_metadata ; // might actually be faster to just convert to string rather than compare type_tree directly; so far the difference is negligible
2016-05-12 23:38:59 +00:00
compute_container_sizes ( rcopy . type , pending_metadata ) ;
2016-05-03 06:11:33 +00:00
if ( contains_key ( Container_metadata , rcopy . type ) )
r . metadata = get ( Container_metadata , rcopy . type ) ;
}
2016-09-10 16:59:32 +00:00
void compute_container_sizes ( const type_tree * type , set < type_tree > & pending_metadata ) {
2016-05-03 06:11:33 +00:00
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
trace ( 9993 , " transform " ) < < " compute container sizes for " < < to_string ( type ) < < end ( ) ;
2016-05-03 06:11:33 +00:00
if ( contains_key ( Container_metadata , type ) ) return ;
2016-09-10 16:59:32 +00:00
if ( contains_key ( pending_metadata , * type ) ) return ;
pending_metadata . insert ( * type ) ;
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 ) {
assert ( type - > left - > atom ) ;
if ( type - > left - > name = = " address " ) {
compute_container_sizes ( type - > right , pending_metadata ) ;
}
else if ( type - > left - > name = = " array " ) {
const type_tree * element_type = type - > right ;
2016-09-17 07:43:13 +00:00
// hack: support both array:num:3 and array:address:num
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 ( ! element_type - > atom & & element_type - > right & & element_type - > right - > atom & & is_integer ( element_type - > right - > name ) )
element_type = element_type - > left ;
compute_container_sizes ( element_type , pending_metadata ) ;
}
// End compute_container_sizes Non-atom Cases
return ;
}
assert ( type - > atom ) ;
2016-05-03 06:11:33 +00:00
if ( ! contains_key ( Type , type - > value ) ) return ; // error raised elsewhere
type_info & info = get ( Type , type - > value ) ;
if ( info . kind = = CONTAINER ) {
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
compute_container_sizes ( info , type , pending_metadata ) ;
}
// End compute_container_sizes Atom Cases
}
2016-09-10 16:59:32 +00:00
void compute_container_sizes ( const type_info & container_info , const type_tree * full_type , set < type_tree > & pending_metadata ) {
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
assert ( container_info . kind = = CONTAINER ) ;
// size of a container is the sum of the sizes of its element
// (So it can only contain arrays if they're static and include their
// length in the type.)
container_metadata metadata ;
for ( int i = 0 ; i < SIZE ( container_info . elements ) ; + + i ) {
reagent /*copy*/ element = container_info . elements . at ( i ) ;
// Compute Container Size(element, full_type)
compute_container_sizes ( element . type , pending_metadata ) ;
metadata . offset . push_back ( metadata . size ) ; // save previous size as offset
metadata . size + = size_of ( element . type ) ;
2016-05-03 06:11:33 +00:00
}
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
Container_metadata . push_back ( pair < type_tree * , container_metadata > ( new type_tree ( * full_type ) , metadata ) ) ;
2016-05-03 06:11:33 +00:00
}
2016-05-12 23:38:59 +00:00
container_metadata & get ( vector < pair < type_tree * , container_metadata > > & all , const type_tree * key ) {
2016-05-03 06:11:33 +00:00
for ( int i = 0 ; i < SIZE ( all ) ; + + i ) {
if ( matches ( all . at ( i ) . first , key ) )
return all . at ( i ) . second ;
2015-03-27 04:06:14 +00:00
}
2016-05-03 06:11:33 +00:00
tb_shutdown ( ) ;
2016-09-04 22:30:34 +00:00
raise < < " unknown size for type ' " < < to_string ( key ) < < " ' \n " < < end ( ) ;
2016-05-03 06:11:33 +00:00
assert ( false ) ;
}
bool contains_key ( const vector < pair < type_tree * , container_metadata > > & all , const type_tree * key ) {
for ( int i = 0 ; i < SIZE ( all ) ; + + i ) {
if ( matches ( all . at ( i ) . first , key ) )
return true ;
}
return false ;
}
bool matches ( const type_tree * a , const type_tree * b ) {
if ( a = = b ) return true ;
if ( ! a | | ! b ) return false ;
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 ( a - > atom ! = b - > atom ) return false ;
if ( a - > atom ) return a - > value = = b - > value ;
2016-05-03 06:11:33 +00:00
return matches ( a - > left , b - > left ) & & matches ( a - > right , b - > right ) ;
2015-03-27 04:06:14 +00:00
}
2015-08-11 06:15:00 +00:00
: ( scenario stash_container )
2016-03-08 09:30:14 +00:00
def main [
2016-09-17 07:43:13 +00:00
1 : num < - copy 34 # first
2 : num < - copy 35
3 : num < - copy 36
2015-08-24 20:40:21 +00:00
stash [ foo : ] , 1 : point - number / raw
2015-08-11 06:15:00 +00:00
]
+ app : foo : 34 35 36
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
//: for the following unit tests we'll do the work of the transform by hand
: ( before " End Unit Tests " )
void test_container_sizes ( ) {
// a container we don't have the size for
reagent r ( " x:point " ) ;
CHECK ( ! contains_key ( Container_metadata , r . type ) ) ;
// scan
compute_container_sizes ( r ) ;
// the reagent we scanned knows its size
CHECK_EQ ( r . metadata . size , 2 ) ;
// the global table also knows its size
CHECK ( contains_key ( Container_metadata , r . type ) ) ;
CHECK_EQ ( get ( Container_metadata , r . type ) . size , 2 ) ;
}
void test_container_sizes_nested ( ) {
// a container we don't have the size for
reagent r ( " x:point-number " ) ;
CHECK ( ! contains_key ( Container_metadata , r . type ) ) ;
// scan
compute_container_sizes ( r ) ;
// the reagent we scanned knows its size
CHECK_EQ ( r . metadata . size , 3 ) ;
// the global table also knows its size
CHECK ( contains_key ( Container_metadata , r . type ) ) ;
CHECK_EQ ( get ( Container_metadata , r . type ) . size , 3 ) ;
}
void test_container_sizes_recursive ( ) {
// define a container containing an address to itself
run ( " container foo [ \n "
2016-09-17 07:43:13 +00:00
" x:num \n "
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
" y:address:foo \n "
" ] \n " ) ;
reagent r ( " x:foo " ) ;
compute_container_sizes ( r ) ;
CHECK_EQ ( r . metadata . size , 2 ) ;
}
void test_container_sizes_from_address ( ) {
// a container we don't have the size for
reagent container ( " x:point " ) ;
CHECK ( ! contains_key ( Container_metadata , container . type ) ) ;
// scanning an address to the container precomputes the size of the container
reagent r ( " x:address:point " ) ;
compute_container_sizes ( r ) ;
CHECK ( contains_key ( Container_metadata , container . type ) ) ;
CHECK_EQ ( get ( Container_metadata , container . type ) . size , 2 ) ;
}
void test_container_sizes_from_array ( ) {
// a container we don't have the size for
reagent container ( " x:point " ) ;
CHECK ( ! contains_key ( Container_metadata , container . type ) ) ;
// scanning an array of the container precomputes the size of the container
reagent r ( " x:array:point " ) ;
compute_container_sizes ( r ) ;
CHECK ( contains_key ( Container_metadata , container . type ) ) ;
CHECK_EQ ( get ( Container_metadata , container . type ) . size , 2 ) ;
}
void test_container_sizes_from_address_to_array ( ) {
// a container we don't have the size for
reagent container ( " x:point " ) ;
CHECK ( ! contains_key ( Container_metadata , container . type ) ) ;
// scanning an address to an array of the container precomputes the size of the container
reagent r ( " x:address:array:point " ) ;
compute_container_sizes ( r ) ;
CHECK ( contains_key ( Container_metadata , container . type ) ) ;
CHECK_EQ ( get ( Container_metadata , container . type ) . size , 2 ) ;
}
void test_container_sizes_from_static_array ( ) {
// a container we don't have the size for
reagent container ( " x:point " ) ;
int old_size = SIZE ( Container_metadata ) ;
// scanning an address to an array of the container precomputes the size of the container
reagent r ( " x:array:point:10 " ) ;
compute_container_sizes ( r ) ;
CHECK ( contains_key ( Container_metadata , container . type ) ) ;
CHECK_EQ ( get ( Container_metadata , container . type ) . size , 2 ) ;
// no non-container types precomputed
CHECK_EQ ( SIZE ( Container_metadata ) - old_size , 1 ) ;
}
void test_container_sizes_from_address_to_static_array ( ) {
// a container we don't have the size for
reagent container ( " x:point " ) ;
int old_size = SIZE ( Container_metadata ) ;
// scanning an address to an array of the container precomputes the size of the container
reagent r ( " x:address:array:point:10 " ) ;
compute_container_sizes ( r ) ;
CHECK ( contains_key ( Container_metadata , container . type ) ) ;
CHECK_EQ ( get ( Container_metadata , container . type ) . size , 2 ) ;
// no non-container types precomputed
CHECK_EQ ( SIZE ( Container_metadata ) - old_size , 1 ) ;
}
void test_container_sizes_from_repeated_address_and_array_types ( ) {
// a container we don't have the size for
reagent container ( " x:point " ) ;
int old_size = SIZE ( Container_metadata ) ;
// scanning repeated address and array types modifying the container precomputes the size of the container
reagent r ( " x:address:array:address:array:point:10 " ) ;
compute_container_sizes ( r ) ;
CHECK ( contains_key ( Container_metadata , container . type ) ) ;
CHECK_EQ ( get ( Container_metadata , container . type ) . size , 2 ) ;
// no non-container types precomputed
CHECK_EQ ( SIZE ( Container_metadata ) - old_size , 1 ) ;
}
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.
2015-04-24 17:19:03 +00:00
: ( scenario get )
2016-03-08 09:30:14 +00:00
def main [
2016-09-17 07:43:13 +00:00
12 : num < - copy 34
13 : num < - copy 35
15 : num < - get 12 : point / raw , 1 : offset # unsafe
2015-03-27 04:06:14 +00:00
]
+ mem : storing 35 in location 15
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 ) {
2016-07-22 02:22:03 +00:00
raise < < maybe ( get ( Recipe , r ) . name ) < < " 'get' expects exactly 2 ingredients in ' " < < inst . original_string < < " ' \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 ;
2015-11-02 02:24:17 +00:00
if ( is_integer ( offset . name ) ) // later layers permit non-integer offsets
2015-10-02 07:28:08 +00:00
offset_value = to_integer ( offset . name ) ;
2015-11-02 02:24:17 +00:00
else
2015-10-02 07:28:08 +00:00
offset_value = offset . value ;
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-09-10 23:47:17 +00:00
const reagent /*copy*/ element = element_type ( base . type , offset_value ) ; // not just base_type because later layers will introduce compound types
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 ) {
2016-03-21 09:25:52 +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
2016-05-03 06:11:33 +00:00
assert ( base . metadata . size ) ;
int src = base_address + base . metadata . offset . at ( offset ) ;
2015-10-29 19:09:23 +00:00
trace ( 9998 , " run " ) < < " address to copy is " < < src < < end ( ) ;
2016-09-10 23:47:17 +00:00
reagent /*copy*/ element = element_type ( base . type , offset ) ; // not just base_type because later layers will introduce compound types
2016-04-20 16:58:07 +00:00
element . set_value ( src ) ;
trace ( 9998 , " run " ) < < " its type is " < < names_to_string ( element . type ) < < end ( ) ;
// 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 ) ;
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
const type_tree * root = root_type ( type ) ;
assert ( contains_key ( Type , root - > value ) ) ;
assert ( ! get ( Type , root - > value ) . name . empty ( ) ) ;
const type_info & info = get ( Type , root - > 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 ;
}
2015-04-24 17:19:03 +00:00
: ( scenario get_handles_nested_container_elements )
2016-03-08 09:30:14 +00:00
def main [
2016-09-17 07:43:13 +00:00
12 : num < - copy 34
13 : num < - copy 35
14 : num < - copy 36
15 : num < - get 12 : point - number / raw , 1 : offset # unsafe
2015-02-22 08:15:14 +00:00
]
2015-03-24 06:59:59 +00:00
+ mem : storing 36 in location 15
2015-02-22 08:15:14 +00:00
2015-07-17 21:30:17 +00:00
: ( scenario get_out_of_bounds )
2015-10-07 05:15:45 +00:00
% Hide_errors = true ;
2016-03-08 09:30:14 +00:00
def main [
2016-09-17 07:43:13 +00:00
12 : num < - copy 34
13 : num < - copy 35
14 : num < - copy 36
2015-07-17 21:30:17 +00:00
get 12 : point - number / raw , 2 : offset # point - number occupies 3 locations but has only 2 fields ; out of bounds
]
2016-05-21 05:09:06 +00:00
+ error : main : invalid offset ' 2 ' for ' point - number '
2015-07-17 21:30:17 +00:00
2015-08-09 19:26:31 +00:00
: ( scenario get_out_of_bounds_2 )
2015-10-07 05:15:45 +00:00
% Hide_errors = true ;
2016-03-08 09:30:14 +00:00
def main [
2016-09-17 07:43:13 +00:00
12 : num < - copy 34
13 : num < - copy 35
14 : num < - copy 36
2015-07-17 21:30:17 +00:00
get 12 : point - number / raw , - 1 : offset
]
2016-05-21 05:09:06 +00:00
+ error : main : invalid offset ' - 1 ' for ' point - number '
2015-07-17 21:30:17 +00:00
2015-10-02 07:28:08 +00:00
: ( scenario get_product_type_mismatch )
2015-10-07 05:15:45 +00:00
% Hide_errors = true ;
2016-03-08 09:30:14 +00:00
def main [
2016-09-17 07:43:13 +00:00
12 : num < - copy 34
13 : num < - copy 35
14 : num < - copy 36
15 : address : num < - get 12 : point - number / raw , 1 : offset
2015-10-02 07:28:08 +00:00
]
2016-05-21 05:09:06 +00:00
+ error : main : ' get 12 : point - number / raw , 1 : offset ' should write to number but ' 15 ' has type ( address number )
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
: ( scenario get_without_product )
2016-03-08 09:30:14 +00:00
def main [
2016-09-17 07:43:13 +00:00
12 : num < - copy 34
13 : num < - copy 35
2015-11-16 02:36:34 +00:00
get 12 : point / raw , 1 : offset # unsafe
]
# just don't die
2016-04-11 02:26:37 +00:00
//:: To write to elements of containers, use 'put'.
: ( scenario put )
def main [
2016-09-17 07:43:13 +00:00
12 : num < - copy 34
13 : num < - copy 35
2016-04-11 02:26:37 +00:00
$ clear - trace
12 : point < - put 12 : point , 1 : offset , 36
]
+ mem : storing 36 in location 13
- mem : storing 34 in location 12
: ( 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 ) {
2016-07-22 02:22:03 +00:00
raise < < maybe ( get ( Recipe , r ) . name ) < < " 'put' expects exactly 3 ingredients in ' " < < inst . original_string < < " ' \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 ;
if ( is_integer ( offset . name ) ) { // later layers permit non-integer offsets
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-09-10 23:47:17 +00:00
const reagent & element = element_type ( base . type , offset_value ) ; // not just base_type because later layers will introduce compound types
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 ) {
raise < < maybe ( current_recipe_name ( ) ) < < " tried to access location 0 in ' " < < to_original_string ( current_instruction ( ) ) < < " ' \n " < < end ( ) ;
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
2016-05-04 00:38:33 +00:00
int address = base_address + base . metadata . offset . at ( offset ) ;
2016-04-11 02:26:37 +00:00
trace ( 9998 , " run " ) < < " address to copy to is " < < address < < end ( ) ;
// 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
2016-04-11 02:26:37 +00:00
for ( int i = 0 ; i < SIZE ( ingredients . at ( 2 ) ) ; + + i ) {
trace ( 9999 , " mem " ) < < " storing " < < no_scientific ( ingredients . at ( 2 ) . at ( i ) ) < < " in location " < < address + i < < end ( ) ;
put ( Memory , address + i , ingredients . at ( 2 ) . at ( i ) ) ;
}
goto finish_instruction ;
}
2016-05-21 06:45:03 +00:00
: ( scenario put_product_error )
% Hide_errors = true ;
def main [
local - scope
load - ingredients
1 : point < - merge 34 , 35
3 : point < - put 1 : point , x : offset , 36
]
+ error : main : product of ' put ' must be first ingredient ' 1 : point ' , but got ' 3 : point '
2015-05-14 17:30:01 +00:00
//:: Allow containers to be defined in mu code.
: ( scenarios load )
: ( scenario container )
container foo [
2016-09-17 07:43:13 +00:00
x : num
y : num
2015-05-14 17:30:01 +00:00
]
2015-10-29 18:56:10 +00:00
+ parse : - - - defining container foo
2016-03-21 09:25:52 +00:00
+ parse : element : { x : " number " }
+ parse : element : { y : " number " }
2015-05-14 17:30:01 +00:00
2015-05-18 23:09:09 +00:00
: ( scenario container_use_before_definition )
container foo [
2016-09-17 07:43:13 +00:00
x : num
2015-05-18 23:09:09 +00:00
y : bar
]
container bar [
2016-09-17 07:43:13 +00:00
x : num
y : num
2015-05-18 23:09:09 +00:00
]
2015-10-29 18:56:10 +00:00
+ parse : - - - defining container foo
2015-05-18 23:09:09 +00:00
+ parse : type number : 1000
2016-03-21 09:25:52 +00:00
+ parse : element : { x : " number " }
2016-02-17 18:09:48 +00:00
# todo: brittle
# type bar is unknown at this point, but we assign it a number
2016-03-21 09:25:52 +00:00
+ parse : element : { y : " bar " }
2016-02-19 23:19:36 +00:00
# later type bar geon
2015-10-29 18:56:10 +00:00
+ parse : - - - defining container bar
2015-05-18 23:09:09 +00:00
+ parse : type number : 1001
2016-03-21 09:25:52 +00:00
+ parse : element : { x : " number " }
+ parse : element : { y : " number " }
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
: ( scenarios run )
: ( scenario container_extend )
container foo [
2016-09-17 07:43:13 +00:00
x : num
2016-04-29 00:23:50 +00:00
]
# add to previous definition
container foo [
2016-09-17 07:43:13 +00:00
y : num
2016-04-29 00:23:50 +00:00
]
def main [
2016-09-17 07:43:13 +00:00
1 : num < - copy 34
2 : num < - copy 35
3 : num < - get 1 : foo , 0 : offset
4 : num < - get 1 : foo , 1 : offset
2016-04-29 00:23:50 +00:00
]
+ mem : storing 34 in location 3
+ mem : storing 35 in location 4
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 ) ;
2015-10-30 20:00:16 +00:00
// End container Name Refinements
2015-10-29 18:56:10 +00:00
trace ( 9991 , " 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
}
2015-11-06 19:06:58 +00:00
trace ( 9999 , " 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 ) ;
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 ) ;
2016-02-19 23:19:36 +00:00
trace ( 9993 , " 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 ) ;
}
else if ( is_integer ( type - > name ) ) { // sometimes types will contain non-type tags, like numbers for the size of an array
type - > value = 0 ;
}
// 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
}
2016-06-18 00:22:15 +00:00
: ( scenario multi_word_line_in_container_declaration )
% Hide_errors = true ;
container foo [
2016-09-17 07:43:13 +00:00
x : num y : num
2016-06-18 00:22:15 +00:00
]
+ error : container ' foo ' contains multiple elements on a single line . Containers and exclusive containers must only contain elements , one to a line , no code .
2016-09-12 07:47:44 +00:00
//: support type abbreviations in container definitions
: ( scenario type_abbreviations_in_containers )
type foo = number
container bar [
x : foo
]
def main [
2016-09-17 07:43:13 +00:00
1 : num < - copy 34
2016-09-12 07:47:44 +00:00
2 : foo < - get 1 : bar / unsafe , 0 : offset
]
+ mem : storing 34 in location 2
: ( after " Transform.push_back(expand_type_abbreviations) " )
Transform . push_back ( expand_type_abbreviations_in_containers ) ;
: ( 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
void expand_type_abbreviations_in_containers ( unused const recipe_ordinal r ) {
for ( map < type_ordinal , type_info > : : iterator p = Type . begin ( ) ; p ! = Type . end ( ) ; + + p ) {
for ( int i = 0 ; i < SIZE ( p - > second . elements ) ; + + i )
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
2015-05-14 17:30:01 +00:00
: ( before " End Setup " ) //: 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 ( ) ;
CHECK_TRACE_DOESNT_CONTAIN_ERROR ( ) ;
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 " ) ;
CHECK_TRACE_CONTAINS_ERROR ( ) ;
}
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
2015-10-07 05:15:45 +00:00
: ( scenario run_complains_on_unknown_types )
% Hide_errors = true ;
2016-03-08 09:30:14 +00:00
def main [
2015-05-19 01:40:58 +00:00
# integer is not a type
2015-07-28 21:33:22 +00:00
1 : integer < - copy 0
2015-05-19 01:40:58 +00:00
]
2015-11-17 19:28:19 +00:00
+ error : main : unknown type integer in ' 1 : integer < - copy 0 '
2015-05-19 01:40:58 +00:00
: ( scenario run_allows_type_definition_after_use )
2016-03-08 09:30:14 +00:00
def main [
2015-11-22 19:51:36 +00:00
1 : bar < - copy 0 / unsafe
2015-05-19 01:40:58 +00:00
]
container bar [
2016-09-17 07:43:13 +00:00
x : num
2015-05-19 01:40:58 +00:00
]
2015-10-07 05:15:45 +00:00
$ 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 ) ;
2016-02-15 07:18:33 +00:00
trace ( 9991 , " transform " ) < < " --- check for invalid types in recipe " < < caller . name < < end ( ) ;
2016-03-14 03:26:47 +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-03-14 03:26:47 +00:00
for ( int i = 0 ; i < SIZE ( inst . ingredients ) ; + + i )
2016-07-22 02:22:03 +00:00
check_or_set_invalid_types ( inst . ingredients . at ( i ) . type , maybe ( caller . name ) , " ' " + inst . original_string + " ' " ) ;
2016-03-14 03:26:47 +00:00
for ( int i = 0 ; i < SIZE ( inst . products ) ; + + i )
2016-07-22 02:22:03 +00:00
check_or_set_invalid_types ( inst . products . at ( i ) . type , maybe ( caller . name ) , " ' " + inst . original_string + " ' " ) ;
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-02-22 04:30:02 +00:00
void check_or_set_invalid_types ( type_tree * type , const string & block , const string & name ) {
2015-10-26 04:42:18 +00:00
if ( ! type ) return ; // will throw a more precise error elsewhere
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 ) {
check_or_set_invalid_types ( type - > left , block , name ) ;
check_or_set_invalid_types ( type - > right , block , name ) ;
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-02-26 21:04:55 +00:00
raise < < block < < " unknown type " < < type - > name < < " in " < < name < < ' \n ' < < end ( ) ;
2015-11-07 01:03:02 +00:00
}
2015-05-19 01:40:58 +00:00
}
: ( scenario container_unknown_field )
2015-10-07 05:15:45 +00:00
% Hide_errors = true ;
2015-05-19 01:40:58 +00:00
container foo [
2016-09-17 07:43:13 +00:00
x : num
2015-05-19 01:40:58 +00:00
y : bar
]
2015-10-26 04:42:18 +00:00
+ error : foo : unknown type in y
2015-05-19 01:40:58 +00:00
2015-05-28 18:28:15 +00:00
: ( scenario read_container_with_bracket_in_comment )
container foo [
2016-09-17 07:43:13 +00:00
x : num
2015-05-28 18:28:15 +00:00
# ']' in comment
2016-09-17 07:43:13 +00:00
y : num
2015-05-28 18:28:15 +00:00
]
2015-10-29 18:56:10 +00:00
+ parse : - - - defining container foo
2016-03-21 09:25:52 +00:00
+ parse : element : { x : " number " }
+ parse : element : { y : " number " }
2015-05-28 18:28:15 +00:00
2016-07-24 09:19:40 +00:00
: ( scenario container_with_compound_field_type )
2016-07-24 08:12:20 +00:00
container foo [
2016-07-24 09:19:40 +00:00
{ x : ( address array ( address array character ) ) }
2016-07-24 08:12:20 +00:00
]
$ error : 0
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 ( ) {
2015-07-04 16:40:50 +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-03-14 03:26:47 +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-02-17 17:08:14 +00:00
void check_invalid_types ( const type_tree * type , const string & block , const string & name ) {
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 ) {
check_invalid_types ( type - > left , block , name ) ;
check_invalid_types ( type - > right , block , name ) ;
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 ) )
raise < < block < < " unknown type in " < < name < < ' \n ' < < end ( ) ;
2015-11-07 01:03:02 +00:00
}
}