What are some events/contests besides GSOC and ICPC that a first year undergrad Computer Science Engineering student should get involved with?

There are lots of international programming competitions for undergraduate students .Here are some of the well known competitions(not mentioned by you).As you didn't mention what kind of competitions you were looking for, here are some general competitions. I have provided links to past problems so you can decide which fits you best.
1.Google Code Jam
Code Jam is Google's longest running global coding competition, where programmers of all levels put their skills to the test. Competitors work their way through a series of online algorithmic puzzles to earn a spot at the World Finals, all for a chance to win the championship title and $15,000.
How it works?
Register and compete in Code Jam’s Online Qualification Round. It lasts 27 hours, but you won't need that long to earn the round’s qualifying point minimum. Once you do, you’ll advance to Online Round 1. They offer three sub-rounds for Round 1, and you can compete in as many as it takes for you to finish in the top 1,500 of any of these rounds.
The top 1,500 from each sub-round move on to compete for a spot in the top 1,000 contestants of Code Jam Online Round 2. These top 1,000 contestants advance to Online Round 3 and earn a limited edition Code Jam t-shirt.
The top 25 contestants from Code Jam Online Round 3 will compete in the Virtual World Finals for the championship title and a cash prize of $15,000.
Past Problems
2.Google Hash Code
Hash Code is a team programming competition, organized by Google, for students and professionals around the world. You pick your team and programming language and we pick an engineering problem for you to solve. This year’s contest kicks off with an Online Qualification, where your team can compete virtually from wherever you’d like, alongside your virtual Hub. Top teams will then be invited to compete from our virtual World Finals.
How it works?
Once you’ve registered for the contest, you’ll gain access to their Judge System. The Judge System is their online platform where you’ll form your team, join a Hub, practice, and compete during the rounds. During the Online Qualification, you’ll watch their YouTube livestream to be introduced to the problem, and your team will have four hours to solve an optimization problem using the programming language and tools of your choice. Teams can also compete alongside other teams in your area by joining a virtual Hub . The top teams from the Online Qualification will be invited to the virtual World Finals, where they’ll work together to solve another challenge and compete for cash prizes.
Past Problems
3.Google Kickstart
Kick Start is a global online coding competition, consisting of three-hour rounds of a variety of algorithmic challenges designed by Google engineers. Participants can compete in one or all online rounds held throughout the year, and will have the opportunity to develop and grow their programming abilities while getting a glimpse into the technical skills needed for a career at Google (top participants may be invited to interview at Google).
How it works
Register for Kick Start once on the website and you’ll be set up to compete in any round you’d like! When each round is open, the three-hour countdown begins and you’ll compete on our website solving algorithmic and mathematical problems. Following the round, you can check out your rankings and the round analysis. If you were a top competitor, you may be contacted by Google for a chance to interview.
Last year's problems
4.Microsoft Imagine Cup
Reimagine technology solutions in a competition designed to help you make a difference in an online world. With four new competition categories—Earth, Education, Health, and Lifestyle—there’s even more opportunity to share your tech ideas for some of today’s most pressing global challenges. What could you create next?
Transform your ideas into action with a purpose-driven application using Microsoft Azure technology. You could win mentorship from Microsoft experts, the chance to showcase your work on a global stage, and other great prizes.
Get Inspired
5.facebook Hacker Cup
Hacker Cup is Facebook's annual open programming competition. Open to participants around the world, we invite you to apply problem-solving and algorithmic coding skills to advance through each year’s online rounds, win prizes, and have a chance to make it to the global finals and win the grand prize.

Last year qualification round
Here are some other "competitions" and resources for practice:
1.Codeforces
Codeforces is a project joining people interested in and taking part in programming contests. On one hand, Codeforces is a social network dedicated to programming and programming contests. On the other hand, it is a platform where contests are held regularly, the participant's skills are reflected by their rating and the former contests can be used to prepare. Codeforces constantly develops and we plan to improve the platform to give the participants the opportunity to organize their own contests, filling the project with learning content, developing Codeforces as a training and learning platform.
It also provides contests and practice for ICPC.
Codeforces conducts different competitions for different rated coders regularly and you can participate in it depending on your Codeforces rating.
Competition structure
It may also conduct competitions with other companies and sponsors at times.
2.atcoder.jp
AtCoder is a programming contest website based in Japan.
There are three types of official contests in AtCoder:

AtCoder Grand Contest (AGC). This is our best contest. The problems will have high originality and require interesting observations.
AtCoder Regular Contest (ARC). The problems may be a bit typical compared to AGC problems, but still we think most of you can enjoy them and they are good for practice.
AtCoder Beginner Contest (ABC). This is mainly targeted for those who are new to competitive programming. The problems will be easy and educational.

3.SPOJ
SPOJ (Sphere Online Judge) is an online judge system with over 315,000 registered users and over 20,000 problems. Tasks are prepared by its community of problem setters or are taken from previous programming contests. SPOJ allows advanced users to organize contests under their own rules and also includes a forum where programmers can discuss how to solve a particular problem.
4.Project Euler
Project Euler is a series of challenging mathematical/computer programming problems that will require more than just mathematical insights to solve. Although mathematics will help you arrive at elegant and efficient methods, the use of a computer and programming skills will be required to solve most problems.
The motivation for starting Project Euler, and its continuation, is to provide a platform for the inquiring mind to delve into unfamiliar areas and learn new concepts in a fun and recreational context.
The intended audience include students for whom the basic curriculum is not feeding their hunger to learn, adults whose background was not primarily mathematics but had an interest in things mathematical, and professionals who want to keep their problem solving and mathematics on the cutting edge.

P.S: There are a lot of other programming competitions but it all depends on your interests(including hackathons, A.I competitions, obscure code competitions etc.)
Upvote/accept if you find this useful


Should I correct mistakes in student presentations?

Mistakes should be corrected, but the how can be finessed. You are already correct in giving the private feedback to each student, but you can add an additional level to the game.

Instead of you correcting the student in the live session or later, part of each student's total work product is to produce a report on their own that is distributed to the class soon after the presentation. Much of this can be prepared prior to the presentation and only updated after your private feedback. In it, you can require that the student correct any known defects in the presentation explicitly. They can admit to having made a mistake and provide the correct information without any confession of guilt or error. The info was wrong - here is the real skinny.

There are a lot of reasons for misstatements in a public presentation. You and I make them as well, and we correct them as we can. With students (and new teachers) some of this is actually just a result of stress. So the correction shouldn't increase the stress or give the student any reason to feel bad about themselves. The correction comes from them, even though it was information from you, perhaps, that set them straight.

To simply let it go, misleads the other students of course, so that is a poor solution. But lowering self esteem is also a poor solution. Make the experience a positive one, even though the student is cleaning up her/his own mess.

The written report has an additional benefit, of course, as students need to practice technical writing in any case.


Assisting students with large programming assignments takes too long in class

The problem, in my view, is a misplaced assumption that students should never see one another's code and that seeing it would somehow or other "pollute" the student's mind in some way or make grading invalid.

A clear solution, provided that you can give up that assumption, is to have the students work in pairs in the tutorial, giving help and advice to one another. A more radical approach, that I also favor, is to have students work together to develop the code in the first place.

It has been observed (I have seen the video) that when students work together they seldom need outside help and call for tutor help only rarely. When students work alone and wait for the tutor they are mostly idle while waiting.

The reason for this is that, while both students in a pair may have problems, they seldom have the same problems and so can support one another's learning. When a tutor's help is needed, there has already been a deeper analysis of the issue at hand, since there were two minds working on it.

If you worry less about grading, and less about some students "slacking" you can do a better job overall, especially for those who are interested in learning. Students can learn from one another. It isn't essential that they learn  only from the instructor.

My experience, also, is that when a "better" student helps another, both benefit from the experience. The helper gains deeper insight by having to verbalize an understanding that may be only partly formed.

When abrasive personalities get in the way of pairing, the one that is abrasive needs to learn better behavior in any case if he/she is to be successful in the long run. Instructors need to watch for this, of course, and offer advice as needed.


Best book and video lecture series to follow for an "object oriented programming" course for advanced undergraduates

