How should floating point inaccuracies be explained and justified? When I first started working with floating point arithmetic, issues like the one illustrated in the sample below both frustrated and confused me:

scala> (1f/3)*3d // admittedly a bit contrived using 1f
res0: Double = 1.0000000298023224
scala> res0 == 1.0
res1: Boolean = false

I was used to mathematics, and a calculator which used fixed point arithmetic - an environment in which the answers were always "right" (to a given number of decimal places)! The way most programming languages handled decimal numbers felt broken and almost certainly useless for storing monetary values or for use in scientific code. I didn't appreciate the trade-off being made in terms of speed and space by taking the approach IEEE 754 did until much later on when I looked at the specification in detail and the analogy with standard scientific form was brought up.

At what stage should students be introduced to how floating point numbers are stored, and (more importantly) how can the motivations for this approach be properly conveyed?

If your students can understand why:

$$\frac{1}{3} = 0.\dot{3}$$

then you can explain simply why floating point calculations are "broken".

When you divide one by three on a simple calculator, you can observe that it usually shows 0.333333333... until it runs out of digits (unless you have a more advanced calculator that can show recurring digits like this).

You can explain that the phenomenon observed here is because of the same thing: one third in floating point is an infinitely repeating sequence:

$$ \frac{1}{3} = 0.0\overline{10}_2$$

If we could store that fully, then multiplying it by three would indeed give us one, as expected. But, like our naive calculator, we don't store all the bits in the sequence, so you end up with a slight inaccuracy. Pointing out that
$ 0.333333333 \times 3 = 0.999999999$ should be enough to illustrate the point that with an infinitely repeating decimal, you will not get the correct answer unless all the digits are taken account of (and you'll always be ever so slightly off the correct value, no matter which approximation you use).

It should then be clear to them that unless you use the exact value of $\frac{1}{3}$ in the binary representation, you will also get inaccuracies.

Something to note is that a finite decimal may be a repeating binary fraction (a significant example is $\frac{1}{10}$, which is $0.1_{10}$, but $0.0\overline{0011}_2$), but not vice versa. Clearly, because of this, seemingly finite decimal numbers added together can lead to an infinite binary fraction, and hence an imprecise answer.

If your students are also familiar with scientific notation, then explaining the floating point system of a significant and mantissa should also be relatively painless. Since floating point can represent both very small and very large numbers, representing numbers as $\text{significand} \times 2^{\text{exponent}}$ is the most flexible option. You need not elaborate much further than that, though, I don't think. As Ben I. mentions, a functional knowledge of floating point is needed, but the internals are probably not needed at this stage.

I don't see any reason why you shouldn't introduce the reason why floating point numbers are inaccurate to them quite early on — it's probably worse not to tell them, and leave them to be very confused when their program doesn't work because of the tiny inaccuracies ruining comparisons.

I think floating-point-gui.de does a great job at explaining, very concisely, without any implementation details (and you can read on about the details if you want). Using that as a resource may be helpful to find the right level to teach.

If you want to give your students something to play around with and get an understanding of the format of IEEE 754 floating point, you could try this floating point number converter which will show the representation of any number you enter.

It might also be wise to introduce a strategy to solve this problem—epsilon values. It should be relatively straightforward to explain that you just compare if a number is 'close' to what you expected with a floating point operation, rather than exactly equal; there are plenty of resources available that explain epsilon values further if necessary.


How can I get through very long and very dry, but also very useful technical documents when learning a new tool? Vulkan is a very useful API for rendering projects, and I would like to learn how to use it as it opens up new possibilities for doing some rendering tricks much more efficiently than in OpenGl.

I am having significant trouble learning it, however. It is a very complex API with many essential details. These details, while useful, are not interesting enough in and of themself to reliably hold my attention for long periods, even if I put in significant effort. I find when I go through the written tutorials that I get very distracted by almost anything.

For example, when I was reading about its mechanism for selecting a GPU in a multi-GPU system instead of focusing on the syntax that I want to learn, I ended up thinking about all the implications of such a selection existing, compared to the fact that it does not in OpenGl. Distractions such as that end up drastically increasing the time that I need to spend on the reading, and skimming is not an option either as the details really are important.

There are also diminishing returns as my ability to use will power to remain focused diminishes much more quickly than I would like it to (I can only get through maybe ~10 pages of this reading in a single sitting while maintaining the focus that I feel is necessary.)

This problem is not unique to Vulkan. I had the same problem, but to a much lesser extent, when learning OpenGl. In that instance, I was able to find video tutorials that explained the necessary concepts very succinctly. This helped both because the explanations were more succinct, with only the necessary information (including theory when appropriate) to use the API (and I could look at written alternatives when I wanted more details).

When I attempted this for Vulkan, however, the only video tutorials that I could find were both outdated and contradicted the text tutorials in a few places, making me very weary of using them as I may pick up bad practices or outdated Vulkan. Video tutorials also work well for me as they keep on moving even if I get temporarily distracted, thus pulling my attention back. When reading, if I get distracted I automatically stop reading.

I would also like to note that this isn't an issue of lazyness; I am willing to put in significant time to do it, but I find that my ability to focus is quickly diminishing.

As such, I ask: How can I learn Vulkan (Ideally, the advice will be applicable to other similar tasks as well) reasonably efficiently and how can I counter the described road-blocks?

Man, I'm right there with you. I understand completely your situation, as I've been there myself many times.

The key, I find, is not reading the tutorials.

Instead, I pick a few projects - starting with something that's "hello, world" level. I google and read enough to be able to do that. Then I pick a slightly harder project - for Vulkan, maybe pick a scene of intermediate difficulty, and google and read enough to do that.

If you keep doing this, you very quickly obtain a practical base of knowledge. There are, however, disadvantages to this - obviously, there will be holes in your knowledge, and you could miss style guidelines depending on what you're looking at to write your code (e.g., when I first learned python, I came into it knowing how to program in javascript - so my first instinct was to write variable names in camelCase, and it was only after several years that I actually read PEP8 and changed to under_scores, though in my defense I didn't even realize style guides were a thing at the time).

You might even wish to go through this approach, and then read through the tutorials with the perspective of someone who's "brushing up" - this might fill in the crevices the more trial and error method doesn't fill.

If, however, you wish to fully work through the documentation straight off, I'd recommend reading a paragraph/section, and writing down something about how you'd use what you just learned about in a real program - i.e., mentally applying the small details. You want to build up a 'web' of details, with lots of connections between the nodes, so that every node is much easier to 'get to' (remember). The more you know, the more you remember (as odd/obvious as that sounds).


Conflicting meaning, between exam board / teaching resources, and technical meaning I will soon be teaching a lesson on ROM, RAM, and virtual memory.

The problem is with “virtual memory”:

Some of the teaching resources correctly use the phrase virtual memory, and physical memory, and describe how virtual is mapped to physical via the memory management unit.

 from https://en.wikipedia.org/wiki/Virtual_memory

The computer's operating system, using a combination of hardware and software, maps memory addresses used by a program, called virtual addresses, into physical addresses in computer memory. Main storage, as seen by a process or task, appears as a contiguous address space or collection of contiguous segments. The operating system manages virtual address spaces and the assignment of real memory to virtual memory. Address translation hardware in the CPU, often referred to as a memory management unit or MMU, automatically translates virtual addresses to physical addresses. Software within the operating system may extend these capabilities to provide a virtual address space that can exceed the capacity of real memory and thus reference more memory than is physically present in the computer.

While in other resources they use the phrase “virtual memory”, and describe “paging”.

  Virtual memory is a section of volatile memory created temporarily on
  the storage drive. It is created when a computer is running many
  processes at once and RAM is running low.

  The operating system makes part of the storage drive available to use
  as RAM. Virtual memory is much slower than main memory because
  processing power is being taken up by moving data around, rather than
  just executing instructions. The guide on operating systems explains
  how the OS manages memory.

Taken from https://www.bbc.co.uk/education/guides/zmb9mp3/revision/8 Though I have seen the same in resources approved by the exam board.

So the question is what do I do in these situations?

The exam board is wrong, but clear about what they think the answer is.
The exam board is unclear about the answer.

Context:

UK England, GCSE / A-Level

You are seeing a difference between virtual memory as described to a computer user some number of years ago (this is more frequently called "swap" now), and virtual memory as understood by an operating system developer.

If one goes back and looks at, say... Mac OS System 7, one can see this description:

  Virtual memory adds more memory to your Macintosh by making use of unused free space on the hard drive. Because the extra memory comes from the hard drive, though, it is much slower than the RAM chips.

Or over in retro computing

  To avoid slow performance, Apple suggests that the amount of virtual memory you select be less than the system RAM.

This is the virtual memory as understood by a user.

Virtual memory as understood by a operating system designer and systems programmer deals with the virtual mapping of memory space used by a process to another space that is managed by the operating system.  It is not necessarily on a disk or any other medium.  It is not necessarily continuous in its physical addressing.


Agile / SCRUM Course Structure: Downsides? Resources? I am planning to teach an undergraduate-level course on mobile application development.  I have been thinking about the best way to structure such a course, and am starting to believe that an agile approach might have merit.
The idea is:

Start the semester with a fully populated product backlog that lists all the components of the curriculum.

This means user story statements, detailed descriptions, story point values, and acceptance criteria are all detailed.

