Problematic student at a very high level I teach a high school student who has already developed an understanding of the language used in my curriculum and causes difficulties. The lectures and programming projects in the curriculum bore this student, and as a result, he doesn't cooperate when it comes to doing the coding labs and projects. He simply doesn't agree to do the work. An obvious "solution" is simply to give him a low grade, but it is not an ideal solution, because he has readily mastered the material.

Specifically, what techniques can I employ to encourage him to work on projects and to cooperate? Alternatively, what changes can I make to project guidelines for such students?

Tests reflect that the student knows the material (though it is clear that he is disdainful of the way it is taught).

The best way to deal with this kind of student is to head it off at the pass.  If you can get the student at the beginning, you can often prevent the problem from festering in the first place. I have a student coming in next year who I have already been warned will have this problem, and I plan to show this to my class on the first day:

I will then say something like, "For whom is this situation unfair?"

When the kids point to the fish, I will point out that it is just as unfair to the monkey.  I will then ask them to talk to a neighbor and figure out why.

I will finish up by saying that I have a promise for the fish of the class: everyone who puts in the work will be able to climb the tree.  That's MY job.  However, I have to find a way to be fair to the monkeys as well.  That means that I must reserve the right to try to find ways to push them to get better in my classroom.

If they are in that position, and can get the work done very easily, and find that I give them harder work, I ask a few things of them: (1) understand that this is fairer than it may initially feel, and (2) understand that this comes from a place of actually caring about them as people. Making more appropriate assignments for them is harder for me as well. If I didn't care about them as people, I could just let them get away with the minimum.

In essence, then, I am trying to recast making differentiated, harder assignments into something that the students will understand as both a loving act, and one that respects them deeply as individuals.

First of all, I don't think the student is the problem. If you think he has understood the chapter well, you should also kick it up a notch. Backing down or not stepping up will essentially point that you know the bare minimum that is required to get a teaching job.
Just tell him or your head that he is much more advanced than the class and try arranging for a more complex lesson so that he also gains interest in the lesson.


Physical analogy to introduce a Delegate in .Net programming Delegates are strange beasts (think Pointers with aspirations) and I was planning to introduce them using a physical metaphor: a power strip. The power strip connects to an 'event' (wall socket) and has a 'signature' (the interface of the plug shape and parameters) and provides connectivity to multiple event-handlers (the sockets in the strip), but it doesn't actually "do anything". Other examples would be a USB Hub and a Network Switch (different 'signatures' / plug and socket interface). Delegates can be used for any sort of event situation, not only the Windows GUI, so they are a fairly open-ended idea. ("Can you say 'abstract'? I knew you could.")

This gives something that students can visualize for the terms of a Delegate: what it connects to, how it can provide for multi-cast events, and how methods connect to it. Does this seem like it will work, or is there a better way to introduce this highly abstract yet necessary programming concept?

I know that you are looking for a physical analogy, but I'd say I agree with @ctrl-alt-delor about the 'link to what they already know' part.

I usually start by introducing a simple algorithm, then show how that algorithm can be parameterized. Then we move on to OO, where I discuss how an algorithm can be parameterized with not just a value, but with a piece of code (i.e. creating an interface, and passing an implementation of that interface to a method). For the interface, I always use an analogy like USB.

Then we move on to the delegates, where I introduce delegates as if they were an interface with one method, Invoke(), and whatever you pass to the delegate gets called in that Invoke() method. Then we move on to delegate internals (how they are immutable, and multicast etc.) I also have examples and practices that we do to show them that every solution that uses a delegate can be translated into a more OO version using interfaces (again, referring back to interfaces).

If you've talked about interfaces, you can simply say that a delegate is like an interface for a single method. Interfaces are "implemented" by classes; delegates are "matched" by methods.

Physically, if an interface is a contract that can be fulfilled (implemented) by a party (class), a delegate is simply a term (of a contract).


Teaching "math function" vs. "CS function" The word function has different meanings in math and computer science. For example, f(x) = rand(1) is a valid (pseudocoded) CS function, but it is not a mathematical function because it has multiple possible return values for a given argument.

When and how is it most effective to bring the students' attention to the contrast? In teaching physics, it is a general principle that when possible a student should experience a phenomenon before being given words to describe it. (E.g., have students feel a torque before defining "torque".) (Arons, A. 1997. Teaching introductory Physics. New York, NY: Wiley). Presumably, there is a benefit to be obtained by introducing math functions, CS functions, and the contrast in a particular order and using a particular approach to active learning, but I am unaware of any published result to that effect. What ideas and data can people contribute to this question?

In mathematics a function is a constrained relation between two sets. You can illustrate that in a number of ways. The constraint implies consistence of operation and uniqueness of result.

If you discuss relations (in math) as well as functions it may be easier to get beginning students to grok it.

In most computing languages, a function is an operation that produces a value (and possibly side effects - horror). There is nothing in the definition of a Java function about constraint, not even that successive invocations with the same input produce the same values. A java function is a machine. Drop in 0 or more inputs, turn the crank, get some outputs. You can illustrate that by drawing a machine with an input hopper, and output spigot and a crank.

Students who know math have a lot of problems early on with things that look like math but are not. Other questions in the "hopper" currently explore other aspects (equality, variables)

As far as I know, the word Function does not have a different meaning in mathematics and computers.  To compute is to do mathematics, and all a computer does is compute functions - nothing more.  Functions (and yes, that includes subroutines) in computers are functions in mathematics, period.  They may be functions of other functions, and so on, but they are nonetheless functions, and that is, by definition, all they are.

If there has been some confusion among your students in your teaching of the word Function, can you consider the possibility that your students are confused because you are teaching them the exact opposite of what is in fact true?


Is there some meaningful percentage of students who can't learn to program? A few days ago, I had a high school sophomore (who is now in her third CS class, having passed the prior two) look at this Java code for a solid 3-5 minutes, and was unable to figure out what it did:
int answer = -1;
while (answer < 1 || answer > 5) {
    System.out.println("Please enter a number from 1 to 5.");
    answer = myScanner.nextInt();
}

She couldn't identify the ending condition of the loop, and didn't understand why answer was initially set to a number outside of the 1-5 range.  The understandings that she would need to comprehend this code was covered in a prior class by a different teacher, and it was covered a second time from first principles in mine.
I don't particularly need help with this student.  I will tutor her and give her extra worksheets.  She will almost certainly skirt by and do okay, but if the past is a good indicator, she might never be able to quite put it all together, and larger projects will be impossible for her without some outside help (which I will make sure that she receives).
However, every year, I find a small number of students who just don't seem to get it.  They muddle through, but the CS major program becomes harder and harder for them as their four years go by.  Must it be this way?
Is there any evidence or reason to believe that there are students who genuinely can't learn to program?  Or, flipping the question around, is there any evidence or reason to believe that every student really can learn to program?