Two books come to mind. Both build a project and you learn about object-oriented program design and testing. However, both assume at least a good grasp of basic Java. Nether will cover all of the topics you mentioned, nor do they have videos, but will give you a good idea of how to develop larger programs. You will learn a lot by code reading and osmosis. Both books use Java for implementation.
The first book (https://csis.pace.edu/~bergin/polymorphismBook/index.html) builds a simple four-function calculator. It emphasizes test-driven development and assumes at least a simple knowledge of JUnit testing. The book shows how to decompose a problem into small manageable pieces and take advantage of polymorphism (hence the name of the book). I also like the companion book as it takes a further look at the same problem, but with alternative implementations. Both are paperback books available for approx $20. The author's web page (https://csis.pace.edu/~bergin) also has links to a lot of material he has written.
The second book (http://craftinginterpreters.com/) builds an interpreter for an object-oriented language. It is a far larger and much more complex project. The author does an excellent job of explaining concepts and demonstrating incremental development. If you just made it through the chapter on Scanning, you will have learned a tremendous amount. You will have a much better idea of how Java takes your source files and breaks them down into pieces. Best of all, the book is free to read.
Lastly, if you like videos, check out (https://online-learning.harvard.edu/course/cs50-introduction-computer-science?delta=0). It is Harvard's intro to CS course and covers a whole variety of topics and languages. You can enroll for free and actually do the assignments or just watch videos and work on your own. The instructor is wonderful.


Should programming assignments be graded based on results from unit tests or based on the similarity to the correct implementation?

Actually, life isn't so simple as to choose one or the other here. Code needs to be well structured and it needs to be correct. Given that students are learning, you can't really expect that they will be perfect on either of these and so you need to take both in to account. A program could, be well designed and built but have some, as yet undiscovered, flaw that prevents it from passing its tests. If the students hack it up to get tests to pass they are going backwards, not forwards.

CS students have a lot to learn. Programming is important, but not the most important thing. But to advance on many of the other goals of the CS curriculum, students need to build good code. Even better, would be the ability to build maintainable code, since many of them will start their careers in programming-heavy jobs. Even if they go to grad school, much of what they do will depend on being able to write good code.

So, in grading, points should be gained or lost depending on both code and correctness. If the code is not correct, then someone needs to make an analysis about why the code is failing. It could be something simple or profound.

In my view if a program can't be understood easily and/or seems to be hacked together, it should receive few points. If a program, on the other hand, passes few tests then it is a much more subtle problem that needs deeper analysis. Don't neglect it.

In the question heading you talk about the "correct implementation". I worry about that. Students should not be graded on similarity to any reference implementation, certainly. There are more than a few ways to write a correct program.


Assuming you have a standard projector, here are two ways that I do this:

A printout.  Nothing like going old-school and having physical paper in front of you.  Your students can't see what you've got written down. As a side benefit, you can comment in notes about things to say.  Want to code in some errors and then fix them to make a point? It's easy to document a process this way.
Set your laptop to use dual-monitors, and use the primary as your laptop screen. And the secondary as your projector screen.  A side benefit here is that the text doesn't get as difficult to read on the projected screen.  A challenge is potentially having to turn your head when typing.


How to recast an ASPX application as Object Oriented

The object-oriented and procedural, or imperative, paradigms, and the functional, logical and mathematical, or declarative, paradigms are just that "paradigms." They are the embodiment of thought patterns and methods for modeling solutions. So long as the end result of a paradigm, the language used to implement it, is Turing complete, and the associated hardware can handle the needed elements, a solution that can be developed in one paradigm can usually be reproduced in another.

The issue shifts from "can it be done this way?" to "is this a satisfactory way to do it?" Some problems are better suited to one method while other are easier to solve using a different method. Using any paradigm to solve a problem, or implement a system, requires the ability to "think" within the model which the paradigm embodies.

I don't think it is fair to classify any practical solution as too simple, or too complex, for any given paradigm. Especially within the education arena, where the goal is learning how to employ the paradigm, and most "problems" are structured to meet educational objectives more than "real-world" problems.

As an "example" for future projects, the described system might even be too large for the students to apprehend while also trying to learn the basics it employs. If it had a smaller scale to it, the project could model several different paradigms in concert. Web applications are commonly developed using the MVC architectural pattern. The handling of the data (model of MVC) could be accomplished using a functional language, the HTML/JavaScript/CSS (the view of MVC) can be implemented well with procedural, non OO programming. The OO programming can be done in the system which gathers the data, and adjusts it according to the directives from the user.

However it's done, the hardest part will likely be converting something you know well, done in the paradigm you are most comfortable with, into something you don't have as much practice with, using a paradigm which is, for all practical purposes, a foreign concept. Having a bad example is likely worse than having no example. If you cannot "think" in OO style, you're unlikely to produce good OO code. Similarly, if you know VB.Net very well and don't know PHP very much, you can probably produce excellent examples of solutions in ASPX/VB.Net, and very poor examples in PHP. If you still want to reproduce your system using OO, or functional, programming, find a colleague who is proficient in the paradigm of choice to implement it for you.


Motivating examples for switch/case in Java

Consider why you might prefer to use a switch in a production environment:

Fall through processing. The blackjack example given by @Peter is a good example of this because it mirrors how we think about the problem: all of the face cards fall into the same case & the code follows suit. Be careful with this though, it's easy to abuse this to get terser code at the expense of readability
Default handlers. Personally, I find this most useful not in a 'single moment of code', but over a series of refinements. For instance, it's common to not have all your logic to handle multiple situations in place when you start coding, but it's also easy to miss a special case that you meant to add later. A default handler is a convenient & concise way to stub out code that you haven't yet gotten to.  Default handlers for that throw an exceptions or log the event can help avoid silent failures & are less likely to get 'coded out' by an mistakenly adding or removing an if or else.
Maintainability. I find it safer to add & remove code from a switch statement than an if / else if / else block as I'm more likely to accidentally omit an else from an else if than I am to omit a break from a switch.
As per Joshua Bloch's Effective Java: "Switches on enums are good for augmenting external enums types with constant-specific behavior." For example if you cannot change the source for an Operation enum, but need add support for an inverse method:

public static Operation inverse(Operation op){
   switch(op){
      case PLUS:   return Operation.MINUS;
      case MINUS:  return Operation.PLUS;
      case TIMES:  return Operation.DIVIDE;
      case DIVIDE: return Operation.TIMES;
   }
}

Readability. I find a moderately sized switch statement easier to grok than an equivalent if / else if / else block.

When possible, avoid contrived examples for motivating usage. Instead, show where you (or someone else) used a switch & discuss why it was preferable.


Interesting Programming Exercises to Teach Inheritance?

I'm not as familiar with Python as I am with other languages, but I'm sure your students have played Minecraft.

If you haven't, I suggest taking a few minutes to find some introductory "Lets Play" videos on YouTube first.

Let's talk Blocks.

Minecraft has dozens of blocks. Dirt, some, water, colored wool...

All blocks can be broken, picked up, placed, stacked, stored in chests, and crafted together. But not all blocks do just those things.

The chest let's the player store items in it. The furnace smelts some blocks into other blocks. Grass, when broken, drops a completely different block. Stone doesn't drop anything at all unless dug out with a pickaxe.

Minecraft can do this because of all of those basic methods that subclasses inherit and override.

Take this method (not pulled from source, just based on):

public List<ItemStack> getDrops(World w, Pos p, bool harvest, int fortune, Random rand) {
    //basic implementation
}

The default implementation puts a single item (the block itself) into a list and returns it.

BlockGrass would put dirt into the list instead.

BlockStone would check to make sure that harvest is true and the put cobblestone in the list.

BlockDiamondOre checks harvest and fortune, putting a different number of diamond items into the list, even determining how many based on the Random supplied.

And so on.

There are roughly 100 different methods in the block class to handle all of the possible functionality. Update ticks (crops), neighbor updates (observer, torches), interaction (doors, chest, furnace, crafting bench), whether or not a block has a tile entity (chest, furnace), and on and on and on. Most of them are blank and do nothing, entirely up to the derived class to add to, if it needs it.

The same goes for items, some of which (like sticks) don't even have a derived class of their own because they do nothing special. They just exist and do everything any item can.

This is why the are so many mods for Minecraft that add so many new things: no one1 has to implement anything special in order for everything to Just Work.

1Well, except Minecraft Forge, who maintain the official unofficial mod API. But Forge is a special kind of magic that isn't important here


Equivalent of PISA study for standardised assessment of skills on computational thinking and programming?

There is the Educational Testing Service (ETS) Major Field Test for Computer Science, a standardized multiple-choice test. Scores can be compared to those at other institutions, presumably on a per question basis.

The ETS website includes some sample problems, which include questions about pseudocode, cache variables, trees, graphs, combinatorics, and regular expressions. It looks similar to the CS GRE, which was discontinued in 2013.


The first thing you need to understand is that your second language is, perhaps the hardest of all to learn. You already know "how to program" and so the second language seems to get in the way of that. Alternatively you just use the second language in the same way you used the first, resulting in ugly and sub-optimal programs. So, you want to guard agains that.
It is actually somewhat easier to learn a second language if it is nothing at all like the first, since you can't try to impose habits from one language on the other and have to absorb the actual philosophy of the new language. So, Scheme, for example, after C++ (or before) forces you to think in a new way.
So, learning Java after C++ is especially difficult, since the lowest level syntax of the two is nearly the same, but the underlying philosophy (paradigm) is quite different. In particular, Java and C++ both use what they call classes but they are really different creatures.
One book I'd recommend very highly (since I know and trust one of the authors) is by Barnes and Kölling. It does, however depend on also using the BlueJ IDE which they created and is available free online.
The reason I recommend it is that it introduces objects from the beginning, which is the fundamental difference between C++ and Java. So, if you put aside what you think you know about programming and believe in the authors, you should do well. They both have a very (very) deep understanding of what Object Orientation means.

An alternative that would work, if you somehow object to BlueJ is Cay Horstmann's Big Java Early Objects. It, too, starts with objects which is my primary recommendation. I also know Cay. He also has a Late Objects version that I don't recommend for a bunch of reasons, but one is that the first part of that book would be likely to bore you. While it might seem an easier path, it won't take you where you need to go as directly as the Early Objects version.

A third possibility, though it is intended more for first time programmers rather than for someone with experienced in another language, is Karel J Robot by Bergin, Stehlik, Roberts, and Pattis. This book focuses entirely on object oriented programming in Java but does not try to teach the entire language. It does, however, provide a system in which any program can be written. Like Pattis' original Karel the Robot it is an attempt to provide a minimal but complete system including a simulator in which interesting (and difficult) programs can be written.


How to teach the value of the command line in high school?

I can't speak to cloud9 but I've always taught on Linux and am a CLI wonk.

One thing I do is differentiate between user friendly and learner friendly. GUI interfaces are learner friendly - they're easy to learn but they're not user friendly because they're not that powerful. They're basically program loaders. You load your program, work in it, exit, next.

The Shell is a little less learner friendly (although the fish shell is amazing from the learning point of view) but it is amazingly user friendly because it allows the user to do all sorts of things.

I try to model this over the course of my classes and I try to provide examples.

For instance, if I wanted to resize a bunch of gifs in a directory, I might show the class something like:

ls *gif | while read i
do
  f=`basename $i .gif`
  convert $i -resize 200x200 smaller-$f.gif
done

If you make it useful to them, they'll appreciate it more and use it more.

I wrote a few blog posts over the years with examples including:

pre-processing and cleaning up dirty downloaded data
processing info from google forms (downloaded as csv)
operating on many files across directories

The posts can be found here: https://cestlaz.github.io/categories/cli/


Are there any lists of concepts in a re computer science?

Look at the list of courses offered at the undergraduate and master's level at your own university and a couple of others. The course titles should give you a pretty good idea of the range of things.
The list of courses you say you've had may be a bit focused on applications, rather than theory, and on maths rather than CS. I'm not seeing Operating Systems or Compilers and Language Principles, for example.
Any single university's catalogue should be pretty close to covering it, but might miss one or two things. Look at two or three online. Some will even provide a syllabus if you can find the professors that normally teach the courses.


How should educators ensure their curriculum remains relevant over time?

As a wise man once said, "We are preparing students to solve problems that don't exist / using technologies that haven't been invented."

I agree with alephzero in the sense that you can't avoid this issue.  Every sign is that technologies will keep changing rapidly, at least for the foreseeable future.

This is why we must always keep our instruction oriented towards concepts, not languages.  The syntaxes for arrays and lists will differ in different languages, but the trade-offs between the two remain the same.

One easy way to keep the emphasis on the conceptual is to utilize more than one language.  Over the first 3 years of our major, all students work in Python, Java, C, 6502 Assembly, and Scheme.  Additional languages are used for electives, depending on the nature of the course content.  By providing a more varied exposure, students can easily come to differentiate the underlying concepts from the syntaxes of the languages they are learning.


Becoming a master from a newbie at Computer Science and Electronics

I am glad to see your question, because 40 years ago, I was a child who was extremely interested in electronics, radio and computers, and the resources seemed much more limited then.

I would say, because the field is so broad, it does not matter where you start. Pick something that interests you and go as far as you can with it. My first interest was in building an amplifier to use with a microphone so I could make loud noises (your personal goal does not have to make sense to anyone else) so I read books about transistor amplifiers in hopes of finding a simple design.

My suggeztions are:

Find an Amateur Radio group and participate
build some simple kits
write some simple programs
use the relevant Stack Exchange sites
choose some specific goals or projects
"Nevah, nevah, nevah give up!" (Winston Churchill)

Don't worry if you don't get to your specific goals - I never built that amplifier - you will learn so much on the way, and become a specialist in something. I eventually became an expert in small transmitting loop antennas, C and data communications. Qapla'!


How can I do the best assignments as being a computer science student?

I'm surprised by your question. In the first semester of a program you shouldn't already be expected to know much of anything. But you should be expected to learn a lot of things.

But you learn by asking a lot of questions. Also by answering some of those yourself through reading.

But the most important thing to do is to do a lot of exercises and have your professor give you feedback on how to make them better.

To learn how to program you have to write a lot of programs and to think about why they work or why they don't. You have to learn how to use the tools and what information they give you. That also takes practice.

I worry that you say your instructor insults you. Certainly some teachers do that, but perhaps they are really just criticizing your work. But they need to say more than just "this is bad". They need to give you some help on how to make it better.

But, reading and listening to the instructor is not enough. You have to practice. The more you practice the better you get. Just like futbol.

Depending on the rules imposed by your institution and professors, you might also consider forming a study group of fellow students so that  you can try to learn together. Some places don't allow it, of course, but it can be helpful when possible. But be careful not to give the impression that you are just copying assignments from one another. A study group has to be about learning.


How to make perfect documentation of FYP with less plagiarism?

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 important is it that I know all of the words for the technical terms when mentoring in my second language?

Words matter. The problem is that the kids need to communicate the ideas to one another and to teachers, etc. They also need a way to integrate their Scratch experience into a larger programming set of ideas that they can carry with them.

It is good that you are trying to help, but you need to prepare yourself better first. Build a quick-look glossary for yourself that translates the terms in your native language into the one the kids are speaking. Scratch menus and documentation can help you do this, of course.

As you work, keep a few index cards and a pencil so that you can extend the vocabulary as needed. The glossary itself shouldn't require you to leave the Scratch environment for lookup. Paper is actually good for this - more index cards, perhaps.

Another trick you can use, perhaps, depending on the age of the kids, is to have them tell you the names of the terms when you stumble. Make a note of their answer (check its accuracy), and work hard not to stumble there again - more index cards.

Imperative? Probably yes. Or nearly so. But don't lose your enthusiasm for working with kids.

I'm a bit of an advocate for the use of index cards everywhere, by students and instructors. There is a description of the Hipster PDA in the answer to another question here.


In what branch of science does technology belong?

Actually, technology per se isn't science. But then, neither is mathematics. Technology is normally about the creation of things. Science is about using a certain methodology for trying to discern the truth about the world and natural processes. If you define natural processes broadly, including human processes, then social science is also science.

But mathematics is about using logical process to explore the implications of basic assumptions (axioms).

But both science and mathematics are about ideas, whereas technology is about things.

Technology, as in iPhones and respirators and all, is about the creation of useful things. That is basically why you can patent inventions, but you can only copyright scientific papers.

Some sorts of technology, say vaccines, depend on science to assure safety and efficacy. And some sorts of technology depend on mathematics, such as computers and bitcoin.

Computer Science has elements of both science and technology. But one normally gets a PhD in CS for discoveries on the scientific side, even if the science is an exploration of something created on the technological side. CS actually has elements of mathematics as well, such as in algorithm analysis and computability theory.


I would teach the use of arrays and array indices first (with pictures of a long row of physical mailboxes, or school lockers, etc.)  Then later explain that all of a computer's and/or C program's (process) memory can be thought of as one big array with a pointer being a form of index (locker number) into that (virtual) memory array.

You can then draw a picture of how arrays of char (bytes) might be allocated in memory.  And then show why pointers might be necessary in order to tell a standard string function how to find (or modify) a substring in an arbitrary C string array.


How to learn to solve trees, graphs questions for competitive programming

In fact you are adressing an important issue: You were learning concepts, but you are unable to transfer the concepts to real world problems. This is a major issue in many higher education scenarios and e.g. my students always complain, that they do not find the answers to my question in the course material. Of course they don't, otherwise I would not have to ask the question - I assume they are capable of reading and writing ;-).

Now how can you come to that next level of understanding? The answer once again is practice! You have to understand the underlying structure of a problem (e.g. use a divide and conquer approach to decompose the problem) and build a solution based on well-known blocks (like DFS / BFS, sorting, ...). The final step is to adapt the algorithm to your data structures or other specific needs of your problem.

You have to do this over and over again to get practice. Often it helps if you are trying to understand how others did if for some problems, and websites like Codeforces can give you good examples of problems.

After some practice, you will have gained a good intuition on how to decompose a specific problem. Especially for trees and graphs it is always helpful to draw your data structures and think about how an algorithm would traverse the data structure.


Curriculum choice for AP Computer Science A

With the amount of preparation you're describing, the only thing your students will likely need is a course that teaches them Java syntax and object oriented programming, as the AP CSA exam assumes knowledge of Java:

  SHOW ALL YOUR WORK. REMEMBER THAT PROGRAM SEGMENTS ARE TO BE WRITTEN IN JAVA.

(from https://apcentral.collegeboard.org/pdf/ap-2020exam-sample-questions-computer-science.pdf)

Code.org has a nice list of Java curricula that specifically target the AP CSA outcomes, but really any "Fundamentals of Java" course or online tutorial would likely be just fine.


Method for keeping records in a computer science notebook?

Based on what you say about yourself, I'd guess that the Cornel system is probably better than either of the other two described here. But that is just because you suggest that you seem to lack the ability, currently, to pull out the big ideas as they occur and the other two methods depend on doing that.

But, the goal of all of this isn't really effective note taking. You can have the best notes in the world and still not learn anything. The goal is to learn and to do that you need to reinforce the ideas that are presented, not just capture them in notes. But note that the Cornel system, as described at the link, includes this step as an essential part. Review the notes you take.

I'd go farther, actually. Not only review the notes, but write summaries of them periodically. And don't wait too long before doing that, so you don't lose the track of what you were learning in the meantime.

Another reinforcement trick is to write the important ideas on note cards and always carry a few of these around with you, along with a few blank cards and a pen. Then you can review while otherwise spending wasted time waiting for a bus or whatever.

But in a subject like CS or mathematics where you are actually expected to do something with what  you learn, it is also important to do exercises and solve problems soon after any lesson. This will, again, firm up the learning. Even better if there is someone to give you feedback on your solutions. This normally happens when exercises are assigned, but you might have to arrange it on your own for others. Study groups can be useful for this if they are well designed, requiring actual work from every member. Reading solutions is nothing like producing them.

For what it's worth I now just capture ideas on directly on note cards. One idea per card. I can then group and rearrange the ideas by physically manipulating the cards. Summaries can be developed from the cards. Questions can be written on the backs of the cards. Different colored cards can be used for different sorts of things.


How to explain ETH to undergraduate students?

It seems that you are aiming to convey the significance of disproving ETH? If you're looking to leave some impression, it's always better to show rather than tell.

I think your students need to see some examples of practical areas and difficult problems that efficiently reduce to SAT. If you can demonstrate to them that SAT is a "funnel" of sorts for many other kinds of problems, your students can piece together for themselves why solving SAT in sub-exponential time would be game-changing.

Some example problems could include task scheduling, the traveling salesman problem (and by extension, pretty much any sort of path-finding problem), register-allocation in code compilation, general propositional logic inference, etc. You can also discuss industries that use SAT-solving already, like circuit design and e-commerce.

This would take a fair bit of work, but you could even demo using a SAT-Solver; Sudoku is a popular and relatively easy example problem, and it never fails to amaze me how quickly it solves even the hardest of puzzles. If you need one, CryptoMiniSat is a great off-the-shelf SAT-Solver https://github.com/msoos/cryptominisat/releases.


How should I advise an undergraduate who wants a career teaching CS?

The Technical1
Across the nation, many states have either legislated (or are currently in the process of legislating) mandatory CS instruction, so this is a fantastic time to find a job in CS education.  In general, there are two paths into the classroom (at least in the public schools).
The first way is to go back to school and get a traditional education degree.  There are many graduate degree options available in every state to accomplish this.  The degree program will also typically walk you through the process of getting your teaching license within your state (though details for licensure in ever state is but a few search terms away!)
The second path is often called alternate route (though some states may have different names for it).  Typically, an alternate route position is created by working directly with a school that would like to hire you even though you have no license, and then working with the state through them. There may be a background check needed before you are even allowed to apply. Again, your students should search for "alternate route, StateName" to get a sense of the procedure and requirements for their target state.
The Emotional
Tell them to be prepared for a very steep learning curve when they enter the classroom as a teacher.  While attrition rates are nowhere near the fabled 50%, they are still quite high, and there are many, many reasons for it.
The first several years are physically and emotionally punishing. In my experience (at three schools so far), getting started at a new school or in a new position requires an absolutely breathtaking amount of work just to survive for a few years.  During my first three years as a teacher, it was not unusual for me to be in my school building from 7:30am until 11pm, only to report back the next morning and do the same thing all over again.  Weekends were for planning, and vacations were for catching up on mountains of grading.
Along with all of that work and exhaustion also comes the emotional roller-coaster.  The highs are exhilarating and the lows can be quite dark.  If you can make it through the first couple of years, it really does get easier, and you can switch out of "fight or flight" and really start honing your craft.  That is when the magic really starts :)
Finally
Tell them to join professional associations (like the CSTA).  And, no matter how much they need a break, go to at least one conference during their first year.  Those conferences will bring them a million ideas, give them a chance to meet other teachers, and also remind them of how very sweet that light at the end of the tunnel is.
And tell them to find some place they can go to with questions to help them deal with all of the bumps and pains along the way.  Perhaps even... this very site? ;-)
1 - My knowledge base is primarily in the state of New Jersey, but I have reason to believe that many states work very similarly.


Independent research on bootcamp job placement claims

There's not much out there, unfortunately, and what there is is either suspect or sparse.

CIRR has probably created the best data that we have, as they engage in 3rd-party verification. These results are actually rather positive for the industry, although participation is voluntary, and there aren't many Bootcamps that participate.
The US Federal Government created the EQUIP initiative to convince schools to provide government-quality data in return for student attendees being eligible for financial aid.  Only five organizations qualified.  While I have been unable to locate the data itself, I would presume that those five organizations are probably fairly good.
Course Report is an independent organization that creates an annual survey of outcomes, and it shows consistently good results for Bootcamps nationally, but all of the results are self-reported, so they are not entirely trustworthy.  Also, the organization is very obviously friendly to the industry itself, with founders and employees who attended bootcamps themselves. Their "reports" simply look and read like ad copy.
There is a recent initiative by the schools themselves to create more accountability, presumably in order to counteract rumors that the institutions are simply fraudulent diploma-mills.

If you are considering a Bootcamp, I would strongly recommend only considering schools that have good results with CIRR, as that will both discourage fraud, and encourage Bootcamps to partipate in the process.


Advising college students about whether to take classes pass/fail

Unfortunately, at the current time, a student would be making a decision with incomplete information. I'd be more interested in how graduate schools will treat such grades and I don't know of any who have stated a policy yet. I'm pretty certain that employers haven't really even thought of it yet.

I hope, of course, that they (grad schools and employers) will be reasonable. I also hope, of course, that advisors will be able to give good and accurate letters of recommendation for students no matter which way the students choose on this question.

But there is a vast amount of disruption even beyond the obvious. Expect that even good students will have trouble keeping up to their normal standards. It will require a lot of ongoing support. Some students are stuck in travel-hell. Some will lose family members. Some will have poor connections to their universities. Much, much more.

So, at this time, it is hard to recommend one choice over the other. What is sensible to do now, with available information, may prove sub-optimal when the policies fall in to place.

But you can lobby your own institutions for the quick creation and dissemination of reasonable policies. It is probably required that the whole academic establishment come together with principles. The current mix of policies may actually be adding to the chaos while trying to solve the issue individually.


What are some real life applications of the knapsack problems class?

I'll probably try with this one, from an actual software I almost developed.

There's a factory that produces paints in various colours.
The factory has a single production line that can produce only one colour in a given moment. It's capacity is also limited, i.e. 1000 litres per day regardless of the colour produced.
Different colours have different production costs and are sold at different prices. I.e.: white is cheap to produce and is selling price is low. Gold is expensive to produce because metal sand has to be added in the paint to give it a shiny note. Gold is also sold at higher price. Red lies in between.
Different customer requires different amount of paint, i.e.: customer A asks for 1000 litres of white, customer B and customer C asks for 250 litres of gold each, customer D for 700 litres of red.

That given, the problem is to find the mix of production that maximise the profit.


Explaining why arrays are important for statisticians

If you are tutoring her, it is wonderful that you are trying to motivate the material in a practical way, but don't beat yourself up too much if you aren't that successful at persuading her. Some people just get themselves into a sort of myopic headspace where the only things that they need to learn are the exact operations that they will perform later on in their life.

However, it has been my experience that there is often something else going on in these situations. People aren't creating these excuses because of what will be practical in the future. They have no idea what the future holds. They actually create these utilitarian excuses simply because they don't find the topic intrinsically fun yet.

This also explains why you make no headway when you show her the utilitarian benefits; they aren't truly what is preventing her from diving in. Your best bet, then, is to show her why you think this whole field is amazing.

And if all else fails, go back to a utilitarian approach, but stick to the most direct reason: she needs this so that she will pass her class next semester.  That was a strong enough motivation for her to meet with you in the first place, so it should work out well enough to at least get you through the lessons.

Good luck!


Is it possible to study too many things in parallel?

Actually, what you want to do is commendable. And no, at the scale of things you talk about, I don't think you are likely to get yourself confused. In fact, you may have the opportunity to learn different things in an integrated way. In some ways the educational system, which puts different topics in different boxes, isn't optimal and everyone needs some experience in integrating what they know into a personal whole.

I once learned quite a bit of French by reading Math papers from French mathematicians, though I was already pretty good at math, but you could, for example, read CS papers in Russian. Knowing something of the underlying ideas before you start lets you focus on how they are expressed in Russian, rather than Japanese or English.

You already seem to be aware that you will need discipline and to set aside time for your studies. That works for nearly everyone. If you are studying several things then you can also switch to something else at a point at which you either get stuck on some idea, or get tired of the current topic. Often letting your mind work on something else is a good way to let your unconscious work out details that you might miss when working in a concentrated way.

You should also be aware that you are now (age 20) at the height of your mental (as well as physical) powers. It is never too late to start, but you are starting at a good point. Onward.


Teaching Induction to Prove the Correctness of Algorithms

I think induction should be taught first, and then loop invariants, since you usually need induction to prove that the loop invariant is really an invariant, and also because you need induction for other purposes than just proving that a loop invariant is really an invariant. In fact, in most curricula for Computer Science at university will have some math class that covers induction before a Algorithm Correctness course.

If this isn't the case, you might want to teach induction with some other examples first.

For example, proving that $1+2+\cdots+n = \frac{n(n+1)}{2}$ and a few other, relatively simple induction statements (e.g. sums, divisions, inequalities). If you need to teach recurrence relations as well, then you might introduce them now as well since you sometimes need induction to solve them. I think it is also helpful for the intuition to explain the domino-effect: $P(1)$ implies $P(2)$, $P(2)$ implies $P(3)$, $P(3)$ implies $P(4)$, etc. (also with a concrete example). This also shows the importance of the base case in the induction.

Then, loop invariants.

I would again (as always, actually) start with some easy examples, for example:

x=0
while (x < 2)
    x = x+1

with the invariant being $x \leq 2$. How to find this? Well, just go through the loop. In this case this is doable: $x=0$ becomes $x=1$ becomes $x=2$. Now show them you don't really need to do the whole loop if you have while (x<100), for example. Now it is time to mention induction again: Since you don't want to write all hundred steps, you can use induction to prove this loop invariant.

Students now might think they just need to replace the lesser than with lesser than or equals. Show them this isn't true with an example like this (or use lesser than or equals in the statement):

x=0
while (x < 9)
    x = x+2

Now, it is probably time for some complexer examples.


This is a different sort of answer than what you may be hoping for, but I'd really recommend that you deepen your knowledge of Python first. Learn to be pythonic, learn its OOP aspects. Learn its dynamic aspects. Become a Python Wizard.

The reason for this advice, since you are fairly new at this, is that there is a danger that you will try to learn too many languages too soon and start to think of them syntactically only. There are a lot of "java programmers" for example, who only write C code.

Let me give an analogy from another field. I used to be a very good photographer. I had one manual film camera with a light meter and three lenses. One was a zoom lens since I wanted to backpack with not too much equipment. At that point I could take really nice photos. Artistic. Later I got lots of cameras, lots of lenses, lots of other "stuff" and my ability to really take good photos went down, not up. Too many tools in your tool box is not a help, especially for a beginner.

So, build skill first, then branch out. One big idea is called "creativity under constraint". How much can you do if you artificially restrict your tool set? It sounds dumb at first, but with fewer tools your brain becomes your best and most powerful tool. Suppose your language didn't have loops. What can you still do? Recursion of course, but in an OOP language there are other options. Suppose, instead, it didn't have any sort of selection statements (if/switch...). Can you still write any program? Some become very difficult to write, but attempting to do this increases your brain power. Big Idea here.


I know C++ 2003 How to start learning C++ 2017?

I had a similar problem 8/9 years ago, but with C++11.
The trick is that there is no trick. You simply sit and use the feature you want to use. Besides that it is also beneficial to know C++14 before getting into C++17 and know C++11 before getting familiar with C++14 features. (Obviously prerequisite for C++11 is C++03/98, but that's already covered by OP).
If getting up-to-date with C++17 (C++20 actually was vote in 2020) I would start with feature list grouped here. The problem is that there are so many of them that one may have problems in how to approach them, thus I've provided an ordered list that shows how I would teach it to people:
C++11 warm-up

nullptr - you won't be using NULL of 0 for null pointers anymore
static assertions - allows you to enforce some assertions at compile time
scoped enums - no more enums collisions!
type alias

Basic C++11 stuff

move semantics (overview + SO question) - move semantics and rvalue references are the corner stone of modern C++, what follows is the rule of 5 (or 3/5/0 if being precise)

rvalue references
move semantics in a class
rule of 3/5/0

auto
lambda expressions
ranged for loops - because for(auto const& e: {1, 2, 3}) { std::cout <<e <<'\n'; } is so cool :)
classes related stuff:

default functions/methods
deleted functions/methods
final keyword

constexpr specifier
initializers lists - it is used mainly in std::vector<...> so it's important to know how it works and what are problems involved with them (it is not my favourite C++11 feature)

Extra C++11 stuff

std::tuple

But avoid std::tie, prefer structured bindings from C++17 (you can break the rule here and look them up ahead)

std::thread - no more pthreads!

std::ref - useful when you want to pass references to other threads

variadic templates
forwarding references - useful when want to preserve move semantics when dealing with templates

C++14 & C++17

After these basics I would read about the other C++11 related features or moved to C++14 features listed here (and consult C++11 features list when necessary). Note that C++14 was a nice little amendment to C++11 so there aren't many new (and cool) stuff.
C++17 features worth mentioning (very subjective opinion, at this point you should already know what you want/need to know):

inline variables
structured bindings
if constexpr
fold expressions 1 and fold expressions 2
lambda this capture changes/updates
std::variant + std::optional

C++20

Concepts are the new big thing
immediate functions
IMHO modules will be a dead end as long as C++ will be split into header and implementation fiels (besides Rust have better package/modules concept). But that's just an opinion bouncing in my head.
Remaining C++20 and previous version stuff (obviously only a fraction was covered in this post :)).


Looking for a blog article on the UI/UX design of an interactive coding interface like Khan Academy's

I found it !! Boy, I'm so glad. Had a bolt of insight in how I should use Google's advanced search features, and I found it.
Here is the article:
http://worrydream.com/LearnableProgramming/
An article by Bret Victor, from 2012. A great read, for those curious.


Looking for a text book on object-oriented concepts and programming

My suggestion is "Object Oriented Programming in Python" by Goldwasser & Letscher
https://cs.slu.edu/~goldwamh/oopp/
It's a free PDF download, or you can buy a paper copy.
They have a companion graphics module that is simple to understand for rudimentary GUI applications.
Hope this helps.


What is the best approach to learning things in CS?

The best approach to learning just about everything is twofold. You need to practice and you need feedback on your attempt. You learn by reinforcement, not by seeing something once. This is why coursework depends on student exercises, not just lectures and textbooks.

So, to learn a new thing, I suggest that you first get an overview idea of it, say from some internet readings or a book. Don't go too deep into it yet. Then, find a project that you can build using that technology and work on that. Go back to readings and such as necessary when you get stuck, but make the project and its completion a learning goal. Your readings may suggest a project, actually, but don't use too much of the explanation of the project, or especially its solution, to guide you. Build it yourself.

But that doesn't solve the "feedback" problem. This is always difficult for self learners. "How do I know I've done the right thing?" Perhaps you can find a more experienced person to give you feedback. A teacher or professor with wide experience is probably best. But you can also try to find or form a group of people with similar interests that you can meet with to share ideas.

In the absence of other things, if you can find an actual text book on the topic, it will probably have exercises. Do as many of them as you can find time for, without reference to any answer key. Find a way to verify your answers (feedback), even if it is just a testing framework that verifies your intent.

I'll also note that learning on your own is difficult for other reasons. Suppose you know A and want to learn B. Your approach to B will probably be heavily influenced by what you already know of A. But that may not be the best approach. Knowing the C language and trying to learn Scheme, for example, requires a clear break with what you already know and you need to take a new mental approach. Even moving from one language like Java to a "similar" one like Python, requires a fair amount of rethinking.


Is there any series of videos in which all the main algorithms are discussed without going into things like time complexity and space complexity

Your question doesn't make much sense. First, there are literally thousands of major algorithms, and many of them are quite involved. You don't begin your studies with Red-Black Trees because even their purpose will elude you until you've (at the very least) spent some time dealing with sorts and searches.

Second, if you eliminate time complexity and the actual steps to make an algorithm possible, what is left? A vague discussion of the purpose of the algorithm? Needless to say, no such discussion would include any bits of actual programming, especially not in a low-level language like C.

Speaking of which, why are you focused on C? Do you have a particular reason for this choice of language?  C is a "low-level" language, which means it works quite closely to how machines think, and quite differently from how people think. This is sort of like taking a math class that provides only axioms, and makes the student prove all of the important results on their own. I am not suggesting that there is no value there, but (1) it is much, much harder, and (2) you're more likely to simply give up in frustration when you can't seem to do anything at all, even after months of effort.

Beginners, particularly if self-taught, should start in higher-level languages where they can begin to learn how to actually undergo the process of programming without having to worry yet about pointer arithmetic and memory management.


Making Technical Presentations Safe for Novices

You need to start early
You can not expect them to just one day, stand up in front of the class. You need to prepare them for it.
Encourage mistakes
Encourage students to take risks. Give permission to make mistakes, but not just permission, make it a goal.
At the start of term, when I set out the class rules. I have a few don'ts. I also have some dos: collaborate, work hard, make mistakes …
I tell them that computer programming (and learning) is about making mistakes. In a one hour lesson, if you only make 100 mistakes, then you are not working hard enough.
Get them making mistakes, get  them celebrating mistakes.
One way to celebrate errors, is «test first»: Write test; run test, test fails, celebrate; write code; run test, test passes (maybe); repeat.
Austin's butterfly
So how Austin improved his drawing: He got feedback from the class after each drawing, and used this feedback to make a better drawing. It took six attempts before he drew the final image.

Mind set
Teach them about mind set — Carol Dweck “Whether you believe that you can do it, or believe that you can not, you are correct.”
People with a growth mindset

believe that mistakes are an indication that they are learning.
believe that they are in top set because they work hard.
like challenge.
learn more.

People with a fixed mindset

believe that mistakes are an indication that they are stupid.
believe that they are in bottom set because they are stupid.
like easy work, that they can get correct. Or very hard work that gives them an excuse.
learn less.

Get them helping out with the class.
Build a culture of helping / talking-to each other.

Peer help
help desk
answering class questions
explain to the class


This is a bit of a frame-challenge, but what I'm understanding from your question is that your goals here are to: 1) Not overwhelm your students and avoid them getting lost in a plethora of blocks they won't need, 2) Force students to understand how to implement more complex blocks themselves.
Have you considered instead of providing a restricted version of the language (which, could be complex to install and update and ensure every student is using the same version of), simply providing a list of "recommended" blocks? This could help to achieve your first goal, to act to guide students as to what they'll need for an assignment and avoid them being overwhelmed. And, this still allows students who want to explore a larger set of the languages features to do so if they want, something which I think should be encouraged.
As for your second goal, this depends on your class but it may be effective to simply create an assignment around implementing more complex built-in blocks and enforce the restriction specifically for that assignment.


