Posts tagged ‘end-user programming’

Reflections of a CS Professor and an End-User Programmer

In my last blog post, I talked about the Parsons problems generator that I used to put scrambled code problems on my quiz, study guide, and final exam. I’ve been reflecting on the experience and what it suggests to me about end-user programming.

I’m a computing professor, and while I enjoy programming, I mostly code to build exercises and examples for my students. I almost never code research prototypes anymore. I only occasionally code scripts that help me with something, like cleaning data, analyzing data, or in this case, generating problems for my students. In this case, I’m a casual end-user programmer — I’m a non-professional programmer who is making code to help him with some aspect of his job. This is in contrast:

  • To Philip Guo’s work on conversational programmers, who are people who learn programming in order to talk to programmers (see his post describing his papers on conversational programmers). I know how to talk to programmers, and I have been a professional programmer. Now, I have a different job, and sometimes programming is worthwhile in that job.
  • To computational scientists and engineers, which is the audience for Software Carpentry. Computational scientists and engineers might write code occasionally to solve a problem, but more importantly, they write code as part of their research.  I might write a script to handle an odd-job, but most of my research is not conducted with code.

Why did I spend the time writing a script to generate the problems in LaTeX? I was teaching a large class, over 200 students. Mistakes on quizzes and exams at that scale are expensive in terms of emails, complaints, and regrading. Scrambled code problems are tricky. It’s easy to randomly scramble code. It’s harder to keep track of the right ordering. I needed to be able to do this many times.

Was it worthwhile? I think it was. I had a couple Parsons problems on the quiz, maybe five on the study guide, and maybe three on the final exam. (Different numbers at different stages of development.) Each one got generated at least twice as I refined, improved, or fixed the problem. (One discovery: Don’t include comments. They can legally go anywhere, so it only makes grading harder.) The original code only took me about an hour to get working. The script got refined many times as I used it, but the initial investment was well worth it for making sure that the problem was right (e.g., I didn’t miss any lines, and indentation was preserved for Python code) and the solution was correct.

Would it be worthwhile for anyone else to write this script facing the same problems? That’s a lot harder question.

I realized that I brought a lot of knowledge to bear on this problem.

  • I have been a professional programmer.
  • I do not use LiveCode often, but I have used HyperTalk a lot, and the environment is forgiving with lots of help for casual programmers like me. LiveCode doesn’t offer much for data abstraction — basically, everything is a string.  I have experience using the tool’s facility with items, words, lines, and fields to structure data.
  • I know LaTeX and have used the exam class before. I know Python and the fact that I needed to preserve indentation.

Then I realized that it takes almost as much knowledge to use this generator. The few people who might want to use the Parsons problem generator that I posted would have to know about Parsons problems, want to use them, be using LaTeX for exams, and know how to use the output of the generator.

But I bet that all (or the majority?) of end-user programming experiences are like this. End-users are professionals in some domain. They know a lot of stuff. They’ll bring a lot of knowledge to their programming activity. The programs will require a lot of knowledge to write, to understand, and to use.

One of the potential implications is that this program (and maybe most end-user programs?) are probably not useful to many others.  Much of what we teach in CS1 for CS majors, or maybe even in Software Carpentry, is not useful to the occasional, casual end-user programmer.  Most of what we teach is for larger-scale programming.  Do we need to teach end-user programmers about software engineering practices that make code more readable by others?  Do we need to teach end-user programmers about tools for working in teams on software if they are not going to be working in teams to develop their small bits of code? Those are honest questions.  Shriram Krishnamurthi would remind me that end-user programmers, even more than any other class of programmers, are more likely to make errors and less likely to be able to debug them, so teaching end-user programmers practices and tools to catch and fix errors is particularly important for them.  That’s a strong argument. But I also know that, as an end-user programmer myself, I’m not willing to spend a lot of time that doesn’t directly contribute towards my end goal.  Balancing the real needs of end-user programmers with their occasional, casual use of programming is an interesting challenge.

The bigger question that I’m wondering about is whether someone else, facing a similar problem, could learn to code with a small enough time investment to make it worthwhile. I did a lot of programming in HyperTalk when I was a graduate student. I have that investment to build on. How much of an investment would someone else have to make to be able to write this kind of script as easily?

Why LiveCode? Why not Python? Or Smalltalk? I was originally going to write this in Python. Why not? I was teaching Python, and the problems would all be in Python. It’d good exercise for me.

I realized that I didn’t want to deal with files or a command line. I wanted a graphical user interface. I wanted to paste some code in (not put it in a file), and get some text that I could copy (not find it in one or more files). I didn’t want to have to remember what function(s) to call. I wanted a big button. I simply don’t have the time to deal with the cognitive load of file names and function names. Copy-paste the sorted code, press the button, then copy-paste the scrambled code and copy-paste the solution. I could do that. Maybe I could build a GUI in Python, but every time I have used a GUI tool in Python, it was way more work than LiveCode.