There are a number of reasons why students don't learn, but few non medical ones why they can't. Leaving aside the medical reasons, such as hormonal imbalance or other disorders, I think that students who don't learn either have little desire to learn or have had poor teaching in the past. Even students with some learning disorders can learn given desire and patient teaching, but it can take a lot of work and understanding of the student to enable it. Once common problem with students is extreme introversion. That can make it difficult for the student to seek help and ask questions. It is good if you can find ways to help students deal with that in a positive way. See this question for more on the idea here.
Desire
Some students don't learn what you are teaching because they have little desire to learn it and no incentive to put in the work required. They may be in your course for the wrong reasons and would rather be anywhere else if it were only possible. They put in the time, but nothing else. There is probably not a lot you can do for them as that desire needs to be internal. Some students develop desire after a period of indifference, but I don't think this is common. I've had undergraduates in CS who were only in the major because their family (father) would only support them if they stayed. Such students can be counseled to study something more interesting to them if possible, even if it requires doing that in addition to computing. Better, though, if you can counsel the parents to better support their child.
Some classes are required, of course, and so interest for some will be higher and for some it will be lower. If you know something of the goals of the student you might be able to connect the current class to those goals, increasing interest and desire.
Poor Teaching
Many students do poorly in CS (as in mathematics) due to poor or indifferent teaching; especially the attitude among some teachers that it is OK to leave some students behind. Not every student takes the same amount of effort to teach and every student learns differently. My usual mantra in this situation is that "Your students are not like you." They learn differently than you did. Your presence in the classroom as a teach is proof enough that you are a special case.
Some especially bright kids do poorly in school because they are simply bored and nothing is exciting enough to them to put in the effort. Some students find other subjects especially easy and don't really know what it is like to have to work to learn. Some students don't learn because no one ever taught them how to learn. Some think that hearing something once means they have learned it and are surprised later when they can't recall something, wondering why you never taught it to them. Some students have a fundamental misconception about some small thing that has snowballed into a big block. Some students have never had a positive learning experience (maybe generally and maybe just in some topic) and simply hate everything about the process. Some teacher say incredibly stupid things to students and even some institutions have incredibly stupid ways to deal with students, actively damaging them.
I have examples in my learning and teaching background of each of these things.
As a student I was a thought not very bright when I was a kid and was nearly "held back" to repeat an early grade. However, I was just deadly bored with school. No one ever bothered to tell me why I was there or why or how I should try to succeed. Being bored I was a bit of a troublemaker, leading to lack of support from teachers. Later on, I was given an IQ test and the results were reported back to me as "You probably have the skill to succeed in a Junior College, but probably would only be frustrated by a full undergraduate program." I later earned a PhD, of course, so the assessment was a bit "off". The first course in which I actually learned anything was in Plane Geometry in HS. I got entranced by the problems there. Prior to that, mathematics was, perhaps, my worst subject. The doctorate is in Mathematics, of course.
In teaching, I once had a student with two problems. First he was dying of a chronic condition, but also he had been given misinformation about the precedence of operators by some early teacher that was reinforced when he used a too-simple pocket calculator. He couldn't seem to get it right in elementary programming and learned to hate it. He thought he was stupid that he didn't get it and he thought that all of his teachers also thought he was stupid. I think I managed to convince him otherwise before he died but we banged heads a bit before the reason for his difficulties became clear to me. It took a bit longer to convince him that I wasn't actively trying to deceive him.
I once had a class of students who were almost all doing very poorly. Since my teaching style then was to face them, rather than lecture with my back to them, the diagnosis was pretty simple. No one had ever taught them how to learn in a classroom. They sat passively and listened and watched, taking no action themselves. I asked one why he didn't take notes and he pointed to his head and said "It's all here." Well, I had evidence otherwise, so had to interrupt the syllabus to actually teach them how to learn and to force them to actually do it. I've discussed part of the method in another answer on this site.
Solutions
If you want to teach every student, however, you need to know every student. If someone is doing poorly, you need to try to understand why that is and to tailor a solution to their needs. To do that you need to be dealing with a reasonable number of students, of course, so if you are a professor of 800 students, the individual care must be given by your army of helpers. But even wit 20 or so students you need help. This is why pairing and group work is so important and why you can't always let students choose their own groups. You need to get feedback from the members of the groups (peer evaluation) and you need to find ways to act on what you learn.
The solution to teaching every student is not to individually tutor every student, but to find ways that every student can learn what they need to learn on their own terms. Not every student wants to earn first marks. They want to learn "just enough." They are satisficing rather than optimizing. You can make that work for them too, so that "not earning first marks" doesn't mean "failing."
Success Story
I once had two students (compiler course) who were repeating the course after failing it. The classmates of these two were generally among the best I've ever had in one group. But these two had, seemingly, never had a positive experience in CS. They seemed to be dull, requiring repeated explanations of the simplest ideas over and over. Fortunately the course was taught in an incremental way in which the students could accumulate points toward success rather than by demonstrating it on exams: a project course. I convinced them to come to my office hours and there was never a time thereafter that they weren't there. Fortunately the other students didn't require such high maintenance. I also had simple ways for students to ask questions when they were working on their own and so these two could get small helps whenever they needed it. It turned out that these two wound up (a) explaining things correctly to me by the end of the course (b) earning the highest grades that term, and (c) angering the other students who thought I'd put these two in the class to make themselves look bad. My last contact with them was to remind them of what they had done and that they could repeat that elsewhere if they were willing to put in the same amount of work. I think that teamwork also helped here and they supported one another throughout. Note that I didn't need to put additional time into the course for this to happen. The office hours were required and the mailing list for questions was a common feature of all my courses. Another question here seeks ways to make this out-of-class communication easy, though I think it needs better answers at this time.

I am not a CS educator, I just do far too much programming in the day job.

A question if I may, what course are you teaching, Programming or Computer Science? I would be disturbed to sign up for a CS course only to have it spend significant time on programming.

From the "Computer Science" title I would expect that actually programming the things would be a very, very small part of such a course (And actually not worth many marks, so why really sweat it).
There are far more important things to teach on an introductory computer science course IMO, calculus of sets, complexity, some discrete maths, introductory algorithms, maybe some computer architecture, but programming is not something that it is worth wasting much time on in a CS course.

I don't know if there is anyone who could not be taught to program, but certainly most people can be taught some formal logic and ideas about algorithms. If you can give people the tools to break big problems into manageable chunks that would be counted a win in my view, if you can give them the tools to read specifications with a sufficiently critical eye for ambiguity that would be a HUGE win even if they come out unable to write a line of Java.


What could be the possible advantages of teaching Scheme as first programming language? When I started my Computer Science studies, Scheme was the first thing we learned in our first programming course. Almost 8 years later, I ask a friend of mine, and it seems that they are still teaching Scheme for beginners. Besides the annoying amount of parenthesis, I found Scheme helpful, and I was able to understand important concepts as how interpreted languages work, anonymous functions, recursion and so on.

My question comes, because, except for that semester, I have never used Scheme again, and even though it was helpful I have always thought why not teach another real world use language.

Wouldn't, for example, Python help in the same way? Why Scheme?

I think that the purpose of such a course is not to teach you a language. After all, Scheme, with its abstract syntax, is pretty minimal as a language. The purpose of a course like that is to teach you to think abstractly. If you can do that now, several years later, you can probably thank the course for getting you started. Abstraction, after all, is the big idea about computer languages.

A course in Python or another language can do similar things, but not in quite the same way, since in those languages you also need to learn the language syntax, idioms, and other structures. Scheme pushes all that aside for the opportunity to focus on abstraction. The things that are not in the language make it easier to focus on the big ideas.

This isn't really related to your question, but I note that many language designers start out with a lisp- (scheme-) like syntax to try out ideas in the language before they think very hard about its concrete syntax. It turns out to be very good for such experimentation.

We don't have Scheme in our entire country (here in India) but that honour goes to C programming language.

For the purpose of my answer, substituting C for Scheme, I keep asking myself, why bother with C. After that 1 semester of C, I have never used C professionally anywhere. In fact, once I step out of educational purposes, C becomes useless. That begs the question, after almost 25 years, why are they still teaching C? Why not something else?

I think, why they are still teaching C (in my country) and Scheme (in yours) is probably because it is ubiquitous. there are any number of books written on C. More importantly, the faculties who teach them ( I think most faculties change their jobs once in 60 years) can teach the same thing for the rest of their lives, use the same lab manual, and use the same code, and ask the same questions, use the same evaluations. From a strictly logistical point of view, it makes sense to teach C 30 years ago, and 30 years hence.

Can you image the mess, if every five years, the universities change their syllabus? Thats a logistical nightmare (not to forget other challenges) no one wants to deal with. For instance, one university could decide to go with C sharp, and another with Java. That creates all kind of problems. However, if all universities agree (which is how things are now) to simply keep using Scheme (in your case) and C (in my case), life becomes simple.

Further, the foundation that you get by learning an ancient language is that, everything that came after it, be default, would be easier. I learnt to ride a bike (as in motorcycle, not bicycle) in my dads old bike which was, well not that good. However, because I drove the tough one, all of today's bikes seem like child's play. Although I don't use C itself, anytime I learn a new language, I unconsciously compare it to C, and learn from that.

Update 1 : To add some context, I have been part of the IT industry for 11 years, and 5 of them as a developer/trainer/educator who travels widely. I am sure C is used somewhere, I haven't seen one single enterprise usage of C and I have worked for startups, small companies (less than 100 employees) and for MNCs (more than 2000 employees) and never ever has any division, anywhere talked about C, used C or implemented C.

Again, no disrespect to C (or its legion of fans) but I request that my opinion be taken in this context.