Clear example of the Object-Relational Mismatch

I'm not seeing an explanation of object-relational mismatch there for two reasons:

What are the objects? You've sketched a database table definition and a visualisation, but I don't see a sketch of the application program's structures.
As far as I can see, all of the additional information in the visualisation can be made available in a purely relational database view. I've done this kind of hierarchy visualisation with CTEs.


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


Is less than comparison more natural than greater than comparison?

I think the typical order has more to do with grammatical conventions actually.

  Joe is heavier than Bob

Joe is the subject, the one we're talking about; Bob is just an object we compare against.

  Joe weighs more than 90kg

vs.

  90kg is less than Joe weighs

The second one is a very odd sentence.

  [subject] [verb] [object]

[variable] [operator] [constant]

This would be a pretty normal construction, such as:

x < 0

or

x > 0

but odd would be:

0 < x

Because the value of 0 isn't changing. Zero is not the "subject" of what we're doing. x is the subject, the variable, the interesting thing.

So what if we're comparing two variables?

x < y

It's possible both of these are new values to us, but intuitively, this code feels like it's more about x than about y. Consider:

if x < y: do something
if x > z: do something

Now, clearly, x is our main subject, running against various other variables to see if something needs to be done.

So, my impression is that any preference for < over > or otherwise pales in comparison for the preference to put the "subject" of the comparison on the left.


