Slashdot Mirror
Ask Slashdot: Should Coding Exams Be Given on Paper?
Slashdot reader Qbertino is pursuing a comp sci degree -- and got a surprise during the last exam: being asked to write code on paper.
Not that I'd expect an IDE -- it's an exam after all -- but being able to use a screen and a keyboard with a very simple editor should be standard at universities these days... I find this patently absurd in 2018...
What do you think and what are your recent experiences with exams at universities? Is this still standard? What's the point besides annoying students? Did I miss something?
A similar question was asked on Slashdot 16 years ago -- but apparently nothing has changed since 2002.
Leave your best answers in the comments. Should coding exams be given on paper?
What do you think and what are your recent experiences with exams at universities? Is this still standard? What's the point besides annoying students? Did I miss something?
A similar question was asked on Slashdot 16 years ago -- but apparently nothing has changed since 2002.
Leave your best answers in the comments. Should coding exams be given on paper?
Intellisense is the death of programming.
Everything should be done on paper... or VI. Whatever makes life more miserable.
You modern kids and your erasers have it easy. We had to write our exam code using only 1's and 0's and the 1's we had to make by squishing the 0's.
You are going for a computer science degree. You must be able to express your ideas on paper, a white board, napkin, back of your hand, ....anywhere.
The poster apparently needs to transfer to a code monkey program.
I hear DeGree Mill will take anyone with the $$$$ or student loans.
Not that I'd expect an IDE -- it's an exam after all -- but being able to use a screen and a keyboard with a very simple editor should be standard at universities these days... I find this patently absurd in 2018...
Yes you know better than the university when it comes to evaluating your skills. And I find you patently annoying.
I graduated in early 2000s myself. The finals were all on paper. I had a lot of programming related classes. 3-4 of those 2+ hour tests back to back.
Writing small apps, quick sorts, manipulating data structures, you name it. As much as hundreds or even thousands of lines of code handwritten over the course of a few days, every year. My finger had a mark from the pen. And if you made a mistake, not all professors were ok with just drawing arrows to "insert" code, so there was a lot of starting over too.
The challenge in those exams was not figuring out the solution. It was writing it down. I still have nightmares from it to this day.
"Computer Science and Software Development" graduate of 2004 here,
To the question asked: "Should Coding Exams Be Given on Paper?"
Yes.
Does "Coding Exams" mean "being asked to write code on paper"?
No.
The majority of the "coding" portion of my classes was evaluated through assignments, and practical classes.
The exams ask specific things to test your knowledge, and didn't require "writing a program on paper", and if they did, only asked for psuedo-code, not something that would compile.
This question is pointless.
I don't know about the author's instructor or course, but there's generally a point to this.
* Can the student write a correct algorithm, bug-free without the crutch of running the code. Running code often leads to writing code by trial-and-error without much thinking.
* Does the student know the language well enough to write code without the suggestions of an IDE?
* Avoid all technology problems. My computer crashed. My battery's dead. I accidentally deleted the file. I have the wrong version installed.
There are a lot of rules to make sure that exams are fair, auditable and so that it requires at least a modicum of effort to cheat. The University is likely set up so that all exams are paper so setting new rules for one or two classes is going to be an uphill fight at the best of times. Specific issues you will need to resolve:
1. How do you prevent people cheating (USB sticks, Bluetooth, getting access to the Internet, etc.)? Who's time is going to be used to set this up and enforce it?
2. What if someone's computer crashes? What happens if they accidentally knock the reset switch (I have seen this happen in a "practical exam" of this sort)? What if they "accidentally" knock the reset switch?
3. How do you support students who use assisstive technology on computers (screen readers, specific high-visibility colour desktop designs, desktops in other languages, etc.)? How do you deal with students who sent skieing in the holiday before the exams and broke both arms (again, I have seen this -- and we sorted it out)?
4. Where do you draw the line on "reasonable" support? Text editor? IDE? IDE with documentation? IDE with documentation including code samples?
Critically : it depends on what you are trying to assess. I've had interviews where they want code written on the whiteboard -- how is this different?
but it's sort of a moot point since a real computer science curriculum is mostly about math and math can be done on paper just fine.
I suppose if we still had programming vocational schools, but between the H1-Bs and the offshoring they're really just scams at this point. You can count the number of jobs available for that kind of code monkey on one hand of a retired shop teacher.
Hi! I make Firefox Plug-ins. Check 'em out @ https://addons.mozilla.org/en-US/firefox/addon/youtube-mp3-podcaster/
Hereâ(TM)s how Iâ(TM)ve adjuated my teaching practice for a world with smartphones: 1) All my tests are open book/note. In a world where you can lookup anything anytime, knowledge is no longer a valued commodity. However, using knowledge to solve problems is. So all my questions involve higher level thinking, with students able to use their notes. 2) My tests and exams are all done on computer through Google Classroom (when in a lab setting). So thereâ(TM)s always a keyboard and screen. 3) I have my students write code in their assignments with an IDE, not on tests. Writing code without and IDE has always pissed me off. So, my tests/exams involve things like analyzing code, eg: hereâ(TM)s some code, tell me what it does. Or, hereâ(TM)s some code with problems, what are they and/or how can they be fixed. Or, when would you use a while loop vs a do loop? Or a local variable vs a class variable? I must note that this form of teaching is entirely my own, after spending much time reflecting on how I think teaching and schooling must adjust for a world with instantaneous access to endless information. This is not endorsed by my government (Ontario, Canada) or school board, and even many of my colleagues disagree. However, something has to change in education which still uses methods developped over a century ago for chalk and slate! I do espouse these methods when possible, and continually strive to evolve my teaching for an ever evolving world, but I certainly donâ(TM)t think this is the final answer in education methodology. Any further ideas you have would be welcome! At some point I would like to evolve my tests/exams to be âoeopen Googleâ, but frankly have no idea how that would work. But thatâ(TM)s my thoughts on next steps from where I'm at currently.
[I'm a college professor that does a lot of science-related programming, but not a CS prof]
If you get an IDE and/or compiler to test your program, then the exam changes in kind, turning into a practical assessment more than a theoretical one. This is good in some cases, and bad in others, but I would guess that most programming exams with a functioning compiler might as well be a "take home" software project. If you don't get an IDE or compiler, getting an editor is mostly convenience, but the considerations are the same between a cs paper-code exam and a sociology open question exam.
At our university, I would say 90% of our exams are pen-and-paper based. This is annoying for everyone involved, from the student (RSI, more time spent writing than thinking, no longer used to think "linearly", e.g. without quick editing), the professor (bad handwriting, lugging stacks of paper around that you really shouldn't lose, more difficult o spread the work or grade by question) and support/admin (more difficult to archive, more difficult to check samples post hoc, etc).
The reason why? A lot of our university's exams are in the same weeks (to make it easier to mix and match courses), so there is a peak demand for probably well over a thousand exam seats. Normal computer labs aren't really suitable, both in terms of layout and software (to prevent cheating). They have facilities for digital testing, but it's too expensive to provide enough, so the higher priority courses get served first, i.e. exams like applied statistics where you actually use a computer program for the test.
So, yes you're right that it would be a lot nicer if more exams would be computer based, but in most cases CS is no different from e.g. sociology in this respect.
I've tried this all ways: on paper, computers allowed for help (use your IDE, why not, but answers on paper), and I have some quizzes that are purely on the computer. There are two issues to consider here:
- First, and most obviously: cheating. As soon as you allow student-owned electronics, you open the door to connectivity. If not WLAN, than via mobile phones or ad hoc networks or even bluetooth. This is very difficult to control, and is the primary reason that my school still officially prohibits electronics during exams.
- Second, if you're going to allow a computer, you had just as well allow an IDE and make it more "real world". The thing is, this makes exams more difficult for all but the best students. People who are not (yet) very good a programming might be able to show a believable (but uncompilable) concept on paper, and get reasonable partial credit. As soon as they have a computer, it is natural to expect a program to run. The poorer students will lose lots of time trying to get their program to actually work, and are therefore more likely to fail such an exam.
For the last point: I'm not sure this is bad. Personally, I think the world needs a lot fewer mediocre and lousy programmers. However, while that would improve overall software quality, it would mean less code written overall and make software even more expensive than it is.
Enjoy life! This is not a dress rehearsal.
Years ago, at Georgia State U a couple of us going for MS degrees had to take the C++ programming course.
My classmate had an MS EE and had over decade of C++ programming experience. I had a similar amount.
Both of us tried to get out of having to take it and showed our resumes with our years of experience.
Nope. We HAD to have a class in it from an accredited school.
I sat back, did my assignments and only participated when called upon. My classmate had a tendency to point out the instructors (Ph.D. CS) where he was wrong.
Easiest 'A' I have ever got - but pissed at the money I had to spend for the complete waste of time.
So, yes, sometimes we DO know better.
Good times.
Well, that'll weed out the ones stupid enough to use it.
(NOTE: I don't know why an f-ing iPhone can't submit text properly, but here's my response properly formatted.)
Here's how I've adjusted my teaching practice for a world with smartphones:
1) All my tests are open book/note. In a world where you can lookup anything anytime, knowledge is no longer a valued commodity. However, using knowledge to solve problems is. So all my questions involve higher level thinking, with students able to use their notes.
2) My tests and exams are all done on computer through Google Classroom (when in a lab setting). So there's always a keyboard and screen.
3) I have my students write code in their assignments with an IDE, not on tests. Writing code without and IDE has always pissed me off. So, my tests/exams involve things like analyzing code, eg: here's some code, tell me what it does. Or, here's some code with problems, what are they and/or how can they be fixed? Or, when would you use a while loop vs a do loop? Or a local variable vs a class variable?
I must note that this form of teaching is entirely my own, after spending much time reflecting on how I think teaching and schooling must adjust for a world with instantaneous access to endless information.
This is not endorsed by my government (Ontario, Canada) or school board, and even many of my colleagues disagree. However, something has to change in education which still uses methods developed over a century ago for chalk and slate!
I do espouse these methods when possible, and continually strive to evolve my teaching for an ever evolving world, as I certainly don't think this is the final answer in education methodology. Any further ideas you have would be welcome!
At some point I would like to evolve my tests/exams to be "open Google", but frankly have no idea how that would work. However, that's my thoughts on next steps from where I'm at currently.
Hey, I love fountain pens! I own about a dozen. Main problem is cheap paper isn't made for them anymore--the ink feathers.
Cram based tests are stuck in the past and big hand written ones just make it easy to make spelling / spacing / etc errors.
It all depends, are you testing thinking and code fluency or are you testing for IDE automaticity?
I would suspect that through the programming course, the students have already written several programs using the IDE and turned those on to demonstrate their skills.
The paper exam shows their thinking, familiarity, code fluency, and code grammar and syntax proficiency.
As one who writes code, I still think about it on paper before I type it into the computer, especially when writing algorithms.
Planing on paper really reduces bugs and logic problems because it doesn't require technology. If you just sit down and start coding, it is easy to go down rabbit holes of "why doesn't this work" vs. thinking about the problem.
To me it is similar to writing an outline before writing a paper. You know where you are going and how you plan to get there, Sometimes if I am really pressed for time I will just write comments for the code blocks and use that as my plan, then go and fill in the code blocks.
Alternately, should English exams be given on paper or should students use an IDE like Microsoft Word?
That's great! You're reaching your students that knowledge is useless because of course there are never bad answers to anything on the net. They should just cut n paste whatever shit they find in Google from an h1b posting 8 years ago.
I think we should just remember that writing with pen/pencil and paper is an important life skill, and we as humans should try to keep that skill well rehearsed for the sake of the human race. The skill will come in handy if the lights ever go out.
Laws are rules for the court, but merely a bottom bar to hit for life. Think beyond laws in your actions always.
How do they get around disability laws with this? There are a fair number of people that go into computer assisted professions because they have reading and/or writing disorders such as dyslexia or dysgraphia. I'm at a serious disadvantage on a paper test because I have both. Spell check, grammar check, and syntax highlighting are fundamental requirements for me.
That makes the case for being allowed to test out of a class. Which should be allowed for any class that's not core to the curriculum.
Moderating "-1, Disagree" is simple censorship. Have the guts to post your opinion.
Fine if they want it on paper.
But expect bad pseudocode. Any other expectation is not relevant to the medium!
+----------------- | What is the question!
Except for my martial arts exams and my driving license all exams were on paper. ... because we only had 3 or 4 computers in school, and waiting till one was available seemed unplausible ...
And actually when I was young I wrote many programs on paper first
if you can not explain something on paper (I'm not talking full UML 2.x) you likely have not grasped it enough.
Cost free eBook I read (by iBook/Kobo/Amazon/ObookO/Gutenberg etc.): "The Green Odyssey" by Philip Jose Farmer.
>The point of the paper exams was to check if I understood the *concepts*. Yeah, except when the sadistic professor doesn't actually test you for the concepts and fails you for minor errors that you would call a typo on a computer screen. This was my experience.
I have a computer science degree - obtained circa 2001.
None of my exams during the pursuit of my degree used a computer - all exams were done on paper. Demonstrating understanding of data structures, algorithms, complexity analysis and other CS topics is not coding.
Coding is the implementation work of computer science, much like construction is the implementation work of Civil Engineering.
Would you test a Civil Engineering student by asking him/her to build you a bridge?
The test is not fair.
If the partner you are paired with doesn't have the necessary logical-thinking skills, no amount of explanation will make them competently understand an algorithm with any degree of sophistication at all.
And anyway, your ability to explain things well to others is a separate skill from your ability to create, analyze, optimize algorithms. While it is true that you must understand it well in order to explain it well, it is not true that you must explain it well in order to understand it well.
In addition to write the code, the student should also shape it like a tablet.
Points off if the tablet has rounded corners - that infringes on Apple's patent.
... if the purpose of the exam is to determine coding capability?
I agree with the above advantages of paper over typing. However we have to consider clear handwriting, to know if the test-taker wrote the correct operator. The operators less than, open curly brace, open parenthesis, and open square bracket look similar to each other. And a period and comma look similar. So do ! and | .
If a test is on paper, one way to get around clear handwriting problems is to have a multiple-choice question:
How do you express the ith element of myArray?
a) myArray[i]
b) myArray(i)
You are going for a computer science degree. You must be able to express your ideas on paper, a white board, napkin, back of your hand, ....anywhere.
Not only that, but it's a college course run by a professor. The exam format should be the professor's choice, with a very few exceptions mandated by the university. (For example, blind grading most obviously.)
However, the professor should be up-front about the requirement at the beginning of the class, before the student is locked into taking it.
Real lawyers write in C++
Better yet, allow them access to it, have it only display a single random answer to any specific question, and don't provide a compiler to test if it actually works.
Play with my webcams and lights here
I do my OOP exams on paper because I don't care if you can or cannot write correctly in $LANGUAGE. The IDE and stackoverflow will eventually correct your code syntax. What I want to test is whether you can understand what a piece of complex undocumented code does, how do the OOP concepts work in practice* and whether you are capable of designing a software architecture that uses said concepts to solve a non-trivial problem.
If you think a good programmer is somebody that can translate a pseudo-code algorithm into his/her favourite language blindfolded, think again.There will be an AI available on the market that does that quicker and better than you before you hit 40.
* Here's an example in Java:
class A {
public int x;
public A() {
this.x = 0;
inc();
}
public void inc() {
this.x += 1;
}
}
class B extends A {
public B() {
super();
inc();
}
public void inc() {
this.x += 5;
}
public static void main(String[] args) {
B b = new B();
System.out.println(b.x);
}
}
What does that code print and why? You'd be surprised how many students fail a question like that. Now, this is typically a paper question that doesn't make much sense if computers are allowed. However, I think it's a question that makes a clear distinction between the students that truly understood what polymorphism is and those who did not completely, which is a pretty good indication of who is going to design correct programs and who is not....
Video of some good progressive thrash music
The exam was OOP1 and pure code on paper. So your critique doesn't compute.
We suffer more in our imagination than in reality. - Seneca
If you know the language, a solid text editor is the best way to go. For professional programmers, if you take the time to really learn a great editor the code can flow effortlessly, almost as if your brain is wired directly to the output. Think "delete this block" and your fingers automatically do the keystroke to delete a block.
If you DON'T know the language, having autocomplete make suggestions can help as you guess your way through it.
I do turn on syntax highlighting mostly because it provides an obvious cue if I miss a quote or something - half the screen turns red, which looks obviously very different than how it should look after each statement is written. I don't pay any attention to the details of the syntax colors - there is just a difference in what the screen as a whole looks like when there is a syntax error.
Wait, he's complaining that he has to use paper in order to get a piece of paper?
"National Security is the chief cause of national insecurity." - Celine's First Law
Speaking as someone that teaches second semester CS to 300 undergrads a semester, there is value in both.
Advantage Paper: The computer is a crutch. If you know it, you can write it. You are going to to have to do this in coding interviews. Requires no infrastructure to give an exam without cheating. (I actually don't have the space/computers to give a computer exam to hundreds of students at a time.)
Advantage Computer: I/TAs don't have to grade it, I can just use gradescope.com and students won't argue with me for partial credit.
Are taught to write their code away from a computer. It leads to better code. If you can't code away from the machine, you can't code on the machine.
It's a small world and it smells funny; I'd buy another if it wasn't for the money; Take back what I paid (SoM)
Computer science isn't the same as being a code monkey. A good CS student doesn't actually have to be a good programmer. A good programmer needn't know the basics in CS (but it would be useful). Many skilled programmers doesn't even know the specifics of common algorithms and datatypes but know when and how to use them - and that's fine.
You think your better than the rest of the world? Goodluck.
[($)]
It would be interesting to do a study on the extent to which autocomplete is a teacher vs a crutch.
My guess is that the ideal would be a slow-response autocomplete, slow enough that it never appears while typing things you know, and it gives the learner a second to try to remember. If you stop typing mid-word for a few seconds (because you don't know) it prompts you with reminders.
It's language-dependent too. For example, JavaScript was written in a just a few days. Because of that, the order of arguments and such is inconsistent in places. Reminders are needed more than in a more consistent language such as C. C is also a much smaller language, and therefore should be easier to learn quickly.
Mostly because of how slow ACTUAL information flows back to educational institutions, compared to the Internet-Speed changes in the workplace, educational courses are going to lag actual realities of working with technology by 10-20 years minimum.
Hell, to take computer classes back in the late 80's, they were still REQUIRING you to take a typewriting class!
Never mind that you don't use a computer the same way you use a typewriter or even a dedicated word processing machine...
And, after leaving the Army in the mid 90's, I found that college-level courses were barely more sophisticated.
If I wanted to take programming classes, I had to learn how to use OFFICE?
REALLY?
Chas - The one, the only.
THANK GOD!!!
If you know how to code properly...why do you care about the medium used to do so? Writing stuff down actually forces you not to use shortcuts and demonstrates your actual knowledge. Suck it up! :)
Tired of my customary (Score:1)
I hear what you're saying, many of my colleagues initially react in a similar way (though with more professional language, mind you). They make the same initial, and faulty, assumption -- that my students aren't being taught the skills necessary to analyze information for its authenticity/relevance. If I could pick one skill which is most important in our world of FAKE NEWS and biases galore, it would be that.
Although I suppose we could stick to the government-supplied textbook model of information acquisition. Heck, it's worked for over 100 years, why change?
Back in those days, you didn't have a computer in your pocket. I had no computer access until school started in fall (and then it was really limited). So I wrote a threaded-code FORTH kernel in 6502 assembly on lined paper. Then I debugged it and rewrote it a couple times in between milking cows and attending band camp. By the time I had semi-routine computer access again, I had lots of other stuff I wanted to get to, so I never actually saw it in action.
IOW, big deal, a computer scientist makes do with the tools available to build solutions. Even today, decades later, when I want to _really_ get a problem solved rather than just dicking around with it pretending to work, I take some legal pads to a quiet spot with no computer access and get shit done. When you go interview for a job, they also are probably not going to give you an IDE. When you get a job and have a project proposal, they aren't going to sit and watch you screw around in an IDE for a few hours until you start making sense.
My thought exactly. If I were teaching such a course, I'd only allow the students to use a desktop computer with no network connection, and forbid them to use their cellphones during the test so that they can't use them to research things on the net.
Good, inexpensive web hosting
That would be interesting. Mr. Miyagi would suggest that you'd learn better by being forced to go look it up repeatedly. There is some research that suggests you do learn best when things are difficult, but not impossibly difficult.
I was just discussing with the always insightful Angel'o'sphere the possibility that the proliferation of IDEs with autocompletion is at least partially responsible for some of the poor interfaces in libraries and languages. Java apparently has at least three Date classes, all in different places!
Context: i graduated with a CS degree in 1983, and have been doing systems-ish stuff ever since. Compilers/Runtimes/Binary Translation/Interposing&Intercepting user space calls for security purposes. No web-ish stuff all all. Thus: when interviewing candidates for similar positions, debugging skills are key. Which means that general problem solving approaches are critical. Pseudo-code is just fine. Goofs are acceptable, and if the candidate can adapt to changing requirements (aka annoying product requirement changes) that is a big plus. I've recommended "HIRE NOW!" for one guy who got stuck on one part of the puzzle presented, but admitted it, and clearly had an approach outlined to attempting to solve it with more time. Fortunately, we hired him (great contributor)
I teach at a community college, and all of my exams in programming class have been on paper, except one. Before this exam, I showed students on the overhead that I could see their desktops on my computer. I required them all to leave the IDE maximized (I use the VPL plugin in Moodle). One student did extensive browsing and copying from the net anyway, and I witnessed it. He dropped shortly thereafter, and I returned to paper-only exams forever.
The trick is to condition your students to writing on paper. If you don't, most will fail because going from hours of staring at a computer screen to writing on paper is very unsettling. So I give students a 5-10 minute written quiz every class meeting (twice weekly). It seems to work, and although almost every student fails some quizzes, the exam grades are pretty good, on average, compared to semesters when I didn't give daily quizzes. (Quizzes are weighted 10%, exams 50% (2 during term, 1 final), projects 40%.) Of course, this quadrupled the grading I normally do (50 students), but I think it is very rewarding for myself and the students.
As a student this also annoyed the heck out of me. After all, you'll never be without a computer when you're the programmer -- whether it's 1995 or 2018.
As a professional programmer I found great value in being able to write "stream of consciousness" code which compiles, runs, and does what I want it to do.
Over the years, I realized that the only way to get my code to work each time is to be able to write and debug it on paper -- and to master the syntax of the language to the level of not needing the compiler.
So now I give exams on paper and have recently taken away the cheat sheets which I used to allow.
That being said, most of my intro programming classes focus on projects, assignments, and actually writing code during class. It is ABSOLUTELY pointless to have a paper only CS class. I also don't take off too many points for syntax and allow my students to define helper functions during exams without writing the bodies of the functions.
You can (very inefficiently) get code to work by trial and error -- and you HAVE to do this when you're learning.
However, if you can't at least provide the basic idea of what you're trying to do on paper, you haven't mastered the language or the content of the class.
Why not head over to their departments in your university and see how those degree candidates write up their exams:
English Litrrature - paper
Physics - paper
Chemistry - paper
Math - paper
Psychology - paper
Astronomy - paper
Biology - paper
Etc.
Why is Comp Sci different?
Ken
The good point for paper is that students cannot destroy their work by issuing a wrong rm command (with the intent of cleaning up their directory from object files).
My exams were on paper - and my data structures course was also open book, open note.
The professor wanted open book, open note because it let him ask more interesting questions. He wanted to have the exam in the lab so he could ask questions that were even MORE interesting; however, there wasn't a lab big enough where everyone could take the exam at the same time. (I think this is better than having people take it remotely as it helps prevent cheating.)
Also, exact syntax mattered on our exams. Which didn't make things harder - it just made you a LOT more careful about what you put down. If you wanted to write pseudocode, you could take an algorithms class.
Reading code is like reading the dictionary - you have to read half of it before you can go back and understand it.
Why not allow testing out of a class that is core to the curriculum? Perhaps the "test out" test should be harder (deeper and broader and probably longer) than the tests that would be taken by someone taking the class and/or perhaps the "passing score" should be an "A" just to make sure that the person really wouldn't benefit from taking the class because they would likely learn something from it.
Why is there an "insightful" mod and why isn't it "-1"? If I wanted insight, I wouldn't be reading
Any "skilled programmer" should know the specifics of most common algorithms and datatypes - although if they haven't actually used a particular algorithm in years, I don't see why they can't refresh their brain by spending a couple minutes online (i.e., I would count that as "know" as it was "once knew but have forgotten some of the specifics").
Of course, a keypunch operator working off of coding forms doesn't need to understand common algorithms and datatypes.
Why is there an "insightful" mod and why isn't it "-1"? If I wanted insight, I wouldn't be reading
If dedicated computers are configured for "test taking", there shouldn't be any room for academic dishonesty. You probably can't let students use their own laptops unless you really think your honor code is taken seriously by all (which, I think, is rare).
Why is there an "insightful" mod and why isn't it "-1"? If I wanted insight, I wouldn't be reading
Approx. 1996, I took and passed an exam in assembly code on paper. It was the kind of paper with a carbon back that made a copy of what you wrote.
As a long-time CS professor, let me add this: The entire purpose of a university education is to advance your understanding about whatever topic you are studying. To develop mental models. The purpose of a test is to see what you understand, and I want as little as humanly possible between your brain and what you produce for the exam. For the vast majority of students, that means brain to paper, with no distractions in between. My exams never have a lot of writing -- they do tend to have more problems to solve than many students like to solve in one sitting, but they are designed to get to core concepts with as few distractions as possible. I have had many students over the years that struggled with some disability or other that made paper exams difficult (whether dysgraphia or even a blind student in one situation), and so we have accommodations for students.
But again, the entire purpose is to see what you understand. I don't want to see how well you can use a tool, or how fast you can google things, or whether you can do some task like a trained monkey. Do you understand (and can you explain) why a red-black tree is balanced? Do you understand the balancing operation well enough so that you can write down a basic rebalancing operation on paper? Can you analyze the balance property to justify why the tree is O(log n) depth? If you have a clear picture in your mind, and if you really *understand* red-black trees, you should be able to do those things.
That sounds great. I have some co-workers that could use that!
Recently I fixed up some Perl where one of our most senior guys had forked a process to run /use/bin/time. Uhm, did you mean time()?
Actually /usr/bin/date +%s
Which returns the same thing as the Perl built-in time()
Really, AS a student you should be able to do some coding in paper, cardboard, whiteboard etc. This is how we communicate primarily with each other and customers. Also it is an exam not a piece of software going to run somewhere. BTW even after the exam you should still aim for knowing everting the course thought you.
I like your idea on how to condition the students to take exams on paper with regular quizzes. Thanks for sharing!
Wow -- they're using these techniques at the job interview level! I had no idea -- thanks for sharing. The disadvantage of having become a teacher and leaving the programming industry, is that I've left the programming industry. So all my skills have aged, and keeping up has been a challenge. Thanks for the insight!
I love the idea of having a lab which is offline, but at the (public) high school level that's unfortunately not an option for me.
My "online" tests/exams seem to involve all the same things you do, but without code writing. It's taken a lot of time and effort on my part to figure out how to do that -- as I still believe in the validity of tests/exams, just not writing code without an IDE. So, for example, I'll give them code and have them explain what's happening in English. Or I'll give them broken code and have them explain what's wrong or how to fix it. Or I'll ask what situations you'd use one construct vs another. I just don't like asking them to code in tests/exams. It seems like a skill that doesn't mimic the real-world, and to me that's what education is supposed to be preparing them for. Though, I realize that MANY disagree with me on that point.
I'm afraid I respectfully disagree. Without trying to shame you for your opinion, I'll try to explain why I strongly believe the complete opposite of you.
Knowledge WAS power, that is true. In the time of Galileo, in which you have placed your argument, knowledge was hard to come by. One would have to hunt down the proper books, and spend countless hours reading through them to acquire the knowledge necessary for some task at hand. But we don't live in that world anymore. Now, a properly formatted Google search will instantly take you to several resources somewhat-related to what you need. Learning how to synthesize that knowledge into a solution is now where the time can be spent, instead of spending the hours finding and memorizing knowledge which will soon be out of date.
But, I get where you're coming from. It's hard to recognize that a fundamental paradigm shift in society has occurred, and even harder to change oneself as a result. I could have happily gone on teaching as my forefathers have, all the way back to Galileo. It certainly would have been easier! But we're not in Galileo's world anymore, nor will we ever be again.
Does English department expect students to properly punctuate their twisting, or are they allowed to answer questions in pseudo-English?
A computer program in a major programming language generally uses a larger variety of punctuation marks than comparably long prose in English. Even in something like Python that has keywords and indentation for things where C++ and JavaScript use punctuation operators, you need to use all three kinds of brackets (round, square, and curly) in any nontrivial code that handles dictionaries. Nor does English class generally give a grade for handwriting past primary school. That's something you typically see only in logographic languages like Chinese and Japanese.
Nor should they be expected to be writing fully functional programs on a CS test
They are if the question is "How can this be done without mutation operators?" and the language of choice is Haskell or the subset of Scheme without set! or other mutators.