Wednesday, April 18, 2018

Arrays, Loops, and Racing Horses

One of the things I like about using Visual Studio and C# (and Visual Basic for that matter) is the ability to easily create some fun graphical projects. I’ve been using variations of the horse race program for years now. I though it might be fun to share my latest use.

image

Students sometimes have trouble seeing the benefits of arrays because they are used to small projects that can get by without them. I want them to see how the combination of loops and arrays make expanding programs easier.

My students were given a mostly empty project with the objects you see in the image above already part of the project. I don’t want them to get lost in setting up the GUI. There is a “Race” button, a “Reset” button, four picture boxes, and the finish line (a nicely formatted label.) No code though. We’ll create that as a class.

The first thing we do is allocate an array of three picture boxes. Next we assign the value of the existing picture boxes to the array. We talk about how the picture boxes now have two names or two ways of addressing them. This is related to people’s names – formal name, nickname, etc.

public Form1()
{
     InitializeComponent();
     Horses[0] = picHorse0;
     Horses[1] = picHorse1;
     Horses[2] = picHorse2

}

The naming I use (I hope) drives home how identifiers that differ only by a number at the end leads one naturally to thinking about arrays.

We write code to move the “horses” random distances each time a timer fires. Using timers is not absolutely necessary and I have used while loops but timers open some ideas for interesting projects. The “Race” button enables the timer and the horses start moving by changing the Left properties by random numbers of pixels..

for (int index = 0; index < Horses.Length; index++)
{
     Horses[index].Left += r.Next(3, 8);
}

Next we add the code to check to see if the Left property plus the width of the box crosses past the left property of the finish line.

Students are asked to figure out the Reset button on their own and most do so easily. At this point we’ve had a lot of discussion about the code we’ve written so far. Next I ask them to add more horses to the problem. They soon discover that this is a fairly trivial task because of the way we have designed the program.

Since we get to work with interesting arrays and see how setting up loops we cover some important topics. Best of all, students seem to like this project.

There is room for student creativity as well. Some add only a few horses, some add many. Some get fancy with reporting winners. Some explore other images from what I provide. Others decided they wanted that last place horse to disappear before the next race. That involved a lot more work then they expected but they were motivated to try things. But no one, including me, get bored.

Tuesday, April 17, 2018

Training The Next Generation of Computer Science Teachers

The biggest problem in computer science education is training the teachers we need. That seems to be the big thing on my social media in the last few days.

This past week was a major document release in New York of "Priming the Computer Science Teacher Pump: Integrating CS Education into Schools of Ed”. Mark Guzdial wrote about it here. You can also download the actual report here.  Mark also shared the slide deck from the event on Slideshare here. If you don’t have time for the whole report the slides make interesting reading as a sort of summary.

It has been clear to many of us in CS education for a while that we really need schools of education to step up and prepare CS teachers. This report addresses what is needed with some solid recommendations. This being computer science education, others are tossing in their opinions.

Mike Zamansky, who was at the release event, gave some of his thoughts on his blog at - Math For Math Teachers - watering down CS Ed before we even start. Mike comes from a heavy CS background and many years teaching at a highly rated, entrance exam, public high school in New York City. That gives him a particular perspective.

Garth Flint, who teaches as a smaller private Catholic K-12 school in Montana, wrote a blog post on the subject - CS Ed – to water or not to water, that is the question which really covered the situation for a lot of teachers especially those in rural areas and other smaller schools. 

It’s a different perspective from Mike’s. One is not better than another – they’re just different. In a sense those two posts show some of the diversity of educational environments we’re seeing in computer science education.

Preparing teachers for this wide range of needs is definitely going to be part of the challenge. I can’t see a one size fits all CS teacher preparation scheme working. There is really going to have to be some local variation as well as consideration as to different age level preparation. I’m not sure one can easily prepare for the full range of Kindergarten though Advanced Placement Computer Science. Content is one thing but the how to teach is another.

OK, now there is something of a roadmap. Will schools of education move into this space the way we need them to do? We’ll see I guess but I hope so.

Friday, April 13, 2018

Teachers For Now or Teachers Forever?

One really can get a lot out of following Twitter hashtags from conferences and other events. Today I saw the following Tweet:

image

This in a nutshell is the concern with a lot of current efforts to prepare computer science teachers in a hurry. Yes, you can teach a teacher to teach a specific course and you can give them a lot of scaffolding and tools to get by. They may even see great results. But what happens when things change?

My school has something like 20 different courses in the Math department. Can you imagine hiring a teacher who could only teach one of them? Even one that is a soft of default course? Seems like a long shot. We want our Math teachers to be able to teach a range of courses. We want that not just so they can be moved around as needs change or to give them diversity during the day but because we want teachers who know where their course fits into the whole curriculum stream.

Shouldn’t we want that for computer science teachers. The #Home4CS event, from what I can tell from Twitter, was about preparing pre-service computer science teachers in university schools of education. One can easily find Masters degree programs in teaching English or teaching Math or teaching other sciences. A MS is Teaching Computer Science? That’s a bit harder to find. That’s really going to be essential if computer science education is going to grow and mature the way we really need it to develop.

Content knowledge is absolutely critical for teachers to be able to continue as computer science changes. It’s necessary but not sufficient though. Teachers need to know how to teach computer science. It’s not the same as other subjects. Yes, people with deep content knowledge can learn to be good teachers. And teachers can pick up content knowledge and develop into good CS teachers. Learning content AND how to deliver it before starting in the classroom would be a huge advantage. It would be better for teacher and students alike.

It is not going to happen until schools of education start making a home for computer science educators.

Thursday, April 12, 2018

Can We Afford a Digitally Illiterate Congress?

Like many people I found the Zuckerberg Congressional Hearings disturbing on several levels. Yes, there are some serious issues with Facebook and other Internet services with regards to privacy, security, and social impact. We clearly need to deal with them. That is probably a topic for more discussion and blog posts. The lack of understanding of how technology and the Internet works on the part of people who can and likely will pass laws about them was also deeply concerning.

Doug Bergman talked about this at length in his post “The Elephant in the Room.” That’s a great read and I recommend it highly. But I have to stick in my own two cents.

Someone asked me if we required deep aviation knowledge in the members of Congress who questioned Howard Hughes. I think their point was that we don’t expect our Congress people to be deeply technical on all subjects that come before them. That’s a valid point  but at the same time we would hope that they would consult with experts before making decisions. And frankly some of the questions should have been general knowledge and were not deeply technical.

A lot of people who disturbed when Senator Hatch asked how Facebook could maintain a business model where its users didn’t pay for the service. I know I was. Advertising support is a model that predates the internet. It’s a model that allows us free radio and TV for example. To not know that this is how Facebook supports itself is worrying to me.

