-A A +A

Feed aggregator

Statement on National Academies sexual harassment study

News From NSF - Tue, 06/12/2018 - 11:00

In September 2016, the National Science Foundation (NSF) Office of Integrative Activities funded the National Academies of Sciences, Engineering, and Medicine to conduct a study on the prevalence and impact of sexual harassment in science, engineering and medical departments and programs. The results of that study are now publicly available in a new report, Sexual Harassment of Women: Climate, Culture and ...
More at https://www.nsf.gov/news/news_summ.jsp?cntn_id=245752&WT.mc_id=USNSF_51&WT.mc_ev=click


This is an NSF News item.

Workshops for New Computing Faculty in Summer 2018: Both Research and Teaching Tracks

ComputingEd - Tue, 06/12/2018 - 06:00

This is our fourth year, and our last NSF-funded year, for the New Computing Faculty Workshops which will be held August 5-10, 2018 in San Diego. The goal of the workshops is to help new computing faculty to be better and more efficient teachers. By learning a little about teaching, we will help new faculty (a) make their teaching more efficient and effective and (b) make their teaching more enjoyable. We want students to learn more and teachers to have fun teaching them. The workshops were described in Communications of the ACM in the May 2017 issue (see article here) which I talked about in this blog post. The workshop will be run by Beth Simon (UCSD), Cynthia Bailey Lee (Stanford), Leo Porter (UCSD), and Mark Guzdial (Georgia Tech).

This year, for the first time, we will offer two separate workshop tracks:

  • August 5-7 will be offered to tenure-track faculty starting at research-intensive institutions.
  • August 8-10 will be offered to faculty starting a teaching-track job at any school, or a tenure-track faculty line at a primarily undergraduate serving institution where evaluation is heavily based in teaching.

The new teaching-oriented faculty track is being added this year due to enthusiasm and feedback we heard from past participants and would-be participants. When I announced the workshops last year (see post here), we heard complaints (a little on email, and a lot on Twitter) asking why we were only including research-oriented faculty and institutions. We did have teaching-track faculty come to our last three years of new faculty workshops that were research-faculty focused, and unfortunately those participants were not satisfied. They didn’t get what they wanted or needed as new faculty. Yes, the sessions on peer instruction and how to build a syllabus were useful for everyone. But the teaching-track faculty also wanted to know how to set up their teaching portfolio, how to do research with undergraduate students, and how to get good student evaluations, and didn’t really care about how to minimize time spent preparing for teaching and how to build up a research program with graduate students while still enjoying teaching undergraduate students.

So, this year we made a special extension request to NSF, and we are very pleased to announce that the request was granted and we are able to offer two different workshops. The content will have substantial overlap, but with a different focus and framing in each.

To apply for registration, To apply for registration, please apply to the appropriate workshop based on the type of your position: research-focused position http://bit.ly/ncsfw2018-research or teaching-focused position http://bit.ly/ncsfw2018-teaching. Admission will be based on capacity, grant limitations, fit to the workshop goals, and application order, with a maximum of 40 participants. Apply on or before June 21 to ensure eligibility for workshop hotel accommodation. (We will notify respondents by June 30.)

Many thanks to Cynthia Lee who helped a lot with this post

Operations Engineering

News From NSF - Mon, 06/11/2018 - 22:52

Available Formats:
HTML: https://www.nsf.gov/funding/pgm_summ.jsp?pims_id=505202&WT.mc_id=USNSF_25&WT.mc_ev=click
Document Number: PD 19-006Y


This is an NSF Program Announcements and Information item.

Mind, Machine and Motor Nexus

News From NSF - Mon, 06/11/2018 - 22:52

Available Formats:
HTML: https://www.nsf.gov/funding/pgm_summ.jsp?pims_id=505402&WT.mc_id=USNSF_25&WT.mc_ev=click
Document Number: PD 19-058Y


This is an NSF Program Announcements and Information item.

Humans, Disasters, and the Built Environment

News From NSF - Mon, 06/11/2018 - 22:52

Available Formats:
HTML: https://www.nsf.gov/funding/pgm_summ.jsp?pims_id=13353&WT.mc_id=USNSF_25&WT.mc_ev=click
Document Number: PD 19-1638


This is an NSF Program Announcements and Information item.

Mechanics of Materials and Structures

