Posts tagged ‘pascal’

Why do so few schools try LiveCode? We let industry dictate our tools

I’m an old HyperCard programmer, so I like LiveCode.  LiveCode does very well on the five principles I suggest for picking an educational programming language. The language is highly readable, and was actually designed drawing on research on how novices best understand programming. It’s easy to put together something that looks authentic and that runs on virtually any platform — much easier than Python, Java, Scratch, Blockly, or any of the other top five most popular teaching languages. Authenticity is often engaging for students.

The LiveCode folks have just put together a web page (linked below) describing some of the reasons why teachers should consider LiveCode.  But in general, we don’t.  Why not?  I have two guesses:

  1. There is no community of practice. There isn’t a visible community of teachers using LiveCode. There isn’t an obvious industry call for more LiveCode programmers.
  2. We in computing education are mostly driven by surface-level interpretations of industry needs.  It isn’t obvious that it must be so, or even that it should be so.  But the same forces that killed Pascal and promoted Python, Java, and C++ as our intro languages prevent LiveCode from getting adopted.

I think LiveCode, Smalltalk, and Lisp are all excellent pedagogical programming languages, but our teaching decisions in secondary and post-secondary CS education are rarely based on what will engage students, be easier to learn, or lead to transferable knowledge.  Instead, we tend to make decisions on what obviously looks like what current professionals do.  It binds us to normative practices. We’re stuck in apprenticeship as our teaching perspective, and can’t consider social reform or developmental perspectives.

Better Exam Results, Better Real Life Outcomes, More Fun!

Over a third of Scottish schools are now teaching using LiveCode. They are doing this because they have proven results showing that using LiveCode results in more students remaining engaged, reaching good grades, and continuing in the direction of a coding career.

Source: Education | LiveCode

November 10, 2017 at 7:00 am 23 comments

Blog Post #999: Research Questions in Computing Education

The 999th blog post feels like a good point to think about where we’re going.  Here’s how I define the big question of computing education research:

Computing education research is the study of how people come to understand computing, and how we can make that better.

But that’s the big question.  There are lots of research questions inside that.  Here are some of the ones that I’m intrigued by.  This is an overly-long blog post which I’m using as a place marker:  Here’s what I’m thinking about right now at the end of the first 1000 blog posts.  Skip around to the parts that you might find interesting.

What are the cognitive processes of learning to program?

Why is learning to program hard? The empirical evidence of teaching computer science suggests that it is. Failure rates worldwide of 30-50% in the first class have been reported for decades. The misconceptions and challenges that students faced in Scratch in Israel (ITICSE 2011) are quite similar to the same ones documented in Pascal at Yale in the 1980’s (Soloway et al.).

Are there cognitive challenges to learning programming that are unique among other disciplines? Perhaps so. Consider these two possibilities:

  • Agency: Writing a computer program is the task of providing instructions to another agent to execute, but a non-human agent. Miller in 1981 found that humans found it hard to describe task processes to another human, and the produced instructions required human understanding to interpret them. People do not naturally produce instructions at a level detailed enough for a computer to execute.
  • Time: A program uses a variety of notations to compress time, e.g., iteration and recursive constructs. These notations describe a process in brief which will execute repeatedly many times (perhaps millions of times). We know that these notations are among the most challenging for students to grasp.

Both agency and time notations are unique to the challenge of programming. Perhaps these factors (among others) help to explain why programming is so hard, and understanding these challenges will lead to new insight into how humans conceive of agency and time.

Where do problems/difficulties/misconceptions in learning programming come from?

Most students have no experience in programming computers before they enter their first computer science class.  So, no prior conception of assignment, memory allocation, WHILE and FOR loops, linked lists, or recursion — yet these are way up there on the list of things that are hard about learning to program.  They haven’t changed in decades, across multiple languages.  Where did those problems come from?  Do we teach them wrong?  Exactly where so that we can fix it!  Do students have some prior knowledge that is interfering?  What knowledge are students bringing to bear in learning to program?

Can we teach computing without a programming language?
Can someone learn what a computer is, how it works, and what its limitations are simply through non-programming activities?

Mathematicians did. Turing defined what a computer is, without a programming language. Instead, he defined a machine and a language.