Justification for an objects-early approach to introductory programming

tl;dr: When you teach with the OO paradigm, you get to control the flow of ideas and the level of complexity at any moment.
Here we examine the first course in computing, no matter the educational level. Presumably this is for a formal course, though it can be adapted to self-study. Presumably the students have mixed ability and backgrounds, neither all superstars nor laggers.
In my view, the purpose of the first course is to teach students how to program. It is not to teach them a particular language, and not to teach them the esoterica of that language. How you proceed in practice depends on your own background (the teacher or learner) and on the language you choose. Actually the dependency is not on the language itself, but on the paradigm that the chosen language embodies.
In order to learn how to program, you must first have a concept of the nature of a program within a paradigm. But we are burdened by our history: the history of programming languages and the history of how the instructor learned how to program. So we first consider the question What Is A Program. The answer depends on the paradigm. Leaving out assembly language, in which the program is a sequence of simple statements and branches, we have several possibilities.
Fundamental Nature of Procedural Programming
Languages like C and Pascal were designed in an era in which it was discovered that go-to (branch) programming led naturally to unreadable and unmaintainable programs. Dijkstra, Hoare, and others came to the realization that Structured Programming was superior and sufficient. In Structured Programming the fundamental program structures are sequences of statements, selection of alternatives, and repetition. These can be represented explicitly in languages without reference to branching. They can be explained as branching, but it is not essential to think of them in that way. Combining this concept with the idea of (procedural) abstraction (naming coherent parts of a program and invoking them by name) produces the following way to think about the nature of a program:
Envision a problem, for which you do not yet have a solution, as a set of sub-problems. If they all had solutions a known synthesis would let you combine them into a solution of the whole. Note the two requirements: (1) the set of sub problems must be complete and cover the whole, and (2) a synthesis of solutions is known that would combine them into a solution of the whole. The sub problems themselves may have no known solution, but they must be solvable.
For each sub problem does not have a known solution, recursively decompose it just as above. A solution should be a simple program (procedure) that satisfies all of the requirements of that (sub) problem. If you cannot provide the solution, then recurse until you can solve all of the smaller problems.
Once you have solutions to all the small problems build up a solution to the whole from the lower level syntheses, which were known, and which drove the decomposition in the first place.
Thus the nature of a program is a tree of solutions, with each leaf a (hopefully) simple procedure/function. Each procedure/function solves some part of the original problem. The larger problem is now envisioned as a tree of problems and associated sub problems.
If you teach in C or a similar procedural language in the first course then the most important task is to give students practice with this process. Never mind all of the intricacies of int values and mutation, and pointers, etc. They must learn to understand the nature of a program. Everything else is in fulfillment of this goal. If they learn that, but not the whole language, they can fill in those details later, or on their own. Without that structure they will write terrible programs with long and unwieldy structure, and impossible-to-decipher functions.
Fundamental Nature of Functional Programming
The first Functional Language was Lisp (List Processing). It was developed based on Church's ideas on the Lambda Calculus. Functional languages are provably as powerful as those based on Turing Machines - a famous result. Lisp was originally thought to be inefficient since it incorporated an inefficient garbage collector, and that unfortunate judgment has stuck, though modern functional programs can be as efficient (or even more so) as those of other paradigms. Lisp has many modern successors, especially Scheme and Clojure. While Lisp traditionally uses only an abstract syntax (parenthesized lists), other successors have a concrete syntax that appeals to many (including this author). Languages like Standard ML and Haskell fit in that category.
A functional program is best thought of as an expression, which, if evaluated, produces a value. Since functional languages tend to be incredibly regular, the "value" returned by evaluating an expression might, itself, be another expression. I will used Scheme to explain ideas as we continue. In functional languages with syntax, things will look different, but reduce to the same ideas.
In Scheme, a program and its data are represented by lists: (a b c d). If the list is evaluated it is a program in which the first element is a function (expression) and the rest are the arguments (also expressions) to that function. However, the list need not be evaluated, in which case you can think of it as data (or as an expression to be evaluated later).
Different functional languages differ in when the arguments to a function are evaluated. Originally they were evaluated eagerly, before the function itself is invoked. However, it is also possible to design a language so that evaluation of expressions is delayed until they are actually used. Each has advantages and disadvantages, so functional languages usually compromise (using special forms and macros) so that some expressions use their own distinct rules.
Another feature of an expression only language is that you do not have side effects, only values. Output to a printer and graphics construction are not functional concepts, so special forms can again come to the rescue to provide the possibility of side effects, though most programs work to minimize and localize them.
A pure functional language (or the pure core of a more complete language) will be without special forms and side-effects. In a pure functional program the programmer constructs an expression which will produce the required solution to the problem if evaluated. Smaller scale problems are represented as the arguments to that initial expression and they can also be (recursively) arbitrarily complex expressions themselves. Evaluation of the original (top level) expression implies that the arguments are also evaluated in some order dependent on the language.
Since people do not like to write arbitrarily complex expressions, it is also possible to name expressions (abstraction) and invoke them by name. These names are usually called variables but normally they do not (cannot) actually vary. Once a name is bound to an expression (creating a variable) that variable cannot be bound to another, though the name can be reused - a confusing distinction, of course, until you understand scope. Data in most functional programming languages is immutable. One constructs new lists from old, rather than modifying a given list.
So, beginning functional programmers need to understand the expression, subexpression concept and practice it. They also need to learn at least a few special forms and how they behave differently though they actually look the same. For example, an if-then-else selection structure is normally a special form since eager evaluation of the "then" and "else" expressions is usually not desirable (especially if either has side-effects). As their experience with the language grows they need to learn more about the special forms and their individual rules.
There is an additional task for the beginning functional programmer. Normally repetitions (while, for) are not used in functional languages. They are replaced by recursion, especially tail-recursion. So the beginning programmers need to learn how to pose complex problems recursively with a special focus on tail-recursion. This results in some beautiful idioms that can be mind-blowing when first encountered. For example, reversing a list in Scheme can be done in linear time if you know how, but a naive program will likely be quadratic. The programmers do not need to learn more of the language to do this - there is very little "language" to learn - but must learn more of how to use the language, often by thinking recursively in powerful ways.
Fundamental Nature of Object-Oriented Programming
The first object-oriented language (OO) was Simula, which was developed to facilitate the creation of complex simulations, say of industrial equipment or governmental systems. This may be a key to how to teach the paradigm to novices. See this answer to a different question, for example. C++ was conceptually based on Simula. The next OO language was Smalltalk and most object-oriented languages derive from it. The most direct successor to Smalltalk is Squeak, which is a beautiful choice for teaching, but seldom used outside a small circle.
Imagine a problem that you can conceive of as being solvable by some set of things, each of which has the ability to act on request and to return some information based on those actions. Think of how you would design those things. Each of the things itself has a problem, its piece of the original, and that smaller problem is solvable by additional things with the same sort of capabilities. The things are heterogeneous (many kinds), some simple and some complex. Simple objects can be coded in a language, but complex ones need to be further decomposed.
An object-oriented program is envisioned as a web of objects (things), perhaps just one, that cooperate in the solution of a problem. An object itself is a bundle of behavior that provides services normally for other objects. The web arises from the fact that any object can hold a reference to other objects with which it can communicate - eliciting behavior. Each object takes responsibility for some part of the solution. An object is a value that can be queried for information to solve its own piece. Additionally, it can be directed to act in creation of the final result. Communication with an object is called a message. Both the queries and the actions often (usually) cause additional messages to be sent to other objects, which aid it in fulfillment of the query or action.
Additionally, and this is the important point, objects are themselves constructed, mainly out of other objects (recursively): their parts. They communicate with their parts in the same way (messages) that they would communicate with an "external" object. Thus, the structure of an OO program is a web/graph of communicating objects that are themselves (recursively) webs of objects at a lower level. The execution of such a program is a flow of messages that cause actions and return results from queries.
To create such a program, from scratch, you define one or more objects (using classes in Java or prototypes in JavaScript, etc.) and send a message to an object to start the computation.
OO languages have many features, usually including inheritance, which is often thought to be the biggest idea in the paradigm. In fact, it is not. The big idea is that OO enables the programmer to consistently build complex objects out of simpler parts by composition, keeping the parts essentially invisible to the clients of the object (encapsulation). Variables, other than references at the top level, are used to refer to the parts of an object so that it can maintain a consistent internal state and provide the public services.
In effect, an object provides an abstraction layer, above that of the language itself, in which the programmers building the system can think and extend, without reference to lower-level constructs, even those of the base language itself. Thus a set of objects provides a world that is self-consistent and complete enough to solve the question at hand. Once such a world exists, even novices can program within its framework and can think at that new virtual level. Thus, once a world with, say wombats, food, predators, etc has been provided, perhaps by the instructor, students can extend it, and can solve complex problems within it by creating objects and their web of interactions.
A beautiful OO program is one in which the objects themselves are simple, with simple methods. The complexity is not in the objects themselves, but in the interactions. When I am writing an OO program, I start to get "itchy" when any method has more than about three statements. Any structure nesting (if, while, ..) beyond two is cause for concern. McCabe's cyclomatic complexity metric should give you really small numbers. An implication, of course, is that there are lots of objects, and often, lots of classes. Fortunately, modern IDEs make these easy to create and manage.
Teaching the first course
You can teach the first course in just about any language and within its associated paradigm. If, however, you confuse your students about the nature of a program in that language you have failed.
The students should also write beautiful programs that their mothers would be proud of. The techniques you teach them should scale to larger programs than what they write in the first course. It should never be necessary for any student to unlearn bad habits and bad practices. If they can only program by writing two-page functions/methods filled with deeply nested selection and looping structures they are failing. The parts they build in whatever language/paradigm need to be small and understandable.
Consequences for teaching the first course (focus on OO)
If you need to teach a course and intend to do so without any preparation, the procedural paradigm is likely the easiest for you. You need a suitable language, a compiler, and an editor. The language provides the "stuff" of programming in its few data types and program structures. To be a success here, giving students the essential idea of procedural programming, you will need to find interesting problems. This is difficult since your tools are so primitive. You will also need to guide them into the problem decomposition and program composition to build up the two trees (problem - solution). They often tend to do too much in a given function. Make them factor out every difficult bit and apply intention revealing names to the parts factored. Require then to use short functions, limited nesting of program structures, etc.
If you want to teach OO programming, on the other hand you need to prepare before the students begin. You need to have in hand one or more virtual worlds found, or constructed by yourself, in which they can do interesting things. Making it interesting is easier, since the structure of the world is up to you. Students programming in one of your worlds can start out with nothing more than sequences of messages to one or more objects to get some desired effect. If your world is graphical, all the better, since the students can see the effect of their program, and hopefully where they go wrong when they do.
Next, in the OO world, students can extend one of your (say class) structures to add some additional behavior. They can do this by inheritance if the language permits or not. I would strongly suggest that you not overemphasize inheritance. Certainly avoid deep inheritance hierarchies. Ignore the concept of "reuse" and instead just extend the made-to-order world with interesting behaviors and/or objects. Since you have built the virtual world, you can control the order in which ideas are presented to the students and can control the complexity of what they must deal with at any moment. You can introduce deep concepts in a simple way in order to achieve some local small/scale effect as well. Not every program needs to be math-like as you have richer things than integers, etc.
If you want to teach them OO programming, do not think that you first have to teach them procedural programming. Some of the ideas of procedural programming naturally occur in writing methods of OO programs, only in a smaller scale. It is easier to move from OO to procedural than the other way, actually, since the methods written are a lot like the procedures/functions of the procedural paradigm. It is also not quite as likely that the students will write monster methods, though you need to guard against the SEE-ALL-DO-ALL class, just as you need to guard against the ONE-TRUE-FUNCTION in procedural programming.
The beauty of the OO paradigm for teaching is this. While any language defines a virtual layer in which to program, the objectives of the language designer were not pedagogical. When you define a higher level virtual world atop the language level, you, in fact can use pedagogical principles to construct it and provide a world in which the key concepts are easier to learn. If that world is also Turing Complete, all the better, but it is not essential - especially if you intend to use several smaller worlds rather than a single framework.