Why do computer-science majors learn calculus? I am curious why computer-science majors have to learn calculus to receive their bachelor’s degrees. My father worked as a software engineer for twenty years and never used it. It seems to have little more value in programming than other forms of mathematics. What is it about calculus that makes it a requirement for computer-science majors? Is it just that it's a tradition in STEM fields?

There are several answers:

Answer 1: Not all CS programs

First, not all CS programs require calculus in order to get a bachelor's degree. The Bachelor of Arts (BA) program at Mills College, where I teach, does not require calculus. Instead, we require two semesters of discrete mathematics, which we consider far more useful to computer scientists, because it (at least the way we teach it) includes:

inductive proofs
Boolean logic
proof by contradiction
sets
combinatorics
basic probability
recurrence relations
graph theory
matrices
regular expressions
finite state automata
formal languages

Answer 2: Scientific foundation

That said, getting a Bachelor of Science (BS) degree from Mills or just about any other school requires calculus as part of general scientific knowledge, along with introductory chemistry, biology, physics, etc., none of which we claim someone will necessarily be useful to a computer scientist. These courses are part of the college-wide BS core, not specified by any individual department. The idea is that anyone holding a BS degree should understand the fundamentals of major scientific fields even if they will never apply them in their careers. (Similarly, most colleges require students to take classes in history, even though they are unlikely to become time travelers.)

Answer 3: Historical reasons

Computer science as an academic discipline has not been around that long. Most CS programs started within either Mathematics or Electrical Engineering programs. Both of those fields legitimately require calculus. I went to MIT, where CS was added to the EE department. All CS majors were required to learn both digital and analog electronics, the latter of which requires calculus.

Personal thoughts

In my decades as a computer scientist, including in industry, I never used any of what I learned in the required calculus (I, II, and III), linear algebra, or differential equations. That said, they did give me the background to go into computer graphics, electrical engineering, or machine learning, had I later chosen to.

Whether programs should require calculus is another question.

As Computer Science students, you should know the fundamentals of university mathematics, for the further development of your own skills.

I believe that all science-oriented persons must study mathematics. For one thing, that study helps you to learn both of your subjects. And fundamentally, philosophically, I don't think that the two subjects are divided. Which is mathematics, and which is science? They are of a piece, essentially—they form an undivided unity.


