def construct(self):
title = TextMobject('The Call Stack').to_edge(UP)
t1 = TextMobject("Alright, let's do a more complicated one!")
self.add(title, t1)
self.wait()
code_scale = 0.75
main_code = CodeBlock(
'Java',
r"""
public static
void main(String[] args) {
System.out.println(foo(1));
}
""",
code_scale=code_scale,
)
# Start line: 5
foo_code = CodeBlock(
'Java',
r"""
foo(int a) {
int b = bar(a, 2);
int c = bar(a, b);
return c;
}
""",
code_scale=code_scale,
)
# Start line: 10
bar_code = CodeBlock(
'Java',
r"""
int bar(int x, int y) {
int a = x + y;
int b = a * 2;
return b;
}
""",
code_scale=code_scale,
)
cg = VGroup(main_code, foo_code, bar_code)
cg.arrange(DOWN, aligned_edge=LEFT, buff=MED_SMALL_BUFF)
cg.next_to(title, DOWN, buff=MED_SMALL_BUFF).to_edge(RIGHT)
self.play(
FadeOut(t1),
FadeInFrom(cg, RIGHT),
)
self.wait()
frame_width = 3.0
args_ref = TextMobject('[ ]').scale(0.5)
main_frame = StackFrame(main_code,
'main()',
3, [('args', args_ref)],
width=frame_width)
main_frame.next_to(cg, LEFT, buff=LARGE_BUFF * 2).to_edge(DOWN)
main_code.move_hidden_highlight(3)
self.play(
FadeInFromDown(main_frame),
main_code.highlight_lines,
3,
)
self.wait()
foo_frame = StackFrame(foo_code,
'foo(1)',
5, ['a', 'b', 'c'],
width=frame_width)
foo_frame.next_to(main_frame, UP, buff=SMALL_BUFF)
xi = main_code.pre_call(foo_code, 1)
self.play(
*main_code.get_control_transfer_counterclockwise(xi),
FadeInFrom(foo_frame, UP),
)
foo_code.post_control_transfer(xi, self)
self.wait()
self.play(foo_code.highlight_lines, 2, foo_frame.set_line, 6,
foo_frame.update_slot, 'a', 1)
self.wait()
bar_frame = StackFrame(bar_code,
'bar(1, 2)',
10, ['x', 'y', 'a', 'b'],
width=frame_width)
bar_frame.next_to(foo_frame, UP, buff=SMALL_BUFF)
xi = foo_code.pre_call(bar_code, 1)
self.play(
*foo_code.get_control_transfer_counterclockwise(xi),
FadeInFrom(bar_frame, UP),
)
bar_code.post_control_transfer(xi, self)
self.wait()
self.play(bar_code.highlight_lines, 2, bar_frame.set_line, 11,
bar_frame.update_slot, 'x', 1, bar_frame.update_slot, 'y', 2)
self.wait()
self.play(bar_code.highlight_lines, 3, bar_frame.set_line, 12,
bar_frame.update_slot, 'a', 3)
self.wait()
self.play(bar_code.highlight_lines, 4, bar_frame.set_line, 13,
bar_frame.update_slot, 'b', 6)
self.wait()
xi = bar_code.pre_return(foo_code, 2)
self.play(
*bar_code.get_control_transfer_clockwise(xi),
Uncreate(bar_frame),
)
foo_code.post_control_transfer(xi, self)
self.wait()
self.play(foo_code.highlight_lines, 3, foo_frame.set_line, 7,
foo_frame.update_slot, 'b', 6)
self.wait()
bar_frame = StackFrame(bar_code,
'bar(1, 6)',
10, ['x', 'y', 'a', 'b'],
width=frame_width)
bar_frame.next_to(foo_frame, UP, buff=SMALL_BUFF)
xi = foo_code.pre_call(bar_code, 1)
self.play(
*foo_code.get_control_transfer_counterclockwise(xi),
FadeInFrom(bar_frame, UP),
)
bar_code.post_control_transfer(xi, self)
self.wait()
self.play(bar_code.highlight_lines, 2, bar_frame.set_line, 11,
bar_frame.update_slot, 'x', 1, bar_frame.update_slot, 'y', 6)
self.wait()
self.play(bar_code.highlight_lines, 3, bar_frame.set_line, 12,
bar_frame.update_slot, 'a', 7)
self.wait()
self.play(bar_code.highlight_lines, 4, bar_frame.set_line, 13,
bar_frame.update_slot, 'b', 14)
self.wait()
xi = bar_code.pre_return(foo_code, 3)
self.play(
*bar_code.get_control_transfer_clockwise(xi),
Uncreate(bar_frame),
)
foo_code.post_control_transfer(xi, self)
self.wait()
self.play(foo_code.highlight_lines, 4, foo_frame.set_line, 8,
foo_frame.update_slot, 'c', 14)
self.wait()
xi = foo_code.pre_return(main_code, 3)
self.play(
*foo_code.get_control_transfer_clockwise(xi),
Uncreate(foo_frame),
)
main_code.post_control_transfer(xi, self)
self.wait()
def fake_frame(name):
frame_name = TextMobject(name).scale(0.75)
br = BackgroundRectangle(frame_name,
buff=SMALL_BUFF,
fill_opacity=0.15)
br.set_fill(color=[ORANGE, BLUE])
return VGroup(frame_name, br)
println_funcs = [
'BufferedWriter.write("14", 0, 2)',
'BufferedWriter(Writer).write("14")',
'PrintStream.writeln("14")',
'PrintStream.println(14)',
]
println_frames = [fake_frame(f) for f in reversed(println_funcs)]
for n, p in zip(println_frames, [main_frame] + println_frames):
n.next_to(p, UP, buff=SMALL_BUFF)
self.play(FadeInFrom(n, UP))
self.wait()
for f in reversed(println_frames):
self.play(Uncreate(f))
# self.wait()
self.play(main_code.highlight_lines, 4, main_frame.set_line, 4)
off_screen_code = CodeBlock('Java', 'off_screen')
off_screen_code.shift(UP * 8) # Offscreen up
self.add(off_screen_code)
xi = main_code.pre_return(off_screen_code, 1)
self.play(
*main_code.get_control_transfer_clockwise(xi),
Uncreate(main_frame),
)
off_screen_code.post_control_transfer(xi, self)
self.wait()
self.play(FadeOut(main_code), FadeOut(foo_code), FadeOut(bar_code))
self.wait()
def construct(self):
code_scale = 0.75
foo_code = CodeBlock(
'Java',
r"""
int foo() {
int n = bar(2, 1);
n += bar(2, 2);
return n;
}
""",
code_scale=code_scale,
)
bar_code = CodeBlock(
'Java',
r"""
int bar(int x, int y) {
if (x == 1) {
return y;
}
int b = bar(x - 1, y + 1);
return b;
}
""",
line_offset=5,
code_scale=code_scale,
)
main_code = CodeBlock('Java', 'off_screen')
main_code.shift(UP * 8) # Offscreen up
self.add(main_code)
title = TextMobject('CodeBlock Stepping Demo')
title.to_edge(UP)
foo_code.next_to(title, DOWN)
bar_code.next_to(foo_code.get_code(),
DOWN,
buff=MED_LARGE_BUFF,
aligned_edge=LEFT,
submobject_to_align=bar_code.get_code())
self.play(*[FadeIn(o) for o in [title, foo_code, bar_code]])
self.wait()
# Step through both code blocks until done.
xi = main_code.pre_call(foo_code, 1)
self.play(*main_code.get_control_transfer_counterclockwise(xi))
foo_code.post_control_transfer(xi, self)
foo_code.prep_annotations(2, 3)
foo_code.generate_target().highlight_lines(2).set_annotation(2, 'n: ?')
self.play(MoveToTarget(foo_code))
n = self.run_bar(bar_code, foo_code, 2, 2, 1)
self.play(foo_code.highlight_lines, 3, foo_code.set_annotation, 2,
None, foo_code.set_annotation, 3, 'n: %d' % n,
bar_code.fade_labels)
n += self.run_bar(bar_code, foo_code, 3, 2, 2)
self.play(foo_code.highlight_lines, 4, foo_code.set_annotation, 3,
'n: %d' % n)
xi = foo_code.pre_return(main_code, 1)
self.play(*foo_code.get_control_transfer_clockwise(xi))
main_code.post_control_transfer(xi, self)
self.play(FadeOut(title), FadeOut(foo_code), FadeOut(bar_code))
self.wait()
def construct(self):
high_quality = False
# - Foo calls bar passing some args. Bar does something, returns.
code_scale = 0.75
main_code = CodeBlock(
'Java',
r"""
public static
void main(String[] args) {
foo();
}
""",
code_scale=code_scale,
)
foo_code = CodeBlock(
'Java',
r"""
static int foo() {
int n = bar(1, 2);
return n;
}
""",
code_scale=code_scale,
)
bar_code = CodeBlock(
'Java',
r"""
static int bar(int x,
int y) {
int a = x + y;
int b = a * 2;
return b;
}
""",
code_scale=code_scale,
)
fbg = VGroup(foo_code, bar_code)
bar_code.next_to(foo_code, DOWN, aligned_edge=LEFT, buff=LARGE_BUFF)
fbg.to_edge(TOP)
title = TextMobject('We have two Java functions, foo() and bar()')
title.to_edge(UP)
self.play(
ShowCreation(title),
FadeInFromDown(fbg),
)
self.wait(duration=2)
# Let's write down what happens when we run this.
t2 = TextMobject("Let's run them and write down\\\\"
"each variable as we go...")
t2.to_edge(LEFT)
self.play(Write(t2), fbg.to_edge, RIGHT, {'buff': MED_SMALL_BUFF})
self.wait()
t3 = TextMobject('Running foo() and bar() by hand').to_edge(UP)
if high_quality:
self.play(ReplacementTransform(VGroup(title, t2), t3))
else:
self.play(FadeOut(title), FadeOut(t2), FadeIn(t3))
self.remove(title, t2)
title = t3
self.wait()
t4 = TextMobject('First, make a place\\\\to write each variable')
t4.next_to(title, DOWN, buff=LARGE_BUFF).to_edge(LEFT)
self.play(FadeIn(t4))
self.wait()
foo_vars = VGroup(TexMobject('n:', '\\_'))
foo_vars.next_to(foo_code, LEFT, buff=LARGE_BUFF * 2)
bar_vars = VGroup(
TexMobject('x:', '\\_'),
TexMobject('y:', '\\_').shift(DOWN * .75),
TexMobject('a:', '\\_').shift(DOWN * 1.5),
TexMobject('b:', '\\_').shift(DOWN * 2.25),
)
bar_vars.next_to(bar_code, LEFT, aligned_edge=TOP, buff=LARGE_BUFF * 2)
self.play(Write(foo_vars))
self.play(Write(bar_vars))
self.wait()
t5 = TextMobject("Start in foo()...")
t5.move_to(t4, aligned_edge=LEFT)
self.play(FadeOut(t4), FadeIn(t5))
self.wait()
foo_code.move_hidden_highlight(2)
self.play(FadeOut(t5), foo_code.highlight_lines, 2)
self.wait()
foo_n_q = TexMobject('?').move_to(foo_vars[0][1],
aligned_edge=BOTTOM).shift(UP * 0.1)
self.play(Write(foo_n_q))
foo_vars.add(foo_n_q)
self.wait()
xi = foo_code.pre_call(bar_code, (1, 3))
self.play(*foo_code.get_control_transfer_counterclockwise(xi), )
bar_code.post_control_transfer(xi, self)
self.wait()
bar_x = TexMobject('1').move_to(bar_vars[0][1],
aligned_edge=BOTTOM).shift(UP * 0.1)
bar_y = TexMobject('2').move_to(bar_vars[1][1],
aligned_edge=BOTTOM).shift(UP * 0.1)
a = Arrow(bar_code.get_code().get_lines(2),
VGroup(bar_x, bar_y).get_right(),
stroke_width=3)
self.play(Write(bar_x), Write(bar_y), ShowCreationThenDestruction(a))
bar_vars_extras = VGroup()
bar_vars_extras.add(bar_x, bar_y)
self.play(bar_code.highlight_lines, 3)
self.wait()
bar_a = TexMobject('3').move_to(bar_vars[2][1],
aligned_edge=BOTTOM).shift(UP * 0.1)
a = Arrow(bar_code.get_code().get_lines(3),
bar_a.get_right(),
stroke_width=3)
self.play(Write(bar_a), ShowCreationThenDestruction(a))
bar_vars_extras.add(bar_a)
self.play(bar_code.highlight_lines, 4)
self.wait()
bar_b = TexMobject('6').move_to(bar_vars[3][1],
aligned_edge=BOTTOM).shift(UP * 0.1)
a = Arrow(bar_code.get_code().get_lines(4),
bar_b.get_right(),
stroke_width=3)
self.play(Write(bar_b), ShowCreationThenDestruction(a))
bar_vars_extras.add(bar_b)
self.play(bar_code.highlight_lines, 5)
self.wait()
xi = bar_code.pre_return(foo_code, 2)
self.play(*bar_code.get_control_transfer_clockwise(xi), )
foo_code.post_control_transfer(xi, self)
self.wait()
foo_n = TexMobject('6').move_to(foo_vars[0][1],
aligned_edge=BOTTOM).shift(UP * 0.1)
a = Arrow(foo_code.get_code().get_lines(2),
foo_n.get_right(),
stroke_width=3)
self.play(
foo_code.highlight_lines,
3,
ReplacementTransform(foo_n_q, foo_n),
ShowCreationThenDestruction(a),
)
foo_vars.add(foo_n)
self.wait()
# - Now give the variables "homes" in each function. Variables like
# homes; they're warm and safe and sized just for them!
print('Give variables homes')
t1 = TextMobject('So how does the\\\\computer do this?').to_edge(LEFT)
self.play(FadeIn(t1), foo_code.remove_highlight)
self.wait(duration=2)
t2 = TextMobject(
'Every variable is stored\\\\someplace in memory').to_edge(LEFT)
new_title = TextMobject('Where are variables stored?').to_edge(UP)
self.play(
FadeOut(t1),
FadeOut(title),
FadeIn(new_title),
FadeIn(t2),
)
title = new_title
self.wait()
em = TextMobject('M')
slot_height = em.get_height() + SMALL_BUFF * 2
slot_width = em.get_width() * 4 + SMALL_BUFF * 2
def build_var_home(name, value):
var_name = TextMobject(name)
slot_box = Rectangle(height=slot_height,
width=slot_width,
stroke_width=1)
var_value = TextMobject(value)
var_value.move_to(slot_box)
var_name.next_to(slot_box, LEFT)
stack_slot = VGroup(slot_box, var_name, var_value)
return stack_slot
foo_homes = build_var_home('n', '6')
foo_homes.move_to(foo_vars, aligned_edge=LEFT)
self.play(ReplacementTransform(foo_vars, foo_homes))
self.wait()
bar_var_vals = [('x', '1'), ('y', '2'), ('a', '3'), ('b', '6')]
bar_homes = VGroup()
bar_homes_shift = 0
for n, v in bar_var_vals:
bar_homes.add(build_var_home(n, v).shift(DOWN * bar_homes_shift))
bar_homes_shift += 0.75
bar_homes.move_to(bar_vars, aligned_edge=LEFT)
t3 = TextMobject("Each variable lives in a\\\\``slot''").to_edge(LEFT)
self.play(
ReplacementTransform(bar_vars, bar_homes),
# FadeOut(bar_vars),
FadeOut(bar_vars_extras),
FadeIn(bar_homes),
)
self.wait()
self.play(
FadeOut(t2),
FadeIn(t3),
)
self.wait()
# - Now arrange the homes into a "stack frame".
print('Build stack frames')
t4 = TextMobject(
"All slots for a function\\\\are put together in a\\\\``frame''")
t4.to_edge(LEFT)
self.play(FadeOut(t3), FadeIn(t4))
frame_width = 2.8
foo_vars = [('n', '6')]
foo_frame = StackFrame(foo_code,
'foo()',
3,
foo_vars,
width=frame_width)
foo_frame.move_to(foo_homes, aligned_edge=LEFT).shift(LEFT * .5)
self.play(ReplacementTransform(foo_homes, foo_frame))
self.wait()
bar_frame = StackFrame(bar_code,
'bar(1,2)',
9,
bar_var_vals,
width=frame_width)
bar_frame.move_to(bar_homes, aligned_edge=LEFT).shift(LEFT * .5)
self.play(ReplacementTransform(bar_homes, bar_frame))
self.wait()
t5 = TextMobject("\\textit{They're happy and warm\\\\together!}")\
.scale(0.75).next_to(t4, DOWN, buff=LARGE_BUFF)
self.play(FadeIn(t5))
self.wait()
# Cool, so where do frames live?
print('Where do frames live')
t6 = TextMobject('So where do frames live?').to_edge(LEFT)
self.play(
FadeOut(t5),
FadeOut(t4),
FadeIn(t6),
)
self.wait()
t7 = TextMobject("On the ``call stack''!").next_to(t6,
DOWN,
buff=LARGE_BUFF)
self.play(FadeIn(t7))
self.wait()
new_title = TextMobject('The Call Stack').to_edge(UP)
t1 = TextMobject('Function calls push a new frame\\\\onto the stack')\
.to_edge(LEFT).shift(UP)
t2 = TextMobject('Returning pops a frame off\\\\the stack').next_to(
t1, DOWN, buff=LARGE_BUFF)
box_count = 8
colors = color_gradient([BLUE, ORANGE], box_count)
little_boxes = VGroup(*[
Rectangle(height=0.25, width=0.75, fill_opacity=1, color=colors[i])
for i in range(box_count)
])
little_boxes.arrange(UP, buff=0.1)
little_boxes.next_to(VGroup(foo_code, bar_code), LEFT, buff=LARGE_BUFF)
self.play(
ReplacementTransform(title, new_title),
FadeOut(t6),
FadeOut(t7),
FadeOut(foo_frame),
FadeOut(bar_frame),
FadeIn(t1),
LaggedStartMap(FadeInFrom,
little_boxes,
lambda m: (m, UP),
lag_ratio=1.0,
run_time=4.0),
)
title = new_title
self.wait()
self.play(
FadeIn(t2),
LaggedStartMap(FadeOutAndShift,
VGroup(*reversed(little_boxes)),
lambda m: (m, UP),
lag_ratio=1.0,
run_time=4.0),
)
self.wait(duration=1)
t3 = TextMobject(
"Let's run again and see\\\\the call stack in action...").to_edge(
LEFT)
t3.shift(UP)
self.play(FadeOut(t1), FadeOut(t2), FadeIn(t3))
self.wait()
print('Run with real call stack')
# Let's also put main() into the picture. Start it off-frame upper right
t4 = TextMobject("... and get main()\\\\into the picture.")\
.next_to(t3, DOWN, buff=LARGE_BUFF)
main_code.next_to(title, DOWN, buff=MED_SMALL_BUFF).to_edge(RIGHT)
main_code.shift(UP * 3 + RIGHT * 3)
g = VGroup(main_code, foo_code, bar_code)
self.play(
g.arrange,
DOWN,
{
'aligned_edge': LEFT,
'buff': MED_SMALL_BUFF
},
g.next_to,
title,
DOWN,
{'buff': MED_SMALL_BUFF},
g.to_edge,
RIGHT,
FadeInFromDown(t4),
)
self.wait(duration=2)
t1 = TextMobject('Start in main()...')
t1.next_to(title, DOWN, buff=LARGE_BUFF).to_edge(LEFT)
frame_width = 3.0
args_ref = TextMobject('[ ]').scale(0.5)
main_frame = StackFrame(main_code,
'main()',
3, [('args', args_ref)],
width=frame_width)
main_frame.next_to(g, LEFT, buff=LARGE_BUFF).to_edge(DOWN)
main_code.move_hidden_highlight(3)
self.play(FadeIn(t1), FadeInFromDown(main_frame),
main_code.highlight_lines, 3, FadeOut(t3), FadeOut(t4))
self.wait()
foo_frame = StackFrame(foo_code, 'foo()', 5, ['n'], width=frame_width)
foo_frame.next_to(main_frame, UP, buff=SMALL_BUFF)
b1 = BraceLabel(foo_frame,
'Calling foo()\\\\pushes a frame',
brace_direction=LEFT,
label_constructor=TextMobject)
xi = main_code.pre_call(foo_code, 1)
self.play(
*main_code.get_control_transfer_counterclockwise(xi),
FadeInFrom(foo_frame, UP),
FadeInFrom(b1, UP),
FadeOut(t1),
)
foo_code.post_control_transfer(xi, self)
self.wait(duration=2)
self.play(foo_code.highlight_lines, 2, foo_frame.set_line, 6,
FadeOut(b1))
self.wait()
bar_frame = StackFrame(bar_code,
'bar(1, 2)',
10, ['x', 'y', 'a', 'b'],
width=frame_width)
bar_frame.next_to(foo_frame, UP, buff=SMALL_BUFF)
b1 = BraceLabel(bar_frame,
'Calling bar()\\\\pushes a frame',
brace_direction=LEFT,
label_constructor=TextMobject)
xi = foo_code.pre_call(bar_code, (1, 3))
self.play(
*foo_code.get_control_transfer_counterclockwise(xi),
FadeInFrom(bar_frame, UP),
FadeInFrom(b1, UP),
)
bar_code.post_control_transfer(xi, self)
self.wait()
self.play(bar_frame.update_slot, 'x', 1, bar_frame.update_slot, 'y', 2,
FadeOut(b1))
self.play(bar_code.highlight_lines, 3, bar_frame.set_line, 11)
self.wait()
self.play(bar_frame.update_slot, 'a', 3)
self.play(bar_code.highlight_lines, 4, bar_frame.set_line, 12)
self.wait()
self.play(bar_frame.update_slot, 'b', 6)
self.play(bar_code.highlight_lines, 5, bar_frame.set_line, 13)
b1 = BraceLabel(bar_frame,
"Returning pops\\\\bar's frame",
brace_direction=LEFT,
label_constructor=TextMobject)
self.play(FadeIn(b1))
self.wait(duration=2)
xi = bar_code.pre_return(foo_code, 2)
self.play(
*bar_code.get_control_transfer_clockwise(xi),
Uncreate(bar_frame),
FadeOut(b1),
)
foo_code.post_control_transfer(xi, self)
self.wait()
self.play(foo_code.highlight_lines, 3, foo_frame.set_line, 7,
foo_frame.update_slot, 'n', 6)
b1 = BraceLabel(foo_frame,
"Returning pops\\\\foo's frame",
brace_direction=LEFT,
label_constructor=TextMobject)
self.play(FadeIn(b1))
self.wait()
xi = foo_code.pre_return(main_code, 3)
self.play(
*foo_code.get_control_transfer_clockwise(xi),
Uncreate(foo_frame),
FadeOut(b1),
)
main_code.post_control_transfer(xi, self)
self.wait()
self.play(main_code.highlight_lines, 4, main_frame.set_line, 4)
self.wait()
t1 = TextMobject(
'And when main() returns\\\\the program ends').to_edge(LEFT)
self.play(FadeIn(t1))
self.wait()
off_screen_code = CodeBlock('Java', 'off_screen')
off_screen_code.shift(UP * 8) # Offscreen up
self.add(off_screen_code)
xi = main_code.pre_return(off_screen_code, 1)
self.play(
*main_code.get_control_transfer_clockwise(xi),
Uncreate(main_frame),
FadeOut(t1),
)
off_screen_code.post_control_transfer(xi, self)
self.wait()
t1 = TextMobject("Alright, let's do a more complicated one!")
self.play(
FadeInFromDown(t1),
FadeOutAndShift(g, RIGHT),
)
self.wait()