At the beginning of each week's session,

get the product owners (the students) to choose the topics for the coming week's lectures and assessment.
do a retrospective on the previous week's outcomes.

Periodically, replan and reschedule the curriculum (backlog).

The students are seniors or juniors and one deliverable for the course is that, by the end, they have written a mobile application that makes use of web services, location services, graphical information display, and a mobile database.
Also, the students should be able to use version control, do an appropriate amount of software and UI/UX design, perform reviews of others' code, incorporate automated and manual testing into their projects.
Because they are nearing the end of their studies, I believe showing them how a "real world" agile project might work in the scope of what they currently do (studying) would be a good secondary goal.
My questions are:

What are the downsides to this approach for the students? For me?
Does anyone have any resources referencing others who have taken this approach?

Update
Sprints
So it looks like, based on the school calendar, that we'll have enough time for an introductory session, four three-week sprints, a final demo session and two floating sessions available or other work.
What is the Product?
So there are two approaches to this:

Assume the "product" is student knowledge about mobile application development and have each student select items from the generic backlog to work on each sprint.

Assume the "product" is a mobile app that must meet certain criteria in terms of functionality and have each student define their app, which will then produce user stories.

Product: Student Knowledge
This can be seen as subvert[ing] the very purpose and essence of agile development, as Buffy noted.
If done properly, this might not be the case: the aim is to fill in each student's knowledge gaps.  That will need to be highly adaptive per student and, probably, per topic area.
If I'm the product owner then I get to say whether they've met the acceptance criteria --- they know enough about the topic of the user story.
If, instead, we get another student to be the product owner (or perhaps "QA" with delegation from me as PO), then the idea of pairing can be brought in as the student will have to come to some mutual understanding of the "definition of done".
Acceptance Criteria
Examples of User Stories
Product: Mobile App
If the product is the mobile application, then this simplifies things and makes the agile approach closer to what a software engineer would have to follow in a real work environment.
Here, if I'm the product owner, then I'll need to understand all the possible apps (if the students get to choose their own app idea).
Again, it might be better for that to be delegated to another student or group of students.
Acceptance Criteria
Examples of User Stories

Don't subvert the very purpose and essence of agile development: the ability of the product owner to re-target the project (almost) instantly and make changes and adjustments to the backlog as business conditions dictate. The alternative of specifying everything at the start has failed repeatedly in long running projects in which it makes no sense whatever to follow the initial plan.

Some of what I write below assumes you (or a future reader) is familiar with the terminology and the purpose of the various roles and tasks. To try to be complete would require a text-book.

So....

You need to separate the developer group (Devs) from the product owner (PO) (person or group). I normally do this randomly, but other things might work. The PO has control of the backlog and releases features from it per iteration. The developers don't see the whole thing other than in overview form at the start. If you don't want the Devs to do estimation you aren't doing agile, so they should do that, per iteration for the most currently relevant cards (features). Then they give the PO a "velocity" that will determine how many features can be in the iteration. If you are doing a project in one term, iterations should be short (1 week?) and small. But even if they don't estimate time per task, having been pre-determined, then they should still give velocity, having seen a few of the features desired now. Otherwise they will just be frustrated by too much work in too little time. That leads to burnout and is not agile.

The downside is that the PO doesn't get to develop. That may be an advantage depending on the makeup of your student group, or not. I prefer to be the PO myself so that I can throw in a kink or two along the way.

As ctrl-alt-delor says, you need to prevent speculative, build-ahead, development. You have to be fierce in rejecting all attempts at it. Not showing the entire backlog helps with this, but simply rejecting any feature produced speculatively is needed. The problem is that your students have likely gotten in to one bad habit. They have probably in the past been given partly specified projects and assignments where "creativity" is valued. So they try to get creative, by their own definition, ignoring the needs of the PO. In the real world it seldom works that way (Startups excepted) and you need to learn to work to someone else's vision not your own. So you need to make that work in the class.

The following is speculative and I haven't tried it. If you really want every student to experience every role then do this: Appoint a PO somehow for the first iteration and they hold that role throughout. Accepting or rejecting (with your guidance) backlog items as they are "completed." Then at the end of the iteration rotate roles so that the old PO becomes a developer and some other student takes on the PO role. They will need some time to become familiar with the backlog, however, so it probably can't happen that the iteration ends one day and a new PO takes over and specifies the next iteration immediately. A negative aspect of this is that the old PO will have knowledge they shouldn't have (and wouldn't have) in reality which may make them eager to speculate.

I would also require the "small-ball" skills (sorry, US baseball term) that Extreme Programming suggests. I.e. personal skills: pairing, test first, etc. Pairing will help them teach one another and build team skills.

Another possibility for doing a course on Agile Development, though it doesn't match your stated requirements is as follows. (I say this as others may benefit). Instead of one large project have a bunch of tiny projects with 10 minute features and 30 minute iterations. If you run a course in 3 hour segments this can be made to work. In fact, I know of one real-world outfit that does this sort of thing on real (i.e. large) projects - maybe one hour iterations.  With such a scheme a person is PO for one project but will take a different role the next day.

At some point in any agile course, trying to be realistic, you need to throw a curve-ball (sorry). Change the backlog/project-direction in some fundamental way. Estimate from the current code-base and move on as usual. It really happens that way (experience here) and also shows that the word "agile" actually means something. Trying to make the initial requirements too precise is also a problem/trap  that will encourage speculation. Real agile projects don't work that way. The initial backlog is pretty vague about specifications. It is only as you approach the iteration in which a feature appears that it becomes specific.

You will need to guide the PO so that they do sensible things. You will probably need to be the project Coach. If you need to ease the development you could provide some of the tests (unit tests) to guide the developers. After doing this initially they can take over. But you need to give them advice (as coach) on the quality of their tests.

Note that I've merged ideas from both Scrum and XP here. Scrum works well for the overall management (Backlogs, acceptance...) and XP for the day to day tasks (pairing, testing...). If you don't require day-to-day level skills the students will probably just thrash. Agile requires discipline, which is often missed - especially by those who reject it.

There is more to say, of course. But the bottom line is that to teach agile you need to be agile.


is there any good specific pedagogy research to teach spreadsheets? There is a lot of good research on how to teach introductory programming. But maybe(?) more important to most students is the ability to use a spreadsheet. What is the best way to teach introductory spreadsheets?

While I've never taught spreadsheets to anyone other than myself, I don't think there is any unique magic here. In fact, since a spreadsheet is its own metaphor, the pedagogy should be fairly straight forward. It is like learning any other skill, even swimming.
Lots of practice. Lots of feedback.
What I'd do is create a list of short instructions (lectures or other) followed by a lot of exercises using what was in the recent instructions. The instructions can become increasingly complex as can the exercises. Feedback to students is required for the exercises, perhaps by grading, and perhaps by distributing correct (and maybe incorrect) solutions. The incorrect "solutions" can illustrate common mistakes so as to make them explicit in the minds of the students, thus making them recognizable when they occur in practice.
One sort of exercise you might consider is a "fixer-upper" which is an example of a design pattern of the same name. A Fixer Upper is a partial solution to be completed by the students, or it is a complete solution that has had specific errors introduced that should be found and corrected. It is possible to combine these in a more sophisticated version, though simpler examples should be given at the start.
I would also make sure that the students have access to the documentation of the spreadsheet program and are tested on their understanding of it. This can come by giving exercises that have not had prior instruction other than to point them to the details in the documentation.
For the first exercises it is probably best to test single features, such as summing a column. For later ones, combinations should be introduced.
And if you want to go to extremes, note that some spreadsheet systems are Turing Complete, so it is possible to do arbitrary programming within them. In particular, recursive programs are possible.


Analogy for abstract classes Abstract classes are peculiar things.  Consider:

public abstract class Shape {
    String name;
    protected Point startPoint;

    public Shape(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }

    public abstract double getArea();
}

The classic way to explain them is to say that they are like interfaces, but can implement methods.  But explaining this way seems counter to their essential nature, and forces us to devolve into a series of random-factoid comparisons between interfaces and Abstract classes.  (Interestingly, the JavaDoc commits this particular sin.)  At no point in that discussion do we even try to get at the intuitive heart of what abstract classes really are.

On the other hand, classes can also be declared "abstract" even if everything is fully implemented and there are no abstract methods at all, which the programmer can do simply to make sure that the class cannot be instantiated directly.

This lends itself to a different kind of explanation.  We could say that "Abstract classes represent abstract ideas, so that means that we can't instantiate them, and they can declare methods that must be implemented by child-classes."  But, of course, they can have constructor methods.  This seems mysterious until you realize that they are instantiated during constructor-chaining, so saying that they can't ever be instantiated is really not true.

I can think of no explanation for abstract classes that really gets to their essential nature.  Has anyone else found an elegant way to describe them?

The rules for abstract classes are the same as for other classes, with a few minor differences:

An abstract class may have methods that do not have a body
An abstract class has to be sub-classed, at some level, to a non-abstract class before you can instantiate an object
It is not legal to directly instantiate an object of an abstract class

With an abstract base class that has abstract methods, or methods without bodies, all of those methods must be implemented in the subclass, at some level, before instantiation of an object is allowed.