I also know Smalltalk better than most. Here’s a bit of an embarrassing confession: I’ve never really learned to build GUIs in Smalltalk. I’ve built a couple of toy examples in Morphic for class. But a real user interface with text areas that really work? That’s still hard for me. I didn’t want to deal with learning something new. LiveCode is just so easy — select the tool, drag the UI object into place.

LiveCode was the obvious answer for me, but that’s because of who I am and the background that I already have. What could we teach future professionals/end-user programmers that (a) they would find worthwhile learning (not too hard, not too time-consuming) and (b) they could use casually when they needed it, like my Parsons problem generator? That is an interesting computing education research question.

How does a student determine “worthwhile” when deciding what programming to learn for future end-user programming?  Let’s say that we decided to teach all STEM graduate students some programming so that they could use it in their future professional practice as end-user programmers.  What would you teach them?  How would they judge something “worthwhile” to learn for later?

We know some answers to this question.  We know that students judge the authenticity of the language based on what they see themselves doing in the future and what the current practice is in that field (see Betsy DiSalvo’s findings on Glitch and our results on Media Computation).

But what if that’s not a good programming language? What if there’s a better one?  What if the common practice in a field is ill-informed? I’m going to be that most people, faced with the general problem I was facing (wanting a GUI to do a text-processing task) would use JavaScript.  LiveCode is way better than JavaScript for an occasional, casual GUI task — easier to learn, more stable, more coherent implementation, and better programming support for casual users.  Yet, I predict most people would choose JavaScript because of the Principle of Social Proof.

I’ve been reading Robert Cialdini’s books on social psychology and influence, and he explains that social proof is how people make decisions when they’re uncertain (like how to choose a programming language when they don’t know much about programming) and there are others to copy.

First, we seem to assume that if a lot of people are doing the same thing, they must know something we don’t. Especially when we are uncertain, we are willing to place an enormous amount of trust in the collective knowledge of the crowd. Second, quite frequently the crowd is mistaken because they are not acting on the basis of any superior information but are reacting, themselves, to the principle of social proof.

Cialdini PhD, Robert B.. Influence (Collins Business Essentials) (Kindle Locations 2570-2573). HarperCollins. Kindle Edition.

How many people know both JavaScript and LiveCode well?  And don’t consider computer scientists. You can’t convince someone by telling them that computer scientists say “X is better than Y.”  People follow social proof from people whom they judge to be similar to them. It’s got to be someone in their field, someone who works like them.

It would be hard to teach the graduate students something other than what’s in common practice in their fields, even if it’s more inefficient to learn and harder to use than another choice.

June 11, 2018 at 2:00 am 2 comments

End-user programmers are at least half of all programmers

I was intrigued to see this post during CS Ed Week from ChangeTheEquation.org. They’re revisiting the Scaffidi, Shaw, and Myers question from 2005 (mentioned in this blog post).

You may be surprised to learn that nearly DOUBLE the number of workers use computing than originally thought.  Our new research infographic shows that 7.7 million people use complex computing in their jobs — that’s 3.9 million more than the U.S. Bureau of Labor and Statistics (BLS) reports. We examined a major international dataset that looks past job titles to see what skills people actually use on the job. It turns out that the need for complex computer skills extends far beyond what the BLS currently classifies as computer occupations. Even more reason why computer science education is more critical than ever!

Source: The Hidden Half | Change the Equation

ChangeTheEquation.org is coming up with a much lower estimate of end-user programmers than did Scaffidi et al. Why is that? I looked at their methodology:

To estimate the total number of U.S. citizens who use computers in complex ways on the job, CTEq and AIR examined responses to question G_Q06 in the PIAAC survey: What level of computer use is/was needed to perform your job/last job?

  • STRAIGHTFORWARD, for example using a computer for straightforward routine tasks such as data entry or sending and receiving e-mails
  • MODERATE, for example word-processing, spreadsheets or database management
  • COMPLEX, for example developing software or modifying computer games, programming using languages like java, sql, php or perl, or maintaining a computer network

Source: the Hidden Half: Methodology | Change the Equation

Their “Complex” use is certainly programming, but Scaffidi et al would also call building spreadsheet macros and SQL queries programming. ChangeTheEquation has a different definition that I think undercounts significantly.

January 20, 2016 at 8:13 am 8 comments

Should Everybody Learn to Code? Coverage in Communications of the ACM

I spoke to the author, Esther Shein, a few months ago, but didn’t know that this was coming out until now.  She makes a good effort to address both sides of the issues, with Brian Dorn, Jeannette Wing, and me on the pro side, and Chase Felker and Jeff Atwood on the con side.  As you might expect, I disagree with Felker and Atwood.  “That assumes code is the goal.”  No–computational literacy and expression, the ability to use the computer as a tool to think with, and empowerment are the goals.  Code is the medium.

Still, I’m excited about the article.