Once implicit/inferred typing is introduced, how can I impress upon students the importance of not abusing it? I typically have the same students two semesters in a row, for programming I (VB.NET) and programming II (C#). In our early, impressionable time together, I stress to these students (high-schoolers) and show them by example (I write lots of code for them) the importance of writing clear, readable code, which is partly achieved by explicitly specifying types for all variables (at first I do not tell them there are other options)

However, at some point, I have to reveal to my students that they can, indeed, declare a variable as an Object (i.e. Object x = new Horse("Silver");) and that it can hold anything; or, that they can declare a variable as var (i.e. var y = "foo";) and that the compiler will figure out what type it is. Some of them discover this on their own, of course.

Then I inevitably have students who abandon the good habits they had formed and want to make everything an Object, or declare everything as var (note I realize this is not equivalent in the language, but students tend to abuse the usage in the same way). I am always torn about how insistent to be that they revert, because I know the use of var in C# is controversial in the industry. (See the SO discussion use of var in C# for an example). Plus, the more savvy students are hanging out in SO anyway, and they see some questions and answers that lack explicit typing and other good programming habits.

My question is, since these students are still learning, and since it is my classroom after all, should I emphatically require that they always explicitly specify types unless absolutely necessary? (Of course, sometimes it is justifiable, preferred, and necessary NOT to). And, if I do require it, how can I explain the (in my opinion) sloppiness they sometimes see in online communities?

Then I inevitably have students who abandon the good habits they had
  formed and want to make everything an Object, or declare everything as
  var.

These are very different situations. As you observe, the use of var in C# is controversial, but using object as the type of all variables (and then needing to cast any time you want to actually use the variable) is not controversial: it's just wrong.

The first page of answers on the linked SO question about var in C# is incomplete. It doesn't mention that using var can avoid bugs due to typing in one edge case: foreach (var foo in foos) vs foreach (Foo foo in foos). For legacy reasons, if foos is a System.Collections.IEnumerable but not a System.Collections.IEnumerable<> the latter is equivalent to foreach (Foo foo in foos.Cast<Foo>()), which is not especially obvious. (In fact I misremembered and was corrected in comments, which reinforces the advantage of using var here).

TL;DR: blanket prohibitions on var are almost certainly going too far.

  My question is, since these students are still learning, and since it
  is my classroom after all, should I emphatically require that they
  always explicitly specify types unless absolutely necessary? ...
  And, if I do require it, how can I explain the (in my opinion)
  sloppiness they sometimes see in online communities?

var is far from the only controversial subject in programming praxis. The solution in industry is the style guide: whether as a formal written document or as an informal internalised set of opinions which are imparted to new team members by word of mouth when they submit changes which violate the house style. If you're explicitly preparing your students for industry, it is perfectly reasonable to dedicate a bit of time to explaining the concept of the house style, and then when you introduce new material to explain the house style you will enforce for that feature.

The really heavy-duty approach would be to prepare a full industry-style style guide and then to produce a series of increasingly large subsets so that every couple of weeks you can give them a link to an updated style document which specifies how to use the new features you just introduced, or the new features you're about to introduce, and highlights the additions from the previous one.

Teach them c/c++ first, or go into the common uses of each data type first so they have to understand the intrinsic properties.


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

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

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

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

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

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

Here is the Overview from that guide explaining the difference:

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

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

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

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

  Intro to App Development with Swift

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

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

  App Development with Swift

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

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

I find Ray Wenderlich's web guides to be the best resource for teaching iOS development.
https://www.raywenderlich.com/category/ios

There also exists a considerable number of books authored by the team that go through iOS and various important first and third-party frameworks.

https://store.raywenderlich.com


Deep Learning Teaching Resources What would you recommend as the best resources for learning and teaching about Deep Learning?  These could include tools (e.g. TensorFlow), tutorials, books (e.g. Deep Learning), MOOCs (e.g. Udacity's), etc.

I'm working to put together a list of best resources for an upcoming issue of AI Matters. What I'm looking for is the best of the best entry points into an understanding of deep learning. Nothing even so specific as convolutional networks is necessary. As an educator, I am motivated to collect and share the best first footholds for giving students and professionals a start for the mighty climb that is highly motivated by recent achievements. As far as audience, I envision undergraduate intro AI through adult professional.

The first thing that must be discussed in the matter, is the mathematics involved.

Deep learning is first and foremost a mathematical model. An overview of this big subject is given quite well in its Wikipedia article. The page showcases a summary of the subject, as well as links to more resources (2 birds in 1 go).

To explain the mathematical model, I recommend reading this article. This gives a relatively good basis of understanding for neural networks (which are a "supertype" of deep learning algorithm). Afterwards, page 4 of the article is a good place from which to progress towards Deep learning. For example, the neural network in the image from that page:

But what if we had more than 1 hidden layer? Now that's classified as deep learning.

A short google search for "deep learning neural networks" gives this handy website. It, too, gives a brief summary of the mathematics, increasing understanding.

After reading these articles and that website, you and your students should be good to go, and start gaining hands-on experience. Usually, the basic example for a deep learning algorithm is to fit a linear function to a dataset of points.

Another article (again, found through google search) explains the subject with more specific information. I recommend reading it to gain greater understand of the subject.

Because links sometimes go broken, it might be a good idea to download those articles (they are pdf files). Then again, they were found with straight forward google searches, so that's more reliable, especially in such a quickly evolving field.

This is a good list of some Deep Learning online courses, most (all?) have free options with ratings.


How to teach so that your student doesn't feel stupid? I'll start by admitting I'm not a teacher. But I am a professional computer programmer with over 20 years of experience and a BS in computer science. I'm also a dad. My daughter is 9 years old and is about to finish 3rd grade.

She does very well in school, her favorite subject is math and for the last year she's participated in a computer club. She enjoys it immensely and is at the top of her class there -- but no thanks to me.

I've tried to talk to her about programming many times, but somehow it just doesn't work. I don't push it either. Recently she made her way into a programming competition final, and we tried to study the previous year's questions for practice. It was difficult. For some reason she kept getting discouraged.

I talked about this to my wife who is also a computer programmer (hey, it runs in the family!) and with whom I've also always had problems whenever I tried to explain her something programming-related. She helped me put the problem into words - at least somewhat.

The idea is that I somehow make it sound... too easy? Like it should be obvious. But when it doesn't immediately click, it makes the listener feel stupid. And that's when learning stops and inecurities kick in.

I do try to be as encouraging as I can. I'm never impatient, I don't chastise (or give any negative feedback at all) and if the first explanation doesn't click, I try to come up with another and another and another. But when you know the subject very well then it's hard to imagine what it's like for someone who doesn't, and to understand just what doesn't click -- especially if they can't explain it themselves.

Atr there any tricks or methods that can help me here? I'd love to teach the subject that we both love to my daughter, but this is an obstacle that I just don't see how to overcome.

The idea is that I somehow make it sound... too easy? Like it should
  be obvious. But when it doesn't immediately click, it makes the
  listener feel stupid. And that's when learning stops and inecurities
  kick in.

This reminds me of the first time I was teaching an intro to programming class and I was going through a live demo of how some code worked. I mistakenly had an error in my code and got a compilation error. One of my students gasped and said, "You get those too?!"

Previously, it hadn't occurred to me that students thought that people who are "good" at programming didn't get errors. They thought there was some inherent quality that I had that prevented me from making errors like they did.

I'd recommend modeling the problem-solving process. Try doing one of the problems yourself and just let her watch and ask questions. Think aloud and describe everything that goes through your head. Even try explaining different approaches you might consider in solving the problem. It helps demystify the problem solving process of programming when novices get to witness your thinking (and debugging) process.

I just simply give you one advice just don't put the burden of work on your students just give them as much work as they can do. And try to do the task step by step in lecture and give them free hand to approach you anytime.

According to me this is the best thing to do. In this way you get attached with your students even with the low ones.


Programming language for teenagers I have been asked to give an introductory programming course for kids between 14-15 years old. Scratch seems like a good option for young children, maybe up to 12 years old. Python, is also a good language for beginners.

I need help from educators to choose between the two options for the mentioned age group. I'm afraid that Scratch might be too childish for them, while Python might be too complicated.

Update

Basically, the course will meet once a week. However, I have relative liberty in deciding how long the session is and how many weeks the course will be. Actually feedback in this regard is also appreciated. I want the session to be long enough to be productive, but not boring long. My initial thought is meeting for 1.5 hours each week for 6 weeks, and then deciding whether follow up course is a good idea.

I can't say much about the background of the kids. This is part of an extra-curricular school that meets every weekend, and I volunteered to give a programming course to the children to make them more interested in technology.

Update2

The age range was a bit different from expected. The kids were between 10-15 years old.

I started the course with Python and used Turtle library to have a visual output. The kids had some progress, but I felt it was slow and it was a bit hard for some of them to grasp some basic concepts.

After five or six weeks, I decided to switch to Scratch. The progress rate improved significantly. However, a few of the kids who were good with Python complained that Scratch is a language for little children that you can't do 'real' things with. It's definitely hard to please everyone.

I highly recommend checking out a language called Processing. Processing is designed for novices, and makes it easy to create visual and interactive programs without a ton of boilerplate.

Here's an example Processing sketch:

void draw() {
  ellipse(mouseX, mouseY, 25, 25);
}

This is a full program that draws a circle wherever the mouse is, 60 times per second.

Related:

Using Processing as an entry point in an Introductory Course
Programming languages specifically designed for beginners
The order of subjects in beginner's curriculum
Order to Teach Topics in an Intro Programming Class
Make it easier, and quicker to get to the start

Shameless self-promotion: I wrote a series of tutorials for Processing available here. I'd love to talk more about using these in a curriculum.

Anything object oriented I would say. Such as java, C#, or Alice!. The reason is the high level concepts are hard to grasp such as threading, loopers, and ect. For example in Java create a object class called animal what can an animal do? eat and sleep, fight ect. Then grow it from there. Once you establish real world applications for the kids concepts such as inheritance(ex. lion inherits from animal because a lion is an animal) and polymorphism(ex. not all animals have the same growl such as a cow says mooo and an lion says rooaar, so like have a method called growl they have to override) are easy to grasp.


Explaining access levels and visibility in OOP While teaching OOP in a high school CS major (in java), it is important (and part of the curriculum in any case) to explain "what is the meaning of this public and private?" (A question voiced by many students).
The usual explanation is a technical one:

Something public is accessible from anywhere.
Something private is, well, private.
protected ??
default access (when no other access modifier is given).

As for protected, the students know about inheritance but the explanation of "it can be accessed by things down the inheritance tree" doesn't really get the idea through. Examples only show it so far and only works for a number of students.
So this got me thinking: How can access levels be explained in an intuitive way to high school students?
Note: I'm not only asking about protected, that is my main problem when explaining access levels.
Clarification
I am talking about access modifiers for objects and methods, not classes:
public class Example extends JFrame{ //the public in this line is not what I'm asking about.
    private int x; //this is the kind of private asked about
    protected void paintComponents(Graphics g){ //and this is also the kind being asked about.

Here's an analogy that I've used for several years, and that students seem to understand. It doesn't focus on the rules, but why we have public and private and protected.

"Most of you know that I live down at the beach. If you find yourself riding past my house, and it's hot outside, you might come to my front door, knock and ask if you could have a soda. I don't live in a gated community, so anyone can come to my front door and knock. My front door is public. However, you can't open the front door, walk right in to my kitchen, open the refrigerator door, and help yourself to a soda! My refrigerator door is not public.

My children and grandchildren, however, who live next door, think nothing of walking into the house and getting anything they like out of the refrigerator. In our house, the refrigerator is protected; my family can directly access it, but the general public cannot.

Not everything in our family is protected, though. My kids know that going upstairs, finding my Visa card, and charging a new book at Amazon, isn't permitted. My Visa card, and the contents of my wallet, are private. No one else can access them directly; they have to make a request."

I think a good way of looking at it is like legislation in the United states. Public would be national law, it impacts everyone in the country. Private is like state or city level law, much smaller scope. Now, all this legislation fits into the protected category because of ex post facto (after the fact in Latin). If you do something legal, and later it becomes illegal, you cannot get charged for the previous action. One can only be charged if the crime is committed after the legislation is passed.

An example:

(PUBLIC, protected) National level: Pot is completely illegal.
(PRIVATE, protected) Colorado: Pot is legal for medicinal and recreative use.


What is a good analogy to introduce databases and SQL? I think that it is vital to introduce each subject area with a few handy, even if limited, images or concepts that make the idea clear. Here is how I introduce SQL (in part):

  SQL takes a set of data and transforms it in to a new set: a two-dimensional result. Stop reading until you have memorized that, because it is the whole point. Every outcome of an SQL statement (with a few exceptions) is a new Table. That table might be printed on the screen and disappear, or it might be stored in to a new table, or it could be used to update an existing table, or it could be used as input to a program which could do… anything. But, it is a two-dimensional table, and nothing more.

I think that this is the very first concept that needs to lodge in their awareness if they are to make any progress at all. Perhaps it is incomplete, incorrect, too literal, doesn't use the right word (the correct word for Table is 'Relation') and so on. But we have to start somewhere.

I'll compare a database table to a table in Excel, because my students are more familiar with Excel. I'll compare SQL to a command line interface, because my students already know about command line interfaces. Are there better metaphors or analogies to teach SQL and relational database concepts?

I think that to understand the SELECT queries, the Who is Who? / Guess Who? game could serve as a nice metaphor.

The idea of the game is: you have a group of pictures of persons with different facial features. One gamer selects one of them and the other gamer has to make questions to try to eliminate the ones that are not relevant and try to guess which one the other gamer has chosen. It is kind of like what you do in the WHERE part of the SELECT...

SELECT faces
FROM board
WHERE hair = white
AND has glasses
AND has a mustache
...

Maybe this game is now so popular currently... it sure was when I was a kid.

I am not an educator, I am just a student. But I was also interested with the idea, so while I was reading books, taking courses, and writing sample programs, I was able to think of one analogy. I am not sure if my answer is correct, I would also like a comment on its correctness. Any ways, I have written an article so read it, correct me and also see if it something you could use. Here is a link


Use of jshell in AP CS A I recently installed jshell in my IDE for use in demoing concepts in AP CS A. It came at just the right time as it was a powerful way to teach ArrayLists and its associated methods required for the AP CS A Exam. Rather than having to compile, run, change, repeat, I could demo the methods dynamically and instantly show students the results in something closer to real time.

As I look ahead both to exam preparation and to next year's iteration of the course, I am wondering how others have used it and where it has been successful for student learning.

What topics in the AP CS A curriculum are best suited to instruction via jshell?

I have found jshell to be very useful.  It can be used to inspect classes quickly and easily.  You can import any standard library class.  You can also import user-generated classes using the /open command.  It can be very helpful in generating test cases.  You can save your explorations to a file by entering /save foo.jsh.  You can place them in a main method and you have documented the vulnerabilities in the class you created, so if something goes wrong down the road, you know where you don't have to look.

I found it very helpful for teaching about workhorse classes such as the wrapper classes, BigInteger, and ArrayList.   It also came in handy for teaching about polymorphism and interfaces.

It will be a valuable asset in the toolbox in my classes.

Let me second BenI.'s post and go a bit further. My own experience with shell environments is that they are frustrating for all but the simplest things. And the APCS course is not about simple things. It is about teaching people to program (in Java) and also a bit about Computer Science in general. While students think a lot about the exam, I'd think, the real goal, as with any AP course, is to give a college level experience in high school.

There are two possible uses of a shell program; in class demos and private self-learning. I think that a shell program is sub-optimal for both.

In a classroom demonstration, it is true that the instructor can quickly set up a simple statement or two and see an immediate result, perhaps in answer to a question. But we, even instructors, do make mistakes, leading to re-doing the illustration (maybe more than once), since it is hard to edit a previous line. This can be boring for students and can take up valuable time. Some demos, in particular, require a certain amount of set-up before you can demo the key idea; populating an array, say.

Moreover, if the demo is quick it is less likely to be internalized by very many students. It leaves no permanent trace, though it can likely be saved. And the line-by-line responses of the shell may actually get in the way of the retention step, since the code that generated the transcript is not all in one place but dispersed throughout it.

The other use is self learning. Here, too, a shell is useful for answering quick questions, but again at the risk of not properly internalizing the result. I think that using a sophisticated IDE is more productive for learning. But not all will serve equally well.

I use Eclipse for nearly everything now. It isn't really an IDE, but, rather, a framework into which you can pour plug-ins to create and modify an IDE. It is usually used for Java programming, but can be used for other languages and even non-programming purposes. But even just as downloaded, it solves the quick-and-dirty demo problem as well as supporting sustained learning.

The reason for this is that it is organized around workspaces. A workspace can contain one or more projects. A project is a collection of files intended to work together, including source files, tests, jar files (for Java libraries, say), design notes, etc.

When working alone or with others you are normally in one workspace developing one project. But you can have another project open at the same instant. The project is called something like DemoCode and contains a class or two that you use for testing ideas quickly. It has a main function and maybe a class or two. In this project you can easily create a method, static or not, and immediately test it by invoking it from main. There are surprisingly few "extra steps" in doing it here rather than from a shell. A click can take you from one project to another, and you can even have files from different projects open simultaneously in the workspace.

Whether done in a shell or in a program framework, you still have to type the code. If you create a method, you need a header, of course, but the name isn't very important since it is a demo. You can also type the instructions directly into main. When it is time for the next demo it is almost trivial to comment-out unneeded statements as Eclipse provides key combinations for commenting a block. You can also set up a common initialization for a collection of fragments. If you want to use a shell to try to understand, say ArrayList, you still need to create the list and populate it. In the IDE this is preserved for the future and can be corrected (edited) if mistakes are made since it is a saved text file.

Moreover, there is no separate compile step in Eclipse, as it normally brings everything up to date on saving a file, which works fine, and instantly, in any project of student scope. Running the program after the first run is via a single mouse click (the first run is a menu selection). It can hardly be easier or quicker.

Moreover (yet again), once you have typed the code into such a demo project it is available to edit in future, say via cut-paste-change, leaving the original in place but helping you with the new. More important, once you have typed the code, and saved it, you have it available for review later to aid your retention. You can also, in fact, copy code from the DemoCode project into the primary project, which is difficult (impossible?) to do from a shell program as the shell responses interfere with the copying.

But, there is another way to use something like Eclipse as it (as others) incorporate the JUnit testing framework in your project. So instead of little code fragments, you can write tests and make assertions about the code. A set of tests can have a common set-up, say defining and populating a List, against which you run several tests, and the individual tests are all run independently of one another. Making assertions about code, I'll suggest, requires a somewhat higher form of understanding than just watching code run.

There are two things supplementing the answering of student questions, whether you use an IDE or a shell. The Oracle Java Docs are online and can be consulted easily, perhaps via a Google Search for some classname or concept.

The other is Stack Exchange itself, especially StackOverflow.


Why did the percentage of CS bachelor's degrees going to women peak in 1984? As shown by the following graph, the percentage of bachelor's degrees going to women in the US has increased over time in almost every major, with the dramatic exception of CS, which peaked in 1984 at 37%, then fell drastically, never to rise again above 20%.

Why are the numbers for CS so different from every other field?

This is relevant to CS education for those who want to make sure that students have equal opportunity regardless of gender.

Clarification

Since some readers seem to have misunderstood my question, let me be explicit that I am not asking why fewer women than men study CS, nor do I mean to imply that people should not be free to change their own majors. I am asking why the proportion of CS bachelor's degrees in the United States going to women fell dramatically after 1984.

Obviously, there is no way to definitively know the answer to this question.  But my favorite theory has to do with the advent of the home PC, and the original marketing of computer games to boys.  The strongest support for this theory is the timing, which means that I must now give the obligatory caveat that correlation is not causation.

Basically, the theory goes like this: as the home PC started to sell, the good folks in marketing had to choose which groups they would target with their limited ad dollars.  The earliest games that came out involved balls and shooting anyway, so young boys were chosen as the target market.  And thus began a generation of young boys who logged hundreds or thousands of hours with computers, with no corresponding boost for the girls.

As this generation of children reached university age, more boys signed up for computing majors, and professors began to tailor their classes towards this majority of people who already had some background.  Girls who did come in often felt like fish out of water (and abandoned the major), leaving us where we are today.

It does not have to be so.  There are inroads being made into this problem, and I am hopeful that with the total infusion of computers into all of our lives that is going on now, the timing is right for this problem to begin to fix itself, as the experience differential has begun to level out.

The real reason is more about the social issues: if you are a smart girl (or a smart boy) the rest see you as something bad (nerd, stuck up or other things), but it is worse for girls.

What you see at home also makes a difference: my mother had a job and she said that I did not need to take crap from any man, so I am the biggest nerd in the planet (and proud of it).


Is it better to lie to students or to be pedantic when teaching Intro CS? When teaching Intro CS in Java, I sometimes tell students things that are not entirely true, such as that, unlike abstract classes, interfaces cannot contain any code. (For those of you unfamiliar with Java, that was true until functional interfaces were added with Java 1.8 in 2014.)

I realize I could put an asterisk on the slide, or visibly cross my fingers, and let students know I'm not telling the full story, but, when I witness other instructors allude to irrelevant advanced material, I view them as pedantic and fear that students find the additional information distracting or confusing.

I don't mean to open a debate on the importance of functional interfaces in Java -- they're just an example. What I'd like to know is if it's considered better to gloss over details in an introductory class or to always speak the whole truth.

Lying is good. But advertise it when you lie. Make sure students make a note of it that you are lying.
Pedantic is bad. If you try to explain everything you will wind up explaining nothing. Let me take a simpler example. In java we have a special incantation
public static void main(String [] args)

We put it in every program. It distinguishes a program. But if you start your java course explaining every part of it you will (a) confuse the juices out of them and (b) never get to the point of writing a useful program. For the beginner, it is just an incantation like
Riddikulus; // used in defence against a Boggart.

The Java code is just a "charm" for the beginner. All you need to say is that it is a "hook" for the OS to find its way into your program. Explain it later after you've taken up some of its elements for other purposes.
Beginners need a simple but coherent view of their language and system. When you simplify, work hard to keep it consistent. But it doesn't need to be complete and certainly not exhaustive.
When you are giving an "overly" simplified view, say that explicitly. Have the students mark their notes with an asterisk (or the above charm) so that they know it isn't complete. If you are explicitly asked for "the rest of the story" you have to decide whether it will help to include it (after the commercial break, of course) or to defer it or to enlighten the students out of the class context (email, say), or give a reference for those who "will not be denied."
I used to start some discussions with "I'm about to lie to you, but it will be helpful if you accept my lie for a bit". Of course I had to remember to come back an fill in the blanks  later, but it might not be for a while. Complex, inter-dependent topics are like that.
tl;dr: Lie, but honestly and truthfully.
And, perhaps the most important caveat, don't lie in such a way that the student later needs to unlearn something. Lying is giving partial truths, or temporary world views, not sending students into mental blind alleys and backwaters. Withholding some facts may be necessary and valuable as is presenting an incomplete metaphor. UnLearning should never be part of learning.
I'll also note that infants learn to speak a native language without everything being explained to them before they begin. The deeper understanding comes to them only gradually and over time. We are actually conditioned by evolution to work this way.

For starters, there is no such thing as an "Intro CS in Java" course, and the word Interface would never come up in such a course anyway.

"Computer Science" means using computers to solve problems.  Nevermind the fact that Java would never have made it out of the gate were it not for being named after a drink we are all addicted to.  Problem solving has nothing to do with Java, and a weighty language like Java has no place in an Intro class, unless your school is pandering to corporations, or Mao Tse Deng has designed your CS program to go from Freshman to Ph.D in three years.

Intro to CS students should be learning about assignment statements, conditional statements, writing small swap functions, learning about basic loops, memory allocation, and then recursion, fractals, string types, and then toward the end, some more interesting and complex functions and a little bigger programs.

Since Java is garbage collected, and its syntax doesn't represent machine code instructions, there is no place for it in an Intro to CS class, or any CS class really.  This is a science class, not a syntax class.  Use C.  If your students are asking about interfaces, then you are doing something very seriously wrong in your intro class.

Now, regarding lying, I don't know if you are a foreign teacher or not, but it's an extremely strange question in the West.  A teacher should NEVER LIE to a student to any degree and for ANY reason.  A student in a classroom is essentially in a hypnotic state of a priori belief in your authority as the true instruction.  Your students will take your lie, or stretching of the truth, at face value, and will cherish that belief FOREVER.  Most humans hold their beliefs not because they make sense, but because that was the first believe introduced to them on a subject.  Very few people every reach logical escape velocity.

By lying, you will destroy the credibility of your colleagues and any future teacher (who does NOT lie) who will teach that student correctly, and thus will contribute in a very dangerous way to the breakdown of the pillars of civil society itself, which rest on the first principal of integrity.


What program follows "hello, world"? You've just demoed your first bit of code in whatever language you're teaching. The requisite "hello, world" has been said. The program has been compiled (or interpreted) and run. Now what?

There has to be a program that follows "hello, world" that builds upon the basics of printing one line on the screen.

What is the logical next step in an introduction to a new language and possibly to programming as a discipline in general? We all know program #0; what's program #1 and why?

Note: I know this is subjective, but I'm hoping it leans the good way. I'm trying to ascertain the scaffolding at an introductory level. Once the cliched example is complete (not that it doesn't have a lot to teach in and of itself), what makes sense as the next curricular step? I think the need for justification based on experience, expertise, and facts helps it from being too broad, but I'm happy to revise if necessary.

When I was teaching and mentoring first-time students, what got them really excited for the first time was seeing their name in lights. Write a program that allows a student to enter their name, then print it on the screen 10 times (or 10,000).

It introduces the concept of variables and variable types
It shows how computers interact with the outside word by accepting input from the students
It introduces basic looping and conditional statements in a really simple example
It shows how math and computation works in a computer without simply spitting out basic algebra.

The best part is the students don't have to understand 100% of the program to start picking out the individual parts. The basic program flow is somewhat intuitive. You can start without the loop and add it in later as you introduce the concepts. This simple exercise is straightforward enough to teach the underlying concepts of how programming works in a somewhat entertaining, interactive application.

Historically, Hello, <name>, but I think I'm going to go with something like hangman, snake, guess the number... I'm leaning more and more to "hacking" existing programs rather than learning bit by bit.


Pedagogical reasoning behind a minor difference in two loops I keep seeing examples like the first program bellow, in teaching materials.
Is there a pedagogical reason to teach this first program, compared to the second?
answer=input("Do you wish to continue?")

while answer == "yes":
    answer=input("Do you wish to continue?")

print ("Good bye")

2nd program
answer="yes"

while answer == "yes":
    answer=input("Do you wish to continue?")

print ("Good bye")

An argument for the 2nd one
I think the 2nd program is more elegant: it has less repeated code.
note: when I wrote this I copied the 1st line into the other 2 places, then when I tested it I discovered that I missed the closing ", so had to fix it 3 times. This is an example of why repeated code is a problem, when a program needs re-editing. In the second version, the only repeated code is "yes", so still some room for improvement.

This is a really good place to introduce boolean variables (or just to use them, if they've already been introduced. It also introduces the idea of descriptive variable names.

user_wishes_to_continue = True

while user_wishes_to_continue:
    answer = raw_input("Do you wish to continue?")
    if answer != "yes":
        user_wishes_to_continue = False

print ("Good bye")

Note: here I use raw_input, which returns the user input as a string, rather than input, which interprets the  user input as python code (meaning that you have to put "yes" with the quotation marks each time.

Sure, start with the infinite loop, then teach ending conditions later. That is kind of how people learn lots of things: eat, later worry about getting overweight. Maybe we should simply teach all the kinds of bugs, then get to how to actually think through a problem later. After all, doctors are taught about all the kinds of diseases. Health is just a byproduct, maybe, eventually.

Structuring thought and approaching a problem are less important than the initial struggle to grasp the idea that some things in life repeat. It will come after a while. If they repeat the struggle enough. Wait...


On studying Computer Science vs. Software Engineering to become a proficient coder I’m mostly interested in the coding aspect of the CS and SE majors curricula. And I’m trying to decide between the two.

Each major has its pros and cons, and they prepare you in very different ways for a career in coding.

Computer science courses that are provided at my local university range from parallel programming to algorithm design. There's also computer organization/architecture and web programming.

It is to my understanding that (some of) these are exclusive to CS.

I know this post might attract subjective opinions but I'm not looking for answers that simply fill in the blanks. Instead I hope for a final answer where perhaps one major is preferred to the other. Is a question of this nature feasible?

You can find a fair amount of information about accredited programs in the US here, including links to schools that have one or the other programs.

In general, Software Engineering is more directed at the processes involved in creating software, and Computer Science is more generally focused on the underlying theory.

But, I'd suggest that both programs have a focus beyond just programming. In fact, you don't need any formal education to be a programmer, so either sort of program will help you develop programming skills. But that isn't the actual main focus of either. For example, an individual programmer may have little need to know about large scale software process so long as they can do their part in the larger scheme of things. He or she may be able to build things while having little understanding of the theory.

I'll also say that a "career" as a coder isn't going to be especially rewarding, either in pay or in responsibility. Many people start out there, but it is much more important, in any field, to know what should be built rather than how to build things. A degree program will give you some insight into the more important problem (though more is needed). But an entry level job after a degree may require programming but if it is the end point then your education was really wasted.

I, myself, sometimes do a lot of coding, but it is never the main thing. It is just a tool that can be used for the realization of something important. Focus on that last part, not the actual coding.

Note that Tim Cook of Apple has recently said that you don't need a degree to be a coder. Actually, though, he meant more than just "coder".

Choose the one that is faster to complete. The programming trends change year by year so it is more important to have more experience. Anyways nowdays you can find online all the things you need to improve yourself.

When I was studying, the waterfall process was the thing, and extreme programming just appeared. Until I finished no one was using waterfall. So no point studyng programming  4-5 years when you can finish in 2-3 and then keep yourself updated with the current trends. Also you will not get much specialized knowledge at uni, but you will have to study yourself, depending on the things you work on. For example, if you are developing a distributed database, you will probably want to study paxos algorithm, but if you are working on a 3D game or developing a software for graphics card, you will need to study shading algorithms.

You should choose the one that is faster to complete, and keep yourself updated with the newest trends. For example nowdays it is serverless development, while if you were studying at uni a couple of years ago, you wouldn't learn about that process. Uni is not very good for our industry because we need to continue learning in order to keep our knowledge up to date. I would even go as far to say that value/cost ratio for studyng CS/SE in Uni is very bad. The best programmers learn continuously without the need for someone to teach them.

I know a lot of great programmers who don't have a degree in CS or SE.

If you are studyng something where you need a lot of expensive equipment (like radiology, specimens, dead people, electronic microscopes, lasers), then it is better to go to uni. But you don't need uni to learn programming processes, languages, architectures etc. On the contrary, you need to keep learning a lot, even after you finish faculty.


Teaching a blind high school student I am teaching a blind high school student in my APCSA class.  All students are using a combination of CodeHS and Project Lead the Way curriculum.  Neither of these are very friendly to my blind student because there are so many visual that his screen reader can't interpret.

Does anyone have experience in this?
I'm looking for something that can be done pretty independently as he will be in the class  with others working on a different curriculum.  I want to support him in his endeavors to become a computer scientist but I don't know where to start as an inexperienced CS teacher myself!

Any help would be greatly appreciated.

A quick online search led me to this.

A Beginner's Guide to Access Technology for Blind Students

It covers all the essentials

Screen Access Software
Braille Embosser
Notetaker
Scanner and Optical Character Recognition

I am essentially listing things from that article It seems like something that was written years ago, but I assume, it should be a good starting point for you.

Further, the city I live in does have a national institute on speech and hearing, which includes folks who are sight challenged. If this is something serious, I can drive up there and talk to someone and hook you up with a professor or something.

The HS curriculum of PLtW appears to use the Python programming language.  Python can be learned and used from a command-line plus text editor, with zero graphics, which is good for screen readers.


What are good sample programs for learning to use a debugger? One skill I teach students in Java 1 is how to use a debugger, specifically:

single-stepping through code
using breakpoints
viewing the values of variables
going up and down the call stack

I have been unable to come up with good programs for them to use when learning to use the debugger. Specifically, I would like to provide them with a program with a bug that they're unlikely to find just by looking at the code but can find with a debugger.

A few Java specific examples come to mind:

Using % with a negative number - I recently came across this and had to remember how Java treats modulus v. remainder (cf. this thread)
Listing switch statements without the proper break; at the end of each case - maybe something that can be seen right away, but stepping through each line would be good to visualize this process
Integer division is also a classic - using the conventional Celcius-to-Fahrenheit (or vice versa) conversion program with the formula broken down over several lines would force them to see line by line what is happening when you evaluate 9/5 or 5/9
Operations with increment/decrement operators in prefix and/or postfix position throughout a program - I like this one a lot because of how variables may change without that change always being seen

I'll edit and add ideas as more occur to me.

I found this nice Java example on Horstmann's web site. A complete example with a variety of exercises. Very well written, as are his books.


What student exercises force them to modify and extend their own thinking process and methods? Beginners in CS will generally benefit from changing and expanding their thinking skills. Some of our thought processes may not be intuitive to a beginner and exercises can help them expand their thinking tool box.

Lectures that make these new ways of thinking explicit can help, of course, but exercises can deepen and reinforce the knowledge. Especially helpful are exercises that lead a student to an a-ha moment in which that was unclear has become clear.

In the context of extending their thinking and problem solving skills, what particular problems and exercises would you suggest to use at the novice level for teaching computer science?

In discussions in the CSEducators Classroom it was originally noted that "puzzle problems" may be especially helpful in this regard - especially those problems for which a person's ordinary intuition might not be helpful, but which lead the student to a deeper understanding of the essence of CS thinking.

Since there are two slightly different questions here

one in the topic

  What student exercises force them to modify and extend their own thinking process and methods?

and one in the detail section

  In the context of extending their thinking and problem solving skills, what particular problems and exercises would you suggest to use at the novice level for teaching computer science?

I am going to give an answer about exercises that focus on problem solving skills. The odd thing when I was building this list is how much it reminded me of those aptitude test they give you in grade school.

When it comes to problem solving one first has to be aware that there is no one way to solving problems that always works and there may not always be an answer to a problem or there may be an answer but getting the answer is not practical.

Algorithms commonly used
Depth First Search
Breath First Search
Divide and Conquer
Inferencing - Analogy: Connecting the dots

and also thinking in orthogonality of dimension/field.

For one of the simplest exercises of using depth first search is the game Unium which is to simply draw a line connecting a set of selected squares. This basically has only one dimension, a line and one method, depth first search. The puzzles get harder and harder, but you basically start drawing the line, see a problem, back up to where the problem occurred and then choose a different option and keep going and repeating until you complete the object and onto the next image to cover. This teaches that for some problems you can go back to a decision and change it to get the correct solution.

For breath first search the game checkers works as you can't make your next move until your opponent has made theirs and so can't resort to DFS. OK I know it really is a min-max game but BFS still applies. This teaches one that you have to look at all options available before moving.

For divide and conquer you will needs something that has simple rules and allows you to move off a sub-problem if it is to hard but still allows you to solve the problem. For this MineSweeper is a good game. This teaches that if you get stuck on something hard try some place else and you can still get the answer; in other words some paths to the solution are easier than others.

For something a little harder try A Good Snowman Is Hard To Build as this requires at least one good a-ha moments to build a snowman. The rules are simple but is uses three dimensions. When I did this with my small class it seemed most of the students had the same a-ha when building a certain snow man because the way to the solution seemed illogical, but until one learned to do the illogical they were stuck. I won't say what lead to the a-ha moment but I suspect that if you play the game you too will be saying a-ha at one point.

So far the way of thinking has been procedural but to add some functional thinking take a look at the Great Permutator as this adds functions, e.g. partition using every other, accumulate, dup, swap among others. I like this one also because you can try out different combinations of the function parts before solving the whole problem.

For a game that adds the dimension of concurrency take a look at SpaceChem. While this doesn't look like programming if you know how to program with locks and fork-join you will see the patterns and the best part is that it is visual. If my teacher had used this when teaching OS design it would have been a lot easier.

Getting back to procedural and adding in variables and the Jump instruction take a look at Human Resource Machine. One of the better parts of this is that it has challenges for the least number of steps and the least number of instructions. The answers to these challenges are not intuitive but get you to realize that machines don't have to work like we think to get a better solution.

For more advanced procedural/functional and back to the essence of what a microprocessor/ALU does check out Silicon Zeroes. This one also covers the idea of parameters and state.

To get out of the algorithm type problems have fun with the Crazy Machine Elements collection. This will make you think and sometimes you can even find solutions that don't use all of the parts. What is nice about these problems is that some of the elements affect others in nonintuitive ways like reversing gravity. This teaches that you can't always have orthogonality of dimension.

When you start playing with the dimension of time things really get interesting but finding a game that is simple but alters just time is not so easy to find, but The Misadventures of P.B. Winterbottom seems to do the trick. This game reminds me of a single person composing a song by recording a melody, playing the melody back and adding on another melody and so on. Get one melody wrong and you have to start over. This is interesting in that it teaches one that time is also a critical dimension for solving some problems.

Speaking of playing with different concepts what about having cooperating concepts? That brings us to Portal and Portal 2. I only wish they took the idea of cooperating concepts further and used other fields such as time, color, etc, and also have them competing some how. This is really interesting because it bring lots of a-ha moments if you don't look for the answers online.

The Turing Test changes out different dimensions/fields for solving the problems in different rooms but makes them harder as you go so that you are continuously being challenged. This helps to teach you that different properties of certain things can be used for other than their primary use, e.g. a block has weight but it can also block a beam.

For more of a real world problem but still simple enough for learning an essential concept common with neural networks being classification would be Papers Please. I have not yet played this one, but if it doesn't live up to what other say I will strike it from the answer.

Another game I have yet to check out but seems to deal with graphs which are essential to so many data structures in computer science is Mini Metro.

For the concept of composition I have on my list Infinifactory; again one I have not personally vetted.

So as you can see to learn how to problem solve start with simple methods and limited dimensions and keep adding on slowly with fun using games and one can learn a lot about problems solving.

In the real world when there are known to be exact solutions to a problem I tend to find that brining in combinatorics helps to solve the problem and one puzzle that quickly jumps to mind here is a Rubik's Cube. If you know the basic moves and how to apply them you can even find God's Number which will teach you a lot of good math and computer programming algorithms.

For more look at puzzle and logic problem books as they have lots of exercises. I did one of these books decades ago using Prolog before it had constraint satisfaction and after seeing how constraint satisfaction worked with Prolog find it to be one of my favorite languages for problem solving when dealing with closed world assumptions.

So by now for problem solving with computers you can see the need for algorithms (methods) and data structures (dimensions/fields) which is why the book Introduction to Algorithms is so popular.

If you have reached this far then check out the book "How to Solve It" by G. Polya. While it is useful to both students and teacher, it is limited in that it was written with math in mind.

If you are learning programming and reading this, I can not stress enough how much you should learn other paradigms of programming, e.g. procedural, functional, logic, and other concepts like matrices in MatLab, neural networks and learn as much math as you can.

One last point that AFAIK seem to be the only one I know who uses this rule when faced with a problem I can't solve. Most advise is to back off, break the problem apart and tackle a simpler part. However at times I find that finding a harder problem and reading about it then makes my problem easier and more enjoyable. So go regularly read about quantum mechanics and theoretical physics, etc., and you hopefully you will see that your problem is not that hard.

I can spend much more time on this question but hopefully I have given you enough to get started and shown you the path to expanding on how to build out ones problem solving toolbox.

I just wanted to put in the word that before people expand their thinking toolbox, they need to have mastered the very first and most essential tool: the concept of named variables and mutability. Without that they will do no better than driver's education students will do with their eyes closed.

I don't understand why the idea of variables and assignment gives people so much trouble, but the evidence is in: it does. Perhaps it is because nothing else in the universe works this way, and so we do not encounter such things in our daily lives. But if students do not learn right away that the whole point of programming is basically this mental game called symbolic thinking -- give a name to an arbitrary idea and then manipulate the contents of the name -- they will fail.

I also do not know the best way to inculcate this understanding. I learned the "Post Office Box Model" sitting in front of a teletype 40 years ago when I was in middle school. Is that the best way? I don't know. Maybe the little 'ding' that the teletype made caused Pavlovian Conditioning, so that I just associated names with content and assignment of variables. If so, we need to dredge up some teletypes, or start ringing little bells in class. But there is no secret to this association, and no way around learning it.

To a kid with a variable, everything is a program. One of my students the other day said in exasperation, "Everything is a variable!" as if he expected that programming would turn out to be something else. It hasn't and won't. Everything (in programming) is indeed a variable.


How can I convince my fellow CS teachers that reaching every student is a worthwhile goal? I tried hard, in the latter part of my career, reach every student in every class period that I taught. That this may be an unreachable goal is of little interest to me. I think that I must do this.

It seems common to teach to some perceived ideal level, especially in courses that depend fundamentally on traditional lecture. Some teachers focus on the best students, hoping the "average" students will do ok and largely ignoring the less-than-average. Some teach to "the middle" - at least, as they perceive it. Few seem to aim for the bottom, leaving the best students to learn on their own.

I want to give everyone something to advance their learning in each class period. Not everyone in a course will want or need the same things.  I want to give them each the things that they will judge valuable. I have a few ideas, most involving active learning techniques and student teams, following a structure into which each student can fit their own goals, and find satisfaction achieving those goals. Traditional A-F grading is a poor vehicle for this.

I don't think spending a lot of effort on reaching the unreachable is productive. Some students will be in your class for the wrong reasons and may be uninterested in any reasonable of success. To make this achievable, make the following assumptions:

The student population is diverse in background, preparedness, skill, and drive.
The students have different personal goals.
All students want to learn
All students can be convinced to put some effort into the process.
It is the student who will judge whether he/she learned something of value.
The "something" learned can be different for each student.

The somewhat transcendental question is: How can I convince others to reach for this goal?  How can we be convinced to try to set the conditions so that they can all be reached - continuously in every class period?

Please don't...

...give the students who are ahead more of the same kind of work to do. Please. That's just boring. If they get it, they get it.
...make groups by mixing the students who are ahead with the students who are behind - often, the students who are ahead won't teach the behind students, but will just do the whole thing themselves. I say this from personal experience, and my friends' experience.
...categorize students by listening to them, or watching them, or their friends, or anything like that. I know one of the shyest people ever in class, but with her friends, she's talkative, and excited about tons of different things. I know another person who isn't classified as "gifted" by my school, but we have had multiple very interesting talks about physics. There's also people out there with autism or Asperger's (I know one there, too) who have a harder time with some things that to us seem "normal" but are actually quite intelligent.
...listen to stereotypes (this goes with the previous point) - the girl in our school that was voted "most likely to be an olympian" is also in the gifted program, and so on. The nerd stereotype also isn't often fulfilled - I have friends who are very intelligent but also dress nicely, do not have trouble with social interaction, etc. Though of course, people can fulfill the nerd stereotype, or whatever stereotype. Just be able to see past that.
...think that those who are a little behind aren't working hard, or aren't interested. There's people out there who don't care, but those people often hide from sight those who do.
...expect less of certain groups. It is hard to rise above expectations. I remember reading about an experiment that was done, where teachers were given a student group (none of whom were gifted) and were told that a few students were gifted. By the end, they were gifted, because the teachers had treated them differently. From personal experience - I've been given assignments that were just kind of easy (for a lot of people). Did those people go for the really hard option (not provided for extra credit)? No. Why would you? I certainly didn't. Have high expectations for everyone. (According to BenI., this is called the Pygmalion Effect.)

Know...

...that reaching every person takes more work than aiming at a medium. There's no curriculum that can be created in advance that will tell you about the student who's got dyslexia, the student who's tired of school because it's too easy, the student who is tired of being looked at as average, the student who has depression...every student is different. These are people we're talking about here, with personalities, hopes, and dreams.
...I have been inspired by teachers. Why is it important to reach every student? Because you will never know what will happen when you do. I once talked to someone who was kind of interested in physics about, I don't even remember, quantum mechanics, I think. I'm definitely a nerd, so I was really excited talking about it. And they said, "You have any books you can loan me?" That was kind of an understatement =P We've had multiple physics conversations since then.
...Be EXCITED! You get to show the next generation why your subject is awesome! I know it sounds exaggerated, but people feed off of excitement. Have you ever been in a baseball game, and the whole crowd is cheering, and even though normally you wouldn't bother, you're up on your feet chanting with everybody? I have a teacher who is so incredibly excited about their class. They joke around, they jump up and they make their point, you can just tell that they love what they do. I mean, you chose this for a job. Make it fun. Love what you do, and I guarantee you people will notice.

Often, an amazing way to persuade people is by showing them. As they say, a picture is worth a thousand words (though I'd say a demonstration is worth ten thousand). So, in this case, try to show other teachers with your class. One of my teachers is kind of an amazing guy. He teaches 8th grade science. So he made up a few songs, and sang them in front of the class (which to a bunch of adolescent awkward teenagers was kind of jaw-dropping), and taught us about the layers of the Earth that way. And he told stories to make a point. I really think everyone in the class liked him, as a person at least. And he told us at the beginning of the year that every one of us could get an A, if we worked hard enough, that he would make sure of that.

And the other thing about this is most teachers, I think, know that they should try to reach everyone. It's a matter of doing it. Another teacher of mine pulled a couple of us aside and told us we were to be her guinea pigs - she was trying to start figuring out a system to start trying to reach some of the different levels of students. So I'd say, most people recognize it - then take the plunge! Ask students to help you out. In the end, though, it's the teacher's choice to do that.

Another thing I should point out - yes, there are kids out there who are total jerks, or who seem not to have picked up that yes, they are in 9th grade, and yes, acting like a 3 year old is no longer an option, but there are also tons of kids out there who are more mature than some adults. Please, don't blow us off.

Unpopular but : Not everyone is the same and reaching "all" is unachievable in the great majority of cases. Live with it. While you never want to leave people behind it's also the responsibility of the weaker students (often merely as a result of lack of application than ability) to keep up - possibly by seeking you out for extra tuition or possibly that 2 minute chat that can "reveal all". You are doing your good students a disservice if you ignore them and "slow up" for political gain and social media darling awards and pats on the back from fellow lecturers who think forging ahead something somehow "bad".