So, imagine the school's official letterhead. At the top is the school logo, name, address, and maybe their motto. Everyone sending an official letter from the school is supposed to use the same letterhead, and they should use the same style and format as other official letters. Sometimes it's allowed to add to the top, such as when the principal gets to add his name to the letterhead, but others are not supposed to do that. To make it easier for everyone to follow the same format at style, the secretary created a "sample" letter for everyone to use. Still some people just didn't get it right, especially the Athletics Department, who used a totally different letterhead. Finally, to end the problem the principle made one, perfect, letter. Instead of real information, however, he used place holders. It looks something like this:

The School of Choice        $School of Choice$          342-54-87971
15 Our Plaza, NE      $Best Students & Best Teachers$   342-54-87915 fax
Best Town, Milan              $Better Grades$           @school_of_choice

From: {your name here}                                     {today's date}

TO: {name of recipient}
    {address of recipient}
    {address line 2}

Subject: {subject goes here}

{your letter goes here

Mauris ut mattis dolor. Donec mollis arcu a augue varius, eu pharetra
ante gravida. Sed ut posuere mi, vitae luctus urna. Vestibulum porta,
velit quis facilisis hendrerit, nibh magna faucibus urna, a pellentesque
arcu nisi a tortor. Suspendisse nec maximus lorem. Maecenas convallis
lorem quis neque fringilla, sit amet fermentum justo rutrum. Maecenas.

Vivamus elementum consequat semper. Nullam consectetur nunc quis turpis
scelerisque pellentesque. Proin blandit, nulla a imperdiet vestibulum,
odio dui tempor neque, sit amet vehicula magna nibh in tortor. Fusce nec
sapien vitae nibh faucibus hendrerit. Nam fermentum egestas arcu in
vulputate. Proin vulputate metus libero.

}

                                                www.school-of-choice.edu

This "letter" is saved on the school's network where any faculty member can access it, but students cannot. (It wouldn't be right for students to send out "official" letters would it?) The "letter" is also made read only. When a teacher needs to send a note to your parents (oops!) they can Word and load this letter template. They cannot save the template because it's read-only, [it is an abstract letter] but they can save a copy of it with a new name [a subclass of the letter]. Still, if they just printed this, and mailed it, it would look really bad for the teacher [it is still an abstract letter]. In order to make the letter "legal" to send, all the {your name here} type things have to be replaced with real information [replace the abstract methods with real ones]. If the teacher's department has its own web page on the school's site, then it can replace the last line, www.school-of-choice.edu with the full page address www.school-of-choice.edu/comp-sci/ [override a base class method]. Now that everything is replaced it is "legal" to print the letter [instantiate it], and send it to your parents. (Yikes!).


Self Learning Quantum Computing and helpful resources that can aid, guide and teach Quantum Computing from CS&E perspective Most technologists have some basic understanding of quantum computing.
Quantum bits are represented by qubits, and information isn’t simply a
zero or one, it can be both at the same time, representing much more
information.  A quantum effect known as entanglement linking two
particles allows instantaneous communication.
Ultimately, quantum computing promises to be a disruptive technology
with such dramatic speed improvements that real tractable solutions to
hard problems could be solved in hours and days. These same problems
would take hundreds of years to solve on our best supercomputers,
known as a classical computer, by brute-forcing their way searching
through all possible solutions.
...

Reference: Ludlow, Nella. Forbes. Why Quantum Computing's Time Is Now. Feb 24, 2019. Date Accessed - Dec 27, 2020.

Quantum Computing is regarded as one of the most disruptive technology as well as emerging technology[1,2]. This field has attracted a lot of computational startups and investments in the recent years[3, 4, 5]. With such a pretty new field to learn and work on lacks some material/online courses to self learn Quantum Computing from Computer Science and Engineering perspective. So, the question focuses on the good quality resources to/for:

Self-Learning Quantum Computing to build Quantum Computing Simulations on a digital Computer.

Development of software, programming of such computer systems.

Hardware and Physical implementation from the perspective of CS Engineers.

Deployment and Integration (hybrid systems) with Digital Computer.

Related areas of disruption of cryptography, internet, data, AI, etc.

The answers may be answered in the forms of links/resources to - scientific articles, papers, online courses/videos and Books that can aid or teach self learner Quantum Computing.

Bibliography:

Sharma, Vivek. www.marshall.usc.edu. What makes Quantum Computing disruptive?. Oct 23, 2017. Date Accessed - Dec 27, 2020.

The Cipher Brief. www.thecipherbrief.com. Why Should I Care about Quantum Computing?. Mar 19, 2020. Date Accessed - Dec 27, 2020.

Vance, Jeff. Network World. 10 hot quantum-computing startups to watch. Feb 15, 2019. Date Accessed - Dec 27, 2020.

Bajpai, Prableem. Nasdaq. Quantum Computing: How To Invest In It, And Which Companies Are Leading the Way?. Feb 11, 2020. Date Accessed - Dec 27, 2020.

Qureca. Overview on quantum initiatives worldwide. Sept 7, 2020. Date Accessed - Dec 27.

The answer written here has been referenced from some of the leading Quantum Computing research Journals or Publications. The interested readers are advised to visit their website in order to get the rough idea of research trend and field segments before self reading Quantum Computing.
The publications/journals include -  IEEE Quantum, Quantum Information Processing by Springer, Journal of Quantum Computing By Tech Science Press, Quantum Journal and Quantum Computing by IOP [1, 2, 3, 4, 5]. Trends were mainly picked up from Google Scholar, ArXiv Open Access Repos and Online Courses by Reputed Universities.
The interested enthusiast may start from the notes/cheatsheets before moving to books/online course videos.

Methodology
Books were given preference over paper as it can be more helpful for a self learner or anyone needing assistance/help in the field. The main books are solemnly chosen on the basis of higher citations (quality and research impact), whereas reference books on the basis of citations (atleast more than 50 for the given topic) as well as date of publication (newer material given more preference). The order of listing is on the basis of citations only!.
The answer includes video material/courses as well as papers/cheatsheets that'd be helpful for a beginner in an arbitrary order and not in any preference!

Cheatsheets/Notes

Microsoft Research - Quantum Computing

Books

Quantum Computing and Quantum Information :

Quantum Computation and Quantum Information By Michael A. Nielsen & Isaac L. Chuang

Reference Books:

Introduction to Quantum Computation and Quantum Information By Hoi Kwong Lo, Sandu Popescu, Tim Spiller

A First Introduction to Quantum Computing and Information By Bernard Zygelman

Quantum Networking :

Quantum Networking By Rodney Van Meter

Reference Books:

Schrödinger’s Killer App Race to Build the World’s First Quantum Computer By Jonathan P. Dowling

Quantum Artificial Intelligence:
1.Quantum Machine Learning By Siddhartha Bhattacharyya, Indrajit Pan, Ashish Mani, Sourav De, Elizabeth Behrman, Susanta Chakraborti (Eds.)

Reference Books:
1.Supervised Learning with Quantum Computers By Maria Schuld Francesco Petruccione
2.Quantum Machine Learning What Quantum Computing Means to Data Mining By Peter Wittek

Quantum Optics:

A guide to experiments in Quantum Optics By Hans A Bachor, Timothy C Ralph

The Quantum Theory of Light By Rodney Loudon

Simulations and Hardware:

Quantum Optics for Engineers By F.J. Duarte

2.Dancing with Qubits By Robert S Sutor

Quantum Error Correction and Fault Tolerance :

Quantum Error Correction - DA Lidar, TA Brun

Quantum Entanglement:
1.Geometry of Quantum States: An Introduction to Quantum Entanglement By Ingemar Bengtsson, Karol Życzkowski

Important Papers/Resources on Quantum Mechanics

A. EINSTEIN, N. ROSEN and B. PODOLSKY, Phys. Rev. 47, 777 (1935). Can Quantum-Mechanical Description of Physical Reality Be Considered Complete?;

Introduction to Quantum Mechanics By David J. Griffiths

Spontaneous parametric down-conversion

Courses/Video Lectures

Quantum Information and Computing
Quantum Computing

Bibliography

IEEE Quantum. https://quantum.ieee.org/
Quantum Information Processing. https://www.springer.com/journal/11128
Journal of Quantum Computing. https://www.techscience.com/JQC/index.html
Quantum - The open journal for Quantum Science. https://quantum-journal.org/
Quantum computing. https://iopscience.iop.org/article/10.1088/0034-4885/61/2/002/meta


"Franklin" Method for learning good programming? I was reading Ben Franklin's biography(the one by Walter Issacson), and it describes his method for learning to write: he would take excellent essays, jot down the basic ideas, then try to reconstruct them some time later and compare his version to the actual essay. It occurred to me that this could fairly easily be applied to programming. Has this kind of technique ever been studied?

(Side question: does anyone know of a library of excellent programs to learn from?)

I have thought it strange that we teach students to write programs before we teach them to read them.

A short time ago I read about some research about this. It stated that the problem is finding good programming works that is of a standard similar to the standard of great literary works. They may exist, but no one has compiled a collection.

They would have to be at least:

Free Software / Open Source.
Well written.
“Reading age” appropriate. (That is programming reading age)

I will try to remember where I read it, and report back.

