From: Carlos Agarie <carlos.agarie@...>
Date: 2012-09-24T16:38:32+09:00
Subject: Re: sandwhich principle (ruby koans)

--047d7b5daf30143b5004ca6dadf2
Content-Type: text/plain; charset=ISO-8859-1
Content-Transfer-Encoding: quoted-printable

Roelof,

This principle says that when you have two pieces of code that are almost
identical, except for the "middle" part, you can create a method that takes
a block to fill the "middle" part.

For example, suppose you have two methods, and both need to save
information to a log file before and after execution:

def hello
  save_in_logfile "Starting to execute method 'hello'"
  puts "first method"
  save_in_logfile "Finishing execution of method 'hello'"
end

def world
  save_in_logfile "Starting to execute method 'world'"
  puts "second method"
  save_in_logfile "Finishing execution of method 'world'"
end

The "sandwich" the koan talks about could be interpreted as the
save_in_logfile methods being the slices of bread and the puts calls the
meat. So we could use blocks to create this:

def sandwich(string)
  save_in_logfile "Starting to execute method '#{string}'"
  yield
  save_in_logfile "Finishing to execute method '#{string}'"
end

And the two methods would become:

def hello
  sandwich("hello") do
    puts "first method"
  end
end

def world
  sandwich("world") do
    puts "second method"
  end
end

This way, the repetitive part (save_in_logfile stuff) is called in only one
place. This technique is used in the File::open method - when you call it
with a block, the opened file is automatically closed after the block is
executed.

Hope that helps!

2012/9/24 Roelof Wobben <rwobben@hotmail.com>

>  hello,
>
> I'm working on ruby koans.
>
> Now I have to do some sandwhich code.
>
> The exercise looks like this :
>
> require File.expand_path(File.dirname(__FILE__) + '/edgecase')
> class AboutSandwichCode < EdgeCase::Koan
>   def count_lines(file_name)
>     file =3D open(file_name)
>     count =3D 0
>     while line =3D file.gets
>       count +=3D 1
>     end
>     count
>   ensure
>     file.close if file
>   end
>   def test_counting_lines
>     assert_equal 4, count_lines("example_file.txt")
>   end
>   # ------------------------------------------------------------------
>   def find_line(file_name)
>     file =3D open(file_name)
>     while line =3D file.gets
>       return line if line.match(/e/)
>     end
>   ensure
>     file.close if file
>   end
>   def test_finding_lines
>     assert_equal "test\n", find_line("example_file.txt")
>   end
>   # ------------------------------------------------------------------
>   # THINK ABOUT IT:
>   #
>   # The count_lines and find_line are similar, and yet different.
>   # They both follow the pattern of "sandwich code".
>   #
>   # Sandwich code is code that comes in three parts: (1) the top slice
>   # of bread, (2) the meat, and (3) the bottom slice of bread.  The
>   # bread part of the sandwich almost always goes together, but
>   # the meat part changes all the time.
>   #
>   # Because the changing part of the sandwich code is in the middle,
>   # abstracting the top and bottom bread slices to a library can be
>   # difficult in many languages.
>   #
>   # (Aside for C++ programmers: The idiom of capturing allocated
>   # pointers in a smart pointer constructor is an attempt to deal with
>   # the problem of sandwich code for resource allocation.)
>   #
>   # Consider the following code:
>   #
>   def file_sandwich(file_name)
>     file =3D open(file_name)
>     yield(file)
>   ensure
>     file.close if file
>   end
>   # Now we write:
>   def count_lines2(file_name)
>     file_sandwich(file_name) do |file|
>       count =3D 0
>       while line =3D file.gets
>         count +=3D 1
>       end
>       count
>     end
>   end
>   def test_counting_lines2
>     assert_equal 4, count_lines2("example_file.txt")
>   end
>   # ------------------------------------------------------------------
>   def find_line2(file_name)
>     # Rewrite find_line using the file_sandwich library function.
>   end
>   def test_finding_lines2
>     assert_equal __, find_line2("example_file.txt")
>   end
>   # ------------------------------------------------------------------
>   def count_lines3(file_name)
>     open(file_name) do |file|
>       count =3D 0
>       while line =3D file.gets
>         count +=3D 1
>       end
>       count
>     end
>   end
>   def test_open_handles_the_file_sandwich_when_given_a_block
>     assert_equal __, count_lines3("example_file.txt")
>   end
> end
>
> But I don't get the principle.
> Can anyone explain this to me ?
>
> Roelof
>
>
>