Note that a few additional paradigms have been omitted here - concurrent programming, in particular.
A paradigm is a way of thinking. Adopting a new paradigm may require a radical change in how the students think. This is much like the change in warfare from aristocratic knights on horseback to a peasant army of longbow archers that was first recognized at Agincourt in 1415. However the change did not become complete for about 100 years, Henry V to Henry VIII. After Henry VIII, English kings were no longer trained as knights.
Paradigms are by nature distinct. They are not ordered. A longbow-man did not need to have any of the knight's training to be successful. The computing paradigms are also distinct and self-consistent, not ordered. It is not necessary to learn one before any other. Nor is it necessary to mix them. In fact, the second paradigm learned is always difficult, as you already know how to do things, so the new structures seem superfluous to you. That is not a reason for not learning several, but it needs to be kept in mind to help explain the difficulties. The first course, however should be pretty pure to avoid confusing students.

It is a fundamental principle of modern computer languages that they define an internally consistent, Turing complete, view of programming that needs no appeal to lower level constructs to be understood. While it is true that such languages are in fact compiled to lower level constructs it is inherent in the concept that understanding does not flow from compilation, but the other way about. In fact, most of us (non-compiler-builders) would have a hard time understanding the intricacies of what really goes on in an optimizing compiler. The basics are easy to get, and the details are very complex. If you had to understand all of that to write a C program you would never know where to begin. You make assumptions, but they may be wildly wrong in light of modern systems with multi-level cache, co-processors, etc. That understanding is not needed if the language itself is complete and consistent.
Many languages are designed around a particular paradigm, sometimes just due to the time of creation. C is procedural. Java is Object-Oriented. Haskell is Functional. Some, however are multi-paradigm; C++, for example, is neither duck, nor dog.