I’m increasingly coming to believe that those are outliers — Turing and mathematicians who figure out computing without a computer are unusual, and we can’t do that at-scale.  Learning to understand computing is learning to understand a notional machine (duBoulay), to construct a mental model of how you expect the notional machine to work (Norman), and that mental model consists of decontextualized parts (deKleer and Brown).  It’s very hard to think about those parts without having names or representations of them.  It can happen, but it takes enormous cognitive effort.  It’s not going to be effective and efficient to reach our learning goals without a language.

Challenges for CS10K

The CS10K effort (to have 10,000 high school teachers capable of teaching CS:Principles in 10,000 US high schools) requires answers to some significant research questions. Some of these include:

What kind of pedagogy will fit into the lives of in-service high school teachers and other working professionals?

Computer science pedagogy today is mostly apprenticeship-based: Students get a bit of instruction (perhaps some modeling of good behavior), and then are expected to learn through doing, by programming in front of an IDE. While the apprenticeship-based model is effective, it’s inefficient if the goal is understanding about computer science, as opposed to expertise as a software engineer.

In-service high school teachers are a particularly challenging audience. Most likely, they will never be professional software engineers, and they are full-time (overworked) professions, so they have neither the motivation nor the time to engage in apprenticeship-based learning. How do we teach CS to these teachers in the small bits of time that they have available?

How do we create sufficient, high-quality on-line materials to lead to successful CS learning at a distance?

The best distance learning programs in the world (such as the Open University UK) rely significantly on text-based materials, because we know how to control costs while creating and maintaining high-quality content. CS is not best taught with printed text, since visualizations and simulations play a key role in student learning. How do we create sufficient (e.g., at reasonable cost), high-quality materials to support CS learning at a distance?

What will motivate high school teachers to take classes in computer science, to be engaged with the content, and to sustain their interest?

The existing CS teaching programs in the United States are woefully undersubscribed, e.g., Purdue’s CS methods course has never had more than one student enrolled each term that it is offered. What will drive more teachers into CS education?

What do teachers need in order to develop into successful computer science teachers?

High school teachers will not need to be professional software engineers. They do need to be able to present CS ideas, to assign and assess student work, and to mentor, e.g., to help facilitate student debugging and guide development. What are the learning objectives for CS high school teachers? How do we assess that development?

CS PCK: What is Computer Science Pedagogical Content Knowledge?
In most disciplines, there is a body of knowledge of how to teach that.  How People Learn has a whole chapter on domain-specific teaching practices, and points out that those are much more powerful for effective teaching than domain-general teaching practices.  For example, science educators explain how to support inquiry-based learning, and mathematics educators know how to build on innate understanding of number.  We call that knowledge pedagogical content knowledge.    How do we best teach computer science?  How do we help future educators develop the unique skills to teach computer science?

May 3, 2012 at 6:16 am 18 comments

The syntax problems in high school CS

This is a nice account of personal struggles with syntax getting in the way of playing with computer science ideas.  The stories are believable, about facing a course in Basic that was more about memorizing history, about a course in Pascal that made Basic seem simple in comparison, and about layers of languages leading to layers of complexity.  I also believe the idea that Scheme, with its minimal syntax, lets the learner forego memorizing “rules” of syntax.

However, I don’t buy the subtitle: “Simple language makes learning complex concepts easy.”  Simple language means that you don’t struggle with complex language.  Hard ideas in computer science are hard ideas.  Hard ideas in a complex language may be impossible for some students.  Hard ideas in a simple language means that you can focus on the right things–it’s easier, but I don’t buy that just the language alone makes complex CS ideas easy.

Simple Language Makes Learning Complex Concepts Easy

The thing I liked most about taking this course in Scheme was that I knew that I was learning something. Every concept I had ever tried and failed to understand comprehensively in my Pascal class – searching and sorting procedures, recursion, processing binary trees – was made clear when I studied them in Scheme. These things occur so naturally in Scheme that I couldn’t help but understand. After mastering the concept, I could then go back into my Pascal class and easily master the code. The point here is that concepts like these are universal in computer science. After you understand them, then you can learn the rules of any language in order to encode them. But it doesn’t matter how well you have mastered the syntax of a language if you don’t understand the meaning of what you are typing or the reason why it works.

via High School Computing: The Inside Story | Institute for Mathematics and Computer Science.

January 4, 2012 at 7:50 am 12 comments


Recent Posts

November 2017
M T W T F S S
« Oct    
 12345
6789101112
13141516171819
20212223242526
27282930  

Feeds

Blog Stats

  • 1,452,053 hits

Enter your email address to follow this blog and receive notifications of new posts by email.

Join 5,177 other followers

CS Teaching Tips