Could be one of these:
 - Mind-storms — Seymour Papert (page < 116 (I am up to page 116) )
 - Hacking The Curriculum — Ian Living Stone & Shahneila Saeed (page <= 72)
 - Hello Word magazine issue 3
 - Somewhere else.

Sorry I can't find it. It is most likely in the 1st, then the 2nd etc. If I find it then I will update.


Examples of innocent looking faulty code for shock effect I'm becoming more and more convinced that starting with an imperative attitude is not doing a favor to the students, especially if it's all about scheduling and repeating some scanf and printf in loops. I ignore if this teaching technique has any systematic treatment or evidence of efficacy, to me it seems that it produces students unable to process data, as I'll explain soon.

I have a class of students who show the following features, for which I'm unable to find a good framework besides listing them (but perfectly and angrily knowing where they come from):

They are convinced that for (i=0; i<5; i++) return i is going to return 5 results. They are obviously so much confused in thinking that they're doing a minor variation of for (i=0; i<5; i++) printf("%d\n", i).
Given a function that needs X as input they constantly point out to me that somewhere in the first lines we need to read X from somewhere, they just ignore that we can add another argument as needed.
They cannot trace the execution of a for loop, they don't check the loop condition: to them it's just "I do the body N times", I don't yet know what do they think of the index used in the loop besides that it magically happens to take the values 0..N-1.

I'm on the edge of despair. Just showing them how I'd do something and explaining its operational interpretation obviously doesn't work, they even show a sort of resistance to abandon this method of doing any imaginable thing just by throwing scanf's and printf's around. Do you have any suggestions for better framing their difficulties, or any examples that might be illuminating in this situation?

I am finding incredibly difficult to produce some wrong code that might appear correct in their eyes and could possibly shock them and making them understand that things are a bit different from what they believe. Any ideas?

My advice to all of these problems is the same. Your students do not know how to draw out memory. This is a basic technique that most people who have been programming for a while do mentally, but that nearly all students need to be explicitly taught and shown on paper.

How to Draw Memory

There is a good chance that you have seen something like this before. Maybe when you were learning to program, or maybe when watching another instructor teach a beginner class. Drawing memory is about physically (with pencil or chalk) drawing a diagram of the state of the program's memory. For beginner programmers, some things are typically abstracted away, such as the idea of a register and the specifics about how memory is loaded and stored.

I am going to create a short video tutorial, showing how I personally draw memory, including how I draw loops and functions, but here are some basics in text form:

Variable is declared => I write the name of the variable and draw a box with a slash through it to signal that it is Null.
The Variable is defined => I erase the slash and write the value in the box. If the variable is ever reassigned, the value is erased, and the new value is written in its place.
The Variable is a pointer => the box contains an arrow to another, larger box that holds the data.
Loop => I draw loops (and other smaller scope constructs) as circles or "bubbles." At the top are the condition and an iterator value if it's a for loop (the iterator value is drawn like any other variable). An arrow points from the bottom of the loop to the condition. All locally scoped values are drawn inside the circle, and the whole thing is erased once the loop finishes.
Function => I draw functions as large blocks. At the very top, any parameter values are placed in their own box that is linked with an arrow. All locally scoped values, loops, etc. are drawn inside the function block, and the output is linked to the bottom of the box. I typically do not erase function boxes since they are likely to be used again, but you can if you wish.
Print Statements => I find it helpful to have a three-board view when drawing memory. One display contains the code, which we will go through line-by-line. The next display contains my drawing, an abstract representation of what the program "knows." The third contains the text output. This helps students visualize the distinction between what is happening and what is displayed to the console.

How to Teach Drawing Memory

In lecture, you should draw memory constantly. Any time you review what a piece of code does, you should draw it out with and for your students.

Since your students already sort-of know some basics, you will likely need to go back and explicitly teach them how to draw. Talk to them about why it's important to understand what the program knows at any given time and how it flows through lines of code, and ask them to brainstorm some ways to keep track of that.

Then, show them the basics for a very simple program that they understand. Something that declares and defines two variables and uses an if statement. Have them practice the drawing structure in small groups or pairs on a slightly different problem. Switch gears back to your normal lecture topic. The next lecture, have your students tell you how to draw yet another variant on the same few lines of code. If they can do that, introduce the next drawing construct, maybe a while loop. Repeat this slow and methodical process over the course of several lectures until your students are able to draw anything they can code. Then, when you introduce a new concept, you should show them how to draw and visualize it as part of the initial learning.

The goal is to make drawing second nature so that they do it when they hit a bug or look at code that is not their own. Tell them that eventually, they will be good enough at drawing that they can do it in their heads, but that for now, they should always do it on paper or a board so that they can practice. Until they are at least intermediate programmers, you should encourage or even mandate that your students draw the state of memory every time they approach a problem.

As you teach them this important skill, you should have them practice on code that works and on code that does not work. Give them something with a bug- a one-off error, or a logical issue. Tell them to draw it out or do it with them on the board. Once they are done, ask them to tell you what the issue is and how to fix it. Have them draw it again once it's fixed.

Once they know how to draw, you can ask them to do so in all sorts of situations. Put it on a quiz or test. Require a memory drawing before helping with a bug in their projects. Make sure your TAs do the same. Have them continue to draw memory during class, and encourage them to draw out tricky parts of assignments as they work on them.

How Drawing Solves Your Students' Confusion

You gave three specific examples of holes in understanding. Drawing solves all three.

  They are convinced that for (i=0; i<5; i++) return i is going to return 5 results. They are obviously so much confused in thinking that they're doing a minor variation of for (i=0; i<5; i++) printf("%d\n", i).

A drawing of a function only has one return value, and it is at the bottom. They will see clearly that once a value is returned, the function is over. Since they won't reach the return statement until the end, they will return once, the final value of i. Due to erasing past values, they will only see the most recent assignment.

  Given a function that needs X as input they constantly point out to me that somewhere in the first lines we need to read X from somewhere, they just ignore that we can add another argument as needed.

A drawing of a function has input values included. In practicing drawing, you will demonstrate that those inputs can be used as defined variables.

  They cannot trace the execution of a for loop, they don't check the loop condition: to them it's just "I do the body N times", I don't yet know what do they think of the index used in the loop besides that it magically happens to take the values 0..N-1.

Drawing the loop involves updating the iterator each time through. They will never forget again after drawing out a loop that updates 10+ times.

I hope this helps, I will try to upload a rough video tutorial in the next few days and will update my answer with a link.


Is less than comparison more natural than greater than comparison? I was teach on mathematics that on real line small numbers are on left and big numbers are on right. Therefore, I think the comparison 0<1 is more natural than 1>0, and in general, x less than y is easier to read than y greater than x. Is there any statistics if there are less bugs on programs that uses only less than comparisons than programs uses greater than comparisons or both?

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

  Joe is heavier than Bob

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

  Joe weighs more than 90kg

vs.

  90kg is less than Joe weighs

The second one is a very odd sentence.

  [subject] [verb] [object]

[variable] [operator] [constant]

This would be a pretty normal construction, such as:

x < 0

or

x > 0

but odd would be:

0 < x

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

So what if we're comparing two variables?

x < y

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

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

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

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


Grading source code in an online environment In the past students have submitted hardcopy of the programs and output for grading (electronic version was also supplied if I wanted to run the programs).
I always annotated and graded the source listing and associated output on the paper copies that I then returned to students in class. Now with COVID-19 and teaching all online, I will only have Canvas submissions, and I am able/willing to print them as needed, but no way to get feedback/hardcopy easily back to students. This is particularly important for my CS I students.
What are you all doing with regard to this? Annotating paper is the most time efficient way for me to do this. I had one colleague last spring who took images of all the grading and then uploaded a set of .jpgs for each student - a ridiculously time consuming process that she gave up on soon.
Scribbling on source code, circling sections etc is what I'd like to do.
Any suggestions?
Please note that this is mostly for my CS 1 course - many of these students will not have had any programming experience. They will struggle enough with the basics of Eclipse and Java - so I don't necessarily want to burden them with extra technical demands.

I would suggest you use a code review tool. This is something they will likely need to be using when working in industry. So worth upskill them on it now.
You can use githubs one for free.
(You are teaching version control so that should be easy enough)
Get your students to create a pull request and review that.
You can highlite specific lines and put comments against them etc.


Opening a machine learning course in high school I'm a computer science teacher and our department is thinking about opening a data analysis and machine learning course for upperclassmen at my high school.

What are some topics that could be covered in a year long timespan that could be done by students with a basic understanding of Python and basic statistics (correlation/regression, measures of central tendency, hypothesis testing)?

I'm thinking the total time commitment available to students is 3.5 hours a week of in-class time, and approximately 2 to 3 hours a week of coding, learning, or doing homework.

Some topics that we were thinking might be relevant are image processing and natural language processing.

Are there any projects that really hit the ground running in terms of showcasing a topic in machine learning?

There are all sorts of things you could cover — machine learning is an extremely interesting and growing field, with many different approaches and tools you could explore.

Some of the more popular tasks for machine learning algorithms include classification, regression and clustering. Not every application fits into this grouping (e.g. AlphaGo, the Go playing program which beat Lee Se-dol).

I might suggest starting with Naive Bayes classifiers. Your motivating example here could be spam filtering; Naive Bayes classifiers were used in some of the first 'learning' spam filters, dating back to the 1990s. If your students are familiar with Bayes' theorem, the assumptions of NB classifiers shouldn't be a huge leap (you may find this derivation interesting).

