Distance or Part-Time Graduate/Doctoral Study I have a friend with a bachelors degree from a good school. He currently teaches Secondary School CS but wants to continue his education. However, he is limited in his ability to move except within a radius of a hundred or so miles from NYC. Short term travel outside his home range is probably a possibility, but not a residential program.
He is bright and works hard and is focused, for now, on teaching Computer Science. His goals require an advanced degree, ultimately a research doctorate, not just self learning. He is looking to remain in teaching and to do research as well.
What opportunities does my friend have for part time and/or distance graduate education?
I've suggested to him that there are (must be) week-end and summer programs that, while intensive, only require part time presence outside his home range. What options do you know about that might help him and others like him?
If you suggest a program/institution, please say why you think it is appealing. Note that MOOC type programs are not useful here. The program can be very intense, but needs to provide a solid, recognized degree.
Serious and continuous contact and interaction with faculty and other students would be considered as an important plus.

Georgia Tech announced an Online Master of Science in Computer Science degree in 2013, which has received very positive press. You said you don't want MOOCs because they don't "provide a solid, recognized degree." Georgia Tech's degree is solid and reputable.
According to a 1996 New York Times article:

With one of the top 10 computer science departments in the nation, according to U.S. News & World Report, Georgia Tech had a reputation to uphold. So it made the online program as much like the residential program as possible.
Charles Isbell, a senior associate dean at the College of Computing, helped lead the effort. Mr. Isbell has a Ph.D. in artificial intelligence and machine learning from M.I.T., and he teaches those subjects at Georgia Tech.....
In theory, on-campus programs offer direct access to professors and peers. Mr. Isbell began noticing differences in that respect between his residential and online students. He was interacting much more with students who had never set foot on the Atlanta campus.
“I never see students at my office hours,” he said. A few linger after class to ask scheduling questions, but that’s about it.
Many of the thousands of online students, by contrast, are constantly interacting on a website set up for that purpose, where Isbell can log on and help. “I can jump in and say: ‘No, you should be thinking about this,’ ” he said. “I spend more time helping them with assignments online than I ever do on campus. The experience for the students and for me is much richer online.”

This seems to provide the desired interaction with professors, albeit online.
While it is not a research master's, it should put someone in a good position to apply to PhD programs.
Update
Commenters have correctly pointed out that this is not a research Master's, and a Master's degree is not needed to apply to PhD programs. Thus, it is not a perfect fit. It is, however, the only highly reputable distance CS grad program of which I am aware.


Teaching (2,3) and AVL Trees: information in internal nodes or in external nodes? Are there practical applications (or other reasons) to teach (2,3) and AVL search trees with both keys and the associated information (as opposed to only search keys) in the internal nodes, as opposed to internal nodes having only keys and leaves having the information associated to them?
Two generic Data Structures implementing the Dynamic Dictionary Abstract Data Type are "(2,3) Trees" and "AVL Trees". Such a dynamic dictionary data structure implements (at least) the methods insert(key,info), search(key), remove(key,info). When teaching those, in order to simplify, save space and draw examples quicker, one can omit the "information" part, hence reducing the dynamic dictionary abstract data type (ADT) to a dynamic set ADT. This generates some minor technical differences:
A. inserting the pairs (10,A), (20,B), (30,C) in a dictionary (2,3) Tree yields a tree of height 1, with the pair of keys (20,30) at the ternary root separating 3 leaves coding for the 3 pairs (10,A), (20,B), (30,C); while
B. inserting the keys 10,20,30 in a set (2,3) Tree yields a tree of height 2, with a binary node (20) at the root, separating two binary nodes (10) and (30) [separating 4 empty leaves, if this makes any sense].
I find solution B a bit confusing to me (albeit I can cope with that) but, more importantly, confusing to undergraduate students, who end up learning how a search tree works without understanding why it works this way. I am wondering if it is an example of simplification making it (voluntarily) more complicated, or if there are reasons (e.g. practical applications) to study search trees with information (or pointers to information) along with the search keys in the internal node.
Notes: Obviously  enough,

Splay trees SHOULD have the information (or pointer to it) along with the search keys in the node; and
any search tree optimizing memory accesses (such as B-Trees) should have all information in the leaves in order to minimize paging while navigating the internal nodes.

I think the two situations are entirely different in applications. In the case that the internal nodes are only search keys we find applications in database indices. By associating keys with internal nodes we obtain space efficient dictionary types.
The contrast between the two cases could help learners understand the concepts more easily. By focusing on the differences between the two cases, perhaps without too much reference to the implementation of the tree operations themselves, learners would better understand the utility of the datatype.
Once that is the case you could choose either case to explore the operations in more detail. Or why not be groovy and use red/black trees. As a student I found AVL and 2-3 tree theory deeply boring whereas red/black trees were quite exciting. I think because the rules are so much more interesting, involving colours rather than arithmetic.
As a teacher I have always regarded me being confused as a sure sign that my learners will be. Perhaps more visuals would help out - and that means colours - and those tree rotations are beautiful!
I would also say that such things are not really confusing - its just how they work out - like music, its just that way. Similarly AVL trees and 2-3 trees being the data type analogue of Manhatten Transfer are less inspiring to a modern audience than https://www.youtube.com/watch?v=HZfnmNf5MwA.
What you say about splay trees, and the finer implementation details of B+tree indices is correct, but who really cares - not your students - they are already confused. Give them some colours, give them a taste of the good stuff and ... then start looking at 2-3 trees, I mean, when you are no longer bored, confused and not listening - but instead - curious and inspired, those 2-3 trees ... well are they
Fibonachi? I mean, thats better than dyadic surely ....
Answer - its best if your students are still awake after 10 minutes, ;)


Engagement advice on Creative computing I'm preparing a course for next year, aimed at kids from ~6-16. It's based around the concept of creative computing:

http://scratched.gse.harvard.edu/guide/index.html

I think it will be a great experience. We'll be working around Scratch, and a lot of stuff involving game development, animations, and who knows what else will come.

The real challenge I see in this course (as well as the main objective) is how to engage the kids into this world of development: The stereotypical kid in this age range is just interested in playing games with their parent's smartphone or tablet. Some of them have a PlayStation or other gaming system, but at the end, they spend a lot of hours playing modern games, which are ridiculously easy to play (don't get me wrong, some of those are great, but the majority of them don't promote any required value like endeavor or perseverance). Those kids don't know the amount of work that those games involve, and I'm a bit afraid of them getting frustrated by the fact they cannot easily make AAA games like the ones they're used to in a matter of minutes.

Has anyone experience in a similar environment, who can provide experiences and feedback? How do you engage those kids into this world that requires so much sacrifice and willing to learn?

Show them the cool stuff they can do with Scratch.

Don't focus on explaining that they can't make a AAA game. Focus on showing them examples of stuff that is engaging and interesting, that they can do with Scratch. Come up with a showcase of interesting programs. Make sure your assignments are engaging and interesting.

Taking a step back, I'd also recommend you give your students the benefit of the doubt. Don't come in with an attitude that assumes they only care about modern video games and smartphones. Connect your lessons with stuff they do care about. Have them draw a scene from their favorite show, or have them make a game or animation about their friends.

And taking another step back, the age range of your students is very high. A 6 year old and a 16 year old are very different. I'm not sure Scratch is the right choice for 16 year olds. Maybe try something like Game Maker or Processing? I've mentioned Processing in a bunch of my other answers, and I'd be happy to talk more about it with you if you're interested.


Where can I find a breakdown by race and gender of US CS bachelor's degrees? I know where to find the percentage of CS bachelor's degrees going to women in the US (Figure 2-16) and the percentage of CS bachelor's degrees going to people of different ethnicities at research universities in the US and Canada participating in the Taulbee Survey (Table B-3). Where, if anywhere, can I find the percentage of bachelor's degree in CS, ideally over time, broken down by both ethnicity and gender?

the Taulbee report An-In Depth Examination of Data and
Trends Regarding Women in Computing provides summary data on computing degrees by ethnicity & gender for 2013 in Table 2 on pg 20 and cites the Integrated Postsecondary Education Data System (IPEDS) as their data source. You can either filter through their data online or download it:

  Data are available starting with the 1980-81 collection year for the Complete data files and Custom data files functions, which zip the data into comma separated value (*csv). Beginning with the 2010-11 collection year, data for each collection year are compiled into an Access database.

Some tips for using their online data statistics:

Try using the 'Statistical Tables' option on the 'Use the Data' page
When select institutions, if you select 'By variables', there's an entry called 'Completions' which has an option for reporting 'Number of students receiving awards/degrees, by race/ethnicity and gender'
After that, select the specific gender/ethnicity info you're filtering for


How to make perfect documentation of FYP with less plagiarism? For a student of BS(CS), a supervisor wants documentation of final year project with high vocabulary and with less plagiarism, but the students write documentations on their own, without copying paste process but still there are a lot of mistakes and plagiarisms in documentation. What method should be applied to make documentation with less plagiarism and with broad vocabulary?