--=20
Carlos Agarie
Control engineering student
Polytechnic School
University of S=E3o Paulo

--047d7b5daf30143b5004ca6dadf2
Content-Type: text/html; charset=ISO-8859-1
Content-Transfer-Encoding: quoted-printable

Roelof,<div><br></div><div>This principle says that when you have two piece=
s of code that are almost identical, except for the &quot;middle&quot; part=
, you can create a method that takes a block to fill the &quot;middle&quot;=
 part.</div>

<div><br></div><div>For example, suppose you have two methods, and both nee=
d to save information to a log file before and after execution:</div><div><=
br></div><div>def hello</div><div>=A0 save_in_logfile &quot;Starting to exe=
cute method &#39;hello&#39;&quot;</div>

<div>=A0 puts &quot;first method&quot;</div><div>=A0 save_in_logfile &quot;=
Finishing execution of=A0method &#39;hello&#39;&quot;</div><div>end</div><d=
iv><br></div><div>def world</div><div>=A0 save_in_logfile &quot;Starting to=
 execute=A0method &#39;world&#39;&quot;</div>
<div>=A0 puts &quot;second method&quot;</div>
<div>=A0 save_in_logfile &quot;Finishing execution of=A0method &#39;world&#=
39;&quot;=A0=A0</div><div>end</div><div><br></div><div>The &quot;sandwich&q=
uot; the koan talks about could be interpreted as the save_in_logfile metho=
ds being the slices of bread and the puts calls the meat. So we could use b=
locks to create this:</div>
<div><br></div><div>def sandwich(string)</div><div>=A0 save_in_logfile &quo=
t;Starting to execute method &#39;#{string}&#39;&quot;</div><div>=A0 yield<=
/div><div>=A0 save_in_logfile &quot;Finishing to execute method &#39;#{stri=
ng}&#39;&quot;</div>
<div>end</div><div><br></div><div>
And the two methods would become:</div><div><br></div><div>def hello</div><=
div>=A0 sandwich(&quot;hello&quot;) do</div><div>=A0 =A0 puts &quot;first m=
ethod&quot;</div><div>=A0 end</div><div>end</div><div><br></div><div>def wo=
rld</div>
<div>=A0 sandwich(&quot;world&quot;) do</div><div>=A0 =A0 puts &quot;second=
 method&quot;</div><div>=A0 end</div><div>end</div><div><br></div><div>This=
 way, the repetitive part (save_in_logfile stuff) is called in only one pla=
ce. This technique is used in the File::open method - when you call it with=
 a block, the opened file is automatically closed after the block is execut=
ed.</div>
<div><br></div><div>Hope that helps!</div><div><br><div class=3D"gmail_quot=
e">2012/9/24 Roelof Wobben <span dir=3D"ltr">&lt;<a href=3D"mailto:rwobben@=
hotmail.com" target=3D"_blank">rwobben@hotmail.com</a>&gt;</span><br><block=
quote class=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc=
 solid;padding-left:1ex">




<div><div dir=3D"ltr">