How can I prepare CS majors for non-programming jobs?

Sci/Tech journalism
There's a common complaint that people in science journalism, who may have journalism or English academic backgrounds, are okay at writing but vastly underinformed about the computers (or physics, or chemistry, or other subject matter) they're writing about. I've seen it firsthand, and while there are of course exceptions, the complaint is justified in many cases. Your students would have a big advantage in this field because of their technical backgrounds, especially since you mention writing and interpersonal skills. Some basic journalism and psychology coursework might be handy, in my opinion.

Tech writing
Also in the writing category, there's the field known simply as technical writing. Technical writers often deal with creating documentation or manuals but may work on any specialized, um, writing that is technical. In my experience, these people often have either English backgrounds, with most of the rest having technical backgrounds, and whichever one you have, you're perceived as not having enough of the other. There's no running around and interviewing strangers as there is with journalism, so brushing up on writing skills on paper is the first thing I'd recommend here.

Requirements engineering
Adjacent to that is requirements engineering. Reqs engineers are on technical teams and work with programmers but don't do any coding themselves. They think bigger-picture about what the needs of systems will be, communicating with customers and developers and other relevant people (I suppose I should say "stakeholders" but that feels so business jargon) to figure out what a project should do, what it reasonably can do, and how it should do those things (and also, what it shouldn't do).