News From NSF - Mon, 06/11/2018 - 22:52

Available Formats:
HTML: https://www.nsf.gov/funding/pgm_summ.jsp?pims_id=13355&WT.mc_id=USNSF_25&WT.mc_ev=click
Document Number: PD 19-1630


This is an NSF Program Announcements and Information item.

Civil Infrastructure Systems

News From NSF - Mon, 06/11/2018 - 22:52

Available Formats:
HTML: https://www.nsf.gov/funding/pgm_summ.jsp?pims_id=13352&WT.mc_id=USNSF_25&WT.mc_ev=click
Document Number: PD 19-1631


This is an NSF Program Announcements and Information item.

Engineering for Civil Infrastructure

News From NSF - Mon, 06/11/2018 - 22:52

Available Formats:
HTML: https://www.nsf.gov/funding/pgm_summ.jsp?pims_id=505488&WT.mc_id=USNSF_25&WT.mc_ev=click
Document Number: PD 19-073Y


This is an NSF Program Announcements and Information item.

Engineering Design and System Engineering

News From NSF - Mon, 06/11/2018 - 22:52

Available Formats:
HTML: https://www.nsf.gov/funding/pgm_summ.jsp?pims_id=505478&WT.mc_id=USNSF_25&WT.mc_ev=click
Document Number: PD 19-072Y


This is an NSF Program Announcements and Information item.

Dynamics, Control and Systems Diagnostics

News From NSF - Mon, 06/11/2018 - 22:52

Available Formats:
HTML: https://www.nsf.gov/funding/pgm_summ.jsp?pims_id=505182&WT.mc_id=USNSF_25&WT.mc_ev=click
Document Number: PD 19-7569


This is an NSF Program Announcements and Information item.

Biomechanics and Mechanobiology

News From NSF - Mon, 06/11/2018 - 22:52

Available Formats:
HTML: https://www.nsf.gov/funding/pgm_summ.jsp?pims_id=13523&WT.mc_id=USNSF_25&WT.mc_ev=click
Document Number: PD 19-7479


This is an NSF Program Announcements and Information item.

Reflections of a CS Professor and an End-User Programmer

ComputingEd - Mon, 06/11/2018 - 02:00

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, who Software Carpentry addresses. Computational scientists and engineers do not write code occasionally to solve a problem. 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, so teaching them 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 of people that 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.

Dear Colleague Letter: Removal of Deadlines for the Core Programs in the Directorate for Engineering

News From NSF - Fri, 06/08/2018 - 19:32

Available Formats:
HTML: https://www.nsf.gov/pubs/2018/nsf18082/nsf18082.jsp?WT.mc_id=USNSF_25&WT.mc_ev=click
PDF: https://www.nsf.gov/pubs/2018/nsf18082/nsf18082.pdf?WT.mc_id=USNSF_25&WT.mc_ev=click

Document Number: nsf18082
Public Comment: This Dear Colleague Letter (DCL) references Frequently Asked Questions (FAQs) Removal of Deadlines for Core Programs in the Directorate for Engineering NSF 18-083.


This is an NSF Program Announcements and Information item.

Frequently Asked Questions (FAQs) for Dear Colleague Letter (DCL) NSF 18-082: Removal of Deadlines for Core Programs in the Directorate for Engineering

News From NSF - Fri, 06/08/2018 - 19:32

Available Formats:
HTML: https://www.nsf.gov/pubs/2018/nsf18083/nsf18083.jsp?WT.mc_id=USNSF_25&WT.mc_ev=click
PDF: https://www.nsf.gov/pubs/2018/nsf18083/nsf18083.pdf?WT.mc_id=USNSF_25&WT.mc_ev=click

Document Number: nsf18083
Public Comment: These Frequently Asked Questions (FAQs) refer to Dear Colleague Letter: Removal of Deadlines for the Core Programs in the Directorate for Engineering NSF 18-082.


This is an NSF Program Announcements and Information item.

Dear Colleague Letter: Removal of Deadlines for the Core Programs in the Directorate for Engineering

News From NSF - Fri, 06/08/2018 - 19:32

Available Formats:
HTML: https://www.nsf.gov/pubs/2018/nsf18082/nsf18082.jsp?WT.mc_id=USNSF_179
PDF: https://www.nsf.gov/pubs/2018/nsf18082/nsf18082.pdf?WT.mc_id=USNSF_179

