Posts about teachinghttp://cestlaz.github.io/categories/teaching.atom2018-09-19T23:47:48ZMike ZamanskyNikolaPD for people who know CShttp://cestlaz.github.io/posts/pd-for-cs/2018-06-27T14:41:59-04:002018-06-27T14:41:59-04:00Mike Zamansky<div id="outline-container-org6242d00" class="outline-2">
<h2 id="org6242d00"></h2>
<div class="outline-text-2" id="text-org6242d00">
<p>
I saw a couple of tweets from Sarah Judd this morning:
</p>
<blockquote class="twitter-tweet" data-conversation="none" data-lang="en"><p lang="en" dir="ltr">A lot of CS Ed PD assumes you are new to CS. I really want CS Ed PD for people like us that came from a CS background and want to understand the pedagogy for CS in particular better. Do you know of some?</p>— Sarah Judd (@SarahEJudd) <a href="https://twitter.com/SarahEJudd/status/1011785286693552139?ref_src=twsrc%5Etfw">June 27, 2018</a></blockquote>
<script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>
<blockquote class="twitter-tweet" data-conversation="none" data-lang="en"><p lang="en" dir="ltr">Yes! I love SIGCSE and CSTA. I just feel like... Math teachers don't get PD that starts with "and this is how you add and subtract!" and I'd love more CS PD that assumes the content is there, and can focus on the pedagogy.</p>— Sarah Judd (@SarahEJudd) <a href="https://twitter.com/SarahEJudd/status/1011966102795059200?ref_src=twsrc%5Etfw">June 27, 2018</a></blockquote>
<script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>
<p>
It wasn't the first time I've heard this refrain. Last year I attended
my first CSTA conference. I had numerous conversations with CS
teachers on the fact that everything was on an intro level in terms of
both content and teaching. Further conversations with local teachers
with stronger CS backgrounds led me to run a professional development
session at Hunter this past election day for more experienced CS
teachers at schools that offered more than the basics.
</p>
<p>
While it's not surprising that most of the PD opportunities for CS teachers are
rather rudimentary given that nationally most programs are new and
most teachers are new to the subject but there are a few deeper
reasons.
</p>
<p>
To start, there are big players in the CS Ed movement that are pushing
curricula and specific programs and that leads to scripted PD for
their products and not depth of knowledge nor deep pedagogical content
knowledge let alone basic pedagogy. Add to this the fact that many of
the "thought leaders" in the space don't have experience teaching CS
at the K12 level and in many cases don't have a background either in
teaching nor tech and you can see where the problem comes from. On top
of this we have the erosion of respect for teaching as a profession
where reformers are trying to take the teacher out of teaching and are
trying to reduce pedagogy to following scripts. This problem goes well
beyond CS Ed but as the new kid on the block it probably hits us
hardest.
</p>
<p>
In any case, preparing beginners is both necessary and appropriate for
the time being but we can and must do a better job than what's
currently "state of the art." At the same time we have to do something
with the CS teachers who indeed do have strong content knowledge but
don't feel comfortable with imparting that knowledge.
</p>
<p>
So, what should we do?
</p>
<p>
For new teachers the solution will ultimately have to come
from pre-service programs but what we end up getting is going to
largely be dictated on what's required by individual states. If states
merely require passing an exam like the Praxis CS exam which, from
what I can gather isn't a horrible content exam then we're going to
see CS teachers bumble through their early to mid careers while trying
to figure out how to teach CS much like I did way back when. If they
end up endorsing pre-service programs that are focused on specific
curricula - APCS-A for teachers, APCS-P for teachers, <a href="https://cestlaz.github.io/posts/math-for-math-teachers/">Math for Math
teachers</a> if you will but for CS, we're also not going to get strong
well prepared pedagogues. On the other hand if you can design a
program that has a strong pedagogical component to go along with the
content, you have a chance. Even with a well designed program
implementation will still be a challenge. Who will teach it? Education
professors who don't have CS backgrounds? CS professors with little
pedagogical training? Neither of those groups necessarily have any
real experience as actual K12 teachers. If you can find honest to
goodness experienced, strong K12 CS teachers to teach your pedagogy
courses that's a big win but that's going to be hard in most cases.
</p>
<p>
I think we designed a great program at Hunter and have a practical and
strong implementation plan. If you're going to be
at CSTA2018 you can hear all about it and why we designed it as we did
in the talk I'm giving.
</p>
<p>
For the more experienced I don't have a universal answer but I can say
what I'm planning. Teachers in NY have to complete 100 CTLE hours
every five years. For beginners, there are plenty of options, at least
content wise. For teachers who know CS, not so much. I was at a meetup
talking to a few friends a couple of weeks ago and one mentioned that
they get most of their hours in Math for America CS
workshops. Unfortunately more than a few of my CS teacher friends who
are in MFA tell me that the CS content in these workshops, while they
do satisfy the hours, are somewhat lacking on the CS / CS pedagogy
side.
</p>
<p>
Here's what I'm planning - we (Hunter) will host a once a month
dinner/session for CS teachers who are a little farther along CS
wise. I haven't worked out all the details yet but I've got a few tech
companies that are already interested in sponsoring and helping out
should we need anything and we'll probably set most of our agenda for
the year at the first session where I'll make my best guess at a
useful agenda. This is something I'm pretty excited about. It should
help create a network of more experienced CS teachers which will both
help bolster that segment of the community and provide a long term
resource to newcomers and it should be a lot of fun.
</p>
<p>
In some ways, this is why I ended up joining Hunter. Regardless of
what the city and state do, we're going to prepare the teachers and if
you have a well prepared teacher, you've got a shot.
</p>
</div>
</div>The Tech or the Teacherhttp://cestlaz.github.io/posts/tech-or-teacher/2018-05-31T17:43:28-04:002018-05-31T17:43:28-04:00Mike Zamansky<div id="outline-container-org1d8df13" class="outline-2">
<h2 id="org1d8df13"></h2>
<div class="outline-text-2" id="text-org1d8df13">
<p>
Every morning one of the first things I do is quickly glance at my
emails and other notifications. I really should wait until I'm more
awake but old habits die hard.
</p>
<p>
As some of you know over the past couple of years I've been making a
series of <a href="http://cestlaz.github.io/stories/emacs">videos</a> and related post on using my editor of choice,
Emacs. I've done 48 videos, have over 2500 subscribers on
YouTube and people seem to find some value from the series.
</p>
<p>
This morning one of my emails was a new comment on one of my videos:
</p>
<blockquote>
<p>
Thanks for not describing a single key combination and how that fits
into basic usage of org mode. I was going to subscribe but if all
your videos are going to be about showing off how fast you are at
typing emacs commands on your annoyingly noisy keyborad, then no
thanks!
</p>
</blockquote>
<p>
My first reaction was "you know, you could have said something like
'if you slow down an actually say the keys it would be much easier to
follow and would be more valuable' and it would be much better received" but
then I started to think about instructional videos in general. I
started to make these videos for my students. I thought they might be
helpful and then found that the Emacs community by and large liked
them. They're not teaching anything deep or complicated just how I use
a programmable editor. Even so, I was reminded by this comment about
the limitations of videos and ed tech in general.
</p>
<p>
Videos provide some nice features - you can watch them at any time,
you can pause and replay, and in some cases you can watch at super
speeds. What you can't do is slow the video down and most importantly
you can't ask questions or interact with the instructor. You can leave
comments if the video is on a platform like YouTube but that's pretty
limited.
</p>
<p>
On the other hand, if this was a class, we would have been able to
interact and I as the instructor would have had a much better chance
to make sure this "student" was up to speed.
</p>
<p>
Of course, this wasn't a class. I don't have the time to teach tools
like Emacs in class and since it is a mechanical skill, it can be
offloaded to a video. The video has the ancillary benefit of living on
and being discoverable and viewable by the public at large. This is a
good thing. Videos are tech and tech scales. Unfortunately, good
education doesn't.
</p>
<p>
Videos are tech and tech is the rage. Lots of people are working hard
to get more tech in front of our kids - usually at the expense of
having a great teacher. This is something we don't need. Technology is
nice but I'd rather have my kids in a small class with a knowledgable
teacher and a piece of chalk than all the tech in the world.
</p>
<p>
As a computer science guy and a computer science teacher I think it's
good to remind myself that tech is cool but a good teacher is way cooler.
</p>
</div>
</div>No Magic Bullets - Discovery Learninghttp://cestlaz.github.io/posts/no-magic-bullets-constructivism/2018-04-21T07:40:16-04:002018-04-21T07:40:16-04:00Mike Zamansky<div id="outline-container-orgf11b7f9" class="outline-2">
<h2 id="orgf11b7f9"></h2>
<div class="outline-text-2" id="text-orgf11b7f9">
<p>
The most recent NYC CSTA chapter meeting was "How do I assess CS?" I
wanted to go but it's been such a crazy month I was just too wiped
out. Fortunately, the meetup was <a href="https://www.youtube.com/watch?v=XIMKAZbHAiA&index=83&list=WL&t=1796s">recorded</a>. I was able to watch the
first half this morning while working out on my <a href="https://www.staczero.com/hero">stationary trainer</a>
which leads me to today's rare Saturday morning blog
post. The meetup consisted of two panels. The first was made up of K12
teachers who taught CS. I can't talk about the second panel yet since I'm
only halfway through but there were a couple of points made by my
friend <a href="https://twitter.com/KatieJergens">Katie Jergens</a> who teaches at Dalton that I thought were worth
talking about.
</p>
<p>
The first was when Katie noted that through working with the panel,
one of her takeaways was that:
</p>
<blockquote>
<p>
Giving students an explicit strategy for solving a problem - "this is
how I would do it….," - giving them an explicit strategy first and then giving them a
problem for which that strategy would apply is much more effective than
having them discover it on their own.
</p>
</blockquote>
<p>
This was refreshing to hear after being beaten over the head on
discovery learning and constructivism for the past five or so
years as being the magic bullet for teachers. I shared more thoughts
on this a few weeks ago when I wrote about a SIGCSE paper presented by
<a href="https://cestlaz.github.io/posts/sigcse2018-bootstrap/">Bootstrap World</a> that I very much liked.
</p>
<p>
Katie went on to talk about how the group found that while "discovery
learning" can be effective it can also be frustrating and lose kids
along the way. It also takes a lot of time and preparation, something
that's short on supply in most public schools.
</p>
<p>
This made me think about the recent flurry
of discussion around the debunking of learning styles which had
previously been the magic bullet. When I started, the secret sauce was cooperative
learning.
</p>
<p>
Of course any good teacher knows there's no magic bullet. You fill
your tool belt and chest with as much as you can and use what's
best based on your strengths as a teacher combined with what will work
best with your students.
</p>
<p>
Another point that Katie made that I found refreshing had to do with
something she does with her classes. A good portion of a student's grade is
based on what she calls a "booster." Each student has to work one on
one with her on some project. The student either scores a 0 or a 100 -
the student keeps working with the direct support of the teacher until
it's perfect.
</p>
<p>
The important thing that Katie said with respect to this is "I can
do this because my largest class is sixteen students." No way could
this ever scale to a public school where a teacher can meet with over
150 students a day and barely has time eat lunch let alone
work one on one with a student in a suitably quiet place like an
office. The refreshing thing to hear was the acknowledgment of the
fact that what works in a rich private school won't work in a public
school.
</p>
<p>
All to often education and yes, CS Ed is driven by people who
really have no clue. They're anointed as thought leaders but they
don't walk the walk. Some have some knowledge and experience but many
don't. Until you've gotten a few years under your belt in a strap
cashed public school that takes all comers, don't tell them how they
should do it. Katie didn't - she acknowledged the problem - too bad so
many others don't.
</p>
<p>
I'm looking forward to watching the rest of the video during a future
workout and might have more to share then. For now, take a look for
yourself.
</p>
</div>
</div>Why Strong K12 Teacher Certification is Importanthttp://cestlaz.github.io/posts/strong-teacher-certification/2018-04-10T17:39:30-04:002018-04-10T17:39:30-04:00Mike Zamansky<div id="outline-container-org561132e" class="outline-2">
<h2 id="org561132e"></h2>
<div class="outline-text-2" id="text-org561132e">
<p>
About a week ago New York State's new regulation creating a <a href="http://www.crainsnewyork.com/article/20180327/NEWS/180329893/new-york-will-finally-have-certified-computer-science-teachers">K12 CS
teacher certification</a> went live. Just the other day I was honored to be
interviewed by <a href="https://twitter.com/mflamm_reporter">Matt Flamm</a> of Crain's New York in a <a href="http://www.crainsnewyork.com/article/20180410/TECHNOLOGY/180419999/asked-answered-teacher-changed-jobs-to-push-for-new-york-states-new">follow up piece</a>
about it.
</p>
<p>
Having K12 CS teacher certification is big and having quality programs
that lead to certification is <b>HUGE</b>. In my view, it's a game changer.
</p>
<p>
Let's Focus on high school, my wheelhouse.
</p>
<p>
From a course offerings point of view it's the wild west. I don't mean
this as a bad thing, it's just that there's a huge range of offerings
from AP to home brew, physical computing, game based, cyber security,
you name it, there's a curriculum. The long and short of this is that
schools need teachers to teach all of these experiences. Without a
strong certification pathway we're going to be stuck with the current
training based model where teachers are trained to deliver canned
curricula rather than truly teach. With strong teacher preparation
programs teachers will be prepared not only to deliver all the
existing curricula but, arguable more importantly design their own
learning experiences appropriate for the populations they work with.
</p>
<p>
This is important and alone would make having CS certification
worthwhile but to me the BIG win is that it creates a viable career
path.
</p>
<p>
People say we'll never find enough CS teachers because the tech
industry pays so well. I've never believed that. We find math teachers
even though many could flee to finance and chem teachers in spite of
big pharma's call so why can't we find CS teachers? Because we've
never provided a path into the profession and a viable career track.
</p>
<p>
Certification means that over time schools will be able to build CS
teachers and the discipline will be treated as the other
subjects. Prior to certification, a CS teacher might be cut if a
school's math department downsized. With certification, the career
track for a CS teacher is the same as the track for any other teacher.
</p>
<p>
It also means that young people starting out who are interested in
both teaching and computer science will have a way of getting into the
profession - something that has never before existed.
</p>
<p>
Having CS certification alone won't woo a
plethora of current tech professionals into teaching but over time,
we'll start to have CS Ed majors or CS majors pursuing CS ED Masters
degrees and entering the profession. This won't happen in a press or
election cycle but it will happen.
</p>
<p>
This all hinges on quality prep programs. I think I've hit the sweet
spot with what I've designed at Hunter. The critical components are of
course content and pedagogy. Teacher candidates must have both
sufficient depth and breadth in the subject and all the pedagogical
content knowledge that comes along with it. I don't agree with the
common approach of taking a course to teach a course - that is, having
courses like "APCS - Principles for teachers" or "APCS - A for
teachers." I want my teachers to be able to teach any reasonable
curriculum or design their own so we'll be rolling out courses that
examine the commonly offerd curricula but prepare teachers for a whole
lot more.
</p>
<p>
It's been an exciting week in NY CS Ed and there's a lot more to come.
</p>
</div>
</div>Refactoringhttp://cestlaz.github.io/posts/refactoring/2018-03-21T08:11:38-04:002018-03-21T08:11:38-04:00Mike Zamansky<div id="outline-container-org15eecc3" class="outline-2">
<h2 id="org15eecc3"></h2>
<div class="outline-text-2" id="text-org15eecc3">
<p>
One of my laments on teaching computer science is that students are
rarely taught and given the chance to develop good programming
practices. There's usually not enough time. Beginners work on small
"toys" which don't lend themselves to good software development
practices and later on, there's so much other material like
algorithms, data structures etc. to teach and
learn that programming practices usually amount to lines like:
</p>
<blockquote>
<p>
"Make sure to comment your code.."
</p>
<p>
"Indent properly…"
</p>
<p>
"Use functions…"
</p>
<p>
"It's important to test your code…"
</p>
</blockquote>
<p>
so when I see an opportunity to use a simple example to drive home a
good practice, I try to jump on it.
</p>
<p>
Drawing shapes with text is a typical early project. I've seen it in
text books and online and have been doing it for years. I recall doing
it back in the 80s in Fortran IV when the programs we wrote were on <a href="https://en.wikipedia.org/wiki/Punched_card">punch cards</a>, run
overnight on an <a href="https://en.wikipedia.org/wiki/IBM_1130">IBM 1130</a>, and printouts picked up the next day.
</p>
<p>
It's a nice use of nested loops. The students will write functions to
create assorted shapes out of asterisks like rectangles and
triangles. Typical solutions look like this:
</p>
<div class="highlight"><pre><span></span><span class="cp">#include</span> <span class="cpf"><iostream></span><span class="cp"></span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">box</span><span class="p">(</span><span class="kt">int</span> <span class="n">h</span><span class="p">,</span> <span class="kt">int</span> <span class="n">w</span><span class="p">){</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">r</span> <span class="o">=</span> <span class="s">""</span><span class="p">;</span>
<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">h</span><span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span> <span class="p">{</span>
<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">j</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">j</span> <span class="o"><</span> <span class="n">w</span><span class="p">;</span> <span class="n">j</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
<span class="n">r</span> <span class="o">=</span> <span class="n">r</span> <span class="o">+</span> <span class="s">"*"</span><span class="p">;</span>
<span class="p">}</span>
<span class="n">r</span> <span class="o">=</span> <span class="n">r</span> <span class="o">+</span> <span class="s">"</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">return</span> <span class="n">r</span><span class="p">;</span>
<span class="p">}</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">tri</span><span class="p">(</span><span class="kt">int</span> <span class="n">h</span><span class="p">){</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">r</span> <span class="o">=</span> <span class="s">""</span><span class="p">;</span>
<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">h</span><span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span> <span class="p">{</span>
<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">j</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">j</span> <span class="o"><</span> <span class="n">i</span><span class="p">;</span> <span class="n">j</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
<span class="n">r</span> <span class="o">=</span> <span class="n">r</span> <span class="o">+</span> <span class="s">"*"</span><span class="p">;</span>
<span class="p">}</span>
<span class="n">r</span> <span class="o">=</span> <span class="n">r</span> <span class="o">+</span> <span class="s">"</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">return</span> <span class="n">r</span><span class="p">;</span>
<span class="p">}</span>
</pre></div>
<p>
Which results in shapes like these:
</p>
<pre class="example">
| **** | | * |
| **** | | ** |
| **** | | *** |
| **** | | **** |
| **** | | |
| | | |
| | | |
| *************** | | * |
| *************** | | ** |
| *************** | | *** |
| *************** | | **** |
| *************** | | ***** |
| *************** | | ****** |
| *************** | | ******* |
</pre>
<p>
Then there will be more interesting shapes including things like:
</p>
<pre class="example">
* * *****
** *** * * and more
*** ***** * *
**** *** *****
*
</pre>
<p>
This is a great time to talk about refactoring. All of the shape
drawing functions follow the same pattern - there's an outer loop for
the height and then one or more inner loops to draw each line. We can
factor out the inner loops in to a separate <code>line()</code> function.
</p>
<div class="highlight"><pre><span></span><span class="cp">#include</span> <span class="cpf"><iostream></span><span class="cp"></span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">box</span><span class="p">(</span><span class="kt">int</span> <span class="n">h</span><span class="p">,</span> <span class="kt">int</span> <span class="n">w</span><span class="p">){</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">r</span> <span class="o">=</span> <span class="s">""</span><span class="p">;</span>
<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">h</span><span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span> <span class="p">{</span>
<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">j</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">j</span> <span class="o"><</span> <span class="n">w</span><span class="p">;</span> <span class="n">j</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span> <span class="c1">//</span>
<span class="n">r</span> <span class="o">=</span> <span class="n">r</span> <span class="o">+</span> <span class="s">"*"</span><span class="p">;</span> <span class="c1">// <----- This can be factored out</span>
<span class="p">}</span> <span class="c1">//</span>
<span class="n">r</span> <span class="o">=</span> <span class="n">r</span> <span class="o">+</span> <span class="s">"</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">return</span> <span class="n">r</span><span class="p">;</span>
<span class="p">}</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">tri</span><span class="p">(</span><span class="kt">int</span> <span class="n">h</span><span class="p">){</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">r</span> <span class="o">=</span> <span class="s">""</span><span class="p">;</span>
<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">h</span><span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span> <span class="p">{</span>
<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">j</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">j</span> <span class="o"><</span> <span class="n">i</span><span class="p">;</span> <span class="n">j</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span> <span class="c1">//</span>
<span class="n">r</span> <span class="o">=</span> <span class="n">r</span> <span class="o">+</span> <span class="s">"*"</span><span class="p">;</span> <span class="c1">// <---------------- along with this</span>
<span class="p">}</span> <span class="c1">//</span>
<span class="n">r</span> <span class="o">=</span> <span class="n">r</span> <span class="o">+</span> <span class="s">"</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">return</span> <span class="n">r</span><span class="p">;</span>
<span class="p">}</span>
</pre></div>
<p>
It's just like factoring in algebra:
</p>
<div class="LATEX">
<p>
</p>
<p>
(RectangleOuterLoop × Line) + (TriangleOuterLoop × Line) ⇒ Line (Rectangleouterloop × TriangleOuterloop)
</p>
</div>
<p>
We end up with:
</p>
<div class="highlight"><pre><span></span><span class="cp">#include</span> <span class="cpf"><iostream></span><span class="cp"></span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">line</span><span class="p">(</span><span class="kt">int</span> <span class="n">w</span><span class="p">,</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">c</span><span class="p">){</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">r</span> <span class="o">=</span> <span class="s">""</span><span class="p">;</span>
<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">w</span><span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span> <span class="p">{</span>
<span class="n">r</span> <span class="o">=</span> <span class="n">r</span> <span class="o">+</span> <span class="n">c</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">return</span> <span class="n">r</span><span class="p">;</span>
<span class="p">}</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">box</span><span class="p">(</span><span class="kt">int</span> <span class="n">h</span><span class="p">,</span> <span class="kt">int</span> <span class="n">w</span><span class="p">){</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">r</span> <span class="o">=</span> <span class="s">""</span><span class="p">;</span>
<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">h</span><span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span> <span class="p">{</span>
<span class="n">r</span> <span class="o">=</span> <span class="n">r</span> <span class="o">+</span> <span class="n">line</span><span class="p">(</span><span class="n">w</span><span class="p">,</span><span class="s">"*"</span><span class="p">)</span> <span class="o">+</span> <span class="s">"</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">return</span> <span class="n">r</span><span class="p">;</span>
<span class="p">}</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">tri</span><span class="p">(</span><span class="kt">int</span> <span class="n">h</span><span class="p">){</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">r</span> <span class="o">=</span> <span class="s">""</span><span class="p">;</span>
<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">h</span><span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span> <span class="p">{</span>
<span class="n">r</span> <span class="o">=</span> <span class="n">r</span> <span class="o">+</span> <span class="n">line</span><span class="p">(</span><span class="n">i</span><span class="p">,</span><span class="s">"*"</span><span class="p">)</span> <span class="o">+</span> <span class="s">"</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">return</span> <span class="n">r</span><span class="p">;</span>
<span class="p">}</span>
</pre></div>
<p>
It's simpler, cleaner, and also can lead us to thinking about the
"harder" shapes in an interesting way. Instead of looking at the right
justified triangle as a triangle, we can think of each level as two
lines - one of spaces (shown here as dashes) followed by a line of
stars:
</p>
<pre class="example">
----* *
---** **
--*** ***
-**** ****
***** *****
</pre>
<p>
Noticing that for a height of 5, the dashed lines count down in
length 4,3,2,1,0 and the star lines count up 1,2,3,4,5, we get:
</p>
<div class="highlight"><pre><span></span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">tri2</span><span class="p">(</span><span class="kt">int</span> <span class="n">h</span><span class="p">){</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">r</span> <span class="o">=</span> <span class="s">""</span><span class="p">;</span>
<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">h</span><span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span> <span class="p">{</span>
<span class="n">r</span> <span class="o">=</span> <span class="n">r</span> <span class="o">+</span> <span class="n">line</span><span class="p">(</span><span class="n">h</span><span class="o">-</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span><span class="s">"-"</span><span class="p">)</span> <span class="o">+</span> <span class="n">line</span><span class="p">(</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,</span><span class="s">"*"</span><span class="p">)</span> <span class="o">+</span> <span class="s">"</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">return</span> <span class="n">r</span><span class="p">;</span>
<span class="p">}</span>
<span class="kt">int</span> <span class="n">main</span><span class="p">()</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">r</span> <span class="o">=</span> <span class="n">tri2</span><span class="p">(</span><span class="mi">5</span><span class="p">);</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">r</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
</pre></div>
<p>
Here we have typical early CS assignment that really lends itself to
talking about structuring programs and refactoring. Where else can we
inject good programming practices in ways that make sense early on?
</p>
</div>
</div>Sigcse2018 Bootstrapworld on Creativity in CS classeshttp://cestlaz.github.io/posts/sigcse2018-bootstrap/2018-03-02T09:27:33-04:002018-03-02T09:27:33-04:00Mike Zamansky<div id="outline-container-org70bfbd0" class="outline-2">
<h2 id="org70bfbd0"></h2>
<div class="outline-text-2" id="text-org70bfbd0">
<p>
I really didn't know what to expect at the <a href="https://dl.acm.org/citation.cfm?id=3159471">Creativity, Customization,
and Ownership: Game Design in Bootstrap: Algebra</a> session. I've been a
big fan of <a href="http://www.bootstrapworld.org/">Bootstrep</a> for years and looking at the authors, <a href="http://blog.acthompson.net/2017/10/cs-teacher-interview-emmanuel.html">Emmanuel
Schanzer</a>'s been a freind forever. I've never met <a href="https://twitter.com/ShriramKMurthi">Shriram Krishnamurthi</a>
in person but am looking forward to it. We've traded emails and blog
comments. I'd like to consider him a friend and I certainly respect
him and his work even though we frequently disagree around the
edges. The third author and presenter, Kathi Fisler was new to me.
</p>
<p>
The Bootstrap program is embedded in algebra classes. In it, students
use Racket (nee scheme) to reinforce math skills while building
computer science skills. The big student project is a graphical game.
</p>
<p>
When designing the project, students are asked to decide on and find
four resources:
</p>
<ol class="org-ol">
<li>The background image</li>
<li>The player image</li>
<li>The target image</li>
<li>The enemy image</li>
</ol>
<p>
Students are given a short amount of time to decide on and find these
four images. I think it was about ten minutes and that's it. That's
all the "creativity" in the assignment. After that, all the students
are essentially creating the same game with different skins.
</p>
<p>
This design makes sense. You can't have students going all over the
place. Constraining the assignment in this way allows teachers who
might now be strong in computer science to guide the kids through the
program to completion.
</p>
<p>
At the time I was thinking: I really like all of this but is it really
open ended creativity and discovery with respect to math or computer
science? As it turned out, Fisler addressed this point at the end of
the talk in a way that made me vary happy.
</p>
<p>
Fisler went on to describe the rest of the student experience and then
went on to talk about the statistics they gathered.
</p>
<p>
One big takeaway was that while all the students were essentially
writing the same game varying only the graphical elements, this
encouraged students to create very different themes. They also created
rich stories around their games. The project might not have been
"creative" with respect to the CS or Math directions but it was certainly
creative in other important areas. The other takeaway was that
survey's indicated all sorts of positives from the program as a whole
so the project didn't seem to have suffered by having the students
essentially write the same program. Participants were proud of their
work, they felt their games were different from their peers and in
general the experience was good.
</p>
<p>
During questions, someone asked about adding a fifth element - a
projectile or missile. It turns out that at one point the program had a
projectile component but that led to the vast majority of projects to
be themed in very similar ways. Even though not the same, it reminded me to something Randy
Pausch said in his <a href="https://www.youtube.com/watch?v=ji5_MqicxSo">Last Lecture</a>:
</p>
<blockquote>
<p>
You make whatever you want. Two rules: no shooting violence and no
pornography. Not because I’m opposed to those in particular, but you know, that’s been done with
VR, right? [laughter] And you’d be amazed how many 19-year-old boys are completely out of ideas
when you take those off the table.
</p>
</blockquote>
<p>
At the very end, Fisler addressed my questions about creativity and
discovery. She posed these questions of her own: "Do we overstate the
case for creativity?" and "Is pure constructivism a win?"
</p>
<p>
I've ranted on contructivism before. It can be great but a
constructivist lesson takes a knowledgeable educator and a lot of time,
preparation, and effort. It's a big ask for, say, a high school
teacher who's already taking home hours of work every evening. Too
often I've seen the following "contructivist" model instead:
</p>
<ul class="org-ul">
<li>Take an isntructor that doesn't know their craft, the content, or
niether.</li>
<li>Let the kids play with stuff.</li>
<li>Show off the couple of autodidacts that figure it out as success
stories.</li>
</ul>
<p>
I'll rant more about this "model" with respect to the new buzz word
"lead learner" at some point in the future.
</p>
<p>
On the creativity side, it's important but there are also times for
the instructor to lead and for guidelines to be followed.
We want to foster creativity but that doesn't mean that it's 100%
creativity 100% of the time. Education is like life, a balance. The
Bootstrap program had to constrain the CS and math learning but
allowed for creativity in other areas. It's smart and it's a win.
</p>
<p>
I still want to meet Shriram in person one day and now also Kathi
Fisler. I didn't know what to expect walking in but I left the talk
reminded of why I'm such a fan of Emmanuel, his team, and their work.
</p>
</div>
</div>Tools can shape how we thinkhttp://cestlaz.github.io/posts/advent-2016-6-4/2017-12-06T16:01:15-04:002017-12-06T16:01:15-04:00Mike Zamansky<div id="outline-container-orgc46ef18" class="outline-2">
<h2 id="orgc46ef18"></h2>
<div class="outline-text-2" id="text-orgc46ef18">
<p>
I've been having fun with this years <a href="http://adventofcode.com">Advent of Code</a> competition. So
far, I've been able to keep up but with I expect that to change in
another couple of days since I'll be traveling for the weekend.
</p>
<p>
After solving a problem, I like looking over some of the other
solutions on the Advent of Code <a href="https://www.reddit.com/r/adventofcode/">subreddit</a>. Even with similar
agorithmic solutions there's a decent amount of variation in the
actual code and solutions in different languages can look radically
different.
</p>
<p>
That got me thinking about how the tools we know and use both shape the ways we
approach solving problems and creating things and either limit or
empower us to go from a mental model of a solution or creation to an
actual artifact.
</p>
<p>
Relating to this are the common themes that come up in the CS
Education world. The idea that it's computer science not programming
and certainly not merely coding. That's true but the tools and
languages we use shape the whole thinking part and can also give the
students a valuable practical tool that they can leverage to great
advantage in both future classes and work and life endeavors.
</p>
<p>
I decided to do this rant as a video. I hope you enjoy it:
</p>
<iframe width="560" height="315" src="https://www.youtube.com/embed/x8cZgEogWNw" frameborder="0" gesture="media" allow="encrypted-media" allowfullscreen></iframe>
</div>
</div>Thoughts On A Hackathonhttp://cestlaz.github.io/posts/thoughts-on-a-hackathon/2017-12-03T08:47:34-04:002017-12-03T08:47:34-04:00Mike Zamansky<div id="outline-container-orgf073655" class="outline-2">
<h2 id="orgf073655"></h2>
<div class="outline-text-2" id="text-orgf073655">
<p>
Yesterday I was one of the judges at <a href="http://stuyhacks.com/">StuyHacks</a>. A one day hackathon at
Stuyvesant run by and organized by the students. I don't have attendee
stats but there were kids from all over the city and at least one team
from New Jersey. The youngest student that I met was in sixth grade
and the oldest were high school seniors. The judging was at the end
but I decided to stop by earlier to see how the hackers were doing.
</p>
<p>
There was an incredible variety of projects using a wide array of
tools. There were projects built with:
</p>
<ul class="org-ul">
<li>Java</li>
<li>Processing</li>
<li>C#</li>
<li>Scratch</li>
<li>A-Frame</li>
<li>Python / Flask</li>
<li>HTML/CSS/JS</li>
<li>and more</li>
</ul>
<p>
A personal highlight for me was running into Sophie - the daughter of
two of my students from #Stuy95. Well, both a highlight and a reminder
that I'm getting old.
</p>
<p>
The StuyHacks team did a terrific job running things and at the end I
told them I'd love to help with future events.
</p>
<p>
I did notice a couple of things at the hackathon that echo things I've
learned as a teacher over the years and I thought they were worth
sharing.
</p>
<p>
The first was the a number of the beginner groups needed more
direction. This didn't seem to be related to grade level or age as
much as CS experience. This isn't a hackathon only issue. It exists in
all learning environments. If as teachers we're too prescriptive
students end up with a single formula to follow. Sure, that'll get
them through a standardized exam like APCS-A but too much of it can
hinder them in becoming creative problem solvers.
</p>
<p>
On the other hand, not enough structure will leave many kids staring
at a blank page. I remember I gave a quiz years ago. It had one
problem: "You have 20 minutes to prove to me that you learned
something about the past unit on Cellular Autmata" or something like
that. Some kids absolutely loved it but many hated it. Stuy kids are
trained test takers. They're prepared for structure. This threw many
for a loop.
</p>
<p>
I noticed this issue with some of the hackers at StuyHacks. Some
beginners really had a hard time figuring out what they could do and
what they should do.
</p>
<p>
A hackathon isn't a classroom so I think the problem is pretty easily
remedied. Groups that were able to latch on to a good mentor seemed to
get the guidance they needed. A beginners hackathon should make sure
they have not only plenty of mentors but they should make sure that
the mentors are prepped with a number of project ideas in a number of
the standard beginner platforms. A hackathon could also provide an
assortment of ideas in a list.
</p>
<p>
The second thing I noticed was at the end of the day as I was
judging. It started with one particular group. They were pretty
apologetic about their project. Basically because it wasn't
finished. Personally, I thought what they accomplished in essentially
7 hours was pretty impressive. What became clear as we talked is that
this group was deathly afraid of failure. Their deepest fear at that
moment was that I was going to give them high marks and they might
have to show off their incomplete (yet rather impressive) project to a
room full of strangers.
</p>
<p>
This fear of failure was prevalent in groups that ultimately didn't
submit their projects for judging and it seemed to be common among
students from high performing, high expectation schools where
frequently one associates a test score or grade with ones value. I'm
not happy to say that Stuy has always had this problem.
</p>
<p>
This isn't really a problem that a hackathon can or should be able to
address. It's just something I noticed. It's a problem for schools and
also for a society that's test obsessed.
</p>
<p>
I hope nobody reads too much into these observations. The day was a
tremendous success. A whole bunch of kids had a great day working
together to build cool things with technology. Congratulations to the
StuyHacks team. They did a terrific job putting it all together. If
you're a middle or high school student or know one, keep an eye on the
StuyHacks <a href="http://stuyhacks.com/">web page</a> and make sure to attend their next event.
</p>
</div>
</div>Early Interesting Problems - Happy Ladybugshttp://cestlaz.github.io/posts/happy_ladybug/2017-10-23T08:47:46-04:002017-10-23T08:47:46-04:00Mike Zamansky<div id="outline-container-orgfb597d3" class="outline-2">
<h2 id="orgfb597d3"></h2>
<div class="outline-text-2" id="text-orgfb597d3">
<p>
We all love interesting problems. The trouble is that it's hard to
find suitably interesting problems for students when they're just
learning the basics. In the very beginning the problems practically
dictate the solution:
</p>
<ul class="org-ul">
<li>loop over a list and add all the elements or calculate the sum of a
list of integers.</li>
<li>Determine if number is prime</li>
<li>Convert a word into pig-Latin</li>
</ul>
<p>
It's not that there's no thought involved in solving these but the
students already know the mechanics of solving these by hand so it's a
direct translation into a program.
</p>
<p>
This isn't a bad thing and it is important but it's fun when we get to the next
level. I've found that a number of the <a href="http://hackerrank.com">Hacker Rank</a> archived
competitions have "easy" problems that can be a good fit for
beginners. One that I found and really like is <a href="https://www.hackerrank.com/challenges/happy-ladybugs">Happy Ladybugs</a> problem.
</p>
<p>
The problems is basically as follows:
</p>
<p>
You get a string of letters. Each letter represents a ladybug of a
different color. Each letter also represents a location of the
ladybug. A space (or underscore in the actual problem) represents a
free space. For example "AABC DDA" is a line of 2 A colored ladybugs
followed by a B colored one, C colored one, a blank space, 2 D colored and then one
more A colored.
</p>
<p>
You can rearrange the line of ladybugs by swapping any ladybug with a
blank space.
</p>
<p>
A ladybug is happy if it is next to another ladybug of the same
color. The challenge is to determine if all the ladybugs can be made
happy.
</p>
<p>
I like this problem because while it is non-trivial it is very
approachable.
</p>
<p>
To me, the key is that while you can rearrange the list you
don't have to. You only have to determine if it is possible to make
the ladybugs happy. You don't actually have to do so.
</p>
<p>
The edge cases are pretty easy to deal with - a string of length one
or two but then a little thought is required.
</p>
<p>
The first insight is that if there are no spaces, you can't rearrange
the ladybugs so all you have to do is scan through the string to test
to see if every ladybug has a neighbor of the same color.
</p>
<p>
The next insight, and the big one is that if you have at least one
space you can arbitrarily re-order the string. You can show this is
possible by using a single space to swap any two elements.
</p>
<div class="highlight"><pre><span></span><span class="n">space</span> <span class="o">=</span> <span class="n">someletter</span>
<span class="n">someletter</span> <span class="o">=</span> <span class="n">someotherletter</span>
<span class="n">someotherletter</span> <span class="o">=</span> <span class="n">space</span>
</pre></div>
<p>
The final insight is that since you can arbitrarily re-order the
ladybugs as long as you have at least 2 of each color, you can make
them all happy.
</p>
<p>
Since my class is currently just starting dictionaries in Python we
solved this with lists and then transitioned to dictionaries.
</p>
<p>
Here's a dictionary based solution:
</p>
<div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">are_happy</span><span class="p">(</span><span class="n">s</span><span class="p">):</span>
<span class="sd">'''</span>
<span class="sd"> This might miss some of the real edge cases in the hackerrank</span>
<span class="sd"> problem. I haven't read the problem carefully in over a year and </span>
<span class="sd"> forget what it specified for things like lists of only spaces,</span>
<span class="sd"> lists with only one bug etc.</span>
<span class="sd"> Also, the Hackerrank question uses an underscore (_) instead of a space.</span>
<span class="sd"> '''</span>
<span class="c1"># handle a string of less than 2 ladybugs</span>
<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">s</span><span class="p">)</span><span class="o"><</span><span class="mi">2</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">False</span>
<span class="c1"># handle the string of 2 ladybugs - both must be the same and not a space</span>
<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">s</span><span class="p">)</span><span class="o">==</span><span class="mi">2</span><span class="p">:</span>
<span class="k">return</span> <span class="n">s</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">==</span><span class="n">s</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="ow">and</span> <span class="n">s</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">!=</span> <span class="s1">' '</span>
<span class="c1"># handle the case of no spaces </span>
<span class="k">if</span> <span class="n">s</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="s1">' '</span><span class="p">)</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span>
<span class="c1"># no spaces, every item must be next to one of the same color</span>
<span class="c1"># so we loop from 1 to len-1 and for each item</span>
<span class="c1"># check the one before and the one after</span>
<span class="c1"># if we ever have an unhappy bug, we can just return False</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="nb">len</span><span class="p">(</span><span class="n">s</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">):</span>
<span class="k">if</span> <span class="n">s</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">!=</span> <span class="n">s</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">]</span> <span class="ow">and</span> <span class="n">s</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">!=</span> <span class="n">s</span><span class="p">[</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">]:</span>
<span class="k">return</span> <span class="bp">False</span>
<span class="c1"># if we ever get here every bug has at least one neighbor of the same color</span>
<span class="k">return</span> <span class="bp">True</span>
<span class="c1"># if we get here it means there's at least one space so we can rearrange the bugs</span>
<span class="c1"># however we please so as long as there are at least 2 bugs of each color</span>
<span class="c1"># we can make them all happy</span>
<span class="c1"># replace the spaces with "" since we don't want to count them</span>
<span class="c1"># Since we know they were in the string we can rearrange but</span>
<span class="c1"># they're no longer needed</span>
<span class="n">s</span> <span class="o">=</span> <span class="n">s</span><span class="o">.</span><span class="n">replace</span><span class="p">(</span><span class="s2">" "</span><span class="p">,</span><span class="s2">""</span><span class="p">)</span>
<span class="c1"># tally up all the bugs to see if there are at least 2 of each</span>
<span class="n">bugcounts</span> <span class="o">=</span> <span class="p">{}</span>
<span class="k">for</span> <span class="n">bug</span> <span class="ow">in</span> <span class="n">s</span><span class="p">:</span>
<span class="n">bugcounts</span><span class="o">.</span><span class="n">setdefault</span><span class="p">(</span><span class="n">bug</span><span class="p">,</span><span class="mi">0</span><span class="p">)</span> <span class="c1"># set to 0 the first time we see this key</span>
<span class="n">bugcounts</span><span class="p">[</span><span class="n">bug</span><span class="p">]</span><span class="o">=</span><span class="n">bugcounts</span><span class="p">[</span><span class="n">bug</span><span class="p">]</span><span class="o">+</span><span class="mi">1</span>
<span class="n">counts</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">bugcounts</span><span class="o">.</span><span class="n">values</span><span class="p">())</span>
<span class="c1"># if there is any value of 1 in the counts then there's a lone ladybug</span>
<span class="c1"># that can't be made happy</span>
<span class="c1"># so we return True (happy) if there are 0 counts of 1 in our list </span>
<span class="k">return</span> <span class="n">counts</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="o">==</span> <span class="mi">0</span>
<span class="n">bugs</span><span class="o">=</span><span class="s2">"abaccbe ff eggggggg"</span>
<span class="k">print</span><span class="p">(</span><span class="n">bugs</span><span class="p">)</span>
<span class="n">are_happy</span><span class="p">(</span><span class="n">bugs</span><span class="p">)</span>
</pre></div>
<p>
I love problems like these.
</p>
<p>
I just wish there was an easy way to find all contest problems of a
certain level like "easy" or "medium." If anybody knows please share
in the comments.
</p>
</div>
</div>Programming Idiomshttp://cestlaz.github.io/posts/programming-idioms/2017-10-08T11:51:46-04:002017-10-08T11:51:46-04:00Mike Zamansky<div id="outline-container-orge6d4598" class="outline-2">
<h2 id="orge6d4598"></h2>
<div class="outline-text-2" id="text-orge6d4598">
<p>
I just read Jeff Yearout's recent post titled <a href="http://k12csteaching.blogspot.com/2017/10/the-beginners-garden-of-concepts.html">The Beginner's Garden of
Concepts</a>. Not directly related but it got me thinking about
programming idioms.
</p>
<p>
I've been using the phrase "programming idiom" for years to describe a
short useful recurring code construct. I didn't realize that it was
officially "a thing" until doing a web search on the phrase years
later.
</p>
<p>
As our students grow from newbies on I think it's helpful for them to
see recurring and related patterns and programming idioms gives us a
name to apply to many beginner patterns. An early idiom might be
"finding the smallest in a list:"
</p>
<div class="highlight"><pre><span></span><span class="n">dataset</span> <span class="o">=</span> <span class="p">[</span><span class="mi">5</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">8</span><span class="p">,</span><span class="mi">12</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">7</span><span class="p">]</span>
<span class="n">min_index</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="nb">len</span><span class="p">(</span><span class="n">dataset</span><span class="p">)):</span>
<span class="k">if</span> <span class="n">dataset</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o"><</span> <span class="n">dataset</span><span class="p">[</span><span class="n">min_index</span><span class="p">]:</span>
<span class="n">min_index</span> <span class="o">=</span> <span class="n">i</span>
</pre></div>
<p>
Another is the very similar and more general "do something on every
item in a list:"
</p>
<div class="highlight"><pre><span></span><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">dataset</span><span class="p">)):</span>
<span class="c1"># do something to or with dataset[i]</span>
</pre></div>
<p>
By talking about constructs like these as idioms it helps students see
and develop coding patterns. It also helps them to build mental
abstractions. Each of the above idioms are a few lines of code but
each are also a single concept. Students learn to think of them as the
concept.
</p>
<p>
When students learn about list comprehensions in python they'll
rewrite the "do something…" more like this:
</p>
<div class="highlight"><pre><span></span><span class="p">[</span> <span class="n">f</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="n">dataset</span><span class="p">]</span>
</pre></div>
<p>
but the pattern or idea is the same.
</p>
<p>
Other early idioms might include swapping variables:
</p>
<div class="highlight"><pre><span></span><span class="n">tmp</span> <span class="o">=</span> <span class="n">a</span>
<span class="n">a</span> <span class="o">=</span> <span class="n">b</span>
<span class="n">b</span> <span class="o">=</span> <span class="n">tmp</span>
</pre></div>
<p>
and loops until an exit condition are met:
</p>
<div class="highlight"><pre><span></span><span class="k">while</span> <span class="p">(</span><span class="n">not_exit_condidtion</span><span class="p">):</span>
<span class="c1"># do stuff</span>
<span class="n">modify</span> <span class="n">variable</span> <span class="n">that</span> <span class="n">checks</span> <span class="nb">exit</span> <span class="n">condition</span>
</pre></div>
<p>
Even more difficult concepts like recursion can be described in an
idiomatic way:
</p>
<div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">f</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
<span class="k">if</span> <span class="n">BASE_CASE</span><span class="p">:</span>
<span class="k">return</span> <span class="n">something</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">new_x</span> <span class="o">=</span> <span class="n">modify_to_eventually_get_to_base_case</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="n">f</span><span class="p">(</span><span class="n">new_x</span><span class="p">)</span>
</pre></div>
<p>
Patterns like these, or idioms, come up over and over again. We don't
have to explicitly mention them in our teaching but I think it's
helpful to our students if we do.
</p>
</div>
</div>New Term New Tool - Thonny, a Python IDEhttp://cestlaz.github.io/posts/new-tool-thonny/2017-09-21T07:31:42-04:002017-09-21T07:31:42-04:00Mike Zamansky<div id="outline-container-org0281270" class="outline-2">
<h2 id="org0281270"></h2>
<div class="outline-text-2" id="text-org0281270">
<p>
Last year I <a href="https://cestlaz.github.io/posts/new-term-new-tool-replit">wrote about</a> <a href="http://repl.it">repl.it</a>, an online IDE that supports multiple
languages. At the time it had some rudimentary classroom support and
since I started using it, repl.it has become better and better. I
used it last year with my class because I had to start the year in a
lab where I couldn't easily install my own software. I'll continue to
use repl.it - mostly for it's ability to schedule publish and manage
assignments but when possible, I like having my students work
locally.
</p>
<p>
This year I'm excited about another tool - <a href="http://thonny.org">Thonny</a>. Thonny's a simple
Python IDE designed for beginners. I discovered it last year but at a
time when it was impractical for me to use with my students. This
year I can and I'm really liking it. I'm still an Emacs guy and will
continue to use Emacs for my python development (<a href="http://cestlaz.github.io/posts/using-emacs-12-python/">video 1</a>, <a href="http://cestlaz.github.io/posts/using-emacs-13-yasnippet">video 2</a>) but
for beginners I think Thonny is the way to go.
</p>
<p>
Some of Thonny's highlights:
</p>
<ul class="org-ul">
<li>An integrated Python 3 virtual environment making for ease of
installation and consistency across student installs</li>
<li>A debugger that shows how expressions are evaluated</li>
<li>Great visualizations of function calls that make it easier to
understand the call stack and scope</li>
<li>The ability to look at memory to understand references.</li>
</ul>
<p>
Rather than go into the gory details in text, I put together this
video:
</p>
<iframe width="560" height="315" src="https://www.youtube.com/embed/lWaCl0WjNZI" frameborder="0" allowfullscreen></iframe>
</div>
</div>Theseus's Curriculumhttp://cestlaz.github.io/posts/theseus%27s-curriculum/2017-09-05T18:41:14-04:002017-09-05T18:41:14-04:00Mike Zamansky<div id="outline-container-org2b56664" class="outline-2">
<h2 id="org2b56664"></h2>
<div class="outline-text-2" id="text-org2b56664">
<p>
With the school year starting I was originally planning on writing
about my class rules.
</p>
<p>
Instead I think I'll riff on <a href="https://twitter.com/alfredtwo">Alfred Thompson</a>'s post today titled
<a href="http://blog.acthompson.net/2017/09/curriculum-is-hard.html">Curriculum is Hard</a>. I'm guessing I found curriculum design and
development daunting decades ago but at this point in my career it's
something I enjoy. In any event, Alfred got me to thinking - when is a
curriculum your own?
</p>
<p>
If you grab a curriculum complete with lesson plans, assignments; the
whole kit and caboodle and you use it verbatim it's clearly not your
curriculum. It probably also isn't really teaching.
</p>
<p>
What about the more common case. Math curricula has basically been set
for years. Algebra, Geometry <sup><a id="fnr.1" class="footref" href="http://cestlaz.github.io/posts/theseus%27s-curriculum/#fn.1">1</a></sup>, and then Algebra 2
and Trigonometry. Most books seem to be sequenced in a similar way
and at least in the schools I know about, the math department has some
document listing a day by day list of topics. This makes sense since
you probably have more than one class of each type and you want some
cross class consistency. Particularly during the first weeks of the
semester when kids can transfer and then also at the end of term or
year.
</p>
<p>
When a teacher uses that departmental document are they using someone
elses curriculum?
</p>
<p>
What if they create their own homeworks and assigments?
</p>
<p>
Most teachers I know use the department's curriculum but make their
own unit and day to day lesson plans. Most revise them each
semester. Typically these teachers do a little more here or a little
less there depending on a number of factors.
</p>
<p>
Are they creating their own curriculum?
</p>
<p>
What if they re-sequence the topics?
</p>
<p>
How about adding an enrichment topic?
</p>
<p>
Back when I taught math I used the departmental syllabus, as many
texts as I could find, colleagues lesson plans and whatever I could
find but I always pulled it together to something I could call my
own. If I didn't, I wouldn't have been comfortable going in front of
my class. Was it my curriculum? They were certainly my lessons.
</p>
<p>
Now, when designing a course I start from the end outcomes and work
backwards but when teaching a course, I still look at as many
resources as I can find. I'll pull a little from here, a little from
there and combine that with whatever I can come up with myself.
</p>
<p>
So, when is it your curriculum and when is it not?
</p>
<p>
If you're just delivering scripted lessons it's certainly not yours.
</p>
<p>
If you know your stuff and you take someone elses material, make it
your own and add it to your bag of tricks, I think it's now yours as
well.
</p>
</div>
</div>
<div id="footnotes">
<h2 class="footnotes">Footnotes: </h2>
<div id="text-footnotes">
<div class="footdef"><sup><a id="fn.1" class="footnum" href="http://cestlaz.github.io/posts/theseus%27s-curriculum/#fnr.1">1</a></sup> <div class="footpara">which is really logic and deductive
reasoning using Euclidean Geometry as platform</div></div>
</div>
</div>Teaching APCS-A for the first timehttp://cestlaz.github.io/posts/teaching-ap-first-time/2017-08-23T15:56:46-04:002017-08-23T15:56:46-04:00Mike Zamansky<div id="outline-container-orgbbdb472" class="outline-2">
<h2 id="orgbbdb472"></h2>
<div class="outline-text-2" id="text-orgbbdb472">
<p>
I got an email from a friend the other day. Among other things, he
mentioned that he would be teaching APCS-A for the first time this
year. He's a little trepidatious. He knows his stuff but he hasn't
really done much using Java.
</p>
<p>
I was going to respond in an email but thought I might share here
instead.
</p>
<blockquote>
<p>
TL;DR - for all you APCS teachers who are new or new to Java - learn
your core CS, lean on your resources and support and it's OK to tell
your kids "I don't know, I'll get back to you.". Don't worry, you'll be great.
</p>
</blockquote>
<p>
The first time I taught APCS was some time around 1991 or 1992. It was at
<a href="http://www.sewardparkhs.com/Famous-Alumni/">Seward Park</a> <a href="http://www.sewardparkhs.com/History/">High School</a>. It was the AB curriculum - that is one
semester of programming in Pascal and one semester of Data Structures
and Algorithms. Being a computer science major the core material was
never a concern. I had taken APCS the first time it was offered in May
1984 in Pascal and while most of my college and pre-teaching professional work
was in C, my college started it's CS sequence with Pascal. I was more
concerned with the actual teaching part. I had taught math for a year
and a half at that point but never CS and by any measure I was still
wet behind the ears. I never finished that first experience because I
was excessed to Stuy mid semester. I wasn't particularly happy with my
performance but looking back, I think I did a pretty good job given
the situation and my experience.
</p>
<p>
After teaching math for a year and a half I was back in APCS at
Stuy. Still in Pascal. I spent the next few years figuring out how to
teach CS and APCS in particular along with starting a couple of new
classes. When the College Board decided to move the AP class to C++ I
was happy, sad and a little worried. Pascal had a bunch of limitations
but I had never used C++. True, I was a C programmer at heart but I
had never really done the OOP thing. I did, as it turned out, design a
number of my C systems in an Object Typed design: I would use a single
file per "class" where local variables were de facto instance
variables and functions in the file were methods and each file was a
singleton class. I read <a href="https://www.amazon.com/Object-Oriented-Analysis-Design-Applications-3rd/dp/020189551X/ref=sr_1_1?ie=UTF8&qid=1503519770&sr=8-1&keywords=Grady+Booch">Booch</a> and <a href="https://www.amazon.com/Object-Oriented-Software-Construction-Book-CD-ROM/dp/0136291554/ref=asap_bc?ie=UTF8">Meyer</a> on my own but I had no
schooling in OOP and no professional experience.
</p>
<p>
As it turned out, I didn't have to worry. I knew my CS and while it
took me a while to become comfortable with OOP, the class, and of
course I knew this from the get go, started from nothing and built
up complexity a step at a time. The worst that might have happened is
that some of my solutions might have been more C-esque than C++.
</p>
<p>
The move to Java was a little more jarring. Now we had a totally new
language. I couldn't fall back on C. It removed memory management and
explicit pointers and it had to be used in an Object Oriented
manner. I remember asking Mike Schidlowsky, a former student turned
friend who was the Java consultant on the Java edition of Sedgewick's
<a href="https://www.amazon.com/Robert-Sedgewick-Algorithms-Fundamentals-Structures/dp/B008VR3ZH4/ref=sr_1_4?ie=UTF8&qid=1503520269&sr=8-4&keywords=schidlowsky">Algorithms</a> book how to do something. It had to do with passing and
modifying arrays. In C there were a number of ways to accomplish what
I wanted to do. In Java, I couldn't figure out how to do it the way I
wanted. My friend Mike told me "you just don't do it that way in
Java." Again, it turned out that I didn't have to worry. The basic
coding was still the same as were the data structures and
algorithms. The only challenge was that I had to get into a Java OOP
mindset which it turned out wasn't that hard.
</p>
<p>
While I never really warmed up to OOP - I find other paradigms more
natural for me, I knew my CS and got more and more comfortable with
the Java (or C++) way of doing things as time wore on. Sometimes I
would say "I don't know" or "let's figure it out" but that's OK.
</p>
<p>
Nowadays, there are many more resources available for CS teachers. If
you're new, lean on them. Use the mailing lists, stackexchange,
facebook groups. Online resources like repl.it, codehs.com etc. Yes,
it's true that you'll be better next time around and even better years
down the road but right now, you're probably better than you think.
</p>
<p>
A number of my former students volunteer for <a href="https://www.tealsk12.org/">TEALS</a> - a really great
program that brings software engineers into the classroom to work with
non-CS teachers to deliver instruction. A number of my kids have
shared the following sentiment:
</p>
<blockquote>
<p>
</p>
<p>
I don't know if I'm really helping
the teacher to become self sufficient or if I'm a great teacher but I
do know one thing - while I'm there, the kids are getting a hell of a
lot more than if I wasn't there."
</p>
</blockquote>
<p>
– Remember that as well.
</p>
</div>
</div>Three strikes and you're out or third time's a charmhttp://cestlaz.github.io/posts/three-times/2017-07-21T17:38:19-04:002017-07-21T17:38:19-04:00Mike Zamansky<div id="outline-container-orga86917b" class="outline-2">
<h2 id="orga86917b"></h2>
<div class="outline-text-2" id="text-orga86917b">
<p>
<a href="https://twitter.com/CompSci4All/with_replies?lang=en">Brenda Wilkerson</a>, Director of CS and IT education for Chicago public
schools was one of the keynote speakers at this year's CSTA
conference. During her talk, she made a comment about it taking three
times through to get it right so if you're working hard and struggling
in your first year of teaching CS, it's not the time to give
up. Learning to teach takes time.
</p>
<p>
She's absolutely correct. I saw this in myself and I've seen this in
many other young teachers. First year through, your job is to
survive. This is when you rely on colleagues lesson plans, it you can
you shadow another teacher and in general do your best to give what
you can to your students while making it through the semester.
</p>
<p>
Then, I often see something interesting. Year two is frequently a step
back. It was for me and I've seen this in many young teachers in many
subject areas. I'm guessing this happens because we feel we have a
year under our belt and then we overreach while trying to be
innovative and more effective.
</p>
<p>
In year three things start to improve again and then, if the teacher
continues to work at their craft, there's steady progress for years to
come. At the point, the teachers seem to better understand how to
experiment and grow as a teacher in a safer way while also
understanding that it's OK to have a bad day or even a bad unit -
there's usually time to recover.
</p>
<p>
It's also interesting that while this progression is most obvious in
new teachers it also seems to take place with experienced teachers
teaching new courses.
</p>
<p>
All this means that teaching CS or any new subject takes time, effort,
and patience. It means young teachers shouldn't beat themselves up and
that supervisors need to be supportive and give the time and resources
to allow teachers to succeed.
</p>
<p>
It also means that schools with high teacher churn - notably charter
chains create environments that are anything but conducive to allowing
society to build a cadre of expert teachers. It works for these
charter chains because they're exploiting the fact that they require a
small number of teachers as compared to large urban public schools so
can burn through teachers like gasoline and the fact that they're
judged only by standardized tests. The model is not sustainable if
privatizers get their wish and charters become the national norm.
</p>
<p>
Finally, it's another reason for people to wise up to "leadership"
programs like Teach for America where candidates come in for a couple
years before moving on to "better" opportunities.
</p>
<p>
So, if the third time's a charm, how about the flip side? After how long
a period of time should we expect CS teachers to really know their
subject area? I'd say three years is also probably right. Year one,
the teacher is just surviving but after that, I'd expect a teacher to
want to master their subject. When I taught math early on in my
career, I felt overmatched. Particularly at Stuyvesant. I was a CS
major, not a math major. What did I do? I sat in on colleagues
classes and did self study over the summer. Of course by the time I
got up to speed, at least to my standards, I was teaching compute
science.
</p>
<p>
So, if you're a new CS teacher, why not take CS101 and data structures
over the summer instead of doing another scripted PD? Between local
and community colleges, at least in urban areas, this shouldn't be
a problem.
</p>
<p>
So, is third time a charm? Three strikes and you're out? A bit of
both?
</p>
<p>
We have to give our new CS teachers the time and support to learn to
teach and to learn the subject area but at the same time, I think it's
reasonable to require that they do so given the resources.
</p>
</div>
</div>Observing CS Teachershttp://cestlaz.github.io/posts/cs-teacher-eval/2017-07-15T20:13:38-04:002017-07-15T20:13:38-04:00Mike Zamansky<div id="outline-container-org4a20c8e" class="outline-2">
<h2 id="org4a20c8e"></h2>
<div class="outline-text-2" id="text-org4a20c8e">
<p>
Another set of tweets god me thinking:
</p>
<blockquote class="twitter-tweet" data-lang="en"><p lang="en" dir="ltr">How do we help school administrators help and evaluate CS
teachers? asks <a href="https://twitter.com/lsudol">@lsudol</a> of <a href="https://twitter.com/CSForAll">@CSForAll</a> <a href="https://twitter.com/hashtag/csta2017?src=hash">#csta2017</a>
Many don't understand CS</p>— Alfred Thompson (@alfredtwo)
<a href="https://twitter.com/alfredtwo/status/884427047635795969">July
10, 2017</a></blockquote> <script async src="//platform.twitter.com/widgets.js" charset="utf-8"></script>
<blockquote class="twitter-tweet" data-lang="en"><p lang="en" dir="ltr">If the current system is any indication, checklists are not
the answer</p>— Mike Zamansky (@zamansky) <a href="https://twitter.com/zamansky/status/886220912110043136">July 15,
2017</a></blockquote> <script async src="//platform.twitter.com/widgets.js" charset="utf-8"></script>
<p>
I get the intent. CS teachers should be evaluated by people who have
some clue about the subject. Leigh Ann's reporting that some people
are working on checklists got me wondering if it really matters? Sure,
it matters if teacher observations were actually set up to improve
instruction but given what we have in NY does it really?
</p>
<p>
In New York City, teacher observations are a major part of a teacher's
annual rating and the other part is still <a href="https://cestlaz.github.io/posts/2013-09-06-why_i_might_no_longer_be_an_effective_teacher.md/#.WWqzc9_6yEI">that standardized test
nonsense</a>. Teachers are observed at least 4 and commonly 6 times
or more per year. There might be pre and
post observation conferences.
</p>
<p>
Sounds good but the system is amazingly flawed.
</p>
<p>
To start, the DOE uses the <a href="http://schools.nyc.gov/NR/rdonlyres/8A4A25F0-BCEE-4484-9311-B5BB7A51D7F1/0/TeacherEffectivenessProgram1314Rubric201308142.pdf">Danielson Framework</a> which provides a basis
for teacher evaluation. The framework is at best <a href="https://tedmorrissey.wordpress.com/2014/03/23/fatal-flaws-of-the-danielson-framework/">flawed</a> with even
Danielson coming out to say <a href="https://tedmorrissey.wordpress.com/2016/04/27/danielson-framework-criticized-by-charlotte-danielson/">it's being misused</a>. Of course I'm sure she
protested all the way to the bank. A teacher can be a "Danielson
style" teacher and be great but a teacher can also check all
the Danielson boxes and be mediocre at best. Likewise, some of the
best teachers I know break the Danielson mold and if a supervisor
rigidly adheres to the framework these great teachers would be found
ineffective.
</p>
<p>
To make matters worse, the rubric is so large that the DOE just
focuses on small parts which means even if the framework was
comprehensive and correct, teachers are only evaluated on a small
part.
</p>
<p>
When a supervisor evaluates a teacher, they have a checklist with the
rubric where they can rate a teacher 1 (ineffective), 2 (developing),
3 (effective), and 4 (highly effective) and write down some notes.
</p>
<p>
I guess the hope was to have some consistency but the truth is the
process is very subjective. I know a supervisor who gave a teacher a
ratings of 2 (which is basically failing) for the professional
development category even though the teacher fulfilled all contractual
obligations and then some. There are also supervisors who won't give a
rating of 4 out of principle. On the other side, I've met supervisors
loathe to give low scores.
</p>
<p>
The tweets at the top of this post refer to the current situation
where CS teachers are never observed and evaluated by supervisors who
are knowledgeable about CS. Even if someone designs a checklist -
something I'm skeptical about given the fact that there are so few
people strong in CS, experienced as teachers and with an eye for
teacher evaluation out there, if the application of the Danielson
framework is any indication, a CS checklist won't help.
</p>
<p>
Besides, CS won't be any different from any other subject. Since the
destruction of the comprehensive neighborhood high school we've had a
proliferation of small schools. Some people think that small schools
are universally better. They're wrong. You need a mix. One of the
problems with small schools is that you don't have subject area
supervisors. You have a principal and an assistant principal. The
result is that most teachers are evaluated by supervisors with no
subject area expertise and no subject area pedagogical expertise.
</p>
<p>
The old system, even though it was also subject to abuses was much
better - at least in the hands of a good supervisor. The observation
system is inherently flawed. Observations are snapshots out of context
and the mere presence of an observer changes the tone of the
room. That said, if a supervisor knows the heartbeat of their school
and has ongoing conversations with their staff, they can both ensure
teachers are doing an honest job and also help them to improve.
</p>
<p>
The method of observation also doesn't have to be complicated. My
first supervisor made it very simple. He said he looked for one basic
thing - "was learning going on?" The conversation would then go from
there.
</p>
<p>
Sometimes you have to look beyond the lesson. In my first year, I
frequently observed a friend's history class. One day the class seemed
to do very little. It seemed like all talk and play. I talked to the
teacher about this. He said "that was what they needed today." He was
a master and he was right. You might drop in on his class to see
amazing instruction or you might come in and wonder why he wasn't
fired long ago but at the end of the year when you looked at how much
his kid learned and loved his class you realized that he was an
amazing teacher. No rubric or framework needed. Just the eyeball test.
</p>
<p>
They also used to have more peer observations.They had to be coordinated
by the department supervisor and he or she had to be in the loop but
the peer observation model helped cross pollinate ideas in a
department, build camaraderie and it also eased the workload of the
supervisor.
</p>
<p>
To answer Alfred's question from his tweet, how do we help
administrators help CS teachers? Get other teachers involved, keep an
open mind and look at the big picture.
</p>
</div>
</div>CS Teachers - teacher first or content firsthttp://cestlaz.github.io/posts/teacher-to-cs-or-cs-to-teacher/2017-07-04T16:39:43-04:002017-07-04T16:39:43-04:00Mike Zamansky<div id="outline-container-orge4524d1" class="outline-2">
<h2 id="orge4524d1"></h2>
<div class="outline-text-2" id="text-orge4524d1">
<p>
Is it easier to take CS people and teach them to teach or is it easier
to take teachers and teach them CS?
</p>
<p>
The question gets batted around from time to time.
</p>
<p>
This time via twitter:
</p>
<blockquote class="twitter-tweet" data-lang="en"><p lang="en" dir="ltr">Some think it's easier to teach a teacher to teach CS than to teach a CS pro to teach. <a href="https://twitter.com/alfredtwo">@alfredtwo</a> is not one of them <a href="https://t.co/QCUP8d8llZ">https://t.co/QCUP8d8llZ</a></p>— Diane Levitt (@diane_levitt) <a href="https://twitter.com/diane_levitt/status/881874056911388673">July 3, 2017</a></blockquote>
<script async src="//platform.twitter.com/widgets.js" charset="utf-8"></script>
<blockquote class="twitter-tweet" data-lang="en"><p lang="en" dir="ltr">Agreed. It takes a lot of work. More than a week long workshop.</p>— Alfred Thompson (@alfredtwo) <a href="https://twitter.com/alfredtwo/status/882243591090962432">July 4, 2017</a></blockquote>
<script async src="//platform.twitter.com/widgets.js" charset="utf-8"></script>
<p>
The conversation was referring to blog posts by <a href="http://blog.acthompson.net/2017/06/become-computer-science-teacher-in-five.html?spref=tw&m=1">Alfred Thompson</a> and <a href="https://gflint.wordpress.com/2017/06/20/a-week-of-in-service-another-python-course/">Garth flint</a>.
Alfred's key point - one that I've spoken about before is that short
term professional development does not a CS teacher make.
</p>
<p>
As to the lead in question? I've seen both routes succeed and both
routes fail. Both can be heavy lifts but there's a missing part of the
equation that's never addressed.
</p>
<p>
The claim is that it's easier to teach CS to a non-CS teacher because
they already know how to teach. The problem is, particularly in the
later grades that teachers of different subject areas have very
different tool sets. Sure, there are common factors – get the kids
involved, layer, spiral, etc. but you don't teach a CS lesson the same
way you teach a math lesson let alone a literature, history, language
lesson.
</p>
<p>
In a math class, it's common to have students write solutions to
problems up on the board. If you try that in a CS class, you'll be
waiting 20 minutes while the kids transcribe the problems. Likewise,
math homework will likely consist of a certain amount of repetitive
practice problems whereas a CS class won't have something directly
analogous. This is not to say that you don't have opportunities for
students to present at the board in CS class or that there isn't
worthwhile homework but rather that even at this simple level, there
are differences.
</p>
<p>
So, if we're going to teach a non-CS teacher the CS content, beyond
the challenge of giving them the necessary depth and breadth of
content knowledge we have to teach them how to teach CS.
</p>
<p>
I've inventoried some of the techniques my colleagues and I have used
in our classes and the collected methods could easily fill a couple of
graduate education courses.
</p>
<p>
So, what's the answer to the question? It doesn't matter where you
start but if we want to do right by our kids we need to prepare them
in not two but three areas:
</p>
<ul class="org-ul">
<li>CS Content</li>
<li>CS Pedagogy</li>
<li>General education and pedagogy</li>
</ul>
<p>
Short term PD (professional development) won't do it and neither will
scripts for "teachers" to follow. It's going to take time, will, and
effort.
</p>
<p>
Here's hoping that municipalities look at the long game. It's fine to
do PD now to get something started but it's not enough. I wanted my
kids math teachers to know math and how to teach it. We should demand
no less from our CS teachers.
</p>
</div>
</div>Disclosing Bugs - requiring a project roadmaphttp://cestlaz.github.io/posts/disclosing-bugs/2017-06-13T16:30:27-04:002017-06-13T16:30:27-04:00Mike Zamansky<div id="outline-container-org7f35a05" class="outline-2">
<h2 id="org7f35a05"></h2>
<div class="outline-text-2" id="text-org7f35a05">
<p>
Over on Facebook, a fellow CS educator <sup><a id="fnr.1" class="footref" href="http://cestlaz.github.io/posts/disclosing-bugs/#fn.1">1</a></sup> made a comment on something he
wanted to try with his students this summer: having the students
pre-disclose bugs when they submit their projects.
</p>
<p>
The post was asking for any links to "the literature." I can't speak
to that but I I've done something similar to what the post was asking
about so, as per usual, I thought I'd write about it here. It may not
be "research" but I'm more interested in teacher practices than ivory
towers anyway so here goes…
</p>
</div>
</div>
<div id="outline-container-orga467f3e" class="outline-2">
<h2 id="orga467f3e"></h2>
<div class="outline-text-2" id="text-orga467f3e">
<p>
At a very basic level, I ask my students to provide a roadmap to any
project they submit - usually in a readme file. I basically ask:
</p>
<ul class="org-ul">
<li>How to use the project</li>
<li>What's cool and I should make sure to check out</li>
<li>What doesn't work, where were the sticking points and what's the
status.</li>
</ul>
<p>
I tell my students that when I test the project, I'm not "out to get
them" and by their telling me how to navigate the project, it makes
sure I see things in the best possible light. I also tell them that I
will be more harsh on bugs that they don't tell me about -
particularly bugs that only occur some of the time.
</p>
<p>
I also encourage (and sometimes require) that students maintain a
changelog in their repo and also sometimes encourage them to have a
todo list and list of bugs and for longer projects, I expect to see
these and the readme updated over the course of the project (which
should always be up to date on <a href="https://cestlaz.github.io/posts/sigcse-2017-github-4">GitHub</a>, Dropbox or wherever the project
is living).
</p>
<p>
When the students provide a good write up it makes evaluating the
project much easier.
</p>
<p>
When students buy in, they're hopefully thinking more deeply about
their projects in terms of design and implementation and also from the
point of view of someone else using their product. When they maintain
the readme and other files over time, it also enables me to better
support them.
</p>
</div>
</div>
<div id="outline-container-org9b85f5a" class="outline-2">
<h2 id="org9b85f5a"></h2>
<div class="outline-text-2" id="text-org9b85f5a">
<p>
So, does this work? Yes but with some caveats. It works better once
the class and teacher know each other. If the students trust the
teacher they're more likely to be open and honest when they write up
the project. On the other hand, there will always be some students to
"phone it in" and do the bare minimum in terms of writing up their
projects.
</p>
<p>
The bottom line is that having the students do this is has a low cost
and is beneficial to both the students and the teacher. When it works,
it's great and when it doesn't, it's still pretty good.
</p>
</div>
</div>
<div id="footnotes">
<h2 class="footnotes">Footnotes: </h2>
<div id="text-footnotes">
<div class="footdef"><sup><a id="fn.1" class="footnum" href="http://cestlaz.github.io/posts/disclosing-bugs/#fnr.1">1</a></sup> <div class="footpara"><p class="footpara">
I'm not sharing names from the Facebook post because it was
made in a semi-private forum and I haven't asked permission.
</p></div></div>
</div>
</div>Python - Editor or IDEhttp://cestlaz.github.io/posts/python-editors/2017-05-25T15:47:37-04:002017-05-25T15:47:37-04:00Mike Zamansky<div id="outline-container-org2ef5a3c" class="outline-2">
<h2 id="org2ef5a3c"></h2>
<div class="outline-text-2" id="text-org2ef5a3c">
<p>
Earlier today I read Garth Flint's latest post on <a href="https://gflint.wordpress.com/2017/05/25/python-editors-simple-wins/%0A">choosing a Python
environment for his classes</a>. While our classes and populations are
different it looks like Garth and I share a lot of thoughts on the
subject.
</p>
<p>
I started to write a comment to leave on Garth's blog but since it was
getting a little long I thought I'd write it up as a post.
</p>
<p>
The question of development environment can be an important one and
can make a big difference. When I designed the intro course at Stuy,
the fact that Dr. Scheme existed made the use of Scheme in the class
an option. Without it as a supportive and simple environment for the
students I probably wouldn't have been able to use Scheme even though
I really liked it as a teaching and learning tool.
</p>
<p>
Garth writes about issues relating to choosing a local development
environment so that's what I'm going to stick to here. If you want an
online environment check out <a href="http://codesters.com">Codesters</a> - a terrific online Python
environment with lots of educational support materials and features
and <a href="http://repl.it">repl.it</a> - an online environment that supports many languages and
is also developing great teacher and class support – I very much like
both of these platforms.
</p>
<p>
The first question is editor or IDE?
</p>
<p>
As a user, I'm very pro editor. Learn a tool that you can customize to
your tastes and that will work for all sorts of text editing chores
from coding to document preparation to scheduling and more and you're
in great shape. Personally, I'm an <a href="http://cestlaz.github.io/stories/emacs">Emacs wonk</a> but there are other
choices as well.
</p>
<p>
As a teacher, though, Emacs or another programmers editor can be
overwhelming for younger students and rank beginners.
</p>
<p>
This can make IDEs attractive.
</p>
<p>
Some IDEs are too big and cumbersome and can add even more cognitive
load than an editor - think Eclipse for Java development. If you think
writing
</p>
<div class="highlight"><pre><span></span><span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">main</span><span class="o">(</span><span class="n">String</span><span class="o">[]</span> <span class="n">args</span><span class="o">)</span>
</pre></div>
<p>
is a lot of overhead, just wait until you have a novice try to start a
Java project in Eclipse.
</p>
<p>
Other IDEs are more streamlined. One common choice is
Idle. It's big advantage is that it's always available and is "part"
of Python. On the other hand, it doesn't seem to add much to a bare
editor and I've found that it can be somewhat confusing.
</p>
<p>
Garth seems to have settled on <a href="https://www.jetbrains.com/pycharm/">PyCharm</a> from <a href="https://jetbrains.com">JetBrains</a>. It's pretty
streamlined and really easy to get up and running. JetBrains also
provides a free community edition as well as a heavier professional
one available for purchase. Garth notes that it's a Python only IDE
but JetBrains has similar IDEs for a whole bunch of languages and I
seem to recall you can add plugins across their IDEs to basically make
them multi-language development environments.
</p>
<p>
I really like the JetBrains products and if I used an IDE I'm pretty
sure I'd use their products. As a teacher though, I find their IDEs a
little too powerful for my tastes. I want a learner IDE to provide the
bare minimum of features - an interactive REPL, a code window, run and
debug buttons, some completion and help - but to make those features
really easy to use. JetBrains does a little too much.
</p>
<p>
What I ended up using in the past is <a href="http://drpython.sourceforge.net/">Dr Python</a>. For me it hit the
sweet spot. As an added bonus we were already using Dr. Racket (nee
Dr. Scheme) and Dr. Java so our students had a similar environment
across languages and even NetLogo looked and behaved similarly.
</p>
<p>
Is there a right answer? Probably not. Just as with choosing a first
language there are always trade offs. Besides, if you don't have the
right solution, there will be another one next week. Just recently I
saw <a href="http://thonny.org/">this project</a>. A new beginners IDE for python. It looks interesting
and worth checking out.
</p>
<p>
The right IDE can make a big difference while keeping the overhead low
and giving just the right amount of support. For me, the last time
around it was Dr. Python. For Garth, it looks like PyCharm fits the
bill. Looking at the overall plan, I usually start the kids off with a
simple learners IDE and then transition them to a programmers editor
like Emacs as they gain more comfort and experience.
</p>
<p>
As a postscript, let me share these links on how I use Emacs for
Python development (each with a video) as well as my series on how I
use Emacs in general:
</p>
<ul class="org-ul">
<li><a href="http://cestlaz.github.io/stories/emacs/">http://cestlaz.github.io/stories/emacs/</a></li>
<li><a href="http://cestlaz.github.io/posts/using-emacs-12-python">http://cestlaz.github.io/posts/using-emacs-12-python</a></li>
<li><a href="http://cestlaz.github.io/posts/using-emacs-13-yasnippet">http://cestlaz.github.io/posts/using-emacs-13-yasnippet</a></li>
</ul>
</div>
</div>Designing a course with constraintshttp://cestlaz.github.io/posts/design-course-with-constraints/2017-05-19T11:38:20-04:002017-05-19T11:38:20-04:00Mike Zamansky<div id="outline-container-org74017b4" class="outline-2">
<h2 id="org74017b4"></h2>
<div class="outline-text-2" id="text-org74017b4">
<p>
One of the hats I wear at Hunter is to build a new <a href="https://cestlaz.github.io/posts/2016-03-29-hunter-cs.html">CS Honors program</a>
and to bring my particular brand of insanity to <a href="https://cestlaz.github.io/posts/hunter-cs-important">Hunter College CS</a> as a
whole.
</p>
<p>
Yesterday was my last class for the semester so I thought I'd write a
bit about the course.
</p>
<p>
For the Fall semester, I taught an intro programming course to the
entire cohort. For some in the cohort, this was their first exposure
to CS. Others had one or more classes under their belt. It was a
Python based programming class and a big part of it was to start
building the cohort into a community. I'm going to work on tweaking
what I taught for next time around but the constraints of designing
such a course are pretty common – an intro course where the students
all want to be there the level of previous experience varies to some degree.
</p>
<p>
Second semester was more of a challenge. The "next" course was CSCI
135, CS 100 - like APCS but in C++. I could teach that but since some
of my students had APCS credit, they didn't need 135. This would break
up the group. There was also the issue of the students getting credit
for the course without showing any proficiency in C++.
</p>
<p>
Fortunately, Hunter requires students in 135 to take CSCI 136. A 1
credit programming lab. It meets once a week in a computer lab and the
students complete a weekly programming assignment. The lab meets for 2
hours. The instructor goes over anything that's needed for the lab
that hasn't been covered yet and then the students work independently
(with the instructors support) on the lab. Overall it works well. It
makes sure the students are spending at least a couple of hours a week
coding in a supported environment.
</p>
<p>
How did 136 help me? I taught a 3 credit course where 1 day was
basically the lab component (what the students were to do in 136) and
one day was enrichment - the stuff I was going to do with them. This
enabled us keeping the cohort together and it also made sure that by
taking the class, the honors cohort members with AP credit would
indeed get up to speed in C++.
</p>
<p>
I was happy with the basic structure. I was able to cover some topics
in project development, testing, debugging, and software engineering but the
designing and teaching the class proved to be challenging for a number
of reasons.
</p>
<p>
One was timing. The lab class meets 1 day a week for 1 hour. My class,
2 days a week for 1 hour 15. This meant that if we were to keep the
lab to one day either the students would have less time or I'd have to
impose on them to stay late or come early. I wasn't happy with that
but given the inconsistency in the way the other sections handled lab
timings, I think it worked out OK.
</p>
<p>
Some of the other difficulties included:
</p>
</div>
<div id="outline-container-org17b7dfb" class="outline-3">
<h3 id="org17b7dfb">The language was C++:</h3>
<div class="outline-text-3" id="text-org17b7dfb">
<p>
Since the labs were to be done in C++, I had to use that as the
language for the class. That meant no "fun" libraries or frameworks.
</p>
</div>
</div>
<div id="outline-container-org0bb58fa" class="outline-3">
<h3 id="org0bb58fa">The labs were solo assignments:</h3>
<div class="outline-text-3" id="text-org0bb58fa">
<p>
Since the labs were solo projects and there was one per week it made
it very difficult to structure group experiences. I wanted to cover
things like group development, code review, working off of other
peoples code bases but this proved difficult with an outside separate
lab being handed down each week.
</p>
</div>
</div>
<div id="outline-container-org5227042" class="outline-3">
<h3 id="org5227042">Someone else dictated the language sequence:</h3>
<div class="outline-text-3" id="text-org5227042">
<p>
The labs were designed to support what the students were learning in
135 and were only distributed a day or two before the week was to
start. This meant that I couldn't plan too far ahead and had to adjust
frequently. This should be easier next year.
</p>
</div>
</div>
<div id="outline-container-orgba6d2a4" class="outline-3">
<h3 id="orgba6d2a4">Labs didn't match the supplemental material:</h3>
<div class="outline-text-3" id="text-orgba6d2a4">
<p>
The best example of this was when we were talking about testing. We
ended up using <a href="https://github.com/philsquared/Catch">Catch</a> as a testing framework. The problem was that
right afterwards the lab (and also 135 project) didn't lend themselves
to using a testing framework like catch.
</p>
<p>
There were more challenges but overall I think the class went fairly
well. I'll know more when I get feedback from the students and when we
all look back next year with some perspective.
</p>
<p>
It's been an interesting experience designing a class that had to
interleave with another, existing class. I've designed many classes
over the years and I know that whatever you plan, it probably changes
once you're actually in the classroom and working with the kids, or as
Mike Tyson said: "Everyone has a plan until they get punched in the
mouth." This has been a little more of a challenge but I think the
first go through went well and that the course will get better and be
better defined as we go through a couple more iterations.
</p>
</div>
</div>
</div>It feels good to be helpfulhttp://cestlaz.github.io/posts/feels-good-to-be-helpful/2017-05-17T19:12:03-04:002017-05-17T19:12:03-04:00Mike Zamansky<p>
I got some nice feedback today from a couple of disparate places. It
was another reminder that being a teacher isn't just about the kids
currently in your class but it's about who you are and everyone you
interact with. It's not just about teaching a subject but rather about
helping people get to where they can potentially go.
</p>
<p>
About a year ago I started putting together a <a href="http://cestlaz.github.io/posts/using-emacs-introduction">series of posts and videos</a> showing
how I use Emacs. There were a couple of motivating factors. One, I
wanted to put together some resources for my students - something that
would take them from the Emacs tutorial to a point where they would
hopefully see the power of the environment and not buy into the IDE or
editor of the month hype but either really use Emacs proficiently or
use another editor (Atom, Vim) in a similar fashion.
</p>
<p>
The other reason was that I wanted to give something back to the
Emacs community. I don't create Emacs packages or otherwise contribute
but I figured, I'm a teacher, I can do what I do.
</p>
<p>
So, earlier today I got an email thanking me for my videos and also
noticed that over on <a href="http://irreal.org/blog/?p=6218">irreal.org</a>, jcs wrote about moving over to
dumb-jump after seeing one of my videos. It's been nice seeing that
I've been of some value to jcs since I've learned a lot from his
blog. Emails, comments, and notes like this have driven me to continue
the series (even though It's been a busy couple of months). It's
gratifying that even without writing a line of code, one can give
something back to a community that they've found value in for years.
</p>
<p>
A month or so ago, I had a chat with a former student who's finishing
up his last year in college. He was having trouble finding a job, I
couldn't figure out why he wasn't getting offers - he's really
talented. I tried to give him words of encouragement and reminded him
that I was available to help him - as I try to be for the entire
"family" in any way I could.
</p>
<p>
Fast forward to today - I got an email telling me that he got a job
that he's very excited about. He felt the interviews with this company
were going well so he was waiting for them to resolve before reaching
out to me. He also told me that our talk was very helpful to him.
</p>
<p>
Sometimes it's not just in a class where we can have a positive effect
but sometimes just a talk on the side. Sometimes many years later.
</p>A free multi-state clicker with built in redundencyhttp://cestlaz.github.io/posts/thumb_clickers/2017-04-01T17:23:21-04:002017-04-01T17:23:21-04:00Mike Zamansky<div id="outline-container-orgbf38cb1" class="outline-2">
<h2 id="orgbf38cb1"></h2>
<div class="outline-text-2" id="text-orgbf38cb1">
<p>
Last Friday, <a href="https://twitter.com/guzdial">Mark Guzdial</a> wrote about the woes of <a href="https://computinged.wordpress.com/2017/03/31/the-need-for-better-software-and-systems-to-support-active-cs-learning/%0A">using clickers</a> in a
class. The amount of effort required to use his school's approved
clicker technology sounds ridiculous so while we need tools to better
engage students in large class settings we need better tools that can
be integrated into our classes more easily.
</p>
<p>
I've never used clickers. On top of stories like Mark's, there are a
number of problems with using clickers in a public school.
</p>
<p>
You can't force students to buy them and in NYC, until recently,
students couldn't use their phones (which they also might not have).
Forgetting the expense, if the school provides them, is it one per
student? If so, who's going to administer the clicker to student
mapping and how will that be communicated to the teachers. If college
tech infrastructures are sometimes lacking, high schools are orders of
magnitudes worse. The resources just aren't there. Then we have to
deal with loss and breakage.
</p>
<p>
If a teacher somehow gets a class set of clickers, they have to deal
with mapping clickers to students for all of their classes and make
sure the right student has the right clicker. Again, loss and
breakage is a problem.
</p>
<p>
Then you have to create the question content and hope that everything
works in class.
</p>
<p>
The value added given the overhead just doesn't seem worth it
particularly since high school classes, while large, are not in the
hundreds and there are other methods of student engagement.
</p>
<p>
Here's what I use instead. It's not perfect but it's low cost and low
effort with a pretty high return.
</p>
<p>
The basic configuration, is a simple three state broadcast device.
</p>
<p>
It's not without its problems and I don't think it would work as well
in a large lecture but given the cost, it's well worth it.
</p>
<p>
So, what is it?
</p>
<div class="figure">
<p><img src="http://cestlaz.github.io/img/thumbs/fonzup.jpg" alt="fonzup.jpg" align="center">
</p>
</div>
<p>
Thumbs.
</p>
</div>
</div>
<div id="outline-container-org038e1e6" class="outline-2">
<h2 id="org038e1e6"></h2>
<div class="outline-text-2" id="text-org038e1e6">
<p>
Periodically, I'll poll my class.
</p>
<span>
<img width="30%" src="http://cestlaz.github.io/img/thumbs/sidethumb.png">
<img width="30%" src="http://cestlaz.github.io/img/thumbs/upthumb.jpg">
<img width="30%" src="http://cestlaz.github.io/img/thumbs/downthumb.jpg">
<p>
Thumb to the side? Everything's OK. Keep going as you're going. I get
it. Basically, things are good.
</p>
<p>
Thumb up? Speed up, you're going too slow, I got it five minutes ago or
some similar big positive.
</p>
<p>
Thumb down? I have no idea what you're talking about.
</p>
<p>
It's cheap, easy, quick, and once you can get your class to buy in,
you can get a quick sense of the class.
</p>
<p>
The downsides?
</p>
<ul class="org-ul">
<li>The class has to have a level of comfort so that students vote
honestly and don't just give you positive feedback.</li>
<li>No data collection.</li>
</ul>
<p>
The upsides?
</p>
<ul class="org-ul">
<li>quick</li>
<li>cheap</li>
<li>works on any topic on the fly</li>
<li>even if the votes are artificially skewed towards positive, it does
forces the class to be at least a little attentive and to engage in
some physical response</li>
<li>can get analog responses by allowing students to adjust wrist
rotation</li>
</ul>
<p>
As to the redundancy? I've never had a kid leave their thumb at home
or lose it and even if they did, they've got a second hand.
</p>
<div class="figure">
<p><img src="http://cestlaz.github.io/img/thumbs/fonztwo.jpg" alt="fonztwo.jpg" align="center" height="200">
</p>
</div>
<p>
This also works in extreme environments. Try using a clicker or mobile
app with gloves or mittens on or underwater.
</p>
<p>
I don't teach large lectures so I don't know how this would work in a
huge class. I'd imagine it's still worth it given that it's so low
friction and low cost of entry even if it's not perfect.
</p>
</span></div>
</div>Rookie Season Reduxhttp://cestlaz.github.io/posts/rookie-season-redux/2016-12-12T18:41:28-05:002016-12-12T18:41:28-05:00Mike Zamansky<p>
Today was the last day of classes at Hunter thus ending my first
semester of teaching at Hunter College.
</p>
<p>
I very much enjoyed the semester and my class and look forward to
working with the same group when the spring term starts in a few
weeks.
</p>
<p>
At the same time, even though I'm a quarter century veteran teacher,
in many ways this was like my rookie season all over again.
</p>
<p>
My class was an honors intro class so the material wasn't new to me
but there were a number of adjustments going from high school to college.
</p>
<p>
I taught a few college classes as an adjunct back in the nineties but
I was a young teacher at the time and that was a lifetime ago.
</p>
<p>
The biggest difference is that we only met two days a week. Monday and
Thursday and we met for 1:45 rather than 45 minutes. The longer class
is nice but the twice a week means that you don't get that every day
reinforcement you have in high school.
</p>
<p>
It also means that there were times when we would go a week between
classes due to a single day off.
</p>
<p>
The biggest challenge, one that I'm continuing to work on, is figuring
out how much we can do in a class, what and how much to assign between
classes and what's the best way to motivate the student's to space out
the work while doing something every day.
</p>
<p>
That wasn't much of a challenge at Stuy. Having been there so long, I
had a good feel for my students as well as the pace and rhythm of
Stuy. Hunter has it's own rhythm and pace and I'm still figuring it
out.
</p>
<p>
We also had to pivot early on as the student laptops didn't arrive
until a third of the semester was over.
</p>
<p>
On the other hand, much of my work these days has to do with
developing the overall honors program as well as Hunter's forthcoming
teacher education programs in CS so I'm only teaching a single class
right now and it's small.
</p>
<p>
If there are any rookie teachers reading this, congratulations on
getting through your first semester. I know you guys go a little bit
longer, but you're in the home stretch.
</p>
<p>
Teaching right, particularly in public schools with large classes will
always be an all in activity - certainly harder and more draining than
anything I ever did in industry but it does get easier as you learn
your school and students and develop your craft.
</p>First day back, or nothttp://cestlaz.github.io/posts/first-day-back/2016-09-06T10:56:56-04:002016-09-06T10:56:56-04:00Mike Zamansky<p>
The day after Labor Day. The day NYC teachers traditionally return to
work. For the first time in a quarter century, I'm not one of them.
</p>
<p>
It's weird.
</p>
<p>
Instead, I'm in the second week of Hunter College's fall semester. So
far so good on that front. I'm getting to know my students, planning
activities and overall having a good time.
</p>
<p>
But, I do have to reflect on some of the things I'm not going to get
to do this week:
</p>
<p>
I'm not going to have the opportunity to be blindsided by a CS
schedule made without consulting me or any other CS teacher and having
to work frantically to fix it so that the CS teachers have the
programs and rooms they want.
</p>
<p>
I'm not going to be able to have that panic attack when the NFS/NIS
server isn't working and no one can log in.
</p>
<p>
I'm not going to sit through a mindless faculty meeting where nothing
is really ever accomplished.
</p>
<p>
More seriously, I am going to miss seing my friends and colleagues
after the summer and Thursday - the day the kids get back is always a
thrill and I'm going to miss that.
</p>
<p>
In a way, I'm experiencing a version of what retired teachers go
through. Many teachers retire in June but it's not until after Labor
Day when the change really sinks in.
</p>
<p>
Soon, I'll start posting CS teaching content again but for today, I
want to tip my cap to all the public school teachers in NY that are
going back to work today and who will shortly be teaching their five classes
of thirty four kids each <sup><a id="fnr.1" class="footref" href="http://cestlaz.github.io/posts/first-day-back/#fn.1">1</a></sup>.
</p>
<div id="footnotes">
<h2 class="footnotes">Footnotes: </h2>
<div id="text-footnotes">
<div class="footdef"><sup><a id="fn.1" class="footnum" href="http://cestlaz.github.io/posts/first-day-back/#fnr.1">1</a></sup> <div class="footpara">also tipping my cap to my favorite TJ
teacher who's students are back today. I got called to task for
failing to mention her on my facebook shoutout.</div></div>
</div>
</div>West coast trip - a nice close to act Ihttp://cestlaz.github.io/posts/end-to-act-1/2016-07-18T13:18:06-04:002016-07-18T13:18:06-04:00Mike Zamansky<div id="outline-container-org0fcf2fa" class="outline-2">
<h2 id="org0fcf2fa"></h2>
<div class="outline-text-2" id="text-org0fcf2fa">
<div class="figure">
<p><img src="http://cestlaz.github.io/img/end-act-1/facebook.jpg" alt="facebook.jpg" align="center">
</p>
</div>
<p>
If I look at my leaving Stuyvesant and the NYC Department of
Education to join Hunter College as the end of Act I of my teaching
career, then our family's West Coast swing was a nice way to pull
down the curtain.
</p>
<p>
The impetus for the trip was visiting Batya - she's interning at
Facebook this summer and having an absolute blast.
</p>
<p>
The plan was to spend a few days in San Francisco, then a little south
to Mountain View, where Batya was staying, and then fly up to Seattle
for a couple of days.
</p>
<p>
Of course, while out there, why not see if some of the StuyCS family
wanted to get together.
</p>
<p>
I knew I had a lot of former students out on the West Coast but still, I was
overwhelmed and humbled by the number of people who wanted to spend
time and catch up.
</p>
<p>
We kicked things off at Bloomberg Beta thanks to <a href="https://twitter.com/roybahat">Roy Bahat.</a> Roy was
never actually my student but we've gotten to know each other over the
years and I value him as a friend and advisor. Roy provided the food
and the space and about 60 former students + a few old timers showed.
</p>
<div class="figure">
<p><img src="http://cestlaz.github.io/img/end-act-1/bloomberg.jpg" alt="bloomberg.jpg" align="center">
</p>
</div>
<p>
A couple of days later, we had a lunch meetup for the Googlers:
</p>
<div class="figure">
<p><img src="http://cestlaz.github.io/img/end-act-1/google.jpg" alt="google.jpg" align="center">
</p>
</div>
<p>
and a happy hour at Facebook (sorry, no picture). Then in Seattle, a
nice dinner to close things out.
</p>
<div class="figure">
<p><img src="http://cestlaz.github.io/img/end-act-1/seattle.jpg" alt="seattle.jpg" align="center">
</p>
</div>
<p>
Between these events there were some lunches, a barbecue at Batya's
place and even a drive by visit with a former student at
Microsoft. Overall, it was easily over 100 students over the course of
the week or so we were out there.
</p>
<p>
I've often said that one of the things I'm proudest of is helping to
build the StuyCS family. A community of people spanning decades. Over
the week, we had events mixing students from the mid 90's to
youngsters currently in college and on their internships.
</p>
<p>
Seeing all these people meeting and supporting each other gave me a
"proud pappa" type feeling even though I didn't do any more than set
the stage for them getting together.
</p>
<p>
Over the week, the conversations were also great - not the straight
tech ones, but the ones that really made me proud of the crew. From
Seth talking about how to better get good CS Ed to more kids, to PJ
discussing why he feels it's so important to be an active mentor to
his young programmers and how to get them to be real thinkers, to
Mike, Sam, Kathy, and Leo discussing the disconnect between
privileged families and those struggling to get by.
</p>
<p>
What more could a teacher want than their former students being both
happy in their lives and careers as well as good people seeking to
make the world better for everyone.
</p>
<p>
The only thing that made me sad about the trip is that with all the
big events, I really didn't get a chance to spend the time I wanted
with everyone. I hope to do better next time.
</p>
<p>
So, I've now been at Hunter for one semester and things will really
ramp up in the Fall. I'm still a proud part of our StuyCS family and if
being a part of pulling it together is the legacy I left, I can live
with that.
</p>
<p>
The trip was a nice symbolic way to lower the curtain on act 1. I'm
counting on the StuyCS family and all the other players to help so
that we can make sure act 2 is a success and we can build something
similar for more young people throughout the city and perhaps the country.
</p>
</div>
</div>