From 971d146df2b380adc687011f58e5c201141f47d7 Mon Sep 17 00:00:00 2001 From: Matt Mascarenhas Date: Thu, 5 Jul 2018 00:05:06 +0100 Subject: [PATCH] Annotate bitwise045 --- pervognsen/bitwise/bitwise/bitwise045.hmml | 62 ++++++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 pervognsen/bitwise/bitwise/bitwise045.hmml diff --git a/pervognsen/bitwise/bitwise/bitwise045.hmml b/pervognsen/bitwise/bitwise/bitwise045.hmml new file mode 100644 index 0000000..5060d23 --- /dev/null +++ b/pervognsen/bitwise/bitwise/bitwise045.hmml @@ -0,0 +1,62 @@ +[video member=pervognsen stream_platform=twitch project=bitwise title="Domain-Specific Languages In Python, Part 3" vod_platform=youtube id=hP6UY6F6a0w annotator=Miblo] +[0:09][Recap and set the stage for the day][:speech] +[1:46][Review the bit-oriented nature of our DSL (domain-specific :language) rattle, and its lack of abstraction facilities][:research] +[6:18][A few words on the :simulation speed advantage from keeping things as bit-vectors][:language :speech] +[8:00][Consider allowing a circuit component connection-oriented way of expressing things, in addition to the language's current expression-oriented way][:language :speech] +[9:38][Consider supporting "module", in Verilog parlance][:language :speech] +[11:35][An example \@module][:language :speech] +[17:34][An example nested \@module][:language :speech] +[25:00][Note the addition of ordered dictionaries in Python 3.6][:language :speech] +[29:52][Set up to implement modules][:language :speech] +[32:15][Dive into implementing modules, starting by introducing Bit and BitVector classes, and memo() to memoise the result of bits()][:language] +[36:08][Demo the utility of \@memo][:language :speech] +[37:30][Establish the syntax bit\[8\] which comes out equal to bits(8) due to memoisation][:language] +[39:20][Define __and__() in the Node class, introducing check_same_type()][:language] +[42:32][Introduce BinaryNode class][:language] +[43:55][Introduce as_node() and ConstantNode class][:language] +[48:41][Introduce cast() in the Bit and BitVector classes, and __repr__() in Bit, BitVector and ConstantNode][:language] +[52:31][Test as_node()][:language :run] +[54:34][Define __rand__() in Node, and introduce InputNode class][:language] +[55:53][Demo usage of an InputNode, and a trick for doing embedded DSL in Python][:language :speech] +[57:21][Introduce input()][:language] +[57:57][Introduce Module class, using Python's new __init_subclass__][:language] +[59:00][Introduce Adder class using Module class, and walk us through what happens when Python executes this[ref + site="Python 3.7.0 documentation" + page="3. Data model" + url=https://docs.python.org/3/reference/datamodel.html#customizing-class-creation]][:language] +[1:00:49][Change Adder and Module to use a metaclass, also defining __repr__ in the InputNode class][:language] +[1:06:28][Demo the utility of this Module metaclass, noting the alternative way of doing this with a decorator][:language :run] +[1:07:11][Introduce module() to be used as a decorator][:language] +[1:09:09][Demo this decorator-based solution, remove Module class, and walk through how decorators work][:language :programming :run] +[1:11:16][Add an optional name to the Node class][:language] +[1:13:11][Suppress the types in our expression representation][:language] +[1:13:42][:Run it to see the expressions in our Adder class][:language] +[1:14:20][Review module() and consider the need to create module instance nodes][:language :research] +[1:15:23][Introduce Module class, OutputNode class and output(), and enable module() to fill out _inputs and _outputs][:language] +[1:18:48][Test the module inputs and outputs][:language :run] +[1:20:20][Introduce the notion of _connections in the Module class][:language] +[1:25:35][:Run it to see the output][:language] +[1:25:42][Implement our Adder8 and Adder16 modules sketched out earlier][:language] +[1:27:54][:Run it to see the inputs and outputs of our modules][:language] +[1:28:20][Enable __init__() in the Module class to check_same_type()][:language] +[1:30:25][Test plugging a 16-bit node into an 8-bit input and hit a TypeError as expected][:language :run] +[1:30:41][Break][:admin] +[1:31:01][:afk] +[1:31:54][Return][:admin] +[1:32:12][Implement type checking, adding __getitem__() to the Node class, and introducing IndexNode class][:language] +[1:39:50][Print Adder8._nodes][:language :run] +[1:40:22][Test the type checking, fixing IndexNode to correctly detect out of bounds indices][:language :programming :run] +[1:41:02][Implement bit slicing, introducing SliceNode class][:language] +[1:47:57][Test the bit slicing][:language :run] +[1:48:40][Compose error message for check_same_type()][:"error handling"] +[1:48:59][Trigger that out-of-bounds error and continue to test the bit slicing][:language :run] +[1:49:33][Test partial connections, noting that it's picking up the template rather than the instance version of the node][:language :run] +[1:51:37][Make module() delete its own template version of the nodes, and __init__() in the Module class to fill in the real instance nodes, introducing ModuleInputNode class][:language] +[1:59:39][:Run it to see our partial connection][:language] +[2:00:46][Enable module() to handle partial connections for Modules, renaming "nodes" to "definitions"][:language] +[2:05:17][:Run it to see some uninitialised data][:language] +[2:05:41][Define __repr__() in the Module class][:language] +[2:07:49][:Run it to see our Adder8 module all correctly printed out][:language] +[2:09:08][Summarise the day's work on syntactic sugar, type checking and modules][:language :speech] +[2:09:45][That's enough for today, with a glimpse into the future on additional semantic checking][:speech] +[/video]