The problem of literary in education is much more severe in the work of institutions where it is difficult to show individual contributions in different fields in particular. With many others, we found the evidence of literature in the last year of the undergraduate projects. This is an important part of our program. The undergraduate partnership is about 20% of the degree award. Current approaches to detecting non-original material are defective, this paper describes an alternative procedure that integrates with the Internet-based project system that combines the management, monitoring and promotion of good and fair ways. It explains the paper issues associated with the current approach, the use of natural language processing techniques to help prevent literature and its blocking, and to report some preliminary results.


How can we measure proficiency in programming languages? Recently Python and Java have started to be the de facto standard for teaching CS1/2. This means that students arrive in courses like Embedded Systems, Operating Systems or High Performance Computing without any experience with the C language. Where I teach we have a special "C marathon week" that provides an introduction to basic C programming to students who already code in Python and Java. We currently have an exam to try and measure students' mastery of C, but our approach is very empirical. We have impressions about what what they have learned during the first week, but very little of it is actually measurable. Mind you, students are able to do all the coursework, but we do not understand the relationship between their success and our introductory activity nor are able to quantify how much knowledge they gained during the semester (but after the introductory week).

So, are there best practices regarding evaluating their knowledge of C (or any other programming language) separately from their basic programming knowledge? This might generalize to other programming languages/technologies as well, so answers might not need to focus specifically on C.

Ideally, I am looking for something like concept inventories, but that focuses on the mastery of C and not on introductory programming.

I think you are taking a good approach with your boot camp. I'd only suggest a warm up exercise/mini-project in which students get some practice, perhaps writing in groups (pair-programming, perhaps).

One useful sort of project is called a fixer-upper. There is a pedagogical pattern by that name, actually. Give the students a program that you have written. Make it fairly large (bigger than they could write themselves). Make it a good a C program as you can. Then break it in a few ways. Some of the introduced errors are syntactical, which the compiler can catch. Others are more subtle and require thinking. The exercise is to fix the program. It is a good "hot" introduction to a language. In another course than those you suggest, I might give them a program that solves a problem they already know how to solve in, say, Python. But here, it might be better to do something that makes them think about memory.

But, I wouldn't worry overly about mastery at this level. Any "predictor" will be imperfect. Students can grow into the language along with the OS concepts, for example. I learned a lot about machine level programming in just such an environment.

The student needn't be perfect in one thing before they move on to the next.

But you may need to provide additional feedback or mini-lessons along the way if they seem to be a bit off track.


Genetic Algorithm enrichment lesson As a special lesson, I would like to show students the very basic idea of genetic\evolutionary algorithms. I let them play a bit in a genetic algorithm online game, to get the idea.

Then I teach them the main concepts (Population, individual with genes, mutation, crossover, fitness etc.) and I introduce the Traveling Salesman Problem. Then I go through solving TSP with genetic algorithm with them, so they see it in action and in practice. However I'm out of practice exercises.

So, I am looking for problems that have a solution which can vary in its "goodness", and its goodness can be judged by some requirements. To explain this, take the example of a timetable for tests over a month. a solution is a random time table. a good solution is one where tests are suffeciently spaced so that students have time to revise. in the game, a solution is just any vehicle, but a good solution, is one that gets far.

Note: I am not necessarily looking for an answer that shows any previous knowledge about genetic algorithms (though it is appreciated ;)), just any problem as described above.

What kinds of exercises\problems such as those are used?

The students
 are high-school students learning in java, and they are familiar with OOP.

Classification problems are reasonable candidates.  For instance, I wrote a GA that looked at the mushroom dataset taken from the UCI Machine Learning Repository with the goal of classifying an unknown mushroom as safe or poisonous based on its traits.  Each candidate solution encoded a series of rules (Red cap means poisonous, blue spores are safe). During the learning phase I used a portion of the dataset, but to perform the final evaluation I used the full set.

That particular dataset might not be well suited to the high-school level, as it has missing values on some entries, but there are a lot of other datasets. Also, numerical data is generally easier to encode than categorical data. That being said, it was a fun dataset to use - "Hey look, after fixing that bug my GA poisons us 15% less often!"

Beyond that, it might be worth deliberately looking at a variety of problems including some that are poor candidates for GAs in order to demonstrate their relative strengths & limitations.


What statistics should be in a computer science degree? My university has decided that it should give a core (that is compulsory) statistics class to its computer science undergraduates.  This opens the interesting question of what should be in such a class that everyone has to take.

As far as I know most CS degrees don't currently contain statistics classes so it's hard to compare to what already exists.

  Does anyone have any experience of this and what would people
  recommend for a new statistics class for computer science students?

My first thought to provide a bit of something for you to go on was CS2013: The ACM/IEEE Joint Curriculum Guidelines for Undergraduate Degree Programs in Computer Science. This is available at https://www.acm.org/education/CS2013-final-report.pdf. I've copied out two relevant passages from that here:

"Computer science curricula should be designed to provide students with the flexibility to work across many disciplines. Computing is a broad field that connects to and draws from many disciplines, including mathematics, electrical engineering, psychology, statistics, fine arts, linguistics, and physical and life sciences. Computer Science students should develop the flexibility to work across disciplines." (p.20)

"Similarly, while we do note a growing trend in the use of probability and statistics in computing (reflected by the increased number of core hours on these topics in the Body of Knowledge) and believe that this trend is likely to continue in the future, we still believe it is not necessary for all CS programs to require a full course in probability theory for all majors. (p.50)".

It is worth searching that document for 'statistics'. It is mentioned in many other areas, but mostly as something learned in other areas such as Networks, HCI, Cryptography, etc.