Document Number: nsf18082
Public Comment: This Dear Colleague Letter (DCL) references Frequently Asked Questions (FAQs) Removal of Deadlines for Core Programs in the Directorate for Engineering NSF 18-083.


This is an NSF Publications item.

Frequently Asked Questions (FAQs) for Dear Colleague Letter (DCL) NSF 18-082: Removal of Deadlines for Core Programs in the Directorate for Engineering

News From NSF - Fri, 06/08/2018 - 19:32

Available Formats:
HTML: https://www.nsf.gov/pubs/2018/nsf18083/nsf18083.jsp?WT.mc_id=USNSF_179
PDF: https://www.nsf.gov/pubs/2018/nsf18083/nsf18083.pdf?WT.mc_id=USNSF_179

Document Number: nsf18083
Public Comment: These Frequently Asked Questions (FAQs) refer to Dear Colleague Letter: Removal of Deadlines for the Core Programs in the Directorate for Engineering NSF 18-082.


This is an NSF Publications item.

A Generator for Parsons problems on LaTeX exams and quizzes

ComputingEd - Fri, 06/08/2018 - 02:00

I just finished teaching my Introduction to Media Computation a few weeks ago to over 200 students. After Barb finished her dissertation on Parsons problems this semester, I decided that I should include Parsons problems on my last quiz, on the final exam study guide, and on the final exam. It’s a good fit for the problem. We know that Parsons problems are a more sensitive measure of learning than code writing problems, they’re just as effective as code writing or code fixing problems for learning (so good for a study guide), and they take less time than code writing or fixing.

Barb’s work used an interactive tool for providing adaptive Parsons problems. I needed to use paper for the quiz and final exam. There have been several Parsons problems paper-based implementation, and Barb guided me in developing mine.

But I realized that there’s a challenge to doing a bunch of Parsons problems like this — what happens when you find that you got something wrong? The quiz, study guide, and final exam were all going to iterate several times as we developed them and tested them with the teaching assistants. How do I make sure that I kept lined up the scrambled code and the right answer?

I decided to build a gadget in LiveCode to do it.

I paste the correctly ordered code into the field on the left. When I press “Scramble,” a random ordering of the code appears (in a Verbatim LaTeX environment) along with the right answers, to be used in the LaTeX exam class. If you want to list a number of points to be associated with each correct line, you can put a number into the field above the solution field. If empty, no points will be explicitly allocated in the exam document.

I’d then paste both of those fields into my LaTeX source document. (I usually also pasted in the original source code in the correct order, so that I could fix the code and re-run the scramble when I inevitably found that I did something wrong.)

The wording of the problem was significant. Barb coached me on the best practice. You allow students to write just the line number, but encourage them to write the whole line because the latter is going to be less cognitive load for them.

Unscramble the code below that halves the frequency of the input sound.

Put the code in the right order on the lines below. You may write the line numbers of the scrambled code in the right order, or you can write the lines themselves (or both). (If you include both, we will grade the code itself if there’s a mismatch.)

The problem as the student sees it looks like this:

The exam class can also automatically generate a version of the exam with answers for used in grading. I didn’t solve any of the really hard problems in my script, like how do I deal with lines that could be put in any order. When I found that problem, I just edited the answer fields to list the acceptable options.

I making the LiveCode source available here: http://bit.ly/scrambled-latex-src

LiveCode generates executables very easily. I have generated Windows, MacOS, and Linux executables and put them in a (20 Mb, all three versions) zip here: http://bit.ly/scrambled-latex

I used this generator probably 10-20 times in the last few weeks of the semester. I have been reflecting on this experience as an example of end-user programming. I’ll talk about that in the next blog post.

NSF supports development of new nationwide data storage network

News From NSF - Thu, 06/07/2018 - 13:00

The National Science Foundation (NSF) is announcing a $1.8 million grant for the initial development of a data storage network over the next two years. A collaborative team will combine their expertise, facilities and research challenges to develop the Open Storage Network (OSN). OSN will enable academic researchers across the nation to work with and share their data more efficiently than ever before.

"We are ...
More at https://www.nsf.gov/news/news_summ.jsp?cntn_id=245686&WT.mc_id=USNSF_51&WT.mc_ev=click


This is an NSF News item.

Pages

Subscribe to Computing Portal aggregator