Best Training App Ideas When I was learning to program I was building a "DVD Rental" application for the kiosk that would store information about disks, who borrowed them and when they had to return them. Having a simple-to-understand task motivated me to build an app and show to the owners of the kiosk.

Now I'm assisting a web app programming school with helping to design curriculum and I'd like to include some practical apps into the course.

I want students to develop business thinking. New SaaS idea? App to help people. App to help businesses.

I already have some app ideas but I am always looking for more. What was the first app you've built?

Criteria

Our course is focused on business web apps, so no games.
Tasks should be simple to explain and familiar to students (14-18 years old)
Real-life application or attempt to solve a problem.
Focus on "client requirements" and not "implementation"
Simple tasks, limited to 5 data entity types (or tables).

You are welcome to use any of those apps to teach students about data models, databases, relations, UI / persistence. (Note: we use Agile UI platform)

The Librarian

Application to help your local library to organise book catalogue and offer students a way to check which books they have checked out from the library.

Who will use this app?

This app will have two interfaces and two user roles. The first role is a "Librarian", a person who uses a computer inside a library for one of the following tasks:

registering new books and editing number of each book.
registering students
assigning borrowed books to the students
noting down returned books

The second user role is Student, who have account and password, allowing the following tasks:

see which books you have borrowed and when they are expiring
extend borrowed books

Data Model

We need to have the following models:

All the books (includes ISSN, title, author as well as number of copies)
Student (student code, password, email)
Librarians (librarian code, password, email)
"Borrowed book" (record for each borrowed book, date when borrowed, date when book must be returned, link to student and link to a book)

Reports

A Librarian should also be able to see several reports:

List of Student ordered by a number of "Borrowed books" which are Overdue


Should I teach modern web development in an introductory programming course? How? I'm currently teaching a introductory programming class in a technological university course (FYI, this is a type of university course that is not a BS).

The recommended language to use for this class is C and I'm following this guideline, but I know that most of the students will work as web developers at the end of the course (some of them already works as client support in IT companies), so I want to introduce them to some modern web concepts, but I don't know how.

They will have other classes during the course on other important subjects for web development (like computer networks and software engineering), but won't have any class that teaches modern programming languages for web, like Javascript.

Is this introductory programming class a good point to introduce some modern web development concepts (maybe with some Javascript snippets together with the C examples for comparison), or would this approach confuse them more than help them?

If you want to teach students programming concepts along with web-development (HTML/CSS/JS) you should consider lacing programming examples or lessons with examples of HTML/CSS/JS or similar concepts in both. You could also have HTML/CSS/JS as an extra credit assignment or something the class can do if they're ahead of schedule. This will keep the class motivated to learn HTML/CSS/JS, which you probably shouldn't grade as it's an extra addition to the curriculum. This will teach the class the necessary topics along with them not being bored out of their mind, studying for programming AND web development.


HS Lessons On Modeling Virus Spread I'd like to try teaching an online lesson to high school CS students on modeling the spread of a virus. Ideally it would be something that could be coded in a spreadsheet, Code.Org's Game Lab or App Lab, or in Unity.

I'd appreciate any pointers to how to get started – what are the important underlying concepts for students to understand, what are the minimal skills they would need to produce a "satisfying" model, what are the key variables that a model should incorporate?

Suggestions about how to get my own head around the field, or videos of modelers talking about their work, or articles would all be welcome.

Update:

First: many thanks for the great and concrete suggestions coming in, they really help.

Second: this is, or could be, a collaboration across disciplines – math, CS, health, social studies, and art / graphic design all have a role in developing and presenting a good model.

Third: clearly, in these times, this is a distance learning question as well.

Here are two resources that might be appropriate, but neither is a spreadsheet model.

The first is a resource called Contagion that has just been created for the Greenfoot Java system (IDE plus resources). You can find it at the Greenroom.

The second is a section on Simulation in a book called Polymorphism Companion. The book is actually the second volume of a pair and you might need the first one also Polymorphism: As It Is Played. They are both about using polymorphism, especially in Java.

Both of these resources model a disease spreading through a population. They have various parameters you can set to get some realistic(ish) results. Think of a Disease interface, for example, with diseases of various characteristics implemented via polymorphism.


End of Year Movies For CS Classes The last day of school is a half day for us and it isn't one where my students are too engaged...

Last year I showed Hidden Figures and it went over pretty well. Many students were stunned by the lack of respect afforded to people of color in the '60s (and to this day).

Looking for suggestions for other school appropriate CS related movies (my classes are at high school level - US ages 14-18 more or less, but movies for any age range would be welcome).