I haven't often seen requirements discussed at the undergrad level, but they're also not full-on graduate programs. Not that I think you're looking to recommend grad school here anyways. If finding and taking the one graduate requirements course isn't an option, I'm not sure what I could recommend to prepare for this one. Having a CS background will be a huge advantage, and I would almost say necessity, for such a position, though.

Evangelism
An answer that may be a bit more specific to your students specifically, based on your description of your school and your other activity on this site: evangelism. You don't need to be sitting in front of a computer writing code to care about the pipeline problem. The main issue with this answer is that there don't seem to be many places where you can get paid to work on this. Organizations that deal with diversity issues tend to be non-profits that lean heavily on volunteers.


If the objects are something like robots or other things that "move", like froggies, or such, then you can do things like maze solving and other interesting things. If they can move some sort of other objects by picking them up and putting them down in piles, then you can sort and such. Of course they need some sensory behavior to sense boundaries.

There are a number of scenarios available for Greenfoot for example that permit this sort of thing, either with a Java program or with student "actors".

The left hand rule for walking a connected maze is kind of fun. And there are actually sorting routines for physical objects that are unlike the usual algorithms.

But it is moving under some constraint that makes it work.

Find the resources at the Greenroom for ideas. I think the first scenario in Greenfoot involved Wombats, but the developers were then in Australia.