There are also various other interesting options such as random forests (apparently used by Quora to find duplicate questions), support vector machines and so forth which could be explored potentially.

Many of the most 'fashionable' techniques involve neural networks, and I would recommend spending a decent amount of time with the theory. Unlike some of the classifiers and regressors I mentioned earlier, neural networks tend to be a bit more involved — a Naive Bayes classifier essentially just needs to be given some data in an appropriate form and is "plug and play", so to speak.

The (free) online book Neural Networks and Deep Learning gives a reasonably accessible explanation of neural networks in their various forms (starting with perceptrons, leading towards sigmoid neurons, gradient descent, backpropagation, deep learning, etc.). As you can imagine, there is an immense amount of content even in just the field of neural networks.

Likely you won't want to cover all of the book's topics, but you don't need to go too far to reach another interesting motivating example: classifying the MNIST dataset of handwritten digits. That's something which is relatively hard traditionally, but much simpler with the usage of a neural network.

Note that I've discussed a lot without ever actually explaining how you could write any programs. Of course, any machine learning class would be a little incomplete if your students had never actually applied their skills.

Since your students know Python, I can highly recommend scikit-learn. It's widely regarded as an exceptionally good ML library, and the API is very friendly — you can almost treat it as LEGO, and plug together the pieces needed to do your classification/regression/clustering... even without really knowing how each piece works entirely. You can get functional (though not exactly effective) solutions simply by connecting the appropriate pieces in a pipeline.

For example, if you wanted to classify some texts, you'd just:

collect some data
setup a Pipeline of a CountVectorizer and a classifer such as LinearSVC
train it, and then test it.

There's an awful lot of stuff included, but then again, all the batteries you'll ever need are included, too.

For playing with neural networks, Keras might be worthwhile.

That said, your students may derive some value from implementing the algorithms themselves, at first. The key is to be able to find truly motivating problems:

  Struggling with a project you care about will teach you far more than working through any number of set problems. Emotional commitment is a key to achieving mastery. (source)

It's not always easy if you're supervising many students, but it is worthwhile advice to consider.


What technique should be used to make video tutorial for BS(CS) students? For students, there are a lot of different tasks which are given by their lecturer.
One of the task is that to make a professional video tutorial of specific topic which is related to Computer Science. And then upload that video on you tube to give help to others students. But there is one problem how to make a good video tutorial which should be understandable to every one who want to watch and get benefit from it. What technique should be applied during making video?

I don't have a lot of good suggestions for you. However, if you really want a professional quality video, you need to use a professional. The videos deployed by Open University UK, for example, are prepared in the BBC studios with large (large) budgets. I assume you have to get by with something less.

Different platforms have different tools, but there are video/audio capture applications for most of them. You might also need to use various camera and microphone setups, including wearable microphones, in order to capture what you want.

But you will still have a big problem. One is that it is difficult to capture audio in such a way that it can be heard and understood by your audience.

A bigger problem is the time (and software) needed to edit what you capture so that it makes sense to the viewer. Pacing and sequencing are very important.

The key to success for do-it-yourself, however, is to use repetition and feedback to learn how to do it, the same way that students learn. Make something with some tools and then get someone to give you feedback on it. Repeat and repeat again until you get it right. Eventually you will make something you like. Or decide to hire a professional.


Algorithmic Game Theory as an undergrad I am an undergrad going into my junior year this semester. I really wanted to explore algorithmic game theory, as my university has some excellent professors in that field. However, as my undergrad is drawing to a close, it is seeming increasingly likely that I will not be able to do this in my undergrad if I don't step up and teach myself the basics. However, looking online, I am unable to find anything "basic" for intro students to the subject. Would you have any recommendations on how to start learning algorithmic game theory?

You could: Try some online classes/tutorials, e.g., on YouTube, read textbooks recommended by university classes (at your level), or buy the highest ranked textbooks on Amazon.