The Imitation Game: Alan Turing's life through the lens of his work on breaking the Enigma code at Bletchley Park during WWII and his later prosecution as a homosexual during the 1950s. It touches on computer science, World War 2, equality, women's role is CS and society, etc. The movie also casts Turing, inaccurately, as socially awkward and a loner. This provides an opening to explore the "lone programmer" stereotype and the role of teams in real projects.
The Social Network: Interesting look into silicon valley culture, and has a bit of CS content towards the beginning when Zuckerberg is hacking into the various Harvard photo troves. It can be fun to freeze frame at those moments and discuss what is going on. (Much of it isn't really that complicated!)
Inception: a total scifi fantasy, but it does illustrate recursion. — for more info on recursion see https://cseducators.stackexchange.com/a/5756/204


How do I scaffold students toward building meaningful projects? Teaching 8th graders using App Inventor through Project Lead the Way's ICS 1 curriculum.

I am interested in moving the students towards a deeper understanding of the power of CS to improve people lives. We are a high poverty school and I think it would be good for our program for students to make things that were useful to their classmates and community. PLTW has a basic framework for this that involves asking friends and family about needs and then designing based on these user stories. This past year, however, I ended up with 6 different apps that fart when you tap a picture (not completely accurate, but basically).

Any suggestions for developing a sense of responsibility and more interesting, powerful student designed projects?

For context, I teach high school students as part of a 4-year high school computer science major.  My students do, during their 4th year, a full-year project for a client who has a need.  (The clients do not pay for this, they provide a client experience for our budding developers.)  At the end, we have a big event with presentations, outside judges, and a lucheon. I've been playing with the formula for this class for a number of years (and I am still tinkering!), but here are a few takeaways I can share with you that would apply to younger kids and shorter projects:

Pose a challenge to the 8th graders to address a particular world problem.  (You should choose the problem).  It could be global hunger, or too much partisanship, or not enough kids with access to education.  Tell them that their application should address this problem.  Give them three research resources that they can use to explore the issue further.
Make other projects possible only if they write a few paragraphs about why the problem they wish to address is important, and how they intend to address the problem.  They must include a reference to 3 sources about the problem that they want to address.
Get outsiders to come in for a culminating event and "judge" the final projects.  (The outsiders can be other teachers from your building, your administrators, or true outsiders.)  Let the kids prepare a short presentation about their project, science-fair style, and let the judges walk around with a rubric and talk to the students.  Having people from the outside world come in is a powerful motivator (and will prevent a lot of the fart-joke responses).  Similarly, contact your local newspaper and see if they can send someone in for a small write-up.
Give a certificate to the winner, or even a small trophy.
As they work, have each student (or group) create small milestones that they must meet.  These are the core of the evaluation process.  New milestones are created on the same day as the old ones are graded.  They must be very specific, and you must agree to them.

In the following year, you can choose a new problem to address, and you will have a few example projects from the first year.  By choosing only one or two very strong projects (and saving the newspaper writeup), you can really set the tone the second year.  This project will now be a big deal, and kids will take it very seriously!


Research on gender and attainment in CS I am lecturing on gender and computer science and have found plenty of material outlining factors that impact female access to computer science courses.  I stumbled across this paper: https://dl.acm.org/citation.cfm?id=2920173 which shows significant attainment differences at the highest degree level in UK universities. This raises questions about male focused course material and assessment methodologies. I wondered if there were many other papers on gender and attainment in CS? Google scholar has lots of generic studies, but few focused on CS.

Attainment here could be at any level, including compulsory education and work based assessments

Failing to find an answer, I wrote this with Billy and Miles: https://dlnext.acm.org/doi/abs/10.1145/3366016

From the abstract:

The change in the English computing curriculum and the shift towards computer science (CS) has been closely observed by other countries. Female participation remains a concern in most jurisdictions, but female attainment in CS is relatively unstudied. Using the English national pupil database, we analyzed all exam results (n = 5,370,064) for students taking secondary school exams in 2016, focusing on those students taking GCSE CS (n = 60,736), contrasting this against ICT (n = 67,359).

Combining gender with ethnicity and the IDACI poverty indicator, we find that females from the poorest areas were more likely to take CS than those from the richest areas and that CS was more popular among ethnic minority females than white females. ICT was far more equitable for females and poorer students than CS.

CS females typically got better grades than their male peers. However, when controlling for average attainment in other subjects, males got 0.31 of a grade higher. Female relative underperformance in CS was most acute among large female cohorts and with girls studying in mixed-gender schools. Girls did significantly better than boys in English when controlling for CS scores, supporting theories around female relative strengths lying outside STEM subjects.

The move to introduce CS into the English curriculum and the removal of the ICT qualifications look to be having a negative impact on female participation and attainment in computing. Using the theory of self-efficacy, we argue that the shift towards CS might decrease the number of girls choosing further computing qualifications or pursuing computing as a career. Computing curriculum designers and teachers need to carefully consider the inclusive nature of their computing courses.


What are good/bad topics for a non-major CS0 course? I'm teaching CS0 again this fall. This is an introductory course, entirely separate from CS1. It is for non-majors. It doesn't lead to additional coursework or prepare students for CS1 (it's not a prerequisite for anything), so it has no specific goals beyond educating students in concepts of computation and computing. I am specifically asking for recommendations on topics to cover to better help students understand computation and computing, and ideally topics that students who perceive themselves "forced" to take the course will find least objectionable. Below, I will describe what I intend to include, what I am considering adding, and what has been unsuccessful in the past. I am looking for comments/thoughts on any of these things and/or additions.

Given the general education student learning outcomes (SLOs) I have to satisfy/evaluate, I have significant constraints, but I generally want to rethink the course. My goal is to help students appreciate computation and computational thinking and to understand basics of computing systems. I also want to structure the course around labs (although it's not a lab course). I'm going to use Danny Hillis' The Pattern on the Stone, but I'll be adding significant detailed material that Hillis doesn't cover. I am also going to use  Don Norman's The Design of Everyday Things, which I use in my CS0 major course, to introduce designing/planning/functional decomposition.

Here are things I've covered on computing/computational thinking and might bring back:

Basic computer architecture
Boolean logic
Finite state machines

Here's what I have covered on design and plan to bring back:

Norman's concept of "design thinking"
Theory of mind
OODA loop
User testing
Ethics

Some things I might add:

Number systems and base conversion
AI/ML concepts

Some things that have gone very, very poorly, but I would like to include:

Basic prob/stat
Programming basics & AppInventor
Process-oriented design

The typical student for this course has already decided to be miserable; we're typically able to turn a few heads, but many of the students have gone years without math, so a big chunk of the course is necessarily applied arithmetic and algebra. The ones who are willing to engage with trial & error tend to be effective in AppInventor, but they're precious few.

Any thoughts about what to cover, what not to cover, and how to cover things effectively, are welcome!

Since you've described this a standalone course, I'd treat it as a "computer literacy" sort of thing. I wrote another answer yesterday that got me thinking about what topics everyone should know about computer science, which I'm adapting here.

I like that you're starting with basic computer architecture. People should understand that there are logical rules and processes between them pressing on the keyboard or clicking the mouse and pixels lighting up on the screen. A logical step from there might be basic network architecture, for the same reason; just as the inside of a computer doesn't work by magic, neither do e-mails move from one computer to another that way. (Do people still write e-mails? Maybe Facebook or Twitter posts1 instead?)

I also agree with your choice of DOET. It was a part of my own CS education in the distant past, though I didn't realize it until I read the book years later on my own and found a particular section to be very familiar. From there, you might also discuss basic security topics, such as passwords; why they're important, how they work, and how they can fail. Obligatory xkcd 936:

See also Security SE's post about that comic.

A quick mention of the fact that there are problems computers can't solve, no matter how fast we make processors. Not necessarily the whole, heavy mathematical proof, just the concept (again) that computers aren't magic boxes. Maybe a mention of the fact that even though computers are fast, efficiency still matters for computer algorithms.

At least some cursory coverage of programming, algorithms, and data structures should be included, as they are fundamentals of the practical side of things. I've never used AppInventor, but I looked it up just now and it seems like it would do that job. I'm curious why you say it's gone poorly in the past.

AI and ML are cool topics, but I don't see a ton of promise in adding them to the course, given that your students are, by your own description, intending to be miserable, largely uninterested in CS and unlikely to be directly applying what they learn. There is a bit of human element here, which, to be perfectly frank, I probably didn't spend enough time thinking about. Your course plan already seems full to bursting, but if you can make the time, maybe start out day one by asking the students what they hope to get out of the course? It'll be a long and draining semester for everyone, including you, if the students' initial expectation of misery doesn't change.

1: Actually, the first "relatable, common type of web traffic" example I thought of was Netflix movies, but they're technically a terrible example, because Netflix avoids backbone peering. I thought that might be beyond the scope of your course, but I guess that's up to you.


Should students be taught to be first and foremost: scientists or mathematicians? It's undeniable that Computer Science is a mixture of disciplines including science (the scientific method, some physics needed to truly understand how computers work at all levels, testing methodologies etc etc.) and maths (theoretical computer science, programming is essentially logic puzzles that equate to mathematical proofs - at least complex ones, algorithm analysis etc. etc.) and to some extent it's created it's own discipline in programmatic thinking and the learning and analysis of programming languages. - What are the disciplines of computer science/how important is maths in computer science/is it really a science? - are not the questions to be answered here.

Assuming Mathematical and Scientific knowledge are both important in computer science (which they are) - which do we train students to become principally? Is it most important for computer science students to be first and foremost scientists or mathematicians? e.g. in the first year of a CS course is it more appropriate to teach The Scientific Method. Structure of a scientific investigation. Hypotheses. Occam's razor. Controls. Correlation vs causation. Falsification. Examples such as intention to treat etc etc. Or is it more appropriate to teach Mathematical topics - matrix operations, algorithm analysis, complexity, logical expressions, etc etc.

Or maybe a mixture of both? Maths is inherently important to science - but to what degree should budding computer scientists be taught mathematics.

Which skills and talents in the field of mathematics are beneficial to Computer Scientists?

This answer addresses something very different from the other answer I posted on this question, which is why it merits its own answer:

Almost every field in computer science is built on some mathematical theory (this sentence is the only overlap between answers):

The most basic: the number of options that an $n$ long binary number is $2^n$, and that's where it all starts (until Quantum computers come along, but that's something else)
Algorithm correctness: proof by induction.
The entire field of boolean algebra. Need I say more?
The entire field of Machine Learning is nothing but computations of mathematical models (Neural networks are nothing more than the simplest of arithmetic calculations - weighted sums of weighted sums of...)

This list can go on and it strengthens the point that, regardless of learning mathematics before learning Computer Science (that is, learning math with the intent of learning basic Computer science), most applications of computer science are implementations of mathematical models.

This means that when learning a subfield of computer science, an introduction to the relevant mathematics is almost always necessary.

That being said, being a talented mathematician surely would not harm one's level of understanding of those subfields of Computer Science.


Curriculum Design for a Unit on Alan Turing and His Impact on CS At the end of the year, there is a gap between the AP Exam for AP Computer Science A and the last class meeting. Since students don't have to take a final after the AP Exam, there's not a lot of motivation for additional graded work. Nonetheless, I want to make the time meaningful, so my plan is to put together a short unit on Alan Turing, his contributions to CS, Turing Machines, Turing-completeness, the importance of the Halting Problem, the Turing Test, etc. Hopefully, I can integrate clips from The Imitation Game as well to increase engagement.

The unit as a whole would last a little over a week and would be engaging (as something post-AP Exam in May has to be). This would be for a small class of students just having completed two years of AP Computer Science and very likely studying CS in college.

Are there short lessons/units you have on Alan Turing that students respond well to? If you've taught some of the above concepts before (TMs, Halting Problem, Turing Test, etc.), what classroom resources do you have to explain them in a short, student-friendly manner?

With only a few weeks, it's hard to cover much in depth, but you can skim the surface of a few topics.  I would focus the unit by talking about the problem of computability that Turing and Church (and others) were facing.  It's a nice problem, because it is easy to describe in broad strokes, and the implications border on the mystical.

I would then go on as a class to look at how Turing attempted to explore the problem.  I would start with creating Finite State Machines, and run a few class periods of this to help them get the hang of it.  I might mention, but not really explore, the idea of a grammar, and talk about the equivalence of FSMs with regular expressions.

Then I would skip PDAs and move right into Turing Machines.  Have them spend some time building them in class, and finally introduce the Busy Beaver problem with this video.  Be prepared to stop and talk a few times during it to help them keep up to speed. The payoff at the end is totally worth it.

I would finish up by describing the Halting Problem, and talk a bit about what the implications of an Oracle would be if it could somehow exist.

At the very end of the unit, I might mention that Turing created his solution using mutability as a core idea, but that there was another approach created by Church, Turing's mentor from Princeton, that used pure mathematical functions to accomplish the same thing.  The two of them proved that their systems were equally powerful in the Church-Turing Thesis.  And as funny as it sounds to have computation without mutability, there is an entire branch of programming languages devoted to exactly this approach called functional languages.

Obviously just mentioning this won't get them to understand functional languages, but it will set the stage for them later on in their undergrad CS years to appreciate why they are learning functional programming in the first place.


Attempting to prevent learning of poor techniques when self-teaching A big problem of learning alone is that you don't always figure out the preferred style for a language, the most "pythonic" (in the case of Python) way to do it, or how to write code in keeping with the language's features.

Another problem with learning alone is it is very possible to learn to write code that is really terrible - "mislearning", I suppose. Both of these things are true for really any subject one self-studies.

What are some ways to prevent the learning of poor techniques or styles when self-studying?

I think there are two phases here: the first is just being aware of what the correct idioms and best practices are, and second is attempting to apply what you learned and getting feedback.

For the first phase, you can get a lot of mileage by doing research and casting a wide net. In particular, I personally find the following Google queries to be pretty useful at giving me an overview of the best practices and general "feel" of a language:

"X best practices"
"X style guide"
"X idioms"
"X common mistakes"
"X philosophy"
"X ecosystem overview" (or "X popular 3rd party libraries")
"X tips and tricks"
"X history"
"X advanced features"
"X linter"
"X style checking tools"

(Replace "X" with the name of the language. If the language name is common word like "Go" or "Swift", try replacing "X" with something like "Go language".)

This will obviously return a wide range of results, not all of which will be useful, but it's a good way of getting the "lay of the land". Some of the results will be directly useful (for example, you might uncover a popular and comprehensive style guide or a useful linter), and others will be more useful for getting context behind the design and intended use of a language (for example, googling about the language's core philosophy).

Other things I personally find helpful is to browse through the top-voted questions about a particular language on StackOverflow or SoftwareEngineering.SE (previously Programmers.SE). The knowledge won't be immediately useful (or sometimes comprehensible), but it does give you a feel for what sorts of issues programmers using that language tend to worry about, what advanced features people want to learn to use, and what keywords might be helpful when refining your queries.

Something else you can do is to keep an eye on news aggregates for the language of your choice. For example, I like browsing through http://reddit.com/r/python for Python-related news -- every now and then, you run across an article that teaches you something new or reveals a point of contention within the community that's worth keeping an eye on.

Keep in mind that after reading through all of these resources, you'll likely find it hard apply them all at first -- in some cases, you might not even understand the articles you dig up. This is fine: the idea is to be aware of them in the first place so you have a direction to grow towards.

It'll probably be a good idea to start small -- start by finding a style guide and writing your code to be compliant with it, for example. Or maybe try figuring out the recommended best practices for organizing a larger project and using your language's package manager.

The second phase is actually getting feedback on the code you wrote. This can be tricky to do as a self-learner, since you have no direct way of getting feedback, but there are a few things you can try.

One resource to try is CodeReview.SE, though it's probably best to submit relatively small programs for review.

Another idea is to contribute to an open-source project. The more popular projects tend to be relatively picky about following best practices and idioms and will code review your submissions before accepting them. As before, start small: try and find a small and easy bug in their issue tracker, and start with that. It can also be valuable to try googling "open source for beginners" -- that reveals plenty of resources and websites that attempt to connect projects looking for help with beginners.


Paired programming with an odd number of students I have only lately started allowing (and encouraging!) paired programming, and it is going very well.  The kids enjoy it, and they appear to be learning the material with less pain.  Not everyone has done it yet, however.

This is where I am beginning to sense trouble. I have a difficult major programming lab coming up soon, and my students are psyched to work together on it.  I know that many more of them will want to try pairing, but I worry about odd numbers, and I'm not sure how to handle three students who desire to work together without destroying the benefits that the model can provide.  Is there any way to extend the model of driver and navigator to a trio?

My current intention is for each group to create the same product, with no "splitting" of the work.  One monitor, two students.  Driver and navigator.  These are good and responsible kids, and they can usually find quite productive groupings on their own, though I have no problem stepping in to assist in this if I see things headed in a poor direction.

An extension I've come to appreciate is one where you have a "driver", "observer/navigator" and "keeper".

This last role might be considerably more difficult, depending on the lab. The idea is to have someone who keeps track of the design. This means that at the start of the lab, the students should all (or just those who start as keepers) dedicate a bit of time to read up online about design patterns in the language they are using. It's important "not to delve too deep". Just a general idea of what "design patterns" means.

Then they begin working. Two out of the three work in usual pair-programming workflow. The third keeps in mind the design of the program. As with regular pair-programming, the students should switch roles every now and then. In the case of a trio, they should obviously cycle.

If not all students in the lab are in trios, then an additional for the navigator is to remember design patterns. It should be made clear that it's not their primary task, but that it would definitely help with debugging and maintaining the code.

The added bonus of this extension of pair programming is that students are exposed to design patterns. Seeing as they can sometimes be a complicated matter, starting to tackle them is better done sooner than later.

I have found this solution quite useful in labs about subjects in OOP (the more complex the system, the more important SOLID principles become).


Is the algorithm-recipe analogy a good or a bad one? I am growing suspects that the ubiquitous analogy between algorithms and recipes be not so well founded, especially for theoretically oriented students. I am wondering if this may contribute to the evidence of students having difficulties with even simple loops. I believe that bad analogies make more harm than no analogies, so I ask.

My wondering is that recipes, if superficially similar to the idea of sequential steps, do not really encode the logic that is sought to be explained: the logic of state transitions.
Of course there are state transitions in recipes, but i do not feel they being the characterising properties, nor are they the target of attention (I also like cooking). State transitions in recipes (and similar physical operations analogies) seem to be not even caused by the "program" but just happening because of physics. And typically what we get from students struggles is exactly their inability to follow (or design) state transitions. Probably because a fundamental property of a real computer program is that of being the acting cause and not the observer of state transitions, and this is not captured by the analogy. Another issue is that computing systems are typically discrete while physical analogies tend to be continuous, both in time and measured (variables) dimensions.

What screams for attention in recipes are instead "data" dependency constraints (cannot throw in the spaghetti before the water boils), or a kind of "event-driven" situation, and i do not recall seeing students struggling with data dependencies, which might be because 1. the recipe analogy is good in teaching them or (I suspect more probably) 2. it's not what they need help for: data dependencies being more innate than state transitions, especially in a forcefully sequential environment (of course this is a hypothesis, any experiments known?).

On a more concrete side it seems to me that the real world software counterpart of recipes are those things that we usually call scripts: something I love and had made a lot of and which I know perfectly fit their niche problems, but not something that is known for exposing nice theoretical properties, which, I suspect, is what matters more when learning, in order to build a clear mental model of algorithms (and because my pupils are generic science students and not specialist computer developers).

Realistic programs, and especially subprograms if we want to divide et impera, are not sequences of operations but sequences of state transitions.

What do you think of this analysis? Have any empirical data? Does an analogy that takes more care of state transitions exist and I have missed it?

Actually, you are loading a metaphor/analogy with too much import and influence. An analogy isn't supposed to be exactly the same thing as the thing of which it is an analogy. It is only supposed to be similar to that thing in some way. But not in all ways.

Analogies and metaphors in teaching computing are intended only to overcome the initial static inertia caused when a student has no idea whatever about a concept. To use it well, you need to do a couple of things, one of which is to move away from it as soon as is possible. But the more important thing is to be aware of how the analogy fails to be the thing analogized and to watch for misconceptions in the student's mind that are actually induced by the analogy itself. You then need to give a correcting lesson.

I can analogize loops with cooking recipes as: stir the sauce until it thickens. This isn't an algorithm, of course, since it has undefined terms, especially in the stopping condition. If that gives the students a quick mental picture of repetition then fine. But if they put too much weight on "stir" or think that an imprecise stopping condition is normal in programming, then I need to make a correction.

Sometimes that correction is with another, better analogy, but usually it is just a more precise and technical discussion.

Don't put so much weight on any given metaphor. Use it to introduce concepts but know when it fails and make corrections for those (hopefully few) students who draw the wrong conclusion. You can thus avoid being overly detailed and pedantic, losing students in the interactions between all of the small bits that go into anything complex.

I've been told that professional bakers follow their recipes more faithfully than professional chefs do. More careful measuring, for example. But even bakers have to deviate as the flour they use can vary in moisture content, requiring adjustments.


Any good resource for introducing kids to programming using Python's Turtle Graphics? I would like to start volunteering with kids and young teengers in my community by introducing them to programming. I thought teaching them the basics of python would be a good start. I have some experience with teaching in general (but not with teaching kids about programming).
Are there any resources that could help me or at least inspire me to make a good curriculum that goes over many concepts with turtle?
Thank you!

I have found that Python is not the best tool for teaching elementary and middle school students an intro to programming.  Turtle is nice, but you run out of things to do pretty quickly.  If you move on from Turtle to console based coding, many students find it less engaging.
Scratch and similar visual languages are much more engaging for younger learners.  You will be surprised how full featured they are.  There is a lot of great algorithmic teaching that you can do with these.
If you really want a traditional text-based language, you might check out Greenfoot (for Java).  But again, younger learners get lost in the symbols pretty quickly, so it would not be my first recommendation.  Scratch can be much more intuitive for them.


How should one go into learning algorithms and data structures? What do you think is an efficient way to do so? Should one first understand its logic and see its implementation? Or should one try to implement it first oneself?

How should one learn so that one can quickly implement the algorithm or data structure quickly if needed? By practising implementing it repeatedly?

All in all, please throw light on the ways you find it efficient to learn algorithms.

First, if you aren't taking a course, get a good book that has a lot of exercises. Use the exercises to guide your learning. Try to find a way to get some feedback on your attempts.

The way you learn just about anything deeply is to get a lot of reinforcement and feedback.

On the other hand, it is seldom necessary with today's languages and libraries to implement standard data structures. It is however, necessary to understand the fundamental of each and their relationship to various sorts of efficiencies when applied to various sorts of problems.

One way to get a deep understanding is to learn the technique of developing algorithms (not just data structures) from pre and post conditions.

My go-to book for doing that is by David Gries. It isn't cheap, but it can change the way you think about programs. I've mentioned it elsewhere here.

If you don't have other ways to get feedback, you might be able to form a group of like minded people who exchange work and comment on each other's attempts.


What should a teacher do with information about plagiarism before the final submission As probably we all experience, plagiarism is very common in CS. I know that there are several types of plagiarism ranging from simply submitting a copy of the colleagues’ code to other highly sophisticated mechanisms. In my experience, the most common is indeed the simplest one. The student just grabs the code from another colleague and eventually change the names of the variable, and submits the solution (some students don’t even do that!).

While there are several systems that are easily capable of detecting this type of plagiarism, they do it mainly when the student submits the final version of the code. Some other tools, are capable of detect plagiarism and notify the student about that (as if they didn’t already know that!).
In most cases the use of an anti-plagiarism tool will act mainly to support punitive measures.

Although it is not the main focus, as part of my PhD work, I am working in a tool that analyses the source code as it is being written and is able to detect plagiarism in “real-time”. This way, the teacher can be notified about students that are performing plagiarism even before their final solution is submitted, giving the teacher time to act and avoid the punitive measures.

My biggest question is: What should the teacher do with that information? Will this be efficient?

I assume that somewhere you discuss plagiarism and the social good of respecting the IP of others. If not, plagiarism detection is just a "gotcha" that doesn't really benefit the students or your relationship with them.

The following suggestion is offered tentatively, and might require tuning. It might also require research on the effect.

If the tool is good enough to tell you in real time that something bad is occurring, it is also good enough to tell the student at that moment. So you could build that feature into the tool.

However, there is, then, the danger that a student could game the system, modifying things just enough that the warning goes away. So it might be necessary for the warning given the student to also warn that not every "violation" will be reported to the student but will be reported to the instructor.

Caveat: This was "seat of the pants - in the moment" design. I can't claim it is best practice. It is, however, based on the principle that fairness and communication are positive attributes in education. Help the student grow in many dimensions, not just the technical.

In your discussions with students about plagiarism, be sure to include the concept of self plagiarism which many don't recognize as a problem since it doesn't violate IP rules. But does make derived research and attribution more difficult.

And, like any lesson, it needs to be reinforced. Very little that you do just once will actually be learned. Active learninig is reinforcing as lecture is not. Class discussions about plagiarism and its tradeoffs (short term gain - long term  pain) might be useful.


Best way to install and maintain windows 10 in a computer lab I’m looking for the best way to maintain a school lab. There are 20 PCs in the lab. All with windows 10.
What would be the best way to configure them, so that the student will be able to use them, program in visual studio, eclipse, etc, but will not be able to corrupt the system?
Or provide a way to restore some baseline.
Currently using toolwiz timefreeze, but experiencing a lot of problems.

Edit: while investigating the options and reading the (excellent) answers, I started to wonder, why not use windows built in functionality?

Prevent windows destruction: provide the students with a user that cannot do installations and has it's own folder space.
Restore: Use windows restore.
Am I missing something? Did someone tried it? with this solution, I would not need to install anything...

I have experience managing a lab for student-use. We utilized Deep Freeze. I was not responsible for configuring it, but based on what you say you would like to have in terms of OS management, I believe it would check those boxes. We could set specific times for booting up and shutting down. Additionally, we could restore a non-corrupt image each day if something happened. It allowed extensive control and security. I'd encourage you to look into it. I also don't know the cost, so I can't speak to what you'd be paying per device. However, it worked incredibly well across campus.


open source MOOC platforms What are easy to use MOOC open source platforms? Something that I could install on my servers to provision education. I'm looking for ready to use CMS (content management system) type of software with automactic grading of computer science assignments and course content management, where students could run pieces of code and watch lectures, and interact with TAs. ALternatively, the hosted solutions would work too.

I will attempt to break down your query as best I can:

MOOC open source that I could install on my servers to provision education: Canvas, Sakai or Moodle, BUT the downside of having these on your own servers are that you have to complete the updates yourself and many institutions do a "fresh install" each Summer during break.  It is worth considering a cloud version (LMS): you can get a Moodle account on Moodlecloud.com or try out canvaslms.com; Depending on your specific use-case, would Google Classroom work as an option?
ready to use CMS (content management system) type of software...  course content management, I used to upload all of my content to the LMS- these days I structure all my notes, exercises, files, presentations etc. into a folder in my DropBox/OneDrive/GoogleDrive.  I can folders of notes as a link in the LMS.  The advantage is that I can:

Add/Remove notes
Update content

all without having to delete old notes/upload new notes.  I can simply manipulate files on my computer which will synch with the online drive- the LMS acts as a repository of links and the content is elsewhere, and more easily managed.

This is a setup I suggested for a company that are planning to introduce an LMS where I also suggested hosting all the links on a thinklink as well- very little is actually in the LMS, but it's used as a repository.  The advantage (imho) is that is allows you to rebuild your course and use resources in other courses more easily, so you can update once in one location, and the "linked resource" is updated wherever it is used:

watch lectures, and interact with TAs.  All LMS allow you to embed videos (better to embed from YouTube or similar rather than upload large videos to your own server) and provide a chat or forum feature.  If the forum-type/chat in the LMS does not suit you, you will find something like Disqus that you can embed into the course.
students could run pieces of code.  This is the trickiest.  I sometimes write tests that the students can download and run to test their own code. It gives them a chance to look at "test code" and if they take the time to figure out what the code is doing, they will learn something.

It is much more easy to use a MCQ quiz to autograde.  Cloze question types have words missing so this could work in a quiz format.

Another option is to use peer grading and to give each student a rubric to mark peers- often used in many MOOCs and I've done it in Moodle in the past.

Use a site like Rosalind or CoCodingBat for exercises and grading

If you want to write your own specific test conditions, then CodeHS might just give you the features and flexibility that you want.  Because these code graders are not (afaik) integrated into the more popular LMS, you could have the student post a screenshot of their code passing the tests (or not).

If you want something that will return the grade to the LMS gradebook, then there may be something that complies with the (relatively new) Common Cartridge but I am unaware of a tool to meet your requirements at this time.

Hope that this helps answer your question, and that it is of some benefit to you.

Sean.


What are good resources for self learning Finite Mathematics for a CS Student? A student studying Computer Science requires some knowledge of finite mathematics, including logic, probability, counting, etc. In the use-case at hand, a HS or University course in finite math is not an option as the student is self studying.

What are good resources by which a student can learn the necessary material to support a CS degree? These could be books or online resources or perhaps other things not yet considered.

However, one essential aspect is that the student needs access to materials by which the topics can be practiced, not just read about. Resources with lots of exercises at different levels with a way to obtain feedback (answer key or other) would be essential.

John Kemeny et all have published a set of books on Finite Mathematics that are classics. They have lots of exercises but no solutions in the books themselves. However, the solutions guide may be available for some of them online or especially at eBay with a suitable search.

One of the classics is Finite Mathematics with Business Applications. Don't let the title fool you. It is serious mathematics.

Another, more common and possibly lighter weight book is Introduction to Finite Mathematics

These books are both old and out of print, but readily available. I think the latter one is available as a PDF online (but without answers).


Is it necessary or advisable to teach text-based input and output in a non-CS intro programming course? I teach an intro programming course in a social science department. My field is geographic information systems. The goal for the course is for the students to understand scripting in an interpreted language so that they can automate analytical workflows or add custom functionality to off-the-shelf software. The language we use is Python, but the question is more general than that.

Programming languages have some way of obtaining input and displaying output. There is a long tradition in computer science of starting with "Hello, World!" as a basic program that produces output. Additionally, output statements can be used to display the state of variables for debugging purposes. Introducing input and output is common in computer science textbooks (Think Python 1.3 The first program) as well as domain specific texts such as the one that I use for this course.

The problem I am running into is that beginning students can't seem to unlearn this after we move on to new material. Throughout the semester they turn in assignments that are littered with unnecessary print statements. These are "harmless" in the sense that they don't alter program logic, but make for sloppy code, and are perhaps not harmless if the students think that they need to do this and don't transition to, for example, using the IDE for variable inspection as they code.

Q. Is it necessary or advisable to teach text-based input and output (e.g. Python's input and print functions) in a non-CS intro programming course?

Is there pedagogical value? Does it teach something necessary? If so, can it be delayed? What are the alternatives, or is there no alternative?

I've been coding for 20 years in non-cs fields. I've worked on several >100k line code bases.

Almost every program I write comunicates with the outside world via text, usually a file hand or file-handle-like connection to stdin and stdout.

In addition, I also almost exclusively  do my debugging via print statements (or output to debugging logs).

IDEs and graphical debuggers can be very useful tools, but they can become a crutch that excuses the student from thinking. Print statements encorage the student to really reason about the logical and flow of their program - they must be able to hold the program in their mind and understand where it is going to be important to output a variable state, or just ping "here" to the terminal.

Now obviously I wouldn't insist that students must do this when working on large, complex code bases, but while they are making simpler things, things where holding the whole structure in your head is possible, then I think it is good for them.


How to explain the concept of a variable to a 9-year old? My 9 year old daughter is heavily interested in science, robots, computers, … She asked me if I could teach her how to program a computer. So, we started with Scratch, a programming language specifically designed for kids.

She likes it a lot, and she enjoys getting visual results fast. Now we came to the point that you need a variable, and I have realized that she has not yet understood what a variable is. Of course, at school, they didn't have the concept of variables in mathematics yet (mind you, she is 9 years old).

I remember that when I learned to program, I was 12 years old, and I had a hard time grasping that, too. Although I'm a professional software developer, and I help other people a lot to learn to program, I find it very difficult to explain it to her in a sense, that she can understand, and that is suitable.

Of course I can say:

  It's like a box, where you put the number 9 into it. If I ask you how old you are, then you don't say "9", but you give me the box, and I am going to look it up on my own.

That's an analogy, and she understands it, but it's difficult for her to transfer this idea to Scratch code. It doesn't feel correct.

If I say

  It's just a name for a value, and everywhere where you normally would use the value itself, you can now use the name. This has the big benefit that you can change the value, but keep the name.

it feels correct, but it's not easy to grasp any more. To cut a long story short: In contrast to a loop (do this and that for a given number of times) or a decision (if X then Y), variables are way more abstract.

So, how would you explain the concept of a variable to a 9 year old, in a way, that it is easy to grasp AND correct at the same time, i.e. it has a direct relation to writing code?

Buffy's lovely answer shows well how two variables can refer to the same thing, but since we are in early cognitive development and working with Scratch, in which you can't pass parameters, and can't arrange for two different names to refer to the same instance/spawn, I wouldn't focus my efforts on that point yet.  What matters is the idea of a holding place and mutability.

These concepts are hard to describe in a way that a 9-year-old would already know how to mentally model, but one very similar idea with which they are already familiar is the idea of a "role".

The President of the United States is currently Donald Trump.  (You should substitute the head executive leader of whatever country your child lives in for this example.)  But a few years ago, it was Barack Obama.  Later, it could be Mike Pence, or someone else entirely.  When important things need to go to the president, they go to whoever is the president right now.  They don't go to Barack Obama any more, and some day, they will no longer go to Donald Trump.  But they always go to the President.

So, to put this into Scratch, we can make a String in scratch called President, and then we can use the set box to set President to "Donald Trump".  We can then make an item in the main field that behaves as a button, that changes that variable to [insert your child's name here].

Now, we can create another value, called x, and set that to a zero.  Now, when you press the button, change x by 4, and we can watch the variables change.  Press the button 10 times, and the value becomes 40.

So, what can we say about x?  Sometimes we say that x is 40, but is it really?  Or does it just hold 40?

This is the most important early understanding to arrive at when describing a variable.  When we say that x is 40, what we really mean is that x holds 40.


Helping students adjust to using industrial-strength IDEs Something I've often observed is that many students find it challenging to figure out how to use full-fledged IDEs such as Eclipse, Netbeans, Visual Studios, IntelliJ, and PyCharm.

From what I can tell, this is due to a variety of factors:

The UI is often visually complex and intimidating for beginners. This is exacerbated in cases where your IDE unexpectedly changes appearance (for example, after running anything in Eclipse).
Setting up new projects and running even a simple "hello world" program is often non-trivial (you have to pick between several different "project templates", need to adapt to working in this new folder layout, sometimes need to configure your IDE to point to your compiler or editor...)
The IDE can sometimes be unexpectedly initially laggy. For example, IntelliJ will need to "index" your files/your standard library (with minimal visual cues that this process is taking place). This will cause functionality to be mysteriously laggy or missing for about a minute after first using your IDE.
The IDE often introduces several new "metaphors" that need to be explained. (For example, Eclipse has this notion of a "workspace" -- it's not immediately obvious this is actually a folder on your filesystem). This problem is further exacerbated by the fact that a small minority of students don't seem to have a firm grasp of what a filesystem is (which is disconcerting).
It's easy to accidentally screw up the appearance of your IDE. If you accidentally click a small button or drag-and-drop something by accident, you can remove an essential part of your view without an obvious way of getting it back.

In light of these factors (and other ones I may have missed), what is the best way to help students adapt to using IDEs?

I briefly thought about demoing how to install and use an IDE in class, but that seemed like a poor use of class time. My current idea is to provide handouts guiding students through their installation process, but I'm curious to see if there are more creative or effective solutions other people have come up with.

For the purposes of this question, we can assume students have completed at least CS 1, maybe CS 2, and have prior experience using either a text editor or a minimal IDE (such as BlueJ or JGrasp). I'd welcome both language-specific and language-agnostic answers.

IDEs are tools that are designed to solve specific problems.

They're great for stuff like:

Compiling multiple projects that contain a bunch of classes.
Dealing with dependencies on multiple libraries.
Handling stuff related to coding, like starting up servers.
Packaging and deploying your application.

If the students haven't encountered these problems, then honestly they probably aren't ready to use an advanced IDE. They don't have a need for it, and they should probably stick with whatever works for them.

Another consideration is that students need to understand what's going on "behind the scenes" before jumping into using an IDE. At a bare minimum, they need to understand:

Basic command line interaction: How do you navigate over directories? How do you run programs?
System Path: How does your computer know how to locate Java? How can you change this?
Compiling and Running code: How do you compile a .java file via the command line? How do you run a .class file? What is the difference?
Classpath: How do you use a library from your code, from the command line?
Errors: What is the difference between a compiler error and a runtime error? How do you read a stack trace?
Documentation: How do you consult the docs to figure out what functions a class has?

I say they need to understand this, because too often I see students who don't understand what the difference between path and classpath is, or who don't know what the red squiggly lines in their IDE are telling them, or who rely on auto-complete and copy-paste for everything.

All of that being said, I think you should start with a very basic text editor and the command line. Spend some time there and make sure they understand the basics. Then as their projects get more complicated, they'll naturally see the benefits of using an IDE.

Present the IDE as a solution to the problems that they're already experiencing.

"Who here is sick of specifying the classpath argument whenever they compile their code?"
"Does anybody wish it was easy to see what functions a class has without needing to do read through the docs?"
"Now that we know how to export our application via the command line, let's see a quicker way to do that."
"Now that we've learned how to debug using a piece of paper and a pencil, let's see a way to do that automatically."

Then introduce the IDE and point out specific ways to solve their specific problems. Throwing them in the interface and saying "here are 100 different things this can do" is going to be overwhelming. Build on what they already know, and solve the problems they're already experiencing with a more basic editor.

This makes sure that they understand what's going on behind the scenes, which helps demystify the process. It also gives them a good reason to use an IDE, by framing it as a tool that helps make their lives easier, which is what it should be.


How to design a cloze test for a programming language? I teach a course on C++ for 2nd year undergraduates in computer science. So far, the exams in my course contained mostly code-writing questions, such as "write a class that implements a binary tree and supports the following methods: ...", or "write unit-tests for a class that implements a complex number testing the following methods: ...". During the semester, the students have very similar homework assignments, so students who have worked the assignments on their own should get high grades on this exam.

The problem is that such an exam is very hard to read and grade. So this year I would like to try a differnet kind of exam, similar to a cloze test. The idea is to give them an implementation of a class (e.g. a binary tree), but with some important words or statements missing. They have to complete the missing words. For example: there is a destructor heading but its content is missing, or vice-versa: the content is there but the heading is missing. I plan to have about 100 missing words, each of which is worth 1% of the total grade.

My questions are:

How can I design such a cloze-test such that it will be easy for students who have solved the homework assignments by themselves, but hard for students who have  not?
Is this cloze-test used anywhere else for a programming language? I will be happy to see working examples so that I can get design ideas.

I don't think that an entire Cloze test is practical, and in any case, it does not assess deep understanding well.

One problem with longer Cloze examples is that they force the student not only to understand the goal, but also your particular implementation, which will often feel quite foreign to them, even if they are strong students.  A further problem with Cloze-style is that, the more blanks you leave, the more possible combinations of correct answers you leave.

I once had a student fill in a top portion, meant to initialize a variable prior to a loop, with a correct lambda statement that solved the overall problem, and then fill in the following loop fill-ins in such a way as to make sure the loop never entered.  The solution was a good one, so it received full credit.

I use a mix of problem types on my exams. Short Cloze-style questions can address syntactic understanding and the ability to accomplish very basic operations, such as identifying three compatible statements to put in a for loop to
look through an array.

Multiple choice questions are good at making sure that particular distinctions are being made. I use these to isolate what I call "cognitive traps".

Coding exercises are, indeed, hard to grade, but they are also necessary for testing whether everything can be pulled together.

If you need to bring down the grading time, you may want to consider keeping the examples short and making AP-style code rubrics, as they can make the grading far easier.


Scheme vs Haskell for introducing functional programming So, I am not interested in which language is better, because that is a matter of opinion.  What I care about is whether making a switch from Scheme to Haskell will directly help me accomplish my goals.  What programming language concepts does each language bring to the fore?

So, I am seeking input from folks who have taught using these languages about the kinds of experiences they had.  How did the language features of Haskell or Scheme make your students' experience better (or worse)?

For context, my kids come into their junior year knowing Java, C, and Python pretty well.  For their junior year, it was decided that there should be a course in theoretical computer science.  In order to have labs, I further decided that we should move away from imperative programming and expose the kids to a functional language.  So, while the class was not about functional programming, the kids did quite a lot of it.

I used Scheme (DrRacket, to be specific), but over the course of the year, I found that kids were sneaking set functions into their labs, which ran (to my thinking) counter to the goals of the class.  I was also a little displeased with the rather unintuitive way that boolean functions and contracts interacted in the language.

I have, as a result, been thinking about migrating over to Haskell.  If I did this, I know that I would need to redesign my labs (and I wonder if the Turing Machines I have them design would suddenly run very slowly!)

But, other than not having a set function, what other benefits might Haskell bring to my students?  I don't mind putting in the work to redesign the course if there is a sufficient benefit.

I suspect there'll be more universities switching from Scheme to Haskell for introductory functional programming (FP) courses, mainly for the 'real world' appeal of Haskell. I see 15 mentions of Scheme and 16 of Haskell in the recent SIGCSE programming language poll results, although Scheme (as Racket) still has the edge in introductory courses.

We've a little FP in one of our A-level (secondary school leaving exam) CS courses in the UK, and Haskell seems the popular choice; indeed I'm not aware of any schools using Scheme for this. I know of one school that's been using Haskell with six year olds(!). In the US at school level, Scheme (as WeScheme) features in Bootstrap World, but they're using Pyret for some courses now.

There are some good Haskell texts around, e.g. Hutton's Programming in Haskell, and Lipovaca's Learn You a Haskell for Great Good! (free online version), but these are introductions to the language rather than introductions to functional programming - it still seems hard to beat SICP, which is Scheme based. What text are you using at present?

Interestingly, this critique of SICP from 1987 identifies four issues with Scheme, all of which are addressed in Haskell:

Pattern-matching.
A syntax close to traditional mathematical notation.
A static type discipline and user-defined types.
Lazy evaluation.


Tell me a book ( or resources) for creating a good terminal based workflow (for building, debugging) for c++ based project development About me: I started development in python. I consider my self as an intermediate Vim user. I am comfortable with many bash shell commands. For all the python projects (like django or numerical optimization related), I simply open multiple terminals in i3 and then edit different files using vim and get things done.

Here is a fact about me, I have never done project development in C++ ( long back I did write some single source code file in C, but that is all). I would like to develop some expertize in doing C++ based project development using command line interface (no IDE for sure). I know that there will be an addition compiling and linking overhead (this is where python is so good).

I need to learn some tools which will allow me which help me to create good workflow ( or say environment ) to do development of C++ based projects using cli (command line interface). I suspect that the 3 tools which are must for me to create such cli (terminal) based workflow are :

a compiler ( gcc)
gdb for debugging via command line
make ( for build automation)

Can anyone refer me to a book ( or any other resource like online courses, videos, blogs ) which would help me to learn those tools for building a terminal based workflow and would teach me some C++ language itself ?

Note1: Most of the C++ books I found online would simply teach C++ development using some IDE, I have not found a single book which teaches C++ development using make and gdb (or any other command line tools).

Do it in two steps: There are resources for each part.

Start by learning how to compile, link, run code, and launch the debugger, from the command line.
Then learn how to write make files.

You should also read Recursive Make Considered Harmful by Peter Miller. It should direct you away from a lot of common bad practice. When I applied what I learnt from it, to re-right a make file, with the intention to make it simpler, so that it would be easier to add to. It also became twice as fast (but that is not the reason to read this).


How can I find someone online to mentor me on my first research paper? I am an undergraduate student, and I have an idea which I want to explore and write a research paper on. But I am totally new to this.
I don't have good CS community at my place.
So I can only look for a distant mentor.
Please tell me how and where (sites, forums) it is possible.

I would suggest taking to professors at your institution. If the semester is in session, you can go to their office hours; otherwise, you can email your advisor or another professor who knows you. Even if it's outside their area, they should be able to steer you in the right direction.


Example for Introduction to Generics in Java What are some good example classes for introducing generics in Java?

I'm introducing this in the context of implementing ArrayList, but I don't want my first example to be ArrayList itself due to the inability to create arrays of a generic type. I would also like my example to be something that doesn't seem contrived/has a practical use.

While uniform collections are the obvious example, you can also build or use a Pair class in which the types of the two components are given by generic arguments. If you don't want to build it, there is a built-in class with this property: $Pair<K,V>$

But building one like it is simple enough if that is your goal.

Once you have your desired class, Write a function/method that needs to return two things instead of one. Bundle them up in a Pair.


An example that compares a computational with a non-computational thinking approach I have to teach CT to Standard 5 students (11 to 13 yrs). To explain the concept, I am trying to explain to them how CT is beneficial in today's world. The way I learn and appreciate things is by comparison. So I would like to see an example problem which is solved first using a trivial method (without thinking about CT, but still using a computer), and then applying CT. Ultimately which one is better in certain terms can be analyzed and evaluated. The appreciation will be better this way.

While I can see many examples of CT being applied, but I could not find a side by side comparison. If you know any resource that has exactly this thing, please point me to that.

Thanks in advance

I think you have a misunderstanding about something, but I can't say precisely what. You seem to really be asking for two different sorts of CT, not CT vs something else. Both math and CS require some facility in CT and, thus, CT is a prerequisite, whether taught explicitly or learned on one's own.

So, if a student can provide a "trivial" solution to a programming question then they are already engaged in computational thinking. So no "example" is likely to be very powerful in extending their thinking.

But CT is much broader than that and is a skill that people need in general, not just for computing. You need it at the market to pay for things and check that you get the right change (or, you did before electronic payments became ubiquitous). But thinking in terms of orders of magnitude, at least is useful even when reading the newspaper about scientific discovery and maybe even politics.

Let me suggest a couple of things.

If you students seem to be weak in CT, then teach that prior to getting in to the details of programming, which has its own pitfalls. Use something like CS Unplugged if you want something directly connected to computing, or a more general approach. If they are already strong in such things, there may not be any need.

Second, independent of the strength of the student background, use a lot of metaphor in introducing new concepts rather than being pedantic about the details of programming. Use "real life" examples of the concepts so that students "get an idea" first about some important topic. But, always be aware that metaphors have limits and they can give the wrong idea about things. So, be ready to dispel those misconceptions.

An example is "search for the reddest apple". This might be useful as a metaphor, unless you can see all of the apples at once and use powerful visual cues that don't have an analog in computing, where things need to be looked at one or two at a time.


How to write a grading rubric for coding assignments? I'm trying to improve the grading process and I need to write some guidelines for the graders. Students submit Java code for the assignments. Any ideas/suggestion about how to structure the grading?

This is what I have for my Java assignments. Notice that this is not a programming course, but an algorithms course.

Compiling and running (8 points)

1.a 0 points if the program doesn't compile. No points for the rest. Grading complete.

1.b If the code compiles and runs:

a   Full points if it succeeds in all test cases.
b   0.5 deducted for each failing test case.

2. Readability and submission (2 points)

2.1 Documentation (Oracle official)
    a. 0.5 points for complete commenting
    b. 0.4/0.2/0 (%) if we detect 0-25/25-50/75-100 (%) missing comments where expected.
    You should at least use clear commenting for the following:

        a. Classes and interfaces
        b. Fields
        c. Methods, including all input parameters and return values

2.2 Indentation (Oracle official)

    a. 0.5 for appropriate indentation
    b. 0.4/0.2/0 (%) for 3/6/more violations

2.3 Submission:

(0) 1 points for (not) correctly following the requirements for submission.

I would appreciate your feedback on this.


How do I teach about inequity in computing resources? What activities, and with what resources, are effective for students to learn about the status and consequences of inequities in computing resources?

Activities could address inequities within a community or across the globe.

Background:
The Advanced Placement™ CS Principles course has two "essential knowledge" (EK) statements related to this topic:

EK 7.4.1C The global distribution of computing resources raises issues of equity, access, and power.
EK 7.4.1D Groups and individuals are affected by the "digital divide" - differing access to computing and the Internet based on socioeconomic or geographic characteristics.

The AP framework indicates these objectives should be associated in the classroom with the computational thinking practice of "connecting computing" by finding ties among computing concepts, impacts of computing, and connections between people and computing. My question is not necessarily constrained that way, though it seems inherent in achieving the objective.

(I came across a resource on this topic that I wanted to share. A related question here did not exist, so I intend to share the resource in an answer but not to imply that the resource or lesson format I share is the best one. Please share other resources and lesson formats!)

This seems to me to be the sort of topic that is best covered with an assignment such as
Write a paper, citing resources, on the topic of XYZ.
There are a number of other things that can be addressed this way. One advantage of such an assignment is that students have to write using natural language, which often gets too little attention in technical fields.
Another advantage is that you can have the work done in pairs or teams.
Another advantage is that you can follow up with class discussion, seeking consensus on the problem.
You can, of course, provide them with an initial set of resources so that they are forced to look beyond Wikipedia and other easily found resources.
You can also ask for critique of the resources that they find, not just reporting. You can even have a debate. Lots of possibilities since the topic is both serious and open ended.


Robotics Recommendations I have a class of 25 students. We want to learn programming robots using a blockly-type programming language. I would prefer having a robot for every student or at least one per every two students. Price is a concern. I would like to spend about max $50 per student.

I am mostly working with middle-school kids (7th and 8th grades). Most have never worked with robots nor have they programmed in any language (including blockly).

Does anyone have any recommendations?

Take a look at the Edison Programmable V2.0 Robot. (https://www.robotshop.com/en/edison-programmable-v20-robot.html)  Available from Amazon.  Also Makeblock mBot Robot Kit (Amazon.com)

I have read some articles about the Edison be used in school successfully.  The Makeblock I just saw on Amazon.


Any website/textbook with problems+solutions in algorithms? I'm trying to find an online source or textbook with problems+solutions for problems in dynamic programming, number theory, graph theory, greedy algorithms, etc. Do you know of any?

Based on clarification in comments, Algorithms 4th ed. by Sedgewick and Wayne seems to meet your criteria. The book itself doesn't seem to have an official PDF version (I haven't searched for unofficial ones of dubious provenance), but the code is available both at the linked page and on Github, and includes solutions to selected exercises.


How can I speed up the construction of high quality testing materials? Giving the same assessments from year to year causes fairly obvious problems.  Cheating becomes more and more of a potential issue.  Basic testing security dictates that we must create new assessments.

However, generating new material has a few problems of its own:

Quality goes down, because material is less vetted.  There may be unclear instructions, or even outright errors.
Creating this new material just seems to take a really long time.

It is not unusual for the creation of a single test or quiz to take me 3-4 hours to design.  I have to look over the curricular material and brainstorm problems that can get to the heart of the core issues.  I then have to design the problems, test everything in an IDE (to make sure that there are, at least, no typos in the code examples), create grading rubrics and processes, and finish up with final formatting.

I tend to use a mix of multiple choice, free-response (coding by hand), and short answer questions  The first and second of these are what students will find on the AP Computer Science A test, so I need to give students practice with these kinds of activities.  The short answer questions are an easy way to check for understanding of some particular little point.

I have found that, between my various classes, I give an average of one quiz or test per week.  If we assumed a 40 hour work-week (ha!), then designing each assessment fresh would be a commitment of 7.5%-10% of my entire work time.  That doesn't count the time to administer or grade the thing, this is just for the design aspect.

In reality, then, I mostly don't do this, and mostly give assessments from prior years.  I want to change this practice, but I don't see how I realistically can.

Are there strategies to speed up the design of written assessments without losing quality?

Note: I don't want to give fewer assessments, because labs are suspect, and because of the tremendous cognitive benefits of testing.  Instead, I would ideally like to be able to design a high-quality test or quiz in under an hour.  This amount of time would make the entire enterprise more tenable.

For the benefit of future visitors, I will also include my own answer, though given my times, it will (obviously) only be a partial answer.

I have a few suggestions based on my experience this year. I have one prep over two blocks, which meant that for every exam I wrote, I wrote two versions. Moreover, because I take a standards-based approach, students end up retaking the exam but a modified version at that. For some exams, I ended up with 4 versions. Here's how I sped up my own process:

Focus on proficiency. Not every questions needs to "trick" students. (Indeed, "tricking" should never be the goal of an assessment: it should be an accurate measure of what a student knows and can do at a particular moment in time.) If I believe proficiency is 70%, then 70% of the points should be relatively straightforward questions that all students should earn. Maybe another 20% consists of slightly more challenging questions, saving the final 10% for the questions that might focus on the most subtle of details. By focusing on what all students should be able to do, I can worry less after the "craftiness" of my questions and get right to the heart of the matter.

Write questions designed with substitution in mind. Let's say I'm asking questions to test a student's knowledge of basic Linux commands since it's necessary for our IDE. Whether I ask about ls, cd, mkdir, touch, etc. should be irrelevant; they are all fair game. Thus, one approach is to tell students to review from a list of terms, and come up with a potential set of 4-5 answers. Then, from class to class, you can simply change what term you are asking about. The answers don't change, but the questions do. No student will know in advance which terms will be asked about just that they will be asked about.

Keep the method, but change the input. I recently assessed students on Python, and I wanted them to be comfortable with two key concepts: the use of range() for iteration and the basics of string access and manipulation. I didn't have to change the instructions from class to class very much, but by changing the input, I gave the two classes unique exams. They knew to expect questions on strings and iterations, but until they are faced with the actual input, this bit of information does not necessarily help them answer the question.

I may have more ideas come to me as I read more responses, but here's my final, overarching thought:

EXAMS ARE NOT SURPRISE PARTIES. Students, assuming they have been present and attentive in class, should not be surprised by the content of your exams. Let them be occasions for students to show you what they can do. While we as educators might stress over the perfect question to ask about, say, an ArrayList, it should always come back to this: "How I can fairly and accurately assess what a student knows?" It is not, however, a chance for us to show how clever we are. Get to the point. Be clear; be fair. Let students prove how much they have mastered. Keep that mantra at the forefront, and test design can become simpler and faster.

ADDENDUM:

Learn LaTeX. I use LaTeX for the creation of all my exams. While the first couple exams took some time to get just right, now that I have written a large number using it, I cannot imagine using anything else. It takes care of the formatting, the indenting, the point scale, everything. I don't waste a lick of time worrying about how it will print or format, especially when I need to include code samples. The time you invest in learning it will speed up the time it takes to format your exams.


How can Chatbots be useful in CS education? I am reading this book published ten years ago and it says that chatbots can be very useful in helping students with course details and to break the ice. I am not familiar with chatbots, so I have started to build my own "personal assistant" using DialogFlow, but I would like to hear about strategies for using chatbots, particularly in CS education.

It seems best to make good use of the very things that exist and are upcoming in the field in order to teach it in a more engaging way. What has worked and not worked (since this old book was published)? Where can I find out more? Maybe one lesson could be to build a chatbot, as a demo or individual project.

I'm using chatbots to discuss a variety of topics with 14 to 16-year-old high school students.

By "using" I mean that they are the subject of instruction, not a study aid / instrument for the students to use to get automated answers to frequent questions and things like that. So that's probably not what the book you mentioned talks about, but I'll go on anyway because your title asks the more open

  How can chatbots be useful in CS education

Chatbots are a great topic in computer science education because

Everybody knows about them - teenagers know what chatting is and have first-hand experience of doing it, and most students have either encountered a chatbot already or they've heard about Siri and compatriots, which can be framed as chatbots for the purposes at hand.
There are chatbots who try to mimick humans, so you can use them to discuss the Turing Test with your students
Simple chat bots which simply look for some combination of words in the input phrase are easy to build using scripting languages such as Python, and therefore can be used to give the students a first feeling for what needs to be done in order for a computer to correctly identify the meaning of a sentence in a human language. This can easily be extended into a discussion about whether computers can "understand" us.
Coding simple chat bots is easy enough so that it can serve as a first small project for beginners learning to program
In my classroom experience, teenagers love spending some time writing simple chat bots and getting them to provide (often somewhat rude) answers to things their peers type in, so it's a fun topic, too.

I agree with Buffy that using chatbots as a study aid is much, much harder to get right, and I wouldn't try that unless the domain was very, very well specified.


Is SICP appropriate for an advanced high school CS course? One of the most influential texts in computer science is Structure and Interpretation of Computer Programs. Before changing to a Python-based approach, MIT used this book for their introductory programming course. It is freely available with a number of resources thanks to the textbook site. When perusing the list of schools using SICP, I see that all of them are universities/colleges, which leads me to my question.

Is SICP appropriate for an advanced high school computer science course?

In particular, I'm thinking of students who have taken two years of AP Computer Science, so they would have completed a year of CS50 AP and a year of Java. I see that UC Berkeley has a self-paced CS class that works through it. I understand that some things are at the university level for a reason, but I am trying to bridge the gap between post-AP CS classes in high school and intro CS classes in college.

First, I love SICP. I took and later TA'd 6.001. Like many MIT grads, I tried to teach it where I became a professor, and, like most who attempted it, decided not to do so again.

The main reason it is rarely successful outside of MIT isn't the difference in student quality but the difference in the support the school can offer. If I remember correctly, at MIT, there were three lectures a week, two recitation sections, one tutorial section (approximately 4 students meeting for an hour with a graduate TA), and many staffed lab hours. A high school or small college cannot generally provide that level of support. Also, when taught outside MIT, it is usually as a junior-level course, and students still usually find it overwhelming. (An exception is UC Berkeley, which taught it successfully for many years at the freshman level.)

I am not saying a high school class could not succeed, just that it would be very difficult, and the amount of work required would be exceptional.

It might also be hard to motivate students to work so hard on something so abstract, when they could be learning app development, computer games, or another more immediately rewarding topic with less effort.

In summary, I would advise against using SICP for a class at the high school level, although I do think it is possible to supervise an independent study with a sufficiently motivated and sophisticated individual or small group of students.


Student Teaching Minetest Modding in school as club I am a grade 11 student at school. I created and am running a programming club each lunch. We meet once a week (typically, sometimes I have to cancel since my club isn't important). We have 50 minutes each lunch, though I lose 10-15 for logging-in (my school uses Windows), and other time loses.

History

Last year I tried using Godot to teach them, and using Youtube tutorials, but we progressed an average of 15-20 minutes per day. Since they are simply copying the code most the time, and one of the students is nearly always absent. And the school computers don't work with the new version of Godot, so I decided it would be best to change.

Plan

It will be my last year, so I want to at least get some of them interested enough to continue the club once I graduate. I had 3-4 students this year, I might have 3-6 grade 7-9 students next year. Since Godot isn't working and the kids just play games, I thought of modding Minetest with lua. This would allow me to have a buffer at the end of class where they can just play and debug while learning.

Questions

I want to know if there are some resources that could help me teach that club.
Any way to structure class time.
How should I teach them, all work on similar projects, or should they work together on a project.
In what order should I teach concepts
What should I do about absent students

Plan for teaching

Unit 0: Intro

Installing Minetest
Installing text editors (not Notepad) suggestions
Installing a simple mod
Mod folder structure

Unit 1 Creating blocks

Using print
Creating basic cubes
Creating textures using GIMP
...

Unit 2: Formspecs

...

I will edit this more after people answer

Thanks for your help

You seem to be focused on game development, which is probably the right thing to do since at least some of your student colleagues will also be interested. But there are other possibilities to keep in mind, such as some simple information system that your school might use. Teachers might be able to give you ideas about that.

Since you want the club to continue after you leave, I'll suggest two things. You should probably try to develop one student to take your place and spend more time with him/her to foster a leadership role.

More important, I think, is to pick the right project for your group. If you aim for a large result that can be built in parts and where each added part adds visible value (punch) then you might have something sustainable. You don't want a small project (or set of projects) since continuation means finding more projects. You don't want a project that isn't useful/cool/exciting along the way (but only at the end), since you don't get any psychological reward as you go. Pick a project that is large enough so that it can't be "finished" in the time available. It will then be an inducement to continue in the future.

I'd also suggest that you don't try to lecture, but rather form an Agile Software Development programming team, using some of the practices of Extreme Programming. See Activities and Practices at the last link. There are other possibilities but XP is fairly easy to follow. Use short iterations and small stories. But make sure that each story adds gaming-value: something that will actually affect the play of the game.

The above will also favor collaboration, which is a useful skill. Don't worry about absent students. Work with what you have. If the thing is interesting enough people will want to participate. But it has to be interesting both in its own right and also in the day-to-day activities.

I would also suggest, pretty strongly, that, rather than laying out a curriculum for this, that you explore topics on a need-to-know, just-in-time basis. Making it like a regular course might not be as appealing to others as just keeping it like a club.

Don't exclude newbies, but incorporate them, and their enthusiasm, into the project and enable it with Pair Programming, starting them out as Navigator with one of you "old timers."

Good luck with this, and in your future.


Books to use for iOS App Development I'm exploring iOS App Development as an elective for students, and in perusing Apple's iBooks on the subject, I see two similar books: App Development with Swift and Intro to App Development with Swift. On the surface they look quite similar.

Are there significant differences between the two that I should take into account when selecting one for a course?

These are both part of Apple's Everyone Can Code initiative, and both are appropriate for a high-school and college audience.

The Intro book is intended for non-programmers, and teaches programming fundamentals and Swift syntax, with 90 hours of lessons included.

The non-intro book gets into more complex UI development such as working with table views and navigation, and topics like consuming web APIs, and includes 180 hours of lessons:

App Development with Swift Curriculum Guide (where I took that screenshot) also shares helpful outlines of the two curricula that can give you a sense of the differences at a glance.

Here is the Overview from that guide explaining the difference:

  The Intro to App Development with Swift and App Development with Swift
  curricula were designed to teach high school and college students with
  little or no programming experience how to be app developers, capable
  of bringing their own ideas to life.

  The Intro to App Development with Swift course introduces students to
  the world of app development and the basics of Swift and Xcode. The
  course culminates in a final project where they can choose one of two
  basic iOS apps to build.

  App Development with Swift takes students further, whether they’re new
  to coding or want to expand their skills. If they’re already familiar
  with Swift, Xcode, and iOS development, they can move through lessons
  quickly or go straight to the labs, where they’ll build miniprojects
  and test their code in playgrounds. By the end of the course, they’ll
  be able to build a fully functioning app of their own design.

The document goes on to further explain the two courses as follows:

  Intro to App Development with Swift

  This introductory one-semester course is designed to help students
  build a solid foundation in programming fundamentals using Swift as
  the language. Students get practical experience with the tools,
  techniques, and concepts needed to build a basic iOS app.

  App journal activities take students through the app design process,
  from thinking about the purpose of an app to market research and early
  user testing. By the end of the course, students will have created a
  plan for an app they’d like to develop. Even though they might not yet
  have the skills to build the app, the work they put into the framework
  will set them up for future development.

  App Development with Swift

  This two-semester course features 45 lessons, each designed to teach a
  specific skill related to either Swift or app development. Each type
  of lesson takes a different approach:

  Swift lessons. These lessons focus on specific concepts. The labs for each are presented in playgrounds so that students can
  experiment with code and see the results immediately. Playground files
  are provided.
  App development lessons. Focusing on building specific features for iOS apps, these lessons typically take students step by step
  through a miniproject. The labs help students apply what they learned
  to a new scenario.


Is it OK to use "informal" systems such as TeamSpeak or Discord to support classes? Like many of you, in the last weeks, I've been forced to move to distance teaching/learning. While our university has always suggested us to use Zoom, from the first moment, several students said that we should have gone with Discord (which I've never even heard of until then). Among other things, they liked Discord (and not Zoom) because the "chat" didn't disappear after each session and it is much easier to share images and other files. They've also mentioned that Discord was a good choice because they were already there, and so, they didn't need to install another app and create another account. They were also looking for an away to stay closer to the teacher.

So, I decided to give it a try. I've created a "server" and invited them to that server. After a session with them, I've sure realized that for the classes Discord is not as good as Zoom, however, for a more informal way of contact with the students it may be a good choice. Interestingly, several students mentioned that they don't consider a good idea to "mix business with pleasure".

I understand some pros and cons. Any thoughts on this?

We've been using Discord as a central place for all class discussion, and Zoom only for live lessons (rare) and small group meetings, and unpublished YouTube links for most lectures.  So far this has been working quite well.  If I'm totally honest, Discord may be the best part of our workflow.

Discord gives a nice sense of community and comity. Its informal nature is a real boon to keeping class spirit alive, with reactions and animated gifs easily accessible.

You can "pin" important announcements so that they stay at the top.

It also allows for code formatting for short code excerpts just like here on StackExchange, with ` around text to get this effect:

You're using x in your function, but shouldn't you just call getRemaining() instead?

And you can format code to any language using three backticks and a language nane

```scheme
(define nekst (cadr (last lyst)))
(perform-func nekst)
```

That will create syntax highlighting in a Discord comment, and you can replace scheme with the language of your choosing.


How can I show the value of best practices? As someone who likes to advocate for best practices like correct use of VCS, indentation, sufficient commenting, and testing, I try and integrate them when I teach. But for all of these things, my students always ask me why they need to do it for projects of the relatively small size and short duration they're working on. They're right that it isn't necessary, but I don't know how else to teach it and get them to practice it.

What ways do you find effective to introduce programming best practices? How do you ensure that your students continue to use them?

I've faced resistance too. Here are some ideas:

Students would not turn in an assignment to an English teacher that was not properly punctuated and proofread, even if that teacher will be the only reader. They should not turn in an assignment to a CS teacher that is not properly formatted, documented, and tested.
Companies want to hire programmers capable of writing scalable programs. I can write a much stronger letter of recommendation for students who do well at this. (Adapt to college letters of recommendation for high school students.)
Rhetorically ask why people try their best when practicing CPR on a dummy.
When I interviewed job candidates for Google, I asked questions about testing. It would be hard for candidates to answer well without having practiced writing tests.
Give prizes for and share examples of student code that follows best practices. (Get a student's permission before sharing their code.)
Show them disastrous bugs that came from not following best practices, such as this one.