Alternatively, you can have the students simulate a cpu that executes the program, moving some objects on a game board. The hard part of this, however, is capturing the message passing idea of OO. That is a bit easier if the students are, themselves, objects, since speaking/asking is a lot like message passing.


Have you thought about having a solution that you create and test the students test cases against your solution? Then you have a stable platform for running the student defined tests.

Also run test cases which you prepare against the student's code. Now you have graded the two parts independently of one another.

Just out of curiosity, what did you use for auto-grading?


Some of the best information I have heard about how to name variables, methods, etc. comes from the Stanford MOOC on iTunes: Developing iOS 10 Apps with Swift.

In the first couple lectures, the professor talks through how to build a calculator app (and does so in front of the class in real time) and does a fantastic job of demonstrating why he is naming things the way he is. The essence, as he explains it, is this: a statement in code should read like an English sentence.

One of the early requirements for the first assignment is to read through the Swift API Guidelines. Admittedly, this is designed for the Swift language, but there are lessons to take away from this for any language. The naming can be verbose at times, but such verbosity might improve code comprehension as students will have to know what a variable or method does in order to name it properly.

Even just the following two would be a great start for most students:

"Clarity is more important than brevity."
"Write a documentation comment for every declaration. Insights gained by writing documentation can have a profound impact on your design, so don’t put it off."


Do Theoretical Computer Science Conferences Accepts Survey Papers?

That is up to the individual conference. All of them have web sites that will explain what they prefer. I'm skeptical a bit, however.
But, many such CS conferences have different "tracks" and different associated activities. You might find a better welcome at one of these. For example, some have an associated "educator's track" that might welcome something like this. But you need to check individually. The program chair (or conference chair) will probably respond to an email if you don't find what you are looking for online. Most such people have email addresses that are easy to discover even when not listed on the conference site.
Theoretical conferences will, of course, prefer papers that extend the theory.


Advice for becoming more confident in programming

I think you are probably asking the wrong question. You aren't going to become a good programmer in a week. Or a month. Maybe not in a year unless it is well structured.

My advice is to figure out what you are good at, not what you are bad at. Seek jobs that play to your strengths. Not every person that works in computing does so as a programmer, for example. I once told a student who was struggling in a hard course that she would probably wind up as the manager of all the superstar programmers in the class. Why? Because she asked the right questions. Often enough the question is more important than any answer.

You can't go back and undo the mistakes you made getting to where you are. But if you figure out your strengths and write applications that emphasize them and stress them in interviews you may be fine. Just don't suggest you are a programmer, nor stress that you are bad at it.


Teaching students how to construct regular expressions (and other "translation" style problems)

This is the stuff of math teachers' nightmares. The problems here, from my experience teaching about grammars1, are two-fold:

You said that syntax is probably not the culprit here. Students may be able to follow a grammar that has been presented to them, but may not be able to generate an appropriate grammar for a given series of test cases.
Students may not be able to generate appropriate test cases from the word problem itself.

The good news is that, by breaking it down into these two steps instead of one, you can actually help to isolate the problem that your students are having.

If you see your students frequently (as I do), here's a fix-up strategy that you can do in about 30 minutes of class time over three days.  Create a worksheet with a series of word problems, and ask the students, as homework, to generate test cases for these hypothetical machines.  They are not to create the grammars themselves, only create a series of test cases that should be accepted or not accepted.  Emphasize that redundancy is not a goal; you want a minimal set of test cases that could guarantee that some grammar is entirely correct.

The next day, spend about 15 minutes going over two of the problems, round-robin style, at the board.  Ask a student to write a test case for the first problem. Turn to the second student, and ask them to write another test on the board that could potentially uncover new ground.  On to the third student, fourth student, etc., until you are satisfied that you have a good testing set.  Ask if anyone else has any important tests remaining.

Do the same for the second problem, and then discuss the importance (in general) of creating good test sets upon encountering a word problem.  Point out that they will receive word problems on their assessment at the end of the unit, and you expect them to be able to figure out a good set of test cases with which to design a grammar at that time.

Their homework for that second day is to fix up their tests (if they need more work), and to create the appropriate grammars.  I suspect that when you get this homework back on day 3, you'll have much stronger results.

1 - I am using "grammar" as a stand in for "grammars, regexes, FSAs, or whatever type of expression/machine you are trying to get them to create at some particular moment."


Enjoyable and\or fun way to explain cmake

cmake, allows you to define variables, these variables can be filled with strings.
These strings can be tools or files.
Additonally it allows for conditional compiling, setting version numbers and library injection.
I would have a look at: https://cmake.org/cmake-tutorial/

Now on how to explain:
Cmake utilizes a script language to make building projects much easier. It has a feature set that does specific things. Like requiring specific versions of files.
How to make it "fun" I dont know. But you could split your class in groups that each  have to create a header cmake replacement script, with a specific variable name. And a program that does anything they like, but has to use the defines. For example DEBUG
Then each group has to create a list of substitutions, and they share the substitutions. While executing the diffrent substitutions, they have to determine why something breaks or works although it shouldnt. This can be used to examplify, how the header operations work, and also how wrong or malicous usage can wreak havoc in their project.


What are good/bad topics for a non-major CS0 course?

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

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

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

See also Security SE's post about that comic.

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

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

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

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