Introducing file systems to students who really don't understand In this question, Michael0x2a points out something that I have observed, but never formally considered (emphasis my own):

  The IDE often introduces several new "metaphors" that need to be explained. (For example, Eclipse has this notion of a "workspace" -- it's not immediately obvious this is actually a folder on your filesystem). This problem is further exacerbated by the fact that a small minority of students don't seem to have a firm grasp of what a filesystem is (which is disconcerting).

I have had, on occasion, to step all the way back to the idea of folders, directories, and directory trees for confused students, but these conversations always get muddled.  In spite of years of teaching this material, I am always surprised when a student cannot tell me what directory he or she is in, nor link the idea of a directory to some sort of metaphorical location.

Our so-called techno-natives have real difficulties with this, since phones and taskbars hide directory structures almost entirely.  This problem is especially easy to spot the first time a student is introduced to a command line, when I may have a conversation like this:

You are currently in your home directory.  Type cd somedir and press enter.  Great!  We have changed our directory to somedir.  Now type cd somesubdir... where are we now?"'

Some students know, but some are genuinely lost.  The idea of going back up a directory cd .., or that ls lists the items at your current location, is so opaque that the question itself doesn't even seem to make sense.

Many beginning students seem to already come in with an intuitive understanding of folders/directories, but some do not. Are there useful analogies or metaphors that you use to teach file systems to your students? Do you address this problem in your classroom, and, if so, how?

The problems

Hierarchies are not obvious

First let me point out that a hierarchy is not the most obvious or best structure for storing files. It is still based on library categorization systems, where a book can be in only one place. I file could be indexed in more than one place (and sometimes is).

A tag system as used on this-site, gmail and elsewhere, that allows you to give multiple tags to a file, is better. E.g Tag something as education, computers, file-systems, cats, boxes.

Tags should be arranged hierarchically, not files. However as educators there is little we can do about this.

Microsoft's Windows, Mac OS X, Android, and iOS hide things

Of the big four major proprietary Operating Systems (Windows, OS X, Android, iOS), Microsoft's Windows hides the directory structure the least. Apple is probably the big villain here. They made an active decision starting with the iPod and iTunes that directories needed to be hidden, and the world has been moving that way ever since.

What I say in this section applies generally to all 4, but I have given specific example for Microsoft's Windows.

MS-Windows has some strange non-folder folders (Desktop, Documents, Videos, Music), sort of like symbolic links but not. This causes problems of understanding. For example, I have used a tool and known that it has saved to Images, but have taken over 10 minutes to retrieve the file, as I did not know where on the file-system it was.

Recent versions of MS-Windows have dropped the ⬆ up arrow (I think they then brought it back again), in file explorer.
It only has ⬅ ➡ left and right arrows. This makes it difficult to navigate and experience the hierarchy.

Recent versions of MS-Windows, by default hide file extensions. This may not affect understanding of hierarchy but dose affect understanding of file names. (While I agree that file extensions to encode file type are a bad idea, hiding them under the carpet is just making it worse.)

Microsoft wants to store pictures with pictures, music with music, spreadsheets with spreadsheets. I want to store teaching stuff with teaching stuff: A class may have a presentation, a work sheet, some images, some source code, etc. it all needs to be kept together.

Some solutions

A teaching metaphor

I have taught some year 7 pupils (age 11 years old), by showing them a set of slide and telling them a story. The story was about how you can but a box in a box, and a box in a box in a box, and several boxes in a box. Boxes have names/labels, cats have names/collars. You can also put a cat in a box, but you must never try to put a box in a cat. Boxes are like folders/directories, cats are like files.

You can ask students: “Can a box be in more that one box?”, “Can a cat be, fully, in more than one box?”, “Can a box and a cat be in the same box?” …

If using Microsoft's Windows

Disable hide file extensions
Install classic start menu, it will enable ⬆ up arrow for folder navigation.
Do something about these Libraries (non-folder folders): In my Virtual Machine with Windows-7, I have disabled all of the libraries.

Learn the file-system and operating system.

I would teach the Unix command line (UNIX, Gnu/Linux, BSD). It does makes it easier to see how things work. Nothing is hidden, but things are often nicely abstracted. “It is so simple that, if you come up with a metaphor to explain how it works, it probably is how it works.” — miss-quoted from one of the founders of Unix (Thomas, Ritche or other).

I would also recommend using the dolphin file browser. Dolphin has an integrated command line, where directory changes are synchronised in both directions. This makes it easier to switch back and forth between text (command line) and graphical view and/or controller.

  You are currently in your home directory. Type cd «somedir» and press
  enter.

See the change in the Graphical part of the display.

  Click on a directory

See the change, in both GUI and command line

Gnu/Linux with KDE, has a great GUI, and command line. Intuitive, simple, and follows the principle of least surprise.

Gnu/Linux is more available (When compared to some other OSs e.g. MacOS, Microsoft's Windows) : You have the freedom to download it. Run it. Distribute it. Study it. Modify it.


Teaching Induction to Prove the Correctness of Algorithms This is a subject that I have had a lot of trouble clarifying for students.  I can explain the components well enough, but I have trouble getting kids to connect the big picture of the proof to the smaller parts. Finding a good loop invariant almost seems more art than science, and while I can find them myself, I am at a loss with how to break that step down into coherent procedural steps.

So, the question is this: how do you go about teaching Induction so that it is both intuitive and masterable?

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

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

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

Then, loop invariants.

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

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

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

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

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

Now, it is probably time for some complexer examples.


How to convince students that self learning is an important skill? I am teaching beginner programmers with a variety of backgrounds.  Towards the end of the course, we encourage more independent and team based learning rather than lecture based learning.  This is purposeful and many students do understand the benefits.  Some of which are:

learning how to learn
reading technical documentation
finding and vetting resources
discussing and sharing with others

There are only a few days towards the end of the course where the students truly research a topic themselves or teach one another, but even so, there are always 1 or 2 students who feel that they are wasting their time or that they are there to be taught and not learn stuff on their own.

What are some ways that I can highlight to students that learning how to learn a new technology (by using its documentation, online resources and your peers) is skill worth practicing for software developers?

In a few days there is almost nothing you can do. Certainly you can't change their habits and attitudes about how to learn in just a few days. You can try, however, to change their behavior by making their current behavior unprofitable. If it is still possible, make the final work an important part of the evaluation. But that is only a band-aid on the problem, not a cure.

It is true that a number of students want to "be learned". I tell students that "I can't learn you." But my own behavior, not just talk, has to reinforce that. If I teach primarily through lectures and evaluate them based mostly on what they can retain from the lectures, then it is perfectly natural that they take a fairly (or completely) passive role in a course, leaving all of the "learning" up to me.

But if you teach the course again, you can start early and come to a real solution - of behavior, at least, and possibly attitude. Rather than give lectures, give projects, from the beginning. Answer questions often, if not always, not with the answer, but with the strategy for getting the answer. To be successful they will need to change behaviors learned in other courses that aren't very effective in the long run. With adult students the effect is probably even stronger, as they have a longer history of passive learning.

So, from the beginning, stress projects, teamwork, finding your own answers, verifying your own programs, telling you things rather than asking you things, and so on and so forth.

Search around for "Active Learning" and learn to teach in a compatible way.


How to use CSS diner to teach beginners in CSS CSS diner is a game for learning CSS selectors.
But it goes "into the woods" relatively quickly, focusing more on breath of selectors than on mastery of fundamentals
Can it be productively used to teach CSS for beginers?

(as promissed in another question, this is my answer)
focus only on the starting exercices (I go from 1 to 11)
first teach the theory .class, #id, tag, and the selectors for and, or and child (ie p .some_child)
Then allow them to to the exercices; and after do them together
You can often solve one exercise in multiple ways. While this does not help the concept the exercise wants to teach, and sometimes is not very semantical (say, for example, selecting all apples inside plates and all pickes inside plates, when you wanted everything inside a plate) it helps reinforce the selectors


"Computer sciency" and "practical" exercices involving dictionaries I am teaching a course in data structures to a 2o semester.

We hear often that the dictionary is a very versatile data structure, and solves quite so many problems. I'd like to illustrate that, but, unfortunately, find myself lacking some interesting problems.

I am looking for two kinds of problems: "computer sciency" and more "practical".

For a "computer sciency" example, I already have "anagrams", in which you count the letters of two strings to check if they are anagrams of each other.

For a more "practical" example, I already have a dependency tree: You have a discipline, and it lists its name, its code and the codes of its dependencies, and the point is to print a tree of dependencies, using indentation.

I'd love more ideas, though.

Some project ideas:

Implement a very basic programming language. Write the parser for them, but have them manipulate the AST (eval expressions, perform constant folding, etc). (So hey, trees are a thing...) And of course, all programming languages have variables. How do we store variables? Hey, wouldn't having dictionaries be useful...?
Use dictionaries to implement a "sparse vector" class. Use the sparse vector class to implement TF-IDF and cosine similarity. Then, use TF-IDF/cosine similarity to implement a search engine. If the students are unfamiliar with linear algebra, you can skip the "sparse vector" bit and have them implement TF-IDF directly.

Bonus! Have the students also implement page rank, which ties in to graphs.

(Want to integrate even more concepts? Have them write their own sorting algorithms to sort the final results. Go even further? Rather then using a sorting algorithm, have them implement top-k-sort on top of a heap so they efficiently select just the top k results in worst-case O(nlog(k)) time.)
Have them implement literally anything related to graphs. After all, you can pretty much always get away with implementing an adjacency list as just a dictionary of keys to some collection (a list or a set). This means that any problem where you manipulate an adjacency list can also be a dictionary assignment in disguise.

And there's a huge wealth of interesting graph problems out there -- have them implement pathfinding on a map of your local city using Dijkstra's, have them generate interesting and randomized mazes by adapting some MST algorithm, have them analyze a DAG, etc...
If you also want to integrate a bit of systems, you could maybe have the students implement a simplified version of Git. After all, git is just a DAG and all graph problems can be turned into dictionary problems. (It's also an interesting application of hashing!)

You'll probably need to give them code to do file IO for them, and maybe handwave or simplify the whole merge business, depending on how complicated it ends up being. (Or maybe not? I don't know much about the merge algorithms git uses, but it's entirely possible they could end up being interesting applications of dictionaries in their own right.)
A simpler assignment (more for CS 2 students): have the students read in simplified grammars in BNF format. Then, recursively (and randomly) traverse that grammar and generate some output. Have the students invent their own grammar -- there's room for creativity here. You could generate randomized poetry, randomized programs, etc...
Have the students do something with n-grams and Markov chains. As before, this is really just a graphs assignment in disguise -- each node is an n-gram; you store a weighted edge from one n-gram to the next.

If you want to stick with the whole "secretly a graphs" thing but keep the math part light, have the students use Markov chains to generate text. You can have a lot of fun with this -- feed in Shakespeare to generate vaguely Shakespeare-ish text, feed in your Facebook data to generate text that sounds like you... You can also experiment with doing this on a character level and try feeding in corpuses from different languages. As it turns out, auto-generated English is pretty distinct from auto-generated French.

The algorithm to do this ends up being pretty similar to how you do the BNF thing since it's just randomized graph traversal. If you wanted to make a point about the importance of abstracting and refactoring code/adapting to sudden changes in the project spec, you could perhaps tie it in here (though tbh it feels a little contrived/might be more trouble then it's worth though).

Alternatively, if you want to avoid graphs but don't mind bringing in some stats, have them do basic basic classification instead, and give them a taste of machine learning. (E.g. can you classify spam emails vs non-spam emails? Can you classify which human language some text likely came from based on letter frequencies, character n-grams, and so forth?).

My memory is a little hazy here, but I think you don't really need a graph (explicit or implicit) and just need a way of storing a discrete probability distribution. (And a dictionary is great way of doing that -- map n-grams to the probability that n-gram occurs.)

Disclosure: I did variations of assignments 1, 2, and 3 for a data structures course I just finished teaching + made them multi-week partner projects. They went reasonably well, though #1 may have been a tad ambitious.


Analogy to teach beginners the concept of interrupt What will be a simple analogy to use in teaching non-CS people the concept of interrupt as part of OS topic?

Fire alarm goes off during exam.

Nasty uncle Ben shows up in the middle of supper.

Tire blows out while driving.

Student raises hand during lecture.

Baby wakes up in the night, screaming.

Anything in general, that happens without warning and that requires attention or action of some kind.


Ruby backend framework choice: Ruby on Rails vs Sinatra In Ruby, the vast majority of usage is in web backends, 99% of the time with a framework called Ruby on Rails. My problem with rails is that it is full of "magic," wherein you type a command, and suddenly 100 LoC are written for you, or where magic methods make forms for you that include both your JS and CSS. There is another framework called Sinatra which is much closer to the reality of what is happening. I really like that it doesn't have very much "magic," but it also isn't used very much in the real world.

Which would be a better choice for introducing students to Ruby backend web development?

Personally, I'd introduce Sinatra first.

Which one of these is going to be easier to explain? Sinatra's "Hello World" example...

require 'sinatra'

get '/' do
  'Hello world!'
end

Or all the boilerplate that Rails generates...

$ rails new commandsapp
 create
 create  README.md
 create  Rakefile
 create  config.ru
 create  .gitignore
 create  Gemfile
 create  app
 ...
 create  tmp/cache
 ...
    run  bundle install

(and that's just from the script that generates everything!)

I would imagine that Rails would feel a little bit overwhelming for a beginner to web development. It brings a lot of baggage with it, like the MVC pattern and a lot of handy generators that are useful to experienced developers, but hide the logic to a learner.

It seems logical to me to teach using Sinatra first, and then let your students realise what the problems are. They'll be more inclined to go through the process of learning Rails, with all the extra boilerplate involved, if they see why using an opinionated MVC framework is useful.

For trivial backend applications, like you'll probably be developing at first, RoR is overkill, and there are too many concepts that you'd have to teach before actually getting to make anything. I'm a fan of teaching from the basics in this case—showing why each additional layer of libraries and frameworks is needed is far more valuable thank saving some time by skipping Sinatra. And, of course, the motivation to make something can be more easily satisfied by starting with Sinatra, and you can later introduce the 'batteries included' framework of Rails.


How can I credit to sources I'll use for my paid or free video tutorials on YouTube or Udemy? I don't remember that I saw sources section on Udemy tutorials or YouTube videos, whether they are a course or not. Even, on books such as,

https://www.unf.edu/~wkloster/2220/ppts/cprogramming_tutorial.pdf
https://cs.brown.edu/courses/cs173/2012/book/book.pdf
http://lug.cs.uic.edu/wiki/lib/exe/fetch.php?media=cybersecurity_for_dummies._palo_alto_networks_edition_by_miller_l.c._z-lib.org_.pdf

Nevertheless, I really care about plagiarism, ethics, copyright and any other rights of the people or companies and need help for following topic.

I am a computer engineer and I'll generate free or paid courses / videos in the informatics sector such as computer usage, programming, network administration, etc. on Udemy or YouTube.
These courses completely will be generated combination of the Turkish and English information on the web (to generate high quality courses) such as pdfs published by universities as above, videos, official websites (such as microsoft.com, apple.com, etc.), blogs, wikipedia, articles, etc. and will be published as Turkish.
I know that I can't add directly bulk texts, images, video parts from different sources, etc. However, I need to add similar things to them to explain a topic. And I know that I can't tell an article's result is my work, etc.
I plan to use a slider software for definitions section of the videos. However, I don't think every video will have this section. And I plan to tell what I understand from the sources with different words or sentences and add different examples as much as I can.
Does my plan considered as stealing, non-ethical, plagiarism or copyright or any other right issue in this case? Do I need to credit every word or sentence seperately? How can I do this in a video?
Or is it enough to add all of the links in bulk used to generate the course / video at the end of it? Do I need to specify author name, date, etc. of my sources as in academic paper? If yes, which standard should I follow?

The most general rule is that once you cite, you are no longer plagiarizing.  You can submit someone else's entire paper, and as long as you (very clearly) note that you didn't write a word of it, and that it was someone else's paper that you found interesting, you are no longer plagiarizing, as you are no longer representing someone else's work as your own.
The standards for citation are different in different settings.  In fully formal papers, you need to cite fact-by-fact, because every contribution needs to be traced directly.  In a video, it is sufficient to say that what you're presenting isn't developed by you, but really the work of other incredible people, and that you will link to those sources at the bottom of the video.  Again, the standard is whether you represent the work as your own or not.
A setting like an instructional video does not need (and typically does not support) each fact being separately cited.  Further, no one would expect it, any more than they would expect it in a lecture at university.
Good luck creating your course!


How is your teaching affected by how you learned? I constantly have to struggle with freeing myself from two hindrances to my teaching: 1) The way I learned about computers, starting almost 40 years ago, and, 2) Amnesia of how I learned some concepts (like variables) that seem just too obvious now.

Initially, I taught myself most of the time, long before I started college. Mostly I wrote simple self-challenge projects to print shapes on a PDP-11 terminal, because bigger kids monopolized the 2 Apple ][s at my high school. I had no internet (it came along after I was a 'Senior' Programmer Analyst), no textbooks, no magazines even, and no one I knew had any interest. So, my co-instructor often says that she has never met anyone else self-taught to that degree. I both remember how I learned, and cannot recall not understanding basic (ha ha) concepts.

So now, I am faced with people with no such strong drive to learn for its own sake, people with no desire to get shapes to print on the screen (but it is so much fun!) and the internet lapping at their screens. The final blow was seeing how the Visual Studio AutoCorrupt is tormenting them before they can even finish typing a single line! "Crush, Kill, Destroy!" (famous quote from Lost In Space. Even my jokes are old.)

With my co-instructor, we bring two radically different backgrounds and approaches to teaching. It is like a marriage of a rational person and an intuitive one (me, if you can't tell by my writing). But we are both a bit lost about how to motivate students to work through discovering an algorithm for themselves instead of "Bad artists copy, Great artists steal." (Picasso)

How do you teach, differently from how you learned? How do you overcome your own blinders?

Basically, you have to throw away your preconceptions and develop and refine new intuitions based on your teaching experience and your students' backgrounds.

When I started off teaching I was severely limited by an expectation that I'd be teaching students much like myself - students who enjoyed math and abstract problem-solving, and who had some kind of background or at least prior interest in programming (I started off at age 10 in BASIC on my Commodore 64).  When that wasn't the case I found myself in a bit of trouble.

The way I teach now involves collecting and analyzing student data to find out what their challenges are and experimenting with different ways to help them overcome those challenges, and also what their interests are and how I can change the course to cater more to those interests.  I collect feedback in the form of quizzes and projects but also I just ask the students what was easy for them and what was difficult, what they liked and what they didn't like, and then the next year I modify the course slightly to take all of this feedback into account.

Over time, the course gets better.  I find ways to work around the most difficult material until the students are both conceptually ready for it and confident enough in their programming abilities to actually attempt it and not give up right away when they hit their first bump.  I find ways to include more things of the type that students like and find fun and interesting, even if I personally don't find those things fun or interesting at all.  Programming is so big and flexible that there are usually numerous ways into a problem, and luckily I get to make my own curriculum so I am free to explore all of those ways.

For one example, I've found that my students find variable manipulation and iteration monstrously difficult but have no problem with event-driven programming.  I've therefore had more success when starting students off with simple event-driven projects (like, make a browser-based multiple choice quiz in JavaScript) than with the kinds of math challenges (calculate the nth Fibonacci number) that I enjoyed as a student.  I personally find math problems easier and more rewarding than messy UI stuff and JS DOM manipulation, but the kids seem to really enjoy making a nicely decorated quiz to show off to their friends.  Also, most of my kids hate and fear math, which I find sad but have very little influence over.  I later try to work in simple variable manipulation and iteration by building on students' already successful projects once I have their interest and confidence.

So as a general strategy: Try to vary the order in which concepts are introduced and see if one order works better than another.  Try to identify the conceptual building blocks that students who fail to learn the concepts are lacking, and try to find ways to teach those building blocks - or put off teaching more difficult concepts until students have more confidence and problem-solving experience.  Try to give students projects that both motivate them and teach concepts and skills that you want them to learn.  When in doubt, simpler but more feasible and authentic projects are often better than more rigorous/complex projects that students may not even complete or will complete and then never look at again.  You'll know you're successful when students tell you something like "I made a quiz to teach my little sister the 50 state capitals".


Operating System Concepts by Silberschatz and Galvin, how much down the edition timeline can I go to safely understand the core-concept I am student from CS background and I have Operating Systems in my upcoming semester. A simple search around the internet revealed that that Operating System Concepts by  Silberschatz and Galvin is one of the best ones to follow.
Now the above text is probably in its 10th edition currently. Now I won't be able to afford a physical copy of the latest edition, so I was looking around for few cheap used copies and found abundance of 5th edition and few 6th edition texts.
Are these two older editions still recommended? If I only want to build my basics and I have no prior knowledge of the above subject. Any help shall be greatly appreciated...
$\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad$
$\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad$6th edition
$\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad$
$\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad\quad$5th edition

I don't know this book in particular, but I do know Computer Science text books in general, and offer this advice:
Consider the title: Operating System Concepts. It is about basic and fundamental concepts that underlie operating systems. The basic concepts, the core material of the text, are not going to change much from first edition to the tenth.
You are not being asked to study the text in such detail that you would be able to discover the differences between versions.
Many computer science books do get out of date. If the book was a user manual for Windows or a iMac then having an up to date one might be important, but I suspect not in this case.


Suggestions for encouraging good Coding Practices? From an instructor perspective (Middle School or High School), Is there a method, or a set of guidelines, for grading early coders' projects that could enhance good coding practices as the students advance further into computer science?

Are any "online practice sites" or "auto-graders" worthy enough to look at for daily or lab project/practice?

We use the Eclipse plugin Checkstyle. The plugin is configured with a set of rules (defaults styles are available with the plugin), and then generates a set of warnings for any violations of these rules. Toward the end of our CS1, we introduce students to the tool (the students have been taught our expectations throughout the semester). After they are introduced to the plugin, all of their remaining projects will lose points if they have Checkstyle warnings in their project submission (e.g., one points off per warning to a max of 10 points). Checkstyle gives them immediate feedback as they are writing code (in the same way compiler warnings/errors are presented in Eclipse) with the loss of points as incentive to not just ignore the warnings. This practice is continued in CS2 from the start of the semester.

This experience is at University level, but should be applicable to anyone using Eclipse in an AP CS A or similar course.


How can you efficiently assess students web coding? I've been teaching Java and C# for years and I'll be picking up a web development (HTML, CSS, JS) course in the fall semester because our department is down a faculty member and won't be filling the position.

I can run unit tests on Java and C# to make sure the code students are submitting is correct without an issue, but I don't know how to efficiently assess websites. My school uses Cengage for curriculum delivery and their MindTap product does assessments, but I don't want to rely on that for the primary driver in class for a number of reasons.

How can I efficiently and effectively assess student work other than reading through all their code and observing every web page? There has to be some tool out there that I can work with to do an initial sweep for me... right?

Much less detail than the excellent post by Buffy, but directly to the question. Replace unit tests with validations and linters.

Have the students create all content in distinct files: HTML, CSS, and JS. Any styles or JavaScript in the .html file is invalid for the project(s). There are many validators and linters for all three, as well as for any other "code" you choose to use/allow, such as PHP, Ruby, etc.

Since a unit test only gives go/no-go results, a validator is at least as effective. A visual check of the resulting page/site shouldn't take but a few moments as well. If it validates and looks correct, it must be "right."

If you also wish to instill, or enforce, coding standards, comments, indentation, etc., a linter may help.

Running a series of validators and linters, checking the operations of the page/site, and visually scanning the code should take much less time than grading a paper-based exam, so you are still time ahead. If the students are provided access to similar tools, if not the exact ones, or exact settings you use, they can develop the habit of applying the "test" to their own code as part of their development work-flow.

As an extra note, if you need to compare versions/iterations of their code, you can use a system such as git, which need not be based on GitHub, or even use remote repos at all. Each student can be required to create a GPG key for their project work, and sign their commits. With that system, you can use the built-in diff function to see the changes and be certain who committed what.


Who should own the intellectual property on a program developed in classes? I am aware of some teachers that own or collaborate with IT companies, so sometimes the assignments that they provide, to the students, are supposed to solve a specific problem that the company may have.

Although I believe that it is always better to solve a real problem, than to use the same old training problems, is this ethical?

I know that, probably, the schools have their own intellectual property rules, but who should be the owner of the code?

Can a teacher use the code freely? Can the student use the code freely? What is your experience on this?

Who should and who does are often different. There are laws and contracts to consider as well as "common law." In my own view, forcing a faculty member to give up all rights to the intellectual property (IP) that he/she develops is just wrong. However the law is the law. Contracts intervene. A program developed in a class for a client is normally done under contract and the client likely owns everything. But you know this going in.

However, a faculty member can't, morally at least, appropriate a student's work unless contracts are in place. Faculty member should, of course, give proper attribution for anything used and also seek permission if there is something useful to be reused. I don't think it is wise for a professor to assume otherwise.

One possibly useful suggestion is to ask the students at the beginning of a term to agree that code they write is done so under GPL or similar license. But it needs to be agreed to.

In general, though, "if you create it, you own it". That is probably not universal, but widely held.

In situations in which contract or the law do give faculty rights to IP created by students everyone is better served, I think, if the faculty member still respects the more general rights of the student. Just because you can appropriate someone else's work doesn't imply that you should.

On the other hand, if the professor provides the question and guidance in the solution, he/she may have some IP rights to the product.

For what it is worth, companies also appropriate the work of employees, but under contract. That is mostly well justified and needed, but there are some variations on it that are also immoral in my view. Preventing a researcher from ever working on the same problems after employment ends should not be allowed in a contract and such should be struck down. But, then, I'm not a lawyer or judge.

Beyond the narrow question it is possible to think "outside the box." If a faculty member normally publishes work on a website he/she can, with the student's permission, publish a student's work under the student's name. This gives the student some visibility and adds a bit of the professor's reputation to that of the student, providing a boost.

I've also heard of situations in which a student and prof go into business together based on joint work.


“What do you mean it’s plagiarism? It’s from the docs!” I present to you two scenarios that are different, but not enough to warrant two questions.
Scenario 1: You discover that a student copied some section of the code verbatim from the docs of some relevant (or possibly not-relevant-but-applicable) module. Something more significant than the setup is required (because then this scenario would be too trivial to include).
Scenario 2: For the open source language you choose, the submissions need a convenient interface for an auto-grader. It needs to have a standard library. If not for the fact that it’s part of a larger code base, it would never be segregated. Indeed, it is never meant to be segregated from a larger context. And the student worked around these two coincidences due to oversight by copying this relevant but inaccessible-through-the-normal-interface portion of code into an assignment.
It is safe to assume that these courses are for beginners. We see that the docs or some subsection of the stl wasn’t even an independent function. Or it doesn't have what is required to solve a problem. This means that understanding what is being done is then more critical. What should I say? What should I do?

So, my take on this is to sit down with the student and have roughly this talk:

So, I'm a little disappointed by the lab you handed in, for two reasons.  The first is that it is pushing on the edges of plagiarism.  Now, I'm not going to go through the formal process, and there is going to be no punishment this time.  I am instead assuming that this is a distinction that you were unaware of, and I am going to make sure that you are completely aware of it now:
Plagiarism means passing off someone else's work as your own, and this code isn't really your own, and your source isn't fully cited.  As I said, I'm not going to pursue this further at this time, but in academic work, you should be citing sources for anything that is not entirely your own.
The second reason I'm disappointed is because you've even more deeply misunderstood the purpose of the assignment.  You clearly came in thinking that the purpose here was to accomplish the task.  I know that in industry, the idea is often to just get working code out.  But in spite of what you might think, I actually care very little about [insert the result of the lab here, such as "the number of brick arrangements in this oddly-specified wall" or "whether the character in this game can correctly identify a collision"].  Why do you suppose I created this assignment?  Was it because this is an unsolved puzzle, and there is a pressing need to accomplish this task?
Of course not! These problems have been solved many times before.
The purpose of the task is to help you learn and absorb the material, and to help make you a better student and a more capable person.  The ideas in this lab are foundational, and carefully chosen to help you build up to bigger and more difficult ideas in the future.  I want you to absorb these ideas well enough that you can mentally use them to build those bigger and more complex ideas.  The goal was never this algorithm per se.  The goal has always been mastery, so that you can move on to even bigger and better things with a good chance of success.
I think you can see where I'm going with this.  You have kinda cheated me by giving in work that's only sort of your own, and you have kinda cheated yourself by only sort of wrestling with the topic well enough to master it.
We will survive this today, and we will move forward.  But I need you to understand that this isn't the way to approach lab work.  Can I now trust that I won't get this sort of work turned in again?

... and after the student agrees ...

Good. Labs are for learning. I hope that the rest of your day is pleasant.  Take care, and I will see you again in class.


Which topics should one cover in teaching a course titled “Artificial Intelligence and Machine Learning”? If one has to teach a 15-week course titled "Artificial Intelligence and Machine Learning" to the postgraduate students of Electronic Engineering, what topics should one teach? Assume the students have not learned any dedicated course on AI or Machine Learning before.

Here's my proposal.

A little bit of math to "refresh" the concepts needed in the next module.
A little bit of statistics. This is my opinion can be used to analyze data sets from a statistical point of view, useful for some machine learning trained algorithms.
The basics of one programming language you want to use across the course. Not knowing all the details I would say Python because there are a lot of libraries for ML available.
Main neural networks and examples.
Expert systems. Not very much hype about these currently, but in my opinion a good option.
Machine learning algorithms and examples.


What makes a good explanation? I'm thinking of studying, "What makes a good explanation?" in the context of introductory computer science problems.

I'm wondering if there's any pre-existing dataset containing introductory computer science problems (e.g. for loops), as well as multiple different explanations to each of such questions? Ideally, the explanations would be rated, but I can use a crowdwork service such as Amazon MTurk to generate ratings if they are not.

One example of such a dataset in the language learning area could be Duolingo's comments section, where users can rate comments (which are very often explanations) left by other users in response to questions.

I don't think you're going to find a good data set that contains what you're looking for.

The reason is, teaching and learning are very subjective. I don't think there's any one definition of what makes a "good" explanation. An explanation that I think is helpful might not be very useful for you, and vice-versa.

For example, maybe one person just wants to get something working and doesn't care about what it's doing behind the scenes. For them, a simple "copy this line of code" would be most useful. Compare that to somebody else who is much more interested in the background of why things work. For them, a more in-depth analysis including history and lower-level details would be more useful.

  I can use a crowdwork service such as Amazon MTurk to generate ratings

I don't think you can. The only way you can do this is by having people read the descriptions and then rate them: but based on what? How easy they were to read? How much detail they went into? Whether the person learned something?

Comparing curricula is a bit of an apples and oranges comparison. What would you compare? Student grades?

You might be able to get something vaguely similar to what you're describing if you use Stack Overflow's data. Stack Overflow releases all of its question and answer data, and you can query that. Start here or google "Stack Overflow data" for a ton of results. Maybe take all of the answers to every question tagged with for-loop and compare them based on how many votes they got?

But in the end, learning is subjective, so you aren't going to find an objective data set.


Training students to give better feedback, when remote teaching Sorry if not a question about Computer Science / IT / digital literacy. However I am teaching these, and it is about use of IT (Communication Technology) in teaching.

I have now started to teach multiple people remotely (3 classes of >20, yesterday). Key stage 3 pupils (years 7-9) (ages 11-14 ish).

I have sent them work to do. Some of them just get on with in. Others are having difficulty. The problem that I am having is with feedback.

Some are not telling me what a wonderful job of study they are doing (I found out later).
Some are asking for help, but are not clear "I don't get it!". "I tried it, and it does not work".

How do a train this second group in how to give good feedback. I have no idea what these comments mean. They could mean:

I did it, this was too easy, did I miss something. (I would still want them to express what they did and show evidence of learning).
I don't know what you are asking me to do.
I know what to do, but not how to do it.
I can't open the resource.
I know what to do. I know how to do it. If I was in the classroom, then I could do it, but I can't do it here. Because {I don't have the correct equipment, I don't know how to set it up}.

Since you are working remotely, I might direct them to a Google Form that asks followup questions.  So, if they initially chose "Something doesn't work!" the form would follow up with a series of questions:

What, very specifically, doesn't work?
What is it doing instead?
What have you tried so far?
Please paste only the relevant parts of your source code here.  (Don't give me parts of the source code that you are sure are not relevant!)

It's almost like (gently) easing the kids in to SE norms :)