hello, <br>=A0<br>I&#39;m=A0working on ruby koans.<br><br>Now I have to do =
some sandwhich code.<br>=A0<br>The exercise looks like this :<br>=A0<br>req=
uire File.expand_path(File.dirname(__FILE__) + &#39;/edgecase&#39;)<br>clas=
s AboutSandwichCode &lt; EdgeCase::Koan<br>

=A0 def count_lines(file_name)<br>=A0=A0=A0 file =3D open(file_name)<br>=A0=
=A0=A0 count =3D 0<br>=A0=A0=A0 while line =3D file.gets<br>=A0=A0=A0=A0=A0=
 count +=3D 1<br>=A0=A0=A0 end<br>=A0=A0=A0 count<br>=A0 ensure<br>=A0=A0=
=A0 file.close if file<br>=A0 end<br>=A0 def test_counting_lines<br>

=A0=A0=A0 assert_equal 4, count_lines(&quot;example_file.txt&quot;)<br>=A0 =
end<br>=A0 # --------------------------------------------------------------=
----<br>=A0 def find_line(file_name)<br>=A0=A0=A0 file =3D open(file_name)<=
br>=A0=A0=A0 while line =3D file.gets<br>

=A0=A0=A0=A0=A0 return line if line.match(/e/)<br>=A0=A0=A0 end<br>=A0 ensu=
re<br>=A0=A0=A0 file.close if file<br>=A0 end<br>=A0 def test_finding_lines=
<br>=A0=A0=A0 assert_equal &quot;test\n&quot;, find_line(&quot;example_file=
.txt&quot;)<br>=A0 end<br>=A0 # -------------------------------------------=
-----------------------<br>

=A0 # THINK ABOUT IT:<br>=A0 #<br>=A0 # The count_lines and find_line are s=
imilar, and yet different.<br>=A0 # They both follow the pattern of &quot;s=
andwich code&quot;.<br>=A0 #<br>=A0 # Sandwich code is code that comes in t=
hree parts: (1) the top slice<br>

=A0 # of bread, (2) the meat, and (3) the bottom slice of bread.=A0 The<br>=
=A0 # bread part of the sandwich almost always goes together, but<br>=A0 # =
the meat part changes all the time.<br>=A0 #<br>=A0 # Because the changing =
part of the sandwich code is in the middle,<br>

=A0 # abstracting the top and bottom bread slices to a library can be<br>=
=A0 # difficult in many languages.<br>=A0 #<br>=A0 # (Aside for C++ program=
mers: The idiom of capturing allocated<br>=A0 # pointers in a smart pointer=
 constructor is an attempt to deal with<br>

=A0 # the problem of sandwich code for resource allocation.)<br>=A0 #<br>=
=A0 # Consider the following code:<br>=A0 #<br>=A0 def file_sandwich(file_n=
ame)<br>=A0=A0=A0 file =3D open(file_name)<br>=A0=A0=A0 yield(file)<br>=A0 =
ensure<br>=A0=A0=A0 file.close if file<br>

=A0 end<br>=A0 # Now we write:<br>=A0 def count_lines2(file_name)<br>=A0=A0=
=A0 file_sandwich(file_name) do |file|<br>=A0=A0=A0=A0=A0 count =3D 0<br>=
=A0=A0=A0=A0=A0 while line =3D file.gets<br>=A0=A0=A0=A0=A0=A0=A0 count +=
=3D 1<br>=A0=A0=A0=A0=A0 end<br>=A0=A0=A0=A0=A0 count<br>=A0=A0=A0 end<br>=
=A0 end<br>

=A0 def test_counting_lines2<br>=A0=A0=A0 assert_equal 4, count_lines2(&quo=
t;example_file.txt&quot;)<br>=A0 end<br>=A0 # -----------------------------=
-------------------------------------<br>=A0 def find_line2(file_name)<br>=
=A0=A0=A0 # Rewrite find_line using the file_sandwich library function.<br>

=A0 end<br>=A0 def test_finding_lines2<br>=A0=A0=A0 assert_equal __, find_l=
ine2(&quot;example_file.txt&quot;)<br>=A0 end<br>=A0 # --------------------=
----------------------------------------------<br>=A0 def count_lines3(file=
_name)<br>=A0=A0=A0 open(file_name) do |file|<br>

=A0=A0=A0=A0=A0 count =3D 0<br>=A0=A0=A0=A0=A0 while line =3D file.gets<br>=
=A0=A0=A0=A0=A0=A0=A0 count +=3D 1<br>=A0=A0=A0=A0=A0 end<br>=A0=A0=A0=A0=
=A0 count<br>=A0=A0=A0 end<br>=A0 end<br>=A0 def test_open_handles_the_file=
_sandwich_when_given_a_block<br>=A0=A0=A0 assert_equal __, count_lines3(&qu=
ot;example_file.txt&quot;)<br>

=A0 end<br>end<br><br>But I don&#39;t get the principle.<br>Can anyone expl=
ain this to me ?<span><font color=3D"#888888"><br>=A0<br>Roelof<br><br>=A0<=
br> 		 	   		  </font></span></div></div>
</blockquote></div><br><br clear=3D"all"><div><br></div>-- <br>Carlos Agari=
e<br>Control engineering student<div>Polytechnic School<br>University of S=
=E3o Paulo</div><br>
</div>

--047d7b5daf30143b5004ca6dadf2--