Just as students are taught reading, writing, and the fundamentals of math and the sciences, computer science may one day become a standard part of a K–12 school curriculum. If that happens, there will be significant benefits, observers say. As the kinds of problems we will face in the future will continue to increase in complexity, the systems being built to deal with that complexity will require increasingly sophisticated computational thinking skills, such as abstraction, decomposition, and composition, says Wing.

“If I had a magic wand, we would have some programming in every science, mathematics, and arts class, maybe even in English classes, too,” says Guzdial. “I definitely do not want to see computer science on the side … I would have computer science in every high school available to students as one of their required science or mathematics classes.”

via Should Everybody Learn to Code? | February 2014 | Communications of the ACM.

February 5, 2014 at 1:28 am 16 comments

The new Wolfram Language: Now available on Raspberry Pi

The new Wolfram Language sounds pretty interesting.  I was struck by the announcement that it’s going to run on the $25 Raspberry Pi (thanks to Guy Haas for that).  And I liked Wolfram’s cute blog post where he makes his holiday cards with his new language (see below), which features the ability to have pictures as data elements.  I haven’t learned much about the language yet — it looks like mostly like the existing Mathematica language.  I’m curious about what they put in to meet the design goal of having it work as an end-user programming language.

Here are the elements of the actual card we’re trying to assemble:

Now we create a version of the card with the right amount of “internal padding” to have space to insert the particular message:

via “Happy Holidays”, the Wolfram Language Way—Stephen Wolfram Blog.

January 23, 2014 at 1:25 am 1 comment

“Six Learning Barriers in End-User Programming Systems” wins most influential paper award

Congratulations! Well-deserved!  Here’s a link to the original paper.

Brad A. Myers, professor in the Human-Computer Interaction Institute, will be honored for the second year in a row as the author of a Most Influential Paper at the IEEE Symposium on Visual Languages and Human-Centric Computing, (VL/HCC). He is the first person to win the award twice since it was established in 2008.

Myers and his co-authors — former students Andrew Ko, the first author, is now an assistant professor at the University of Washington, and Htet Htet Aung, now a principal user experience designer at Harris Healthcare Solutions in the Washington, D.C., area — will receive the Most Influential Paper award at VL/HCC 2013, Sept. 15-19 in San Jose, Calif. The symposium is the premier international forum for research on how computation can be made easier to express, manipulate, and understand.

Their 2004 paper, “Six Learning Barriers in End-User Programming Systems,” focused on barriers to learning programming skills beyond the programming languages themselves. Their study of beginning programmers identified six types of barriers: design, selection, coordination, use, understanding, and information. This deeper understanding of learning challenges, in turn, supported a more learner-centric view of the design of the entire programming system.

via SCHOOL OF COMPUTER SCIENCE, Carnegie Mellon.

October 10, 2013 at 1:59 am Leave a comment

Is Coding the New Second Language? in Smithsonian Magazine

Nice piece in Smithsonian Magazine about the efforts to move computing into primary and secondary schools.  And hey! That’s me they quoted!  (It’s not exactly what I said, but I’ll take it.)

Schools that offer computer science often restrict enrollment to students with a penchant for math and center the coursework around an exacting computer language called Java. And students frequently follow the Advanced Placement Computer Science curriculum developed by the College Board—a useful course but not for everyone. “What the computer science community has been slow to grasp is that there are a lot of different people who are going to need to learn computer science, and they are going to learn it in a lot of different ways,” says Mark Guzdial, a professor of interactive computing at the Georgia Institute of Technology and author of the well-respected Computer Education blog, “and there are a lot of different ways people are going to use it, too. ”

via Is Coding the New Second Language? | Ideas & Innovations | Smithsonian Magazine.

June 3, 2013 at 1:19 am Leave a comment

LiveCode Community Edition is released: HyperCard is free again and runs on anything!

I’m excited about this and find myself thinking, “So what should I do with this first?”  LiveCode isn’t as HyperCard-like as it could be (e.g., you edit in one place, then compile into an application), and it has all of HyperCard’s limitations (e.g., object-based not object-oriented, lines are syntax).  But it’s freeincluding all engines.  I can program iOS and Android from the same HyperCard stack!  I can build new kinds of programming languages and environments on top of Livecode (but who in the world would want to do something like that?!?) that could compile into apps and applications!  It’s a compellingly different model for introductory computing, that sits between visual block programming and professional textual programming. Wow…

LiveCode Community is an Open Source application. This means that you can look at and edit all of the code used to run it, including the engine code. Of course, you do not have to do this, if you just want to write your app in LiveCode there is no need for you to get involved with the engine at all. You write your app using LiveCode, the English-like scripting language, and our drag and drop interface. Fast, easy, productive and powerful.

via Community Edition Overview | RunRev.

April 26, 2013 at 1:28 am 9 comments

Older Posts


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

Join 4,306 other followers

Feeds

Recent Posts

Blog Stats

  • 1,564,717 hits
October 2018
M T W T F S S
« Sep    
1234567
891011121314
15161718192021
22232425262728
293031  

CS Teaching Tips