The December 2013 issue of ACM Inroads had a good article (http://dl.acm.org/citation.cfm?id=2537777) on the role of mathematics in CS. This included a section on "The Current State of Mathematics in Computer Science Curricula". The article states that "The most-connected mathematical topic [to CS] by far is probability and statistics" and has some references to such. They also present the mathematics requirements of 25 'high quality' CS programs. Stats and Prob was required for 15, Calculus for 21 and Discrete Mathematics for 22.

http://dl.acm.org/citation.cfm?id=1240202 discusses statistics in liberal arts CS curricula.

Searching the CITIDEL syllabus collection (citidel.villanova.edu/ then look for syllabus collection) for 'statistics' might be worth a try, although the website has been varying between unresponsive to slow to responsive lately. Also, some of the material in there is a bit dated, but then again, statistics dates fairly well!

Given that in 2013 60% of sampled 'high quality' CS programmes had statistics, maybe it is more prevalent than you think. Perhaps the best way to obtain the most up to date information is to check the websites of several good CS programmes and hope that if they include statistics, the syllabi are available online.


How to deal with students that don't like CS? This question is really aimed to teachers, especially in high school courses (but everyone is welcome to share some ideas). If you have a student that really does not like Computer Science, what should you do?

Encourage him, he might find his passion in CS
Talk to his parents and tell them maybe he should be in a course more of his liking
Try to find common ground between what he likes and CS (this one is actually very hard to do if you want to comply with the curriculum)

I'm most interested in the answers for a course that is required, but answers for courses that are optional would also be of interest.

If you think this question is not suitable here or should be rephrased, please tell me so in the comments.

On the first day of class, I ask students how Google search can work -- returning an answer to any query over billions of web pages in a fraction of a second. Usually someone mutters "magic". I say, "That's right. What else would you call it when putting together words and symbols enables you to control powerful entities?" Computer programs, I argue, are spells, and robotics is transfiguration. The wizardry in Harry Potter isn't real, but computer science is. Whatever you want to do, computer programming will make you more powerful. (The good people at Code.org similarly call coding a superpower.) I challenge students to name a field of interest, and I tell them how computer science can be applied to it. Whatever your goals are, I say, being able to create computer programs will help you achieve them.

Within the bounds of the curriculum, try to come up with applications that interest the students, and help them keep their eyes on the prize. Stress that they're going from the majority who only knows how to use other people's programs to the minority that can create programs.

I can't say how well this would go over in a high school class, but it seems effective in workshops for high schoolers and for classes at the college level. Of course, as Aurora0001 pointed out, CS isn't for everyone, so there will be some students who don't respond well, but you should be able to capture the imaginations and respect of many students by making sure they understand they're not moving semicolons around, they're exerting god-like power. :-)


Improve motivation in the final part of a project based course Fellow educators,

I am teaching a project based course composed of two parts. The first half of the course focuses on basic concepts and activities that serve as preparation for the second half where students work on a project. The project is based on a grading rubric and, for students, it is very easy to evaluate their own progress.

Lately some students started leaving class earlier. The early leavers are actually the best performing ones and have already accomplished the minimum project goals. Thus, they are already approved in the course even though we still have one month left... (<-- this sounds like a problem...)

My question is: how to improve the "end-game" of project based courses to avoid students leaving early and help them to stay motivated?

In my program, we have a year-long culminating capstone project which has a format that might work well for you.  Traditionally, high school seniors in this area of the world catch a disease called "senioritis" that prevents them from doing a lot of work as they enter into the last few months of high school.  It's a highly contagious disease, though once caught, you often gain a subsequent immunity (such as in college or graduate school).

We

The format of the year is:

Choose projects
Work towards completion
Give final presentations to outside judges
Final cleanup and submission

Here are the details for steps 2-4 that make this all work:

Working towards completion is done using milestones.  The students decide what the next logical part of their project is, and negotiate with the teacher what they will accomplish by the next check-in date. (They also negotiate what the next check-in date will be).

In my experience, I have to dial my students back more often than I have to push them forward. Students often have big ideas, and little sense of how long those ideas will take to enact.

I keep a public calendar of which groups I will need to see each day. With any extra time, I check in with active groups to see if they need any help.
Final presentations

We rehearse our final presentations in small assignments during the weeks leading up to the big day, and I give critiques to help improve the presentations as we go.

On the big day, we use a big(ish) venue, invite the underclass CS majors, and have a panel of outside experts as judges.

It is extremely important that the teacher not be an evaluator for the final presentations. This keeps the pressure up, both on the students, and on the teacher!
Instead, outsiders are brought in (and provided a grading rubric!) who will judge the final projects and finally presentations on their merits.  Some of these outsiders may still be from our institution, but not all of them, and no one who has been in any way involved in a project.

These final grades are averaged together, and will eventually be mixed in with the milestone grades.

But first, the student is given... a zero!

Well, not really. But the grade they receive from the judges is provisional. They have to finish up the last pieces in order to receive this grade.
Final cleanup and submission

This is the phase, usually about 2 weeks after the presentations, during which the students have to do their 'i's and cross their 't's. Is the project actually finished and documented? Do the clients have the access and support they need to actually use them? Are the projects actually submitted on GitHub to the teachers? Have the students filled out an end-of-program questionnaire?

Once those pesky boxes are all checked, students are finally awarded the grades from the presentations.

Put all together, all of these moving parts seem to prevent senioritis completely. The high fliers want to put their best foot forward for the outside experts. The strugglers work very hard to make sure that their project actually comes together before the big day. The final checklist means that I am not left with a bunch of 99% completed projects at the end of the whole process.


Which non-programming skills help make a good programmer? What skills should we strive to foster in our students that will make them good software developers in the future?  They are in our classes to learn coding skills, but what else do they need?  Collaboration skills?  Time management?  Tenacity?  Curiosity?  Persistence?  Some skills are needful in any career path, and we cannot emphasize them all.  On which should we concentrate?  How can we do this efficiently and effectively?

We are charged with educating the next generation.  I'd like to make sure I do my students the service of not only making them good programmers, but also preparing them for the workplace, specifically as Computer Scientists, if that is what they desire.

So, what makes a good programmer?

I don't think this question can be answered in any meaningful way. There isn't a finite list of skills that you need to be a programmer, or that make you a better programmer.

Computer science is a huge field encompassing just about every job you can imagine, and each of those jobs requires a different skillset. No matter what your interests are, chances are you can find a place for yourself in the industry somewhere.

Skills that make one person a good programmer won't necessarily benefit another programmer. One programming job might require an artistic background, whereas another job might require a mathematics background, or a managerial background.

The best answer to this question is going to be very broad.

  So, what makes a good programmer?

The ability to learn. Most programming is not actually writing code. Most programming is reading tutorials, running example code, and looking stuff up in documentation. Programming is more of a craft than people realize.

The ability to break things down into smaller pieces. Again, programmers don't sit down to code as soon as they're given a task. They have to spend a significant amount of time breaking the task down into smaller steps, and then taking those steps on one at a time.

The ability to ask questions. This might mean looking stuff up in the documentation, or on Google, or on Stack Overflow. It might mean asking a colleage or even a rubber duck.

The best software teams are comprised of a bunch of different people from a bunch of different backgrounds, with a bunch of different skills. Instead of trying to focus on a particular set of skills your students need, I'd recommend looking at the skills your students already have and helping them explore those skills in a computer science setting. Have a student who likes art? Cool, teach them about creative coding. Have a student interested in statistics? Teach them about data visualization. Have a student interested in mechanics? Teach them about robotics.

Don't ask what skills you need for computer science; ask what computer science you can do with your skills.


Most beneficial CodingBat problems for AP CS A FRQs I love the CodingBat platform and plan to integrate it throughout my course next year. Yet, since it will be my first year with AP CS A and I have not yet had a chance to study past years' FRQs, I'm not sure which sections I should focus on more than others.

Based on your experience, what sections of CodingBat are most helpful in terms of preparing students for the FRQs on the AP Exam?

(Note: I am asking about the problems already on the site, not ones I could author myself -- that's a separate topic as I see it.)

They've got an AP-1 category which is based on past FRQs. Not the whole question, but pieces. I'd make sure you hit every one in that category during the year. The String-2 and Array-2 are also good.

I use CodingBat and similar questions as warm-ups all year long. We start pretty much as soon as students are able to fill in a method.

Pretty much anything that involves looping through strings or arrays will help them with the test in May. Usually 2 or 3 of the FRQs involve iterating through some type of list structure and doing something with the values. I try to get my students to a point where they really don't have to think about loops, they just type on when they need it.


Excel macro recorder exercises On advanced Excel courses I teach attendees how to use the macro recorder. I also start VBA beginner trainings with the recorder and analysing the recorded code. I find the macro recorder a good entry point to learning VBA and programming. I'm always struggling with exercises though.

What exercises do you use when teaching MS Office macro recorder? Exercises that make sense in the real word. (E.g. creating a macro that writes "Hello World" in the active cell is fun and educational, but completely pointless in the real world.)

The main goal here is to give them a feel for the rigid sort of thinking macros and programming requires, and also to whet their appetite for macro programming, to show them how mundane tasks can be automated.

I'll start by adding the exercises I'm currently using, but please don't let this stop you from posting more!

Create a macro that inserts a header row. (Story: "Every day I download a csv file. Always the same structure, but it is missing the header row. I want a macro that inserts a formatted header above my data.")
Number formatting macro (Story: "I regularly use a certain currency format, and I hate having to dig through menus to get it. I want a shortcut for it.")
Date stamp macro ("I want a macro that puts the current date into the selected cell. I always want the current date, but I want it to stay the same and not change every day.")
Fill empty cells from above ("I need a macro that fills all the empty cells in the selected region with the value above the empty cells. A good use case is a pivot table that has been pasted as values, and is missing the values in the first column.")

On the more complex side, I have an exercise where I ask them to create a macro to copy entire rows from one sheet to the first empty row in another one.

I have a few more, but they are totally artificial practice exercises.


REPL environment for teacher assignments As a teacher on an IT high school, I am teaching the basics of C#, JavaScript and PHP (in different years of their study of course)
For about 3 years I had been happily using the repl.it classrooms. In this environment the pupil could

see the assignment
write and execute code
interact with the console

and I could

inspect his/her code
execute it
give comments
see whether he had tried and/or submitted
Also, depending on the language

I could either set some of his/her submissions as finished
or they simple passed all unit tests and were closed automatically.

However, repl.it had announced the clousure of its classrooms at the end of 2020, replacing it with Repl teams, which are an immature product much less reliable and comfortable compared to the previous classrooms, lacking some of its features
I am looking for any suggestions for an enviroment we could migrate to. I know big universities usually have their own closed systems. But, it there some service that is open to public, for a reasonable fee?

I have been teaching with Cocalc for a few years. It has most of the features you are looking for, but unless you are using python with nbgrader there is perhaps not much support for unit tests/autograding. It's not perfect but it gets the job done, with less frustration to me than trying to grade this stuff in Canvas. Also, I can rely on the simplicity of identical environments, no more babysitting each student's installation and worrying about Windows vs Mac setup, etc.
Cocalc allows the creation of "courses" where each student can receive "Assignments" and "Handouts" from the instructor. The students' projects are self-contained VMs and you can do a bit of central administration on them. They can use free ones, or upgrade for a small fee. You can do some LMS-type things there too, such as grade and comment on returned work. Here's a link to the Teaching documentation. There are a good amount of videos and blog posts put up by other enthusiasts as well.


What is the difference between computer science and computer engineering in brief For a beginner who wants to walk down the path of programming and developing and etc. What is a brief explanation of the differences of the two?

To clarify, Computer science is CS while software or computer engineering is IT what is the simple difference between IT and CS? Thank you

I think you're still slightly confused yourself, actually.  All of the fields below have a great deal of overlap because they are in similar parts of the world

Computer Science: Computer Science is the broad study of computational systems, which can be a little frustrating, because people often use the term to describe some specific subset.  If you major in "computer science" at a university, it is not at all clear what you will be studying after a few intro courses until you inspect the curriculum. It is perfectly possible to get a CS degree without studying almost any content from the other fields outlined below. However, all of those terms could possibly be called "computer science" depending on the context.

I (and some others) hold that Computer Science is purely the branch of mathematics that deals with computation. Some people try to keep things less ambiguous by adding the word theoretical before CS to indicate the mathematical field, but this is not always the case. (Take a look at the Computer Science Stackexchange to get a sense of what I would term "CS".)

Software Engineering: The art and science of creating good software.

Information Technology: The field concerned with the hardware and software infrastructure that manages networks and data.

Computer Engineering: a field that mixes Electrical Engineering with Software Engineering.

Mechatronics: a field that combines Computer Engineering with mechanical engineering.


How to teach image processing and computer graphics to a blind student? I'm not (yet) in this situation, so this is a hypothetical question. What would be viable approaches to teaching image processing (IP) and computer graphics (CG) to a blind college student? IP could possibly be approached by explaining images purely as 2D signals, and yet I'm not sure about how effective that would be. CG seems like an even harder task.

I think you can teach 2D graphics using a tactile approach on a phone or tablet.

Students are very likely to be used to tracing their fingers over a mobile device (I have watched awesome videos of blind iPhone users in action).

So position and shape change of an object could be detected by them dragging their fingers over to get auditory feedback at the edges. Ideally you want a truly tactile surface but I don't know of any such devices. I have my own reasons for wanting a computer-controlled version of one of these

For actual image processing maybe map colours to tone, so as they move their finger over an image they hear a tone vary depending on the average pixels underneath. Then, as transforms are applied, the tones would change. You could possibly teach colour theory by varying the mapping to only one channel of RGB.

Update in one of those great examples of synchronicity, a few days after writing the above I was listening to Matthias Tretter of MindNode on a podcast mention how he had been convinced to add accessibility to MindNode, a visual mindmapping product by a blind user.

His blog posting has videos showing VoiceOver in action. This is a bit tangential to the original answer but a nice anecdote about how preconceptions about the intended purpose of a tool as being visual doesn't rule it out for blind users.


How to convey how much computing power has grown since the 1960s? I was born in 1968 and used dial-up to mainframes back before PCs were available. We got an Apple ][+ when they came out and thought 48K was a lot of memory.

I live in constant wonder at the world we are now in, which seems like science fiction to my childhood self. How can I convey to students born around the turn of the millennium how amazing this growth has been?

I tell them about Moore's Law, of course, and that, when I was young, we paid 25 cents to play Asteroids, back when 25 cents was a lot of money, but I know I sound like Grampa Simpson. I share that a single Google search uses more compute power than all of the Apollo missions, but even I can't wrap my head around that.

How do you convey to students some of the wonder that you feel (as part of motivating them to appreciate and learn computer science)?

This is really difficult to communicate to anyone who hasn't lived through it (and even to those of us who have).

I don't usually go back as far as the 60s.  I show my students a picture of the ASCI RED supercomputer from ~1998, which was the first supercomputer to be able to perform 1 trillion floating point operations in a second (1 TFLOP).  It's basically the size of a warehouse floor, with another floor consumed by its climate control system. It cost ~46 million dollars.

Then I show my students a picture of a typical rack of servers from 2008, which could perform 2-4 TFLOPs.  In a decade, the size had shrunk from a warehouse to a single rack, the computing power had doubled, and the cost was about $200K.

Finally, I show my students a picture of a Nvidia K80 GPU card, which can perform over 2 TFLOPs.  In less than a decade, the form factor has shrunk to a card you can put inside a desktop computer, with the same power. Launch price was about $5K.

That is in less than 20 years.  Extrapolating from that back another 20 years only gets you to 1978; you have to go 10 years beyond that to reach 1968.  It's really hard to communicate the extent of this change.

And that's just the change in raw computational power, ignoring other advances like the Internet...


Talking about new/active subfields of CS to inspire students In a class for highschool students, should I talk about new, active, and exciting fields of CS to inspire them to perhaps further pursue CS or just get them more interested, or would it be better to stick to the basics? If the answer is that it's a good idea, please elaborate with an example of a subfield that would be good to talk about and why.

For example, a field might be quantum computing - covering maybe the basic ideas and mathematics, and giving them some resources to explore, and a nice simulator like this one to play with (or would that be going into too much depth?). Talking about molecular computing would also be an option.

I think a really interesting one would be the idea of cryptocurrency, this may not be what you are looking for particularly, but it is a new horizon that is bringing many new ideas to tech. Ideas to cover, the block chain, the ethereum flash crash, the anonymity (or lack thereof) of cryptocurrency, regulation of cryptocurrency. How mining works. The list goes on and on


Materials on database indexing with examples Is there any good source/textbook with notes about db indexing with examples?

The wikipedia entry is informative.

Database Systems: The Complete Book by Hector Garcia-Molina, Jeffrey D. Ullman, and Jennifer Widom  is probably good. Older versions of database books by Ullman have been accurate and reliable. I haven't seen the latest version, though.

Actually, most of my experience with Ullman has been his compiler books, not database. Still, though, a reliable person. More than just a random author.


What are the basics of CS that I should know, before I start my journey into machine learning I am a non-cs graduate and would love to be a machine learning engineer.

I have learned to code, and know the basics of Machine learning. Now I would like to know what "basics of CS" I should learn to be completely job ready.

I sometimes have difficulties reading CS documentations, and don't know how programs and computers work in the background. I am also naiver on topics like memory management, operating systems, networking, electronics stuff like microprocessor, compiler design etc. Are these all necessary for my transition to AI? If they are, would you please recommend me a short learning path or books or videos. I hope I wouldn't need to go deep in these areas.

Thanks!

The first two paragraphs of the Wikipedia article on Machine Learning will give you a good outline of the things you need to know. Algorithms and Data Structures are key from CS, but you also need quite a lot of things like Statistics, Mathematics, Pattern Recognition and such.

It is a pretty long road if you start out only knowing how to program. It is also a field with a lot of current activity and a lot will change before you get very far along that road. It is good to have a goal, but if you start late in a hot area you need to keep a flexible outlook so that you have options if that field cools off while you study. But those same things needed for ML are also good for other things as well.

So, the courses you mention probably aren't especially necessary but your statement that you have trouble with documentation is a bit worrying. Perhaps that will change with practice.

If you are a young person starting out, don't commit too deeply to any one path. Learn the basics so that you can choose later when you know more, both about yourself and about the state of research at that time.


Pick-me-up exercises for after-lunch brain death If you ever had a class right after lunch break, you know what this question is about. (Student's stomachs full, computers murmuring, room half-lit, teacher droning about something - I don't blame them for falling asleep.)

What short, fun exercises do you use to set student's arousal to the optimal level? It would be nice if it had something to do with CS.

Not sure this needs a context, but where I usually meet the problem: adult education, all-day-long courses, right after lunch break. The problem is universal though, I think.

Some conferences actually have "nap time" right after lunch. Let people nap if they like or catch up on outside tasks. Such conferences are usually residential, of course, so a nap is a real option.

A lecture immediately after lunch is going to lose a lot of people, as you say. Your teaching should account for human nature of course. But an active learning session - say role playing an algorithm - might work. If you have to hit them hard for the complete two days (no naps, no games), make sure that it isn't all just lecture and powerpoint. They will be too passive and will zone out too often. Break it up: lecture, discussion, exercises, role-play, feedback, pairing, group work.

Even a discussion session after lunch would be better than a lecture. You can pose a question to the class about some related topic, preferably one that might generate some differences of view. It could even be somewhat orthogonal to the topic of the course. If the course is about programming, make the question about software process. A simple strategy to start might be to elicit their experiences in development.

You don't win, nor do they, if you lecture beyond their point of caring.


What are the merits of including the history of computers in the entry level curriculum? Should some portion of introductory CS curriculum include something about the history of computers, especially with respect to Moore's law and what that might imply about the growth of computing power?

Would this help give students a perspective regarding the potential of how computing and programming might change in the near future, based on how things have changed in the past?

To give another perspective, when teaching an intro to web development course it's very useful to teach things in a way similar to how they were discovered and contextualize the different concepts in history. It's easy to understand why HTML is a markup language rather than a full fledged language when you consider the time: The Web was used for serving plain text pages, and they wanted a little markup to make it nicer. HTML was born. When styling become larger than HTML could encompass, CSS was born. When interactions wanted to be built in, JS was born, etc. Otherwise you can get into extended discussions about why the front-end environment is the way it is.

In cryptography it's the same way. By following the history you can see the mistakes of those before you, and thus avoid those mistakes. Crypto is all about the cycle of making a new algorithm then having it broken, and the arms race that it causes. History illustrates common pieces of advise, like to avoid security by obscurity, and history also shows why perfect forward secrecy is needed. It shows the need for key exchange, and shows the relationship between unsolved math problems and crypto. All of these are great reasons to teach crypto in chronological order, from the oldest discoveries to the newest.

I would guess that this sense of parallels between the order in which things are invented and the order in which things are taught exists in other fields as well, and so teaching history along with the normal coursework could be very useful.


Uses of high school Computer Science: where can it lead other than university CS? We are trying to get more pupils doing computer science in years 10→11 (UK GCSE) (14→15 years old) and years 12→13 (UK A-level) (16→17years old).

As there are a lot of university educators around here, I was wondering if you can tell me what university courses would benefit, or have an element of computer science or programming, in them.

I am mostly interested in non-computer-science courses, as I think pupils will know that high school computer science leads to university computer science. However, one very thorough answer on computer science courses would also be useful and appreciated.

Note: I am also interested in other pathways (jobs, etc.) that may use computer science or programming. And these would be welcome also.

The Russell Group of Universities has published a useful list of recommended A level subjects for different degree options which suggests that other than a CS degree, CS A level is recommended for:

Aeronautical Engineering
Biochemistry
Biology
Chemical Engineering
Chemistry
Civil Engineering
Economics
Electrical / Electronic Engineering
Engineering (General)
Geology
Materials Science
Maths
Mechanical Engineering
Medicine
Optometry
Orthoptics
Physics
Psychology
Sociology

Problem solving and computational thinking is a hugely transferable skill in itself.  Almost any science / engineering route through academia into the workplace is greatly benefited by the ability to write / modify some code that will process data efficiently and generate exactly the sort of analysis / evidence that you require.

For example, a substantive part of a Psychology degree involves collecting and processing statistical data. Even without the logical and analytical benefits of CS, the ability to write code to automate the analysis of that data immediately gives you huge advantage over peers without any CS skills.


Will you tell students that Algorithms + Data Structures = Programs now(21st century)? Algorithms + Data Structures = Programs occurs in 1976 (in Niklaus Wirth's book). In the past, we (teachers) may usually cite this equation to emphasize the importance of algorithms/data structures.

But, as far as I know, some fundamentalists don't agree on it. They think this equation is out of date and is possible to mislead students into overlooking other skills' significance (like unit test, design pattern, low-level knowledge...).

So, what do you think? Will you tell students that Algorithms + Data Structures = Programs now(21st century)?

The Wirth formula, Algorithms + Data Structures = Programs is still valid. It is also complete. A program is nothing more than algorithms acting on data structures. That formula does not make explicit the difference between a bad, error-riddled program and a good, error-free efficient program. Looking at the formula, however, can show how to improve the first and make it into the second.

Stating that programs are built of exactly two components, data structures and algorithms, means that the only way to improve a program is to improve one, or both, of its components.

  Algorithms + Data Structures = Programs
  Sloppy Algorithms + Mediocre Data Structures = Buggy Programs
  Better Algorithms + Data Structures = Better Programs
  Excellent Algorithms + Efficient Data Structures = Superior Programs.

The Science part of Computer Science in programming is finding the way to create the better, or excellent, algorithms and develop the efficient data structures. That's where the skills, whatever the instructor wants to focus on, come in to effect. Design patterns help to sort out the options, and provide an established pattern to follow when creating a new algorithm or data structure. Unit testing helps to validate the operational correctness of the written code. Low level knowledge of the target system may allow the coder to increase efficiency, and low level knowledge of the chosen language might allow the coder to utilize "tricks" or "quirks" built in to the language (be they bugs or features is unimportant).

Bottom line is that the only way to make a program better is to make its components better. There are only two components to work with; data structures and algorithms.

  Will you tell students that Algorithms + Data Structures = Programs now(21st century)?

Not only will we tell students that, we should have that on the door lintel
of every classroom and lecture hall where programming is taught.


What would be a good first choice to teach game programming to beginners? In my institution we are close to starting a new graduate level program for game development. However, this program will accept non-digital game designers or other non-experts (real architects who are into interactive design), too. Therefore, the programming course must cover inexperienced programmers (an introductory course for adults who have bachelor's). At the same time, it is preferable if it also includes tools for expert programmers who may also have bachelor's in computer science (this part is optional).

The program is designed to be generic. So, some people may prefer to come up with 3D games using an engine, while others prefer to instantiate board games for children. As you may see, programming is not the aim as in CS courses, but just another tool, here.

What language might be a good choice to teach inexperienced programming in the game domain?

For those interested in 3D (though, it can be used in 2D) game making with an engine, I would suggest teaching Unity. It's an engine and a platform for creating games.

Unity can be used with C# and Javascript, which means that those who choose to use it will also have some experience with some very popular high-level programming languages.

Additionally, Unity is, in part, a graphical engine. This means that the game is made in a graphical way, and the student can decide how much coding would be involved (Unity has an asset store, in which some scripts can be used. Some are free and others are not). This allows students to be comfortable with the game they are making, and they decide how much programming they do. This
 degree of freedom is often very beneficial for students.

A portion of making a game in unity involves designing, and artistic work. This can be a very convenient environment for the students who are into interactive design.

Overall, Unity fits the bill by being flexible and answering each students needs and areas of interests and expertise. So I think that it is a very good choice to start with.

From my experience, it's quite enjoyable to make games with it just for the sake of playing around with the software. This isn't too relevant to the question, but students who enjoy working on projects are more likely to make great projects.


What are some non-CS concepts that can be defined using BNF notation? I'm preparing a class on the modified BNF notation that python uses. I.e.,

  Each rule begins with a name (which is the name defined by the rule) and ::=. A vertical bar (|) is used to separate alternatives; it is the least binding operator in this notation. A star (*) means zero or more repetitions of the preceding item; likewise, a plus (+) means one or more repetitions, and a phrase enclosed in square brackets ([ ]) means zero or one occurrences (in other words, the enclosed phrase is optional). The * and + operators bind as tightly as possible; parentheses are used for grouping. Source

For this class, I'm not allowed to assume the students have prior knowledge in CS. Thus I must rely on concepts from general knowledge to provide examples in the use of BNF.

In other words, I can't use something like

longstringitem ::= longstringchar | stringescapeseq,

I must use something like this instead:

digit ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
"a digit is defined as either 0 or 1 or 2 or 3 or 4 or 5 or 6 or 7 or 8 or 9"

What are some non-CS concepts that can be used to illustrate the * sign (zero or more repetitions of the preceding item,) the + sign (one or more repetitions,) the phrase enclosed in [] (zero or one occurrences) and the () (used for grouping) from the BNF notation?

Going with real-world things which they should be familiar with are best, even if it is completely outside of education. As you have applied the tag for adult education, I'm going to presume it is outside of normal university/college courses.

A bit of creativity and looking around can develop many an idea as long as you get outside the box. The cafeteria might be a good place to look.

entree ::= pizza | hamburger | steak
side_dish ::= corn | coleslaw | fries
beverage ::= coffee | tea | milk | soda
dessert ::= (apple|pumpkin) pie | (peach|cherry) cobbler | ice cream
meal ::= water beverage* entree side_dish+ [dessert]

  The water is mandatory (already on the table perhaps), it's possible to have as many drinks, and refills, as you wish. There is always an entree, one side dish is included, but you may have more. Finally, if you choose, you may have a desert.

If the situation is at a regular educational institution you can experiment with using degree requirement courses, and electives. There's enough there to allow the students to create their own versions as practice as well.


Learning to program a Cell Phone Somebody wants to develop applications for his cell phone in Java. He does not know programming and he does not know Java. Should he start learning Java on his cell phone or would he better off learning how to program Java on his PC?

Should he start learning Java on his cell phone or would he better off learning how to program Java on his PC?

These aren't your only options.

IMVHO, Java, especially Android, has a pretty steep learning curve. I would recommend starting with something like Processing to learn the fundamentals, and then I would use those fundamentals to transition to core (desktop) Java. When you have a good grasp on that, then I'd move to more advanced topics like mobile development.

Since you've tagged your post with curriculum-design, here's how I would design a curriculum. I would split it up into at least 3 different courses:

Course 1: Intro to Programming. Use Processing to introduce the fundamentals: functions, variables, loops, control flow.
Course 2: Advanced Programming. Use Java to introduce OOP, inheritance, data structures, algorithms. (In the US I believe this is the standard AP CS class?)
Course 3: Mobile Development. (After course 2 you can branch out into many topics, not just mobile development.)

That's my two cents, but I know other people approach it from other directions. For example I know many folks teach web development first. And Google has at least one curriculum that uses Android to teach the fundamentals.

The question of how to learn the fundamentals of CS has been asked here a few times before, so I'd recommend starting with a search. Here are a few posts to get you started:

How to teach a person to enjoy programming?
Programming language for teenagers
Order to Teach Topics in an Intro Programming Class
Explain to someone that programming isn't just all “if”s and “else”s
Programming languages specifically designed for beginners
Using Processing as an entry point in an Introductory Course

There are many potential paths through computer science education, and I think the best thing you can do is try a few out and see which one works best for you.

Also, like Buffy said, you probably don't want to program on a cell phone. Even if you're programming a mobile app, you're almost always programming on a computer, and then exporting the app to a phone.

Shameless self-promotion: I've written a series of tutorials that take you from Processing all the way through core Java and onto web development and Android, available at HappyCoding.io.


Minecraft to teach programming? Minecraft is very popular, and I know that it can be programmed/scripted.  I looked into it myself but was put off by the learning curve for the Java based version (it looked like it needed Minecraft, NetBeans, a library for my Java code to talk to Minecraft, and possibly setting up a server).  I later found https://www.learntomod.com/, which appears to have a Block-based programming UI (I haven't tried it personally).

My Question(s): Has anyone used Minecraft to teach an 'introduction to programming' type course (CS0 moreso than CS1)?  How did you make the tech work (did you use something like LearnToMod.com, or the whole Minecraft+NetBeans+Java+etc route)? What sort of lessons did you learn?  (I'm particularly interested in "Gee, I wish I had known about X, back when I started")

I am not so certain about teaching people to program by starting out with something like modding Minecraft. There are a lot of technical details that someone just learning to program shouldn't be required to understand or worry about. However, Minecraft can still be excellent playground to learn to program by using pre-made mods like ComputerCraft that add programmable blocks to the game.

In ComputerCraft users are given a couple programmable blocks: computers, which are stationary and have the ability to send serial signals; robots, which you can program to move, pick up elements from the environment, and perform actions; and both elements can communicate over a network. The computers and all the pre-packaged applications are programmed entirely in Lua (including the OS). This means there exists a large existing source code base for students to study. Lua is a very simple and elegant language and I have had no problem teaching it besides the fact there isn't really an introduction to programming book using it (Programming in Lua is written by the language author and is very good, but much like Programming in C in that it isn't meant for beginners).

Using ComputerCraft with blocks from other common mods would allow the students to build machines as well as programs; something more than the sum of its parts. This would allow them to see programs as a part of a greater design, which I believe most students don't get enough experience with in school. Personally, one of my favorite projects I've done in Minecraft using ComputerCraft was implementing a mail delivery system using several computers, ender chests, and pipes.


Exercise or example to reinforce idea of functions? I have a group of students with a very shaky understanding of functions and their purpose (encapsulation, reuse, modularization). The assignments I give them require them to write simple functions that return boolean T/F, an integer or a simple Python object (str, list, etc.), then have the caller use the returned value in a print statement. Their programs are written in Python and run from the Windows command line.
The problem is that from the command line, the programs work but if you look inside it's a mess. The functions ignore the parameters to reach into the main for global variables (misunderstand the idea of parameter passing), the input validity checking is done in the caller (defeating the idea of encapsulation, e.g is day of month valid for a given month), or the function prints the result without returning anything. The worst that I get is the function does all the work of the main and of the function, for example when asking for a simple function to add 1 to its argument, I get:

def add1(x):
    myval = int(input("Number?"))
    print(myval+1)

add1(x)

...which of course is nonsense.

Here's my question... Can I craft an exercise that calls a simple function like add1() that would give a dramatically wrong output, e.g. cause the screen to "blow" up if the function printed instead of returned, or stalled if it kept asking for input. I'm thinking of something that reads a large file of text or numbers.

The students are at the community college level and are not programmers -- they are in electronics technology (and some are convinced that there is no software involved in electronics). I use Python but this is (mostly) language independent (I see the same shaky understanding with C++ functions in the Arduino world in another course).

Thanks in advance
 --Louis

I saw the light at the end of the fiber optic cable as soon as you said that these are students of electronics. There is nothing more modular and encapsulated than that! Software is simply electronics without the hardware part.

If you said to them, "What are the building blocks of a simple AM radio receiver?" they would (hopefully) reply something like: antenna, tuning, rectification, filter, audio output... A crystal radio has all of those. They already know that it is pointless to build the antenna in to the filter, or duplicate the tuning parts more than once. They know that they can work in teams to produce parts that fit together to make a complete radio.

So speak to them in a language they already know: the functional relationship of parts and wholes. Using globals instead of parameters would be like having extra cables going outside the radio to connect different parts of it to the signal path or the power supply. Can you say "Rube Goldberg"? I knew you could.

Man, let me teach them. I have been studying electronics on my own since before anyone I knew even had seen a computer. Electronics students should be the easiest audience in the world to teach programming to. Use examples they already know.


Techniques for encouraging pair programming Suppose I've assigned a project and asked students to pair into two-person teams. I'd like each team to pair-program: work together in person to complete the assignment.

Some students will do this, but sometimes they don't: either one partner monopolizes the work (which hurts the other partner) or the two partners split up the work and work independently (so both students end up having gaps in their knowledge).

I'd like to avoid this as much as possible, which brings me to my core question: what can I do to encourage as many students as possible to (effectively) pair program?

I read this post, which included a several nuggets of useful advice, but am interested in collecting more, if possible.

So far, I plan to:

Allocate time to promote pair programming in lecture
Let students chose their own groups + provide an (optional) survey to help pair students
Let students petition to work individually if they really want to
Skew the projects towards the difficult side to try and get them to at least talk to each other (and provide plenty of office hours as a safety net)
Collect partner feedback at the end and factor that into their final grades

I have no idea how effective these policies will be, though. I'd welcome both suggestions for encouraging pair programming in general as well as feedback on these specific ideas.

Note that this is for a university-level class, and that due to time constraints, all homework needs to be done outside of the classroom (so I can't watch them pair program and offer suggestions or really enforce anything).

Having them do it for homework, and pair program is a big ask. However here is some of my experience with pair programming.

While working as part of a software team, we tried to introduce pair programming, but got lots of resistance, even from the evangelists (no one had done it before, but it seemed like a good idea).

What worked

Pairing with someone that had done it before: At one point we had a contractor that had done pair programming before, when I worked with him, I did pair programming. This experience showed me that it could work. The only people, that are available and have done it before are the year above. A good way to lean is to teach. Therefore pair students with someone from the year above. This way the student in the lower year learns to pair program, and the one in the upper year learns by helping. [You need some intensive to stop the upper year student doing too much work. There is also a bootstrap problem.]
We had read that it takes sometime before pair programming pays off (2 weeks of full time programming, if I remember correctly). We kept giving up on pair programming during this investment phase. However we did discover that if the task is sufficiently hard, then the pay off was immediate. These were problems where we both had enough language experience, the problem was well defined, but nether of us knew how to solve the problem. e.g. setting up the MMU on an ARM processor. One of us knew what they wanted it to do. The other knew what an MMU does, but nether had ever set one up before. Therefore once they have learnt to program, give them a task that would be very difficult to do on there own, and get them to pair it.
Non programming activities: for various design tasks (algorithms and higher level than code), we worked in pairs or small teams (2,3 sometimes as many as 5). This worked well for tasks that are hard. Therefore start pairing with non-programming tasks.


Test takings strategy tragedy Are students generally aware of test taking strategy or do I need to emphasize this? I have to ask because I often reuse tests and some years all the students breeze through with plenty of time, and other years it is challenging, and they might even run out of time. A test where they run out of time is essentially invalid and does not help me.

But, I think there is in those cases a failure to make the best use of the time! I tell them the point values of different items (1 pt for True / False, 4 for Multiple Choice, 5 for Fill-in words) and I say to look over the entire test at the start, to answer all the easy ones (for them) first, then go over it again to get slightly harder ones, then the hardest ones, and finally, review the answers before submitting the attempt. So, I do give them strategy.

But sometimes there is still this tragedy: someone runs out of time half-way through. My tests are almost always open book and notes (but no internet use). When I hear, right from the start, lots of page-flipping, I know it will not end well. Someone is starting at the first question (T/F is at the start, then Multi choice, then Fill-in), and giving equal attention to all of them. I think it is because, even though they know the strategy, they panic and just bear down.

To me, this is work-related learning, and we are giving workplace-relevant training, and so learning not to bear down is a good lesson.

Is there a better way to introduce and reiterate Test Taking Strategy, beyond what I have already done? How to quell their panic, when I hear the page-flipping? Too late?

Test taking is a skill that not every student has. It should be learnable with practice, but not everyone comes to the same level. This is independent of subject. Some people just freeze up, some spend too much time on inessentials, trying hard to "get it right." Some students just panic and nothing you say will alleviate that panic. Every exam is like their first ride on a zip-line or their first rappel down a sheer cliff.

Like anything else, all of your instruction about strategy will only reach some and everyone's response will be different.

However, There are two things you can do. First, my own preference is to avoid stressing tests in favor of projects for grading. Tests are useful for advising, provided that you do advise the students singly when the fall short. For grading, however, projects let students do their best work in a more measured mental state.

However, I found that open-book exams are far from optimal. The only exam I distinctly remember badly failing in College was an open-book test in Physics. The problem is that the student will study wrong before the exam and will come to depend on the book in the exam. That is why you heard the page flipping. The "facts" were in the book. I don't need them in my head.

Prior to any exam that "counts" you want students to review and practice with the material in a way that mimics what they are likely to see on the test. They can/should provide their own review materials, or you can provide them (not as effective). The nature of the problem is that test preparation for an open book test is insufficiently active. They don't do much to reinforce their own knowledge beyond, perhaps, knowing a bit about where they can find various things in the book.

Moreover, your test isn't likely to just ask them to transcribe the book's information, but to do something with knowledge learned. Open book tests actually discourage the actual learning part.

An alternative to open-book is to permit the student to bring one standard sized sheet of paper to the exam on which they may write anything they like prior to the exam. The paper should be signed by the student and handed in with the exam (largely to prevent student B from using a copy of student A's sheet). This forces them to be at least a bit active in their prep.

A second, possibly valid, use of open-book testing is the following. Assuming that the test period is about an hour, announce beforehand that for a five minute period starting at the 30 minute mark, students may consult their books and/or notes. The open-book segment needs to be short and it needs to be after students have had a chance to consider each question.

tl;dr: Consign open-book tests to the dust-bin of history.


Why do educators not set an upper bound for the amount of times we're allowed to compile code? First of all I'm sorry if the wording of my question is off so let me be more specific with what I mean;

At my University we have some platforms we can code on and hand in assignments. They usually let us have as many tries as we want to (Not like they could stop us from compilling outside of the platform) but not once any lecturer or educator has discouraged us from compilling and testing our code as much as we'd like. This is also the case for the exam enviroments (Just with the restriction of a time limit)

I'm asking this out of curiosity, because I've developed a pretty bad habit of programming by permutation/shotgun debugging and in my first few months of Programming and even after 1.5+ years I still fall back to it sometimes. Part of the issue was probably, that I was never forced, or at least encouraged to spend as much time as possible to think about my code until I try something new again.

Is there a bigger reason educators generally see it as pointless to try to enforce a compile limit, or am I reading too much into the whole thing?

Because it's a meaningless obstacle

Putting an upper limit on compilations is like telling a car manufacturer that they must build a new supercar, but are only allowed to test drive it a few times.

This means that you're pushing your developers/mechanics to theorize about whether something would or wouldn't work, instead of actually finding out.

Theories are really just educated guesses; so do you genuinely think that guessing more often will achieve a better result than testing more often?

Because that's not the purpose of education

Especially in a hands-on field such as software development, the goal to learning programming is to keep trying until you stop failing. That inherently means that failing (and thus needed another compilation in the future) is an inevitable step in the process.

You seem to think that compiling often is indicative of a "bad" programmer. It isn't, but let's explore that assumption.
What exactly is your perceived problem with compiling more often? If a "bad" programmer is able to deliver the same end result in the same amount of time as a "good" programmer, does it really matter whether they compiled often or not?

Clients/managers tend to not care about how a programmer achieves their goal, they only care that they achieve it within the set parameters. If anything, I'd be more willing to hire the programmer who continually fact-checks himself (by compiling), compared to the programmer who assumes they know what they're doing (rarely compiling) and thus will get stuck needing to retrace their steps afterwards.

What you're suggesting is the equivalent of not permitting students to redo their calculations on a math exam. You're trying to teach them the exact opposite behavior of what you should be teaching them.

Because that's not how it works in a professional environment

Once you get to the stage of being a self-sufficient developer, there is still much to learn. One thing that junior developers often do wrong is down the problem into sufficiently small and simple parts.

In short, it is better to build something with 50 simple components than it is to build it with 10 moderately complex components.

Cleverness can be damning as a developer. When you're developing something, you understand the ins and outs, and you might find a very clever trick/workaround that may seem counterintuitive at first but actually solves your problem nicely. This can manifest itself in different ways: overly terse syntax, lack of accurate naming, an overly complex algorithm, lack of self-documentation, requiring specialized knowledge of a particular tool/library, ...

However, your cleverness can be your undoing when you (or someone else) needs to reevaluate this code in the future. If there's a bug, it will be hell to find out where the bug is located.
But even when there is no bug, e.g. if the requirements change, you will need to be able to pull the existing logic apart to introduce your changes.

Putting a hard limit on # of compilations wrongly incentivizes developers to only compile (and thus test) large changesets. When anything goes wrong, it's very hard to pinpoint where exactly it went wrong.

However, if you compile (and thus test) small changesets, it's very easy to see where it went wrong, as there is only a limited amount of changes that have occurred between the last (working) version and the current (failing) version.

This is the core argument for using unit testing and continuous integration. Developers are urged to take the smallest possible incremental steps, so that their code can be tested every step of the way, thus making it easier to find the source of a bug/error.

Since there is no purpose to retesting without recompiling; if you want to test often, you must therefore also compile often.

  I've developed a pretty bad habit of programming by permutation/shotgun debugging and in my first few months of Programming and even after 1.5+ years I still fall back to it sometimes.

When all else fails, shotgun programming is the most reliable method of figuring things out.

That is not to say that shotgun programming should be your primary development approach, as it can lead to time wastage. But when all your clever logging and theorizing fails to solve the problem at hand, shotgun debugging pretty much guarantees that you can take (admittedly slow) steps towards finding the solution.

As much as I am pro-shotgun (in certain cases), I do concede that wanton shotgun debugging can be used as a way to brute force a solution and avoiding having to understand the problem, which is counterproductive in an educational context. But this is part of a bigger issue that is not easily preventable.

For example, some students may rely on StackOverflow as a snippet repository and avoid having to understand the snippet or why it works.
To be clear: as a software developer I use it as a snippet repository as well, but I use it as a shortcut or not having to reinvent the water, not as a way to avoid having to learn the core skills required.

The issues of students writing code that works but they do not understand why (regardless of whether it's copy/pasting or brute forcing a solution) is not something you can address with a simple test. This is where oral exams are most useful, because you can very quickly gauge the difference between a student who found the right snippet, and a student who understands the core problem and how to approach solving it.


Feedback request: an assignment on programming a research paper I am teaching an elective course on algorithms for 3rd year undergraduates. There are 12 weekly assignments, each of which is worth 1% of the grade, and a final exam which is worth 88%. I would like to encourage the higher-level students to get into research, and to this end I would like to first encourage them to read research papers. So I plan to add a bonus assignment on research papers related to the course topic. My current plan is to offer them a list of papers and have each student pick a different one. The assignment will have 4 parts, each of which is worth 6% bonus points:
Parts 1+2: understanding the paper

Summarize the paper in your own words: what problem is the paper trying to solve? What are the existing solutions? What is the new algorithm? What problems are left for future work?
Construct at least 3 substantially different examples for the algorithm presented in the paper (besides the examples given in the paper, if any): run the algorithm by hand on each example, and show that the outcome indeed satisfies the output guaratees of the algorithm.

Parts 3+4: programming the algorithm

Write in Python (or another programming language) a skeleton of an implementation of the main algorithm in the paper. A "skeleton" is the heading of a function, without the function implementation. Write unit-tests based on your examples from part 2.
Program the algorithm and test it.

The idea of the programming part is that programming an algorithm requires a very detailed understanding of the algorithm. Additionally, my students are very good at programming, but not as good at reading research papers, so this part of the exercise is like a bridge between what they are good at and the new skill I would like them to learn.
I will be happy for feedback and further suggestions regarding this plan, both in general (e.g. is this indeed a good way to encourage good students to get into the world of research?) and in the details (e.g. is the partition to 4 parts reasonable?).

With regards to your setup, one concern that I have is that the steps might not make a lot of sense, at least as written.  It would be very useful if you provided one exemplar of what you mean for a summary to look like, and what you would like an algorithm "run by hand" to look like.  For the first part, a summary could mean two sentences, or it could mean a few pages with diagrams that break down the activity.  As for the second, I am not sure what is meant by "run by hand", and it would not surprise me in the least if others also find it confusing.
Now, there is the question you didn't ask.  Structurally, a course with 88% of the grade as a final exam is, for all functional purposes, a course with 100% of the grade as a final exam.  Why devalue all of the work, and permit a single bad day to destroy a student's entire semester (and possibly put their entire academic career at risk?)
I once had a student come into an exam several hours after her mother and brother died in a catastrophic car accident.  She didn't say anything, sat for the exam, worked on only two of the problems, turned it in and walked out of the room.  This was not for a super-high-stakes final, just for a regular quiz!
I only found out several days later what had happened.  I quietly threw out the quiz, and gave her a new one after she returned and had had some time to pull her academic life back in order.
I have had students come in after catastrophes, I've had them come in sick, I've had them come in after relationship breakups... none of these were students that came in at my request.  They just showed up.  These experiences have made me very wary of single-entry, "do or die" exams.
Why not three exams at 22%, 22%, and 44%?  This softens the "bad day" problem, and also gives students at least some feedback along the way to help them right the ship if they think that they're in better shape than they really are.
Remember that we don't teach topics, we teach people.  They are our charges, and we are ultimately there to help them.


How to make students confident enough to stop copying each other's code assignment? Mostly students can't code or they are not interested or they become lazy in their work or they are not confident enough to make their own logic and check it before teacher.

For all these students they copy code assignments from other students (which are the intelligent students of the class) and hand it in to the teacher.

So which method must be applied to them so that all students start to code on their own, make their own logic and be confident on their own work?

Growth
You say they copy the intelligent students, so first watch https://www.ted.com/talks/carol_dweck_the_power_of_believing_that_you_can_improve?language=en
Feedback
Then stop with the sumative assessment (Stop grading them). Encourage mistakes: I just heard of a company that has a mistakes wall. They seed it with a few famous quotes about mistakes. Then the leaders (teachers) add some and sign them. If others (students) add to the wall, then the first ones are praised (and awarded prizes), until it becomes the norm.
Help them to get in a situation where they are making small changes, making many small errors, experimenting, learning from feedback as the program runs. Give them code to change. Encourage small changes. Encourage testing after every change.
Programming
Before teaching programming languages, teach them how to program, and before that teach them how to solve problems: That is start unplugged.
Get them to do every problem manually. Teach them to think like a computer. Get them to solve problems like they are a stupid robot.
Then get them to document what they have done. As a set of steps. Get them to test it. Get them to ask their peers to test it. Show them how to test it. Get them to debug/fix it. Show them that you make mistakes. Show them how you fix your own mistakes.
Then when it is working, show them how to translate it, into the chosen programming language.


Lesson ideas for introducing macros in C Thanks to working with Racket recently, I've been spending a lot of time learning about and implementing non-trivial macros. In the process, I have been thinking about ways to apply this skill to my teaching. In particular, I teach students C (in the context of CS50 AP) and would like to show them simple but useful examples of macros in C.

I see the potential benefit as two-fold: 1) it would be helpful for discussing the C pre-processor when I teach the stages of compilation, and 2) it might help students write/understand code with information abstracted away in macros.

What lesson ideas (with code examples hopefully) do you have for introducing students to macros in C?

I introduce C macros as a convenient way of using a single source file that can be used both when debugging code in development and for final delivery, without having to edit and and edit out test/debug code.

I am doing it, in particular, in the context of using the compiler development tools flex and bison, but it would be equally valid when using just C.

For example, say some particular function returns a value:

return(THIS_VALUE);

The student may find it helpful to know what that value is. They could use an interactive debugger, in an IDE (such as Visual Studio), or a stand-alone debugger, such as gdb. Mentioning this makes them aware of the variety of development tools available to professional developers. I also mention that it can also be done without such tools, and code developers need to be aware of these wider varieties of debugging mechanisms. I indicate one of the primitive methods of doing is to add a printf, such as this:

printf("%d\n",THIS_VALUE);
return(THIS_VALUE);

I show, using an example (in flex actually), how this can be helpful. I then explain some of the risks and weaknesses in doing this:

We spawn two versions of the code, a production and debug version of the code
We have to keep editing the prints in and out and may miss some
We may make typos and not actually print the value being returned!

I then illustrate with using the preprocessor, which they may or may not have encountered:

#ifdef DEBUG
printf("The Value is: %d\n",THIS_VALUE);
#endif
return(THIS_VALUE);

I then explain how this can be enabled by using flags in make or gcc or other such tools. The next stage in the explanation shows what can happen when this debug coding happens in many many places:

ONE:
#ifdef DEBUG
printf("The Value is: %d\n",THIS_ONE_VALUE);
#endif
return(THIS_ONE_VALUE);

TWO:
#ifdef DEBUG
printf("The Value is: %d\n",THIS_TWO_VALUE);
#endif
return(THIS_TWO_VALUE);

THREE:
#ifdef DEBUG
printf("The Value is: %d\n",THIS_THREE_VALUE);
#endif
return(THIS_THREE_VALUE);

/* The code does not really look like this. I'm just making paradigms */

I point out how really poor this code is, and how it should be re-factored. This provides an opportunity for discussing re-factoring code and the options available. One option that will immediately occur to the student might be to use some form of procedure or function, like this:

int Trace(int The_Argument)
{
#ifdef DEBUG
printf("The Value is: %d\n",The_Argument);
#endif
return(The_Argument);
}

ONE:
   return(Trace(THIS_ONE_VALUE));
TWO:
   return(Trace(THIS_TWO_VALUE));
THREE:
   return(Trace(THIS_THREE_VALUE));

Students can see that this re-factoring may have improved the code, but now has inefficiencies that the original did not. It also has become type specific, as types were introduced for the first time (not quite true as the format is typed).

At this point Macros can be introduced as a neat and useful way of conditionally including debug code with the problems of editing statements in and out from the source. Something like this:

#ifdef DEBUG
       #define RETURN(x) printf("Returning " #x ": %d",x); return(x)
#else
       #define RETURN(x) return(x)
#endif

ONE:
   RETURN(THIS_ONE_VALUE);
TWO:
   RETURN(THIS_TWO_VALUE);
THREE:
   RETURN(THIS_THREE_VALUE);

This then enables me to explain about the concepts of Macros versus functions. It also shows C stringification and initiates further discussion of these techniques.

I'm now ready to point them at some more professional discussions of the value of Macros, and in particular I like Jonathan Leffler's Stack Overflow answer.

I reinforce this by putting in the specification of their assignment that their code should implement certain specific debug flags which I will enable when assessing their work. They have to then master the technique to get grade points, in addition to having just working code.

Finally, now they know about Macros, I can talk about inline functions, how a Macro can be used to define one, based on the examples above. It also enables me to talk about compiler optimisations and how the compiler might introduce inlining itself without explicit macros from the programmer.

(This is part of a compilers course so such topics will be core knowledge for them).


Tools or methods to make projected code easier to follow When programming on a projector screen, the audience can easily get lost. Besides the obvious things (large enough font size, good indentation, short but helpful comments identifying sections), how do you help your audience follow what is going on?

Students who look away for just a few seconds (to write something down or to change something in their code) will have a hard time finding the small things I have changed in the code. They can't be expected to pay 100% attention all the time, but I hate having to show the recently changed 2-3 words or few lines of code again and again.

I'll post one program I find very useful, but I'd be glad to hear of other tools / methods.

I use a program called Zoomit (For Microsoft's Windows, by SysInternals), that lets you freeze and draw on the screen and zoom in on parts of it. I find it pretty useful when teaching, I came really dependent on it. It is free of charge and easy to use.

Here is a very simple example:


How can we educators improve a lot of the negative behavior within the CS community One thing I noticed in the years I've studied CS and wrote code is the arrogance that a lot of programmers have within the CS community.

I remember in high school, coding was just for the tech savvy children. God forbid you ask them a question about a topic because you would often get a rude response.

Then I went to college and a lot of people were acting the same way. Everyone kind of doing their own thing, very anti social, and keeping to themselves.
I now teach CS and notice the same behavior with kids whereas in other classes (like reading, writing, art) kids are more expressive, outspoken and creative.

If CS were more widely accepted, I believe more people would pursue a career in it.
I think that is the problem with CS - people are afraid to try it because it seems intimidating and is surrounded by this anti social behavior that repels a lot of people.

How do we educators improve the negative attitudes and behaviors that some of our students seem to exhibit?

I reject a lot of the assumptions implicit in the question. Computer science isn't just for geeky or "smart" students. And I don't think it's fair to say that students in other classes are "more expressive, outspoken and creative." Computer science is full of art, creativity, and expressiveness. It's a teacher's job to show that to students and encourage every student to try it out.

I advise you to work on your own assumptions first. If the teacher thinks that computer science is not for creative students, then what hope do the students have?

Things to consider:

How are you "advertising" the computer science courses? Are you highlighting the artistic and creative aspects of it? Are you appealing to  students who might not self-identify as programmers?
What types of programs are you using in your lessons? Are they "boring" command line applications, or are they interactive and visual?
What types of programs are you assigning for homework? Do they encourage students to express creativity?

In addition to working on the assumptions of both your students and yourself, I'd also advise you to consider the needs of students from "non-traditional" backgrounds. More things to consider:

Are you "making room" for students who often get drowned out by louder or more active students? "We've heard from Grace already, why don't we give somebody else a chance to answer?"
Are you recognizing the work done by every student? I'd like to show you all a really creative example of how Ada used for loops in the last homework assignment...
Are you calling out bad behavior? Are you encouraging good behavior? Hey Grace, I know you know this stuff really well, so during lab today would you mind helping me out by answering Ada's questions?

These types of change have to start with you. I don't agree with a lot of the assumptions in the question, and I encourage you to take a harder look at some of the assumptions you're bringing to the classroom (which your students pick up on and perpetuate). Fix those, and you'll be able to help your students fix their own assumptions.


What's a good platform for independently teaching computer science and programming? I've been interested in becoming a computer science/programming educator for a while now, and I have a real passion for it.
I've taught a few people to code through sites like Khan Academy by answering questions and making examples and things, and I also tried out teaching on Reddit a bit, as well as Discord (through their video calling and screen sharing platform). I've taught a few people, but I would enjoy teaching more people, and with a more regular and consistent schedule.
I've thought about platforms like Udemy, but I much prefer to teach on a more personal level, where I can be there with them while they try to code things and answer all their questions and provide them with examples and things. More of a tutoring sort of thing rather than just pumping out content.
Do you guys know of any good ways I could get started? I'm not interested in teaching for a university or a highschool or anything like that at the moment, I'm mostly just looking for a way for me to get in touch with students online.
Even if you don't feel like you have a perfect answer, feel free to share your thoughts and let me know what you think/if you have any ideas. Any comment or answer is appreciated, thanks in advance.

Your question is quite broad, but I think you're suggesting that you wish to tutor, and wish to tutor programming specifically.  In which case, I'd consider tools like Zoom and repl.it.
The ability to live-code alongside your tutee, and watch as the work, closely approximates the experience of sitting at the same computer.  A video-conferencing app then allows you to talk directly, and the whiteboard feature of Zoom allows you to draw on a common paper together while you analyze problems together.