That and other questions could have been and should have been explained during staff preparation of the Congress people while they prepared their questions.  They are pretty basic.

These hearings were one of the best arguments that everyone needs some computer science knowledge. Not just the computer people. Not just the STEM people. Everyone! And just maybe, with the way things are going,  its particularly important for those planning on a career in politics.

It also seemed that several people had trouble understanding the answers even though Zuckerberg tried to make them simple. It seemed like one Congress person had no real understanding of what an encrypted message was about. That’s not just a Facebook or even internet thing. Though we do often discuss it in digitally literacy units (I know I do.)

Monday, April 09, 2018

Why Programmers Need To Ask Questions

I keep seeing suggestions that people don’t need to learn programming because computers will do it better. I am skeptical. In part I am a skeptic because I have been hearing this sot of thing for scores of years and I don’t think we’re getting close to this that quickly. But more importantly I worry that it will take language processing a long time to get good enough at understanding people and language.

For example you may have seen this old joke:

A wife asks her husband, a software engineer "Could you please go shopping for me and buy one carton of milk, and if they have eggs, get 6!" A short time later the husband comes back with 6 cartons of milk. The wife asks him, "Why the hell did you buy 6 cartons of milk?" He replied, "They had eggs."

I like to share that with my students to help them understand ambiguity in language. Today I saw this somewhat macabre version.

write letters

I’m still not 100% sure I want to use this one in class but it does highlight the risks of unclear speech.

One of the things I learned developing applications early in my career was that users use language that works for them and for people in their field but which may not be clear to others. It is important to understand their vocabulary, their understanding of the tasks, and how they work. Without a common set of assumptions trouble is an unavoidable result.

In the first joke above there is no clear connection between eggs and milk and bad assumptions are made. I’ve learned to question my wife closely about the shopping lists she gives me. Things that are totally clear in her head may be totally opaque to me.

Will computers be able to know how to ask the right questions? Or will they make assumptions of their own? I’m guessing this will take a while to work out. In the mean time we, people, are going to have to be very careful about how we instruct computers.

Friday, April 06, 2018

Idealism and Computer Science

Idealism is a good thing. Well, mostly it is. This morning I heard Facebook COO Sheryl Sandberg say that Facebook was too idealistic about somethings and that lead to the current Cambridge Analytica scandal. In another interview she said that Facebook was told by Cambridge Analytica that they had deleted their data which turned out not to be true. But Facebook trusted them.

When people have good intentions they tend to assume that others also have good intentions. The very early computers and Internet had very little in the way of security. Most people had only good intentions and assumed that everyone else had them as well. Why secure things if you are sure that no one will misuse them?

One of the things I learned early in my career is that any program of any size and complexity can be used in ways that the people who created it never intended. We’d all like to assume that no one would using things in bad ways. Alas, this is not the case.

These days we teach a lot about being safe with computers and protecting data. It’s a complex problem and one that I think students don’t always absorb as well as they should. Idealism is strong in the young even though there is evidence of people acting badly all around them.

Many of us get into the field of computing as a way to make the world a better place. Facebook wants to connect everyone in the world to build community. Google wants to index all the world’s information to make it accessible and available for everyone to learn.  Most companies at their core have some ideal of “good” as their mission. This is especially true of many companies, like Google and Facebook, that are founded by young idealistic people.

Somehow we have to get people to understand that there are people who will misuse data and we have to find ways to minimize the negative aspects while enabling the positive. And we need to start with the young so that they can continue their idealism and ideals and at the same time protect the people they are trying to help.

Thursday, April 05, 2018

Thoughts on where CS education tools come from

TouchDevelop is being retired. It’s not the first tool with educational use to be retired by Microsoft. Or from other companies either. While I have used TouchDevelop with my students I was getting ready to move to MakeCode anyway so it is not a fatal move for me by any stretch. I know other teachers who have been using it more extensively who are going to feel some pain though.

I tend to divide CS educational tool sources into four categories.

Professional tools that are useful in education. In this category we see things like Eclipse, Visual Studio, and other development tools that are being used to create real products. These tools are not going anywhere anytime soon. Companies, both those that use them and those who create them, have a vested interest in supporting and improving them.

University developed tools. This includes things like Alice and Scratch but also BlueJ and Snap! and, well, far too many to mention. These are also likely to stay around for quite a while. People tend to build careers around them and use them to attract graduate students who use them, enhance them, and generally want them to be around.

Education companies. Companies like Tynker and Birdbrain are included in this group. As long as these companies can make enough money to keep going their tools will be around.

Industry Research Projects This is often the most state of the art and cool new things. On the other hand they are the least to be around for a long time. AppInventor was originally one such. Fortunately for educators who adopted it, when Google was done with it they were able to hand it off to a major university where it continues. TouchDevelop is another. Hear though, when the researchers moved on to new ideas there was no similar handoff. Both the Touch Develop web app and cloud backend are open source under the MIT license:

There is no indication that anyone is going to take it on though. I always assumed this day would come to be honest. Industry research groups have changing priorities and in some ways that is a good thing. I could argue it is a very good thing in terms of advancing the state of the art in computer science. It’s sad for us in education who aren’t always as quick to adjust as industry is.

As one tool fades another grows. MakeCode is pretty cool and there is a lot there learned from TouchDevelop, the Micro:Bit and educational uses of them both in there. Microsoft is developing a sprite-based game engine for MakeCode and a new course on game programming, in the spirit of CCGA (an interesting curriculum based on TouchDevelop.). One hopes it will be available in some form for teachers to learn it this summer.

I’m not sure where the materials developed by code.org fit into my classifications though. They are a non-profit with industry funding but they are neither industry or academia.  They have some great stuff though. I am using their CS Principles program for example. Chances are I’ll retire before they “go out of business” so I can probably depend on them plenty long enough.

Nothing lasts for ever though and change is the most constant thing in computer science. So we have to learn to adjust and change our tools and our curriculum, probably, a lot more often than educators in other disciplines. At least we’re not going to get bored.

Wednesday, April 04, 2018

Phillips Academy Capture the Flag 2018

Those of you with interests in working on cybersecurity with your high school students this Capture the Flag event will find this to be of interest.


PACTF is back! PACTF 2018 begins Monday, April 16. Like last year, PACTF will work around your schedule and have a challenge for you, whether you’re a seasoned CTF veteran or just beginning. This year, we are proud to offer over $20,000 worth of prizes to the top 150 teams.

Short for Phillips Academy Capture the Flag, PACTF is a computer science and cybersecurity competition for high-schoolers. PACTF is brought to you by Amazon, DigitalOcean, and JPMorgan.

There will be two week-long rounds: from April 16 to April 23, and from April 23rd to April 30, 2017. During each round, you can pick any 48-hour span to compete with your team.

Registration is open — sign up now!

Happy hacking,
The PACTF Team

How To Teach Computer Science

How can I do a better job of teaching computer science? It’s a question I ask myself just about every day. There have been two big influences on my teaching style. The first was my first computer science teacher – Wally Roth of Taylor University. One thing we know is that most teachers tend to teach the way they were taught and using  what worked for them. That doesn’t work for everyone and worse still it ignore changes in knowledge of pedagogy and culture. During my first round of teaching I knew that I was not doing the best job possible. The best I could do with what I knew sure. But I knew I didn’t know enough. Nine years at Microsoft traveling around the country and meeting with other teachers taught me a lot. Much of it I use regularly today.

More recently I have been influenced a great deal by Mark Guzdial. Mark actually researches how to teach computer science. Not just “hey I think this is cool so teach this way” but actual scientific, peer-reviewed research. I use ideas from him all the time. His blog is a must read for me. 

Recently he gave a talk (viewable here https://www.youtube.com/watch?v=N3uCb-95fFE) on a lot of what he has studied. A couple of highlights are:

  • Teaching in context
  • Asking students to make predictions during demos
  • Sub goal labeling
  • Using examples and Parson’s Problems

As I learn more about how to use these techniques and figure out how to fit them into how I teach I am using them more and more. I recommend the video as there is a lot of good information in about 45 minutes of talk.

Tuesday, April 03, 2018

Digital Thinkers?

This message from Brian Aspinall was floating around in my social media the other day and it really resonates with me.

problem solvers

I’ve long said that we don’t need to teach computer science to create more computer programmers (coders). Now teaching computer science or programming does not automatically make people better problem solvers even if we want to really believe it does. But at least it adds another tool to the tool box.

I’m not sure I know what a “digital thinker” is but I am sure we need people who understand computer science. We are depending on computer science to help us solve an awful lot of problems these days. Leaders of the future are going to be in bad shape if they don’t have some understanding of the power and the risks of computer technology.

Monday, April 02, 2018

Is Computer Science Hard to Learn?

It’s been close to 45 years since I took my first computer science course. I really struggled with the first program. OK someone mostly wrote it for me. The third program we worked on together and the third I mostly wrote for the other person. People do seem to learn computer science at different rates. By now a lot of it seems easy. Programming in particular seems pretty easy.

It doesn’t seem to be so easy for students though.  Is it harder now or do I just not remember how hard it was when I started?  Does it take special motivation?

That’s just one thing I started thinking about while listening to Don Wettrick’s podcast with Doug Bergman and his students.

Doug Bergman: The Case for Computer Science in School’

Lots of good stuff in this podcast. Well worth the listen.

Thursday, March 29, 2018

But I Digress

Students sure are good at distracting teachers from the main topic. Especially if they have a teacher who likes to talk. I confess that I am someone who likes to talk (ok stop laughing those of you who know me.) I tend to think that some digressions are a good thing though. Sure it is not very helpful if students get me talking about my wife or grandson (or my son the principal for that matter.) On the other hand sometimes the best lessons come from a little digression.

Yesterday we were talking about validating data – specifically people’s names which are more complicated than many students realize. That alone can take on far afield. From there we moved on to validating credit cards and from there to validating passports. Yep, we got into check digits which I actually think is an important computer science topic. A few minutes to get students  thinking about that is a good thing.

Some years ago a discussion on loops lead to an unplanned set of examples of loops coded in multiple programming languages including Assembly language. A year later a student returning from university told me he thought that was the most valuable lesson of the course. I guess that worked out well.

Sometimes we as educators get a little too attached to our lesson plans. We MUST cover what we have planned for that day in just the way we have planned. We only have so many class minutes and a lot of stuff to cover. Over the years I have concluded that, at least for me, sometimes it is not just ok but very beneficial to digress a bit from the plan. Spending some time on something that students are actually interested in and curious about seems to help the rest of the material to go down better. Serendipity (a word I learned by chance when I was in high school) is a good thing.

As educators we have to be open to taking advantage of serendipity when it aids learning. Given just how much there is in computer science and how much more of it is then we can possibly teach in the time allowed this serendipitous learning may be the most important learning of all.

Wednesday, March 21, 2018

The Problems With Small Programming Projects

Most programming projects for beginners are small ones. They are focused on a specific concept that is under discussion. They are often forced in the sense that a professional programmer would seldom write them they way students are asked to write. They are concept examples or exercises. Often they are also boring. Mike Zamansky wrote a nice post about teaching refactoring  in which he says “Beginners work on small "toy" 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 …”. And he is so right about that.

One of my favorite courses to teach is called Honors Programming which is only a semester long. I have some fun projects but most of them are small ones. Just when we get enough of t he basics to make really interesting projects the semester ends. In one of the Indiana Jones movies, Professor Henry Jones says  “You left just when you were becoming interesting.” How appropriate for my single semester course. I often wish I had a second semester to just take on a couple maybe two, maybe only one, that would really let us get into someone big.

I’d really love to dig into concepts like refactoring, real top down design, user written classes that have serious meaning and importance, code reuse, unit testing, and of course real planning. Multi-person projects would be great as well. I do some of that with smaller projects but there is so much more than can be done with a project of real size.

The existence of the AP CS courses makes a course like this hard to fit into the schedule. Yet another reason I am not a fan of AP CS. Heavy sigh.

What’s it like at your school? Do you feel the need for large scale projects or do you get to do them? Or do you think small projects are enough for now (high school?) and they’ll get to large projects later? Hint: Small projects are a thing in most higher ed programs as well.

Tuesday, March 20, 2018

Should We Do More With Spreadsheets in CS Education?

The Microsoft Research podcast has some very interesting interviews. One of them is How Programming Languages Quietly Run the World with Dr. Ben Zorn There are many fascinating things in this interview. Internet of things, security, software verification, and this interesting line:

So, by numbers, spreadsheets actually are the most important programming language in the world.

You really should listen to the whole podcast or read the transcript get get all of the value from it. I was fascinated, especially by the Internet of Things and security discussion. But the talk of spreadsheets is what I want to think about today.

I think many of us who teach computer science under estimate the importance and value of spreadsheets. They are ubiquitous today and are at the core of many things in business, industry, and even in our daily lives. At my school we teach them for a few days in our freshmen course. We don’t get very deep into them though. About the most computer science like thing we cover is if statements and conditional formatting. It’s a start but we are really only scratching the surface of what spreadsheets can do.

Given how many more of our students will be using spreadsheets later in life compared to how many of them will be serious programmers (using things other than spreadsheets anyway) should we be teaching them more? Or teaching them how computer science and programming are useful in spreadsheets?

I don’t know where this all fits in, or should fit in, to computer science curriculum. Should it be something that is taught by other departments with domain specific examples and issues? That would probably be nice as it would seem more relevant to more students. Teaching things in the abstract seldom “grabs” as many students as teaching in context does. But are teachers in those domains prepared to teach these things? At the university level, probably, especially with adjuncts with industry experience. At the high school and younger levels I am less confident.

So I have some thinking to do. I hope you’ll do some thinking about this and leave some thoughts in the comments. Let’s work on this idea together.

Monday, March 19, 2018

Advanced Placement Computer Science is a necessary evil for #CSforAll

Two controversial assertions in that title. That APCS is necessary and that it is evil.  I thought about leaving this post at that and seeing what sort of conversation started but that didn’t work on Facebook so I figured it would not work here either.

To start things off I should say that I am not a fan of the AP CS program. It’s too limiting. It is too tied to an end of the year test for me. The AP CS Principles course has more freedom than the AP CS A course does but still depends on an end of year test (and two performance tasks). Those performance tasks take up a lot of class time. I really like project based learning and I would love to have more time for larger projects. APCS courses suck the air out of the environment for other, more interesting to me, long term (year long) courses. I think there are better ways to prepare students for later CS education and careers. That’s the evil part.

On the other hand, the Advanced Placement brand carries a lot of weight with school administrators, school boards, parents, and other interested parties. It’s often an easy sale to these people as an argument for a new CS course.  If  we want to see “CS for All” APCS can be very helpful. But is is still necessary?

We have some well accepted starter courses in high school CS. Exploring Computer Science for one. Code.Org’s CS Discoveries is gaining some fans as well. They’re both good starters. In some ways I think they may ultimately lead to more high school Computer Science than AP CS will. But we’ll always want an advanced course to be the capstone of sorts. Should AP CS be that course(s) or should we have something more open-ended and less constrained by an exam?

What would you like to see at the top of the high school CS curriculum? Is AP CS the right answer? Is it a necessary course?

Friday, March 16, 2018

Impressive High School Computer Science Students–Made or Born?

ACM and the Computer Science Teachers Association (CSTA) announced the winners of the 2017-2018 Cutler-Bell Prize in High School Computing recently. Five students from four schools were given this award this year. One of the students was from a public school. The rest from independent schools. The public school has magnet programs but I don't know if the winner is part of those programs.

What does that mean? My best guess is that independent schools allow more flexibility for projects like this. Not just independent schools of course, schools like the Bergen County Academies and schools like Thomas Jefferson in Virginia clearly have a lot of flexibility, extra resources, and are open to encourage things like this. TJ had an awardee in both of the first two years of the award for example. But they are exceptional schools in more ways than one. They are not your typical public school. Looking back on the first three years of awards almost all of the awardees have been from either independent schools or public magnet schools.

It’s not just computer science though. Take a look at the schools who have had the most awardees in the Westinghouse-Siemens research competition. You'll see some familiar school names there. Most of them magnet schools.

My friend Mike Zamansky (blog Twitter) ways these awards say more about the students than the schools. I’m sure that is the case to some extent. But why so many of these students from magnet or independent schools? I think environment is important. If it were all about the student we would not see these clusters of schools that produce an outsized number of awardees.

I don’t know if the motivated students choose these school or the schools themselves develop this motivation. What I do think is that these schools have the flexibility to enable and support these students.  They also have a history of producing “winners” and a culture that sets high expectations but also provides help for students to meet those expectations.

Sure students from “regular” comprehensive high schools can and do earn these awards. That is not the way to bet though. The question in my mind is how to we add the flexibility and support to more students at more schools?

Thursday, March 15, 2018

ACM and CSTA Announce 2017-2018 Cutler-Bell Prize Student Winners

Some cool projects which you can read about here.

For more information about ACM/CSTA Cutler-Bell Prize in High School Computing, visit http://www.csteachers.org/CutlerBell or http://awards.acm.org/cutler-bell/.


ACM and the Computer Science Teachers Association (CSTA) have announced the winners of the 2017-2018 Cutler-Bell Prize in High School Computing. Five high school students were selected from among a pool of graduating high school seniors throughout the US who applied for the award by submitting a project or artifact that engages modern technology and computer science. A panel of judges selected the recipients based on the ingenuity, complexity, relevancy and originality of their projects.

The Cutler-Bell Prize promotes the field of computer science and empowers students to pursue computing challenges beyond the traditional classroom environment. In 2015, David Cutler and Gordon Bell established the award. Cutler is a software engineer, designer, and developer of several operating systems at Digital Equipment Corporation. Bell, an electrical engineer, is researcher emeritus at Microsoft Research.

The winners are Sreya Guha, Castilleja School, Palo Alto, California; Amir Helmy, Eastside High School, Gainesville, Florida; Amy Jin, The Harker School, San Jose, California; and Benjamin Spector and Michael Truell, Horace Mann School, Bronx, New York. The winning projects illustrate the diverse applications being developed by the next generation of computer scientists.

More at https://www.acm.org/media-center/2018/march/cutler-bell-prize-2017

Tuesday, March 06, 2018

Learning By Coding

Throughout my career I have increased my knowledge by working on projects. As a teacher who teaches mostly beginners I don’t see a lot of complicated code. No I take that back beginners write lots of overly complicated code. What I don’t often see, because I don’t often need, are new language features, library routines, or good new ways of doing things.

Now sometimes I have students show me new things. Sometimes they stumble upon them. Sometimes they  go on the internet looking for ways to do things. And sometimes they learn them from parents in industry. These are all good things but sometimes I still feel like I am stagnating. That I am not learning enough. Perhaps even falling behind.

This last week was school vacation. That means time to think ahead and to look at things differently. I did a bunch of reading. Mostly I read papers from SIGCSE. Yes, I pay money for the privilege but its worth it to me. I also wrote some code.

I’ve got to grade Explore Performance Tasks from my AP CS Principles students. Since feedback is important I decided to write a program to help me generate that feedback. What was involved isn’t really that important. In fact I suspect that writing the code isn’t going to save me as much time as it took to write the program.

What is important, to me at least, was that I explored some new things. A new Windows Forms object (CheckedListBox for the curious) for one thing. I also got in some practice with ForEach. That’s not new to me of course but I did think about it in some new (to me) ways. It probably doesn’t seem like a big deal. It’s not going to get me a raise or a new job or even add something new to what I teach in my current classes. On the other hand it is the sort of thing that helps keep programming fresh, interesting, and fun for me.

It may turn out that some student will come to me with a problem that needs just the sort of things I played with last week. That would be great. But even if not, continuous learning is a good thing.

Monday, March 05, 2018

Let The Computer Grade the Projects

It seems like a great idea – have the computer automatically grade student projects. Save all that boring work. Looking at all those projects is a pain. Why not have the computer grade them? It’s what happens in a lot of courses. Harvard’s CS50x online version does it so it must be great. In fact  a lot of huge courses in major universities use automatic grading software. What could be wrong about all of that? I confess that its a very tempting idea at times.

I’ve played a little with software looking at projects with some simple HTML projects. For rote stuff like making sure all tags are present and that open tags have matching closing tags is pretty straight forward. I still want to open the pages in a web browser to see what they look like.

Programming projects? I’m not so sure about automated testing for students. Mike Zamansky blogged recently about a session at SIGCSE (Sigcse2018 - Malloc Lab) where a professor had to deal with students gaming the grading system. This is one of my biggest concerns with automatic grading software. It is easily “game able.”

Getting to the destination is only part of the story. It’s pretty important to understand how students get the results they get. We, as educators, only learn so much by seeing the results of a program. We really need to understand how the programs process inputs and generate outputs. When we read student code we learn a lot about our students. We learn what they know and don’t know.  We learn how they implement algorithms. We also see what they understand and don’t understand. In fact we also get to know our students better. We learn their coding the way English teachers learn student's writing

Students benefit as well. We can give them a lot more feedback than automatic grading routines can give. We can also modify how and what we teach based on what we learn from reading their code. So for now I think I will put up with the extra work. The extra benefits are worth it.

Thursday, March 01, 2018

Registration Now Open for Computer Science Teachers Association’s 2018 Annual Conference

The Computer Science Teachers Association’s 2018 Annual Conference will take place July 7-10, 2018 in Omaha, NE. Don’t miss out on this world-class professional development opportunity, and the ability to network with peers in the computer science education community. Register today at: cstaconference.org

I’ve taken a look at the conference program (http://www.csteachers.org/page/2018conference#program) and it looks amazing.

Monday, February 26, 2018

Cyber Security or Just Good Program Design?

People continue to share things that they learned at SIGCSE online. Recently Ria Galanos, from Thomas Jefferson HS, shared Cybersecurity Modules: Security Injections|Cyber4All @Towson These ae a bunch of modules for teaching about various security issues like integer errors, Input Validation, and buffer overflow. Examples are in a number of languages including C++, Java, and Python. Looks like great stuff really.

From what I understand the majority of security vulnerabilities in software are a result of one of these three types of errors. Clearly they are important concepts but we don’t spend a lot of time talking about them in beginner classes. That probably needs to change.

It seems like we keep adding things to what we should be teaching beginners. Ethics, Accessibility, Security, and let's not forget the stuff for the AP Exam. How do we fit it all in?

Ultimately we have to do things in parallel. I think we have to think about ethical computing, safe programs, and accessible software as all part of good, solid program design. I think it is a mistake to think about all of these things as separate units to be taught in isolation. Projects can be created that integrate security, accessibility, and more by defining them all as good design. Not something special to do just for security or just for accessibility but for sound design.

Now to go look at my projects and see how to do all of that.

Friday, February 23, 2018

Accessibility and Computer Science

I’ve been following, as much as one can, the SIGCSE conference via Twitter this week. One of the comments I read talked about how many places don’t teach accessibility because they don’t see it as part of computer science. I can see that – sort of. On the other hand, accessibility is really an important part of human computer interaction and few fail to see that as an important part of computer science. Human-Computer Interaction is one of the 18 Knowledge Areas discussed in the CS 2013 Final Report

These days are we increasingly recognize diversity as important in teaching computer science I think it is important to realize that accessibility is essential for improving diversity in all areas. That means it should be included in any discussion of Human-Computer Interaction.

Speaking of HCI, the video below is a fun and useful look into what HCI and good design means. It was shown at SIGCSE by Tim Bell of Computer Science Unplugged.

Thursday, February 22, 2018

Modeling Good Coding Practice

Facebook showed me this cartoon this morning.

Programming alone

Teaching computer science means you are often programming while someone watches. I confess that I have been known to write something “quick and dirty” but that is not really an option for anything that students might ever see. Or really anyone else might see. “Do as I say not as I do” really doesn’t work for anything.

Generally I’m pretty careful about how I write code while I am doing a demo or creating a scaffold project for students. It requires a few extra minutes but I think it is important to model good practices. I think I have to make a point of explaining why I am taking those extra steps as they are not obvious to beginners.

Sure it seems unnecessary to rename a label box when there is only one label box on the form. Or to change the text property of the form. Or any one of a number of things that appear to be cosmetic and that don’t keep the program from working. But habits are important.

I remember once asking my father why we had to have perfect table manners at home where no one could see us. My father explained that by developing the good habits at home we would be less likely to mess up in public. It’s a lesson that stayed with me. It is why,even in the small simple code, using good coding practice is important. That way you don’t have to think about it when the coding gets public.

Wednesday, February 21, 2018

Open Letter to People at #SIGCSE2018

The Annual SIGCSE Technical Symposium is taking place in Baltimore this week.  Some of the best minds in computer science education are sharing ideas in sessions, panels, birds of a feather, and hallway conversations. At the same time most of the people who really need that information – classroom teachers, adjunct faculty, and others teaching computer science – are not there to hear it. It’s reality. We can’t all be there. We are starving to hear about what people learn at SIGCSE though.
Now some of us who are members of ACM and SIGCSE will get the papers later but that only goes so far. My request to the people at SIGCSE is that they find ways to share some of the things that don’t make it into the printed papers. Things like the keynotes. What an amazing lineup of keynotes this year it is too!

And the birds of a feather and the hallway conversations and the rest of the stuff that is just so hard to capture.

How should you do it? Well lots of ways. For one thing live tweet the event. Use the official hashtag - #SIGCSE2018. There are people at home watching. We may even ask you questions.

Share things on Facebook. There are a couple of good groups there that would probably welcome SIGCSE posts. I can think of Computer Science Education: Researchers & Practitioners and Computer Science Educators as examples. Or post them as public on your own account so people can share them.

For another write posts on your blog. Don’t have a blog? I tell you what – I will post guest posts from SIGCSE attendees here on my blog. Send them to me at act2@acthompson.net with your attribution information and I’ll post as many as come in.

Consider offering to talk about SIGCSE at a future local CSTA chapter meeting. You’re probably going to share information at your home institution but there are lots of others who would love to hear about what you learned at SIGCSE.

Programming Patterns For Beginners

Ever since I read those papers on the Rainfall program (How Hard Is That Programming Problem?)  I’ve been thinking about patterns in problem solving and programming. There are many of these types of patterns in programming but most of us learn them through experience.

The Rainfall problem is one example. It’s basically a counting and totaling loop that handles exceptions. Anyone who has done one of those (or maybe two if they are like me) probably sees that pattern as soon as they read or hear the problem statement. It’s new to beginners though.

One of my favorite patterns (much more complicated for beginners to see) has to do with avoiding special cases for boundary conditions. Take for example the lights out project (Taking Things To Another Level ) it involves checking the squares above, below, to the left, and to the right of a box in a 5 by 5 grid. Beginners tend to see that as calling for special cases for the corners and edges. Experienced programmers create an invisible row above and below and an invisible column to the left and right of the visible grid which allows all boxes to be checked the same way. It’s a pattern many of us have seen before.

After a while I think most of us don’t even consciously think “oh that is a pattern I have seen before” but we just go with it. Of course there are far too many patterns to teach all of them in a single semester (or single life time I suspect.)

lately I have been asking myself “what are the most common patterns I can think of and how to I create projects to give students experience with them?” And more than that, how can I get them to recognize those patterns in the future? I can’t assign enough projects so I think we’ll be reading some code. Maybe playing with Parsons Problems. But definitely I need to have students read more code.

Do you teach patters explicitly or just implicitly? What patterns do you see as most important for beginners to learn?

Friday, February 16, 2018

Self Driving Everything

Nissan put together this cute little video that starts with self driving slippers and moves on to self driving pillows and chairs and, well, watch it.


What's next? That is the question I would ask students - what else should be self driving? And why?

Thursday, February 15, 2018

Jumanji and the While Loop

Cultural references (term used loosely) can make projects and exercises more interesting for students. Now that there is an updated version of the movie Jumanji out I decided to use that reference again for working with while loops.

If you remember the movie, you will probably remember that people playing the game can be forced to wait in the jungle until another player rolls a 5 or an 8. There are several ways you can use this in an exercise. You can “roll” dice once and use an if statement to report if the person can leave the jungle or not. OK but boring. Or you can simulate rolls to see how many “moves” it takes to get someone out of the jungle. That’s what we did.

There are several things I like about this exercise. We start by asking if the loop should check at the top or the bottom. Of course you can write it either way but the discussion is the valuable part.

Next we take on how the Boolean expression is formed. Finally we talk about the code inside the loop. One die with a range of 1 to 12 or two die with a range of 1 to 6? Which one better simulates real game play and why? Finally we talk about how to do the counting inside the loop.

image

All in all I find it a helpful exercise. As a demo it is simple enough to show the basics but involved enough to have some good conversations about how and why we do things different ways. And it is relatable to things outside of school.

Tuesday, February 13, 2018

Quotes About Programming and Computer Science

While looking for a quote that was mostly remembered except for who to credit with it I found a couple of fun sites with quote collections in them. Some of these I already share with students. I think I may print out some more of these quotes for my bulletin board.

This first site is a single (longish) page with some of the best. One of my favorites is:

When debugging, novices insert corrective code; experts remove defective code. ~Richard Pattis

image

This next list is collected by Rich Pattis who is very quotable himself as you can see above. His list covers more than just programming. I love this one:

Those who know, do. Those who understand, teach. - Aristotle

image

This next one shows you a quote of the day and has a long list of sources in a menu on the side of the page. Lots of great people to check out. I like this quote by Bill Gates:

"Measuring programming progress by lines of code is like measuring aircraft building progress by weight."
- Bill Gates
Read more: http://www.softwarequotes.com/showquotes.aspx?id=579&name=Bill Gates#ixzz570txjSqE

image

This one has two pages of quotes. Some are more interesting than others to me but I did like this one:

“That's the thing about people who think they hate computers. What they really hate is lousy programmers.”
Larry Niven

image

Do you have a favorite source for computer science quotes? Or a favorite quote that you don’t find on one of these lists?

Monday, February 12, 2018

Teaching Diversity in Computing

One of the important topics in computing these days is diversity. Why? Well there are things like concern about equal opportunity. (Why Can’t Silicon Valley Solve Its Diversity Problem?) and that is part of it. It’s often hard to make people understand why that lack of diversity is a problem. People are only starting to understand how bias creeps into software. It creeps in because we all have biases – some more subtle than others. And that influences how we write software.

Here are a couple of issues that have come up based on race for example.

It should be obvious that something like facial recognition should be tested with a wide variety of people with different faces and skin tones. Right? Well apparently it is not so obvious.

Some early color computer monitors used a mix of red and blue colored letters. This is actually a problem because there are a surprising number of people with red/blue color blindness. No one on the design team had the problem of course so it slipped by until the product was released.

There is a story, I haven’t been able to verify it but it is a good example, that early models of the Apple Newton had a very good handwriting reader. Well until they handed it to a left handed person and it could not read their handwriting.

I’ve been talking about testing and debugging with my students lately. It seems like a logical place to talk about algorithmic bias and the need for testing with a diverse population. We talk about how different viewpoints also contribute to more and different ways of looking at problems.

I feel like this is an important topic to cover. Having a more diverse population in computing is clearly an issue of fairness and that is enough of a reason to promote it. But I don’t think it hurts to point out that diversity also results in better software which benefits all of us. If we don’t explain this and teach it than I don’t think all of our students will understand this on their own. Some will of course but it is too important a topic to leave to chance.

ajllogo_wetnmgBTW there is a regular Twitter chat on ethics and computing using the #EthicalCS hashtag. Highly recommended.

For more on the topic of bias in algorithms you  may want to visit the Algorithmic Justice League.

Friday, February 09, 2018

Priming the Computing Teacher Pump

Where are computer science teachers going to come from? That’s the big question. OK it is one of the big questions about Computer Science for All. Increasingly CS is moving to younger and younger grades and a lot of people are asking where those teachers will come from. Many teachers who teach computer science now don’t think of themselves as computer science teachers by the way. In elementary schools most teachers appear to think of themselves as grade level teachers. The generally teach most everything.

I believe we want computer science integrated in the elementary school curriculum and not just a subject taught by specialists. I was a computer specialist in a couple of elementary schools many years ago and while it was fun I think it would have been a lot more effective as a more integrated subject.

But anyway, back to the question, how and where and when are these teachers going to learn to teach computer science? There has long been some discussion about getting schools of education involved. Not much progress and most of the talk seems to have been among computer science education people.

Earlier I saw this post on Mark Guzdial’s blog - Finding a home for computing education in US Schools of Education: Priming the Computing Teacher Pump

So of course I visited the related website  - http://www.computingteacher.org/ – to learn more. Some of the most amazing people in CS education are involved. I hope a lot of schools of education take notice and get involved. We need teachers prepared to prepare all students.



Priming the Computing Teacher Pump: Integrating Computing Education into Schools of Education

This report focuses on Schools of Education rather than Departments or Colleges of Computer Science/Computing for setting up CS teacher education.


We challenge US teacher education programs to innovate and integrate a new discipline into their programs. What we propose is nothing less than a change to the American Education canon. Such enormous change will require innovating in different ways, using different models and strategies, before we find models that work. The report, Priming the Pump, will highlight examples of integration from across the United States, and provide concrete recommendations for discussion.


With the expansion of computing education in mainstream K-12 schools, the current training mechanisms for teachers quickly will fall short of supporting a sustainable pipeline of teachers for the scale many cities and states have committed to.

The Struggle To Keep Programs Simple

Debugging code is hard. Really hard. The more complicated the code the harder it is to debug. Brian Kernighan said it well.

debugging

But oh do my students write clever code. Well, they think it is clever code. If nothing else it is complicated. It’s not really their fault though. Not completely.

Looking at student code the other day I realized that their tool set is limited. They don’t always have the tools to write code simply. I’ve blogged about this a bit before (The Complex Question of Complexity in Programming ) but it is something I keep struggling with. Many problems, like the Lights Out project in that referenced blog post, can be written in far fewer lines of code if you know about arrays. Without arrays it takes many lines of code and there are many places things go wrong. On the other hand the many lines are simple lines while the array version is more complex and has to be thought about a lot more.

Which way is better? Well that is open to debate. Plus it depends on the experience of the programmer.

It’s more than tools though. My students have been writing a project that involves a lot of if statements. They are doing the Ski Lift Ticket Project that I have blogged about before. There  are a lot of ways of constructing this solution. Some are more complicated than others. It always seems like some students want to make it very complicated. Why? I’m trying to figure that out but my working theory is planning. That and working in stages.

Some students try to handle both the age range and the resort status at the same time. For an experienced programmer this is not a big deal. For a raw beginner this can be a bridge too far. Students who first think about the age ranges and test that and then look at the resort status tend to do better. Better as in finish first and have less complicated solutions.

Too often beginners just start writing code without planning. Rather than being that fast way this is the long way. It also tends to result in more complicated code as line after line is added to handle situations that were not thought of in advance. Obviously I talk about planning all the time. And I try to model it when we work though exercises as a class. But well, kids in high school, know better. Just ask them – they’ll tell you.

I keep trying though. I also try to show them code and point out the design steps and the simplicity that makes it easier to follow. And I give them more tools as well. A lot of times a light goes off and a student says “I could have done this other thing a lot easier if I had known about that.” Yep, so keep learning new tools!

Thursday, February 08, 2018

Is that a trick question?

For me at least writing test/quiz questions for programming students is hard. Most of what I assign and grade are projects but sometimes I like to toss out a quiz to see if I can figure out what students really know.  And frankly, some students are more comfortable with traditional quizzes and tests so it feels like a good thing to do. But as I said, writing questions is hard. I tell my students I can write a hard quiz really quickly but an easy one takes longer. I think that is true for a lot of teachers. Either way students like to second guess teachers on the questions they are asked. You’ve all heard it (and maybe said it yourself – is this a trick question?

Now this is a trick question:

What is the value of x after this code executes:

int age = 21;
int x = 15;
if (age >= 21)
     x = 15;
     age = age + 1;
     x = age;

It’s a trick question, in my opinion anyway, because it uses tabs to make it look like three statements are executed if the if statement is true. And that may be the case in some languages but in C-family languages like C, C++. Java, and in my case C# it’s not. I want students to realize that without curly braces x is going to be 22 no matter what else goes on. There is some extra code in there just to confuse things. Is that a good question? Arguably not but students never complain about it. What to they stress over and question me on? The freebee question I tossed in to make the quiz an even number of questions.

Enter the letter A as the answer to this question

I want to fix the first question BTW. I’ve never liked it but I was in a hurry one day. The second one I think I’ll leave as is.

I want more questions that require students to read code. The thing I struggle with is how to write good code reading questions without using poor coding practice. The AP CS A test has some and I toy with borrowing some of them and making adjustments for various programming languages but  so far I spend more of my time trying to come up with projects.

I’ve also used Code Hunt with some classes with mixed results. I may tackle that again soon. It can be tricky to set up your own questions though.

I have been reading about questions that ask students to put lines of code into the correct sequence. (Parson's Problems) That seems like a good idea. I wish I had a good tool for both writing them and having students work them out online. Any one know of such? (Looking at one in the comments.)

What sorts of questions do you ask programming students? What tools do you use to ask coding questions?







Monday, February 05, 2018

Does Anyone Read the Error Messages?

I suspect most if not every Computer Science teacher has had this conversation:

Student: Hey, I’m getting an error.
Teacher: What error are you getting?
Student: I don’t know.

Often they have dismissed the message without reading it. Even if they have it on the screen they may still not have looked at it. Why? I have no idea. So the teacher goes to the computer, looks at the message, and asks the student what it says. The student reads the message and then asks “what does it mean?”

Today I was thinking that maybe I should write up a longer explanation of the most common error and warning messages my students get. Will they read that document? Maybe. Maybe not. Ultimately though the problem is that they give up too soon. They don’t spend enough time reading the message and trying to determine what it means.

It’s not just a problem for beginners though. Years ago I was at a computer company supporting professional developers at a very technical company that built very sophisticated systems. One of the most common parts of my job at times was explaining error messages. Often I was explaining messages I had never seen before but was able to at least parse some meaning out of them.

Now it is easy to blame the people who write the error messages but many of them seem very clear to me. Is that because I have so much experience making errors? Perhaps but I don’t think so. More often, especially with beginners, one is so close to the code and so sure that it is right that is seems incongruent that there is an error message. Many is the time a student has told me “I am doing everything right and still getting an error message.”

In the long run, students can learn a lot from their errors. They can learn about the code obviously but perhaps more importantly they can learn the value of critical thinking and close reading. We as educators have to be careful about finding the thin line between giving clues and giving fast answers.

Thursday, January 25, 2018

Thinking About CS Textbooks

There are a lot of subjects where I found textbooks to be very valuable when I was a student. History for example. One of my degrees is in Sociology where I read all the textbooks cover to cover. In Computer Science I tended to use textbooks more as a reference – a place to look things up – more than as something to read cover to cover. I’m sure that is the same for some but very different for others.

I’ve never really figured how to get the most out of a text book while teaching computer science. For the most part I haven’t used them at all. I do have a lot of materials I make available to my students though. They have copies of all my PowerPoint presentations for example. Lots of them have information in the speaker notes. I also link to videos online. Some I’ve recorded and some by other people. Code.Org has some great ones for example. (https://code.org/educate/resources/videos) I also write up some “how to” for things I don’t necessarily cover in class. This seems to work ok but lately I have been thinking I need more.

As I see it one of the problems with textbooks is that students don’t read them. Flipped classroom (read this at home or watch this at home and we’ll talk about it in class) seems to work for some people but I’m still skeptical. I’ve heard students complain about having to read 150 page books over a months time and wonder how likely they really are to be reading a textbook assignment. Even if they do, what do I have them read?

What I have decided to do is to write my own book. Now I have written traditional textbooks before. I’ve even gotten some good reviews on them. But for now I wanted something different. I want something short and to the point. Something as a reference or a “catch up” for missed lectures. So not pages worth of step by step hand holding. No pages of summary questions or exercises to assign. Just short explanations of concepts with some sample code to read.

I’m starting with my freshmen class. About a third of a semester is spent on learning some basic Visual Basic programming. We don’t got very deep or cover too many concepts. Variables, if statements, and loops – that’s about it. Including title, table of contents and index I’m at about 45 pages. I think that is about right.  Of and about a third of that is stuff I don’t lecture on because they are not core CS concepts but things students can use in their projects to make them more interesting. That way when I get the usual “Mr. Thompson how do I use a timer?” or “Mr. Thompson I want to use images in my user interface” question I can send them to the book. I have half a semester before I can try it out so I can tune it a bit.

For my honors programming class (we use C# there)  I am shooting for between 75 and 100 pages. That is a full semester and we cover a lot more material. Once again I see this as a backup and not my main teaching tool. I’ve got the topics for the first quarter just about finished so maybe I can use that this semester as well.

Now I am wondering how others use textbooks. It’s not a conversation I hear much about. Maybe I would have learned that if I had gone to school for education and not computer science? One of these days I want to attend a birds of a feather discussion about using textbooks.

Monday, January 08, 2018

How Hard Is That Programming Problem?

A recent blog post by Mark Guzdial (Learning Computer Science is Different than Learning Other STEM Disciplines) has my mind going in a bunch of different directions between the post itself and the comments people are making in  various places. I see a bunch of posts in my near future but I’m going to start with asking the question “How hard are the programming assignments we give students?” and “Do we really know?”

Mark Talks about the “Rainfall Problem” that started with Elliot Soloway. (I link to a couple of papers on the subject below)

Design a program called rainfall that consumes a list of numbers representing daily rainfall amounts as entered by a user. The list may contain the number -999 indicating the end of the data of interest. Produce the average of the non-negative values in the list up to the first -999 (if it shows up). There may be negative numbers other than -999 in the list.

If you are anything like me, your first assumption will be that it is easy. A piece of cake. Surely my students will solve that in no time. And yet the research shows that this is a very difficult problem for first year CS students. How can that be? I’m not sure we really know. Of course I will have to assign it to students first chance I get.

A famous interview question is FIzzBuzz.

Write a program that prints the numbers from 1 to 100. But for multiples of three print “Fizz” instead of the number and for the multiples of five print “Buzz”. For numbers which are multiples of both three and five print “FizzBuzz”.

Apparently that is a difficult problem for a lot of CS students as well (Why Can't Programmers.. Program? and Using FizzBuzz to find developers who grok coding) I assign that to my students and tell them in advance that is is hard. Most of them solve it pretty quickly. Am I a great teacher or do I have exceptional students or is something else at play here? Do we even know? Probably not.

In general I find it difficult to estimate how hard a programming project will be for beginning students. Let’s face it, I’ve been programming for 45 years so anything I am likely to come up with for first year CS students in high school is going to be pretty trivial for me to code. After assigning a project a couple of times one gets a sense of course but the variation between classes can be huge.

So if a problem takes too long or too short to complete who is to blame or credit?

Kathi Fisler from WPI said in a recent Facebook comment “From what I've read as I dig deeper into this, a huge factor in whether novices can solve _any_ programming problem is how closely it connects to problems and code patterns that they have seen before.”

That makes a lot of sense to me. DO my students do well with FizzBuzz because they have seen similar patterns in my class? Maybe because of the way my mind works and because of my experience both programming and teaching programming. If so, that raises a new concern. We can’t teach every possible pattern. We don’t even know every possible pattern. So how will our students do when they are exposed to something outside their experience?

My last set of questions, which I am struggling with today, are we teaching to the problem? In other words, do we teach in specific ways to prepare them for the problems we know we will assign? Is that good or bad? If bad, how do we do better? This teaching computer programming is hard!

Rainfall related academic papers

Monday, January 01, 2018

Computer Science Education Things I'm Watching in 2018

This time of year I like to think about what might happen in the year ahead. 2018 looks to be an interesting year for computer science education. There is a lot of momentum going and we'll see how it continues or not. A few specific things I am interested in though.

Advanced Placement Computer Science - Wow! did AP CS principles take off in 2017. Will that growth continue or was there just a lot of pent up demand? What is APCS P going to do to enrollment in APCS A?  I'm not sure anyone really knows. Chances are that both will see increased enrollment this year. How much is the question. AP CS is driving a lot  in high school CS education. It has credibility (deserved or not - a separate question) and that makes it easy to push into schools passed principals and school boards. In a sense it is a path of least resistance.

K-8 Computer Science Education -  This is the exciting place in CS education. APCS is boring. Sorry but it is. We're teaching high school CS the way we've always taught it. In K-8 we have a lot of people who don't have a lot of history teaching CS. They are teaching something new to them in many cases. They are looking to teach CS more like they teach other courses. Plus they are looking to make teaching and learning CS interesting for themselves and their students. This is where I expect to see teaching innovation. This is where we'll see teachers using robots, micro:bits, Android, and more hardware devices. I've been following the #CSK8 twitter chat during the last year. There is a lot of excitement and interest in doing fun things in CS education at the lower grade levels. That twitter chat is a must participate event if you are interested in CS in the younger grades. BTW as I write this the next #CSK8 twitter chat is about physical computing and will happen on 3 January 2018 at 5pm PT and 8PM eastern US time.

State Standards - More states are writing state-wide standards all the time. The trickle in 2017 may turn into a flood in 2018. How will that play out I wonder? What will the K-8 standards look like especially. Will the make CS required for all or just offered to all? I suspect different states will take different paths. It's going to be a lot to watch. My home state of New Hampshire is working on standards and I'll be taking part in that effort. I hope all the states continue to involve classroom teachers in this important work.

So what do others think will be the interesting things to watch in 2018 regarding computer science education?