How to cheat in exams using mobile phones and calculators

On Tue, 13 Dec 2005 00:07:57 +0000 (UTC), "Justin" <[email protected]>
wrote:

I think he was being facetious. I hope I *****ed that right, or is it
"spelt"? This is both top and bottom posted by the way.

Aside: "Stranger in a strange land" is one of my top choices of SF,
along with "The voyage of the space beagle" by Van Voght.

---

› See More: How to cheat in exams using mobile phones and calculators

Wayne Brown wrote:

> grep is a Unix utility that searches for character patterns in text
> files. I assume Mr. Smith is using it in the allegorical sense of
> "grepping" through the course material to gain the valuable knowledge and
> understanding contained within it. (He also may be making a pun from
> the similarity between the programming term "grep" and the pop-culture
> term "grok," which was coined by Robert Heinlein in "Stranger in a
> Strange Land" and is used to indicate deep understanding of a subject
> or situation.)
>

Heh, I actually meant 'grok' but I had been up late doing a lot of unix
scripting the night I wrote that ;-)

--
Richard

Matthew Huntbach wrote:

> In the case of self-taught programmers, I find many of them have some
> quite naive ideas about programming, and it requires a lot of effort to
> get them out of this and to think in a more structured and abstract style.
> Indeed, there are some Computer Science educators, and I have some sympathy
> for them, who warn against self-taught programming, feeling that it leads
> into "bad habits" which are more difficult to teach people to get out of
> than it is to teach progamming from scratch to someone who has never done
> it before.

When I said "self-taught by the age of ten" I only really meant Basic.
And I agree with you that someone who only knows Basic is quite likely
to have more problems when introduced to structured and object oriented
programming.

For my generation (and specific small group of friends), most started by
the age of ten with Basic, on 8 bit microcomputers. Throughout our
teenage years some of us moved 'up' to C and some 'down' to assembly
language on 16 bit machines. This was all quite easy in those days -
the machines often came with programming tools and manuals out of the
box. It was all quite low level and close to the machine - you couldn't
entirely trust your C compiler so it was still quite common for a C
programmer to hand-optimize the compiler's assembly output. (And the
assembly people seem to have ended up working on embedded systems and
hardware. I wonder if your choice of language at age 13 can predict
your future career.)

Personally, I think this is the best way of doing it. If you understand
what is really happening at the machine level, then when you are
introduced to objects at university you just shrug and say "oh that's a
more convenient higher level abstraction for what I'm already doing".
The biggest problem I saw with undergraduates was they couldn't
understand the abstraction because they hadn't experienced the problems
of programming without objects, and they didn't know what was being
abstracted.

I realise that advocates of the 'objects first' approach that seems
popular lately will disagree with me here!

--
Richard

In <[email protected]>, on 12/12/2005
at 04:32 PM, [email protected] (Dr A. N. Walker) said:

> Not so in maths.

Indeed. The student who depends on memorization and rote is in for a
shock the first time he encounters an open book or take home exam.
What may be confusing the OP is the classes in public[1] schools that
are called Mathematics but have little or no Mathematical content. It
is possible to get through such classes with no understanding.

[1] I don't know what they equivalent UK term is. In the US a public
school is one that is funded by taxes rather than tuition.

--
Shmuel (Seymour J.) Metz, SysProg and JOAT <http://patriot.net/~shmuel>

Unsolicited bulk E-mail subject to legal action. I reserve the
right to publicly post or ridicule any abusive E-mail. Reply to
domain Patriot dot net user shmuel+news to contact me. Do not
reply to [email protected]

On Tue, 13 Dec 2005, Richard Smith wrote:
> Matthew Huntbach wrote:

>> In the case of self-taught programmers, I find many of them have some
>> quite naive ideas about programming, and it requires a lot of effort to
>> get them out of this and to think in a more structured and abstract style.
>> Indeed, there are some Computer Science educators, and I have some sympathy
>> for them, who warn against self-taught programming, feeling that it leads
>> into "bad habits" which are more difficult to teach people to get out of
>> than it is to teach progamming from scratch to someone who has never done
>> it before.

> When I said "self-taught by the age of ten" I only really meant Basic. And I
> agree with you that someone who only knows Basic is quite likely to have more
> problems when introduced to structured and object oriented programming.

You are, of course, familiar with what Dijkstra said about Basic,
and if you won't take it from Dijkstra, Eric Raymond quotes him and
agrees:

http://catb.org/~esr/jargon/html/B/BASIC.html

I appreciate Basic has itself developed - are there still people who
use Basic as it was when I first started to program i.e. think of
a program as a long list of statements about which you jump using GOTOs?
I thought in its modern version it had at least caught up with structured
programming.

> For my generation (and specific small group of friends), most started by the
> age of ten with Basic, on 8 bit microcomputers. Throughout our teenage years
> some of us moved 'up' to C and some 'down' to assembly language on 16 bit
> machines. This was all quite easy in those days - the machines often came
> with programming tools and manuals out of the box. It was all quite low
> level and close to the machine - you couldn't entirely trust your C compiler
> so it was still quite common for a C programmer to hand-optimize the
> compiler's assembly output. (And the assembly people seem to have ended up
> working on embedded systems and hardware. I wonder if your choice of
> language at age 13 can predict your future career.)

Yes, I'm familiar with the sort, and yes, it's good to see people who
can quickly hack together code to do things when the majority of the programming
class have trouble getting that far. However, I do find a common phenomenon
with this sort of person is that they end up writing C programs in whatever
language you throw at them. Their approach to some problem is often some
incredibly complex mess. I've seen it happen plenty of times, and the
biggest problem is because they're good hackers, it's hard to convince them
of the benefit of switching to a more disciplined style.

> Personally, I think this is the best way of doing it. If you understand what
> is really happening at the machine level, then when you are introduced to
> objects at university you just shrug and say "oh that's a more convenient
> higher level abstraction for what I'm already doing". The biggest problem I
> saw with undergraduates was they couldn't understand the abstraction because
> they hadn't experienced the problems of programming without objects, and they
> didn't know what was being abstracted.
>
> I realise that advocates of the 'objects first' approach that seems popular
> lately will disagree with me here!

My own experience is that constantly wanting to think of abstractions in
terms of "what really goes on underneath" serves as a barrier to good
use of them. So, yes, I am an objects first person - when I program in
an OO language I want to think of it in terms of abstract objects passing
messages between each other, and not as just one big block of code and one
big block of memory where the OO constructs are just a way of organising it.

A good example of the way in which wanting to see it in terms of what goes
on at machine level is the difficulty I've often experienced in teaching
self-taught hackers the use of recursion. Somehow they just can't get
away from thinking of it as "this calls that then that calls this, then,
oh woops, it's all too difficult, I'll cobble together something with
a while loop and global variables".

However, the big problem with the sort of argument we're having here is
that there isn't the control group of self-taught programmers who aren't
self-taught in Basic graduating to C. As you say, you all start that way.
We can't show that had you started from a more abstract language you'd
be better.

Matthew Huntbach

In article <[email protected]>,
Richard Smith <[email protected]> wrote:
>Matthew Huntbach wrote:
>> In the case of self-taught programmers, I find many of them have some
>> quite naive ideas about programming, and it requires a lot of effort to
>> get them out of this and to think in a more structured and abstract style.

Absolutely. The main problem, IMHO, is that they have almost
certainly never *constructed* a program, but only ever thrown one
together. It's like being shown how to cook after only ever going to
the fridge and "grazing".

[...]
>When I said "self-taught by the age of ten" I only really meant Basic.
>And I agree with you that someone who only knows Basic is quite likely
>to have more problems when introduced to structured and object oriented
>programming.

Whoa! Modern [ie, last 25 years or so ...!] Basics are quite
decent languages, with usable procedures, structures, constructs and
no need for spaghetti; and [in all the cases they're likely to come
across] quite adequate facilities for simple graphics. Self-taught
Basic is surely no worse than self-taught Pascal/C/Java/whatever?
The problem is still very likely to be that the resulting program is
hard to debug, inflexible, etc., etc., primarily because no thought
has been given to the overall design.

In reality, I see very few programmers at all, self-taught or
otherwise, these days. The box is too black. You just can't compete
with the big boys, with their slick graphics and surround sound and
splash screens and exciting buttons, and web sites with all manner of
extra gizmos. So there is no payoff at all from the early stages of
rolling your own, apart from the intellectual challenge.

> [...] If you understand
>what is really happening at the machine level, then when you are
>introduced to objects at university you just shrug and say "oh that's a
>more convenient higher level abstraction for what I'm already doing".

I gave up on that after the PDP 11. Up to then, I learned the
machine code of every computer I used, occasionally wrote assembler
programs, and more-or-less understood the machine architecture. After
that, black boxes struck again. Your PC has several thinggies clipped
to boards; you have to be a real geek to know what they all are, once
you're past "this is the processor, this is memory, that's the fan".
If you do learn the machine code, it's not really the machine code at
all, but a high-level version of the actual microcode. You can't
compete with modern compilers, with their expert knowledge of the
cache behaviour, etc. So at best you write a compiler that converts
your favourite language into C.

The same has happened to consumer goods. The heater packed up
on my car the other day. Twenty, thirty years ago, it would have been
a mechanical problem easily fixed by a local mechanic. Today, the
garage decided it was the "controller", some expensive box buried
several hours deep into dismantling half the car; having uncovered
that and found it was OK, the next step would be some other expensive
box buried several hours deeper into dismantling the rest, costing
more than the car is worth. So my choice seems to be to scrap the car
or shiver ....

--
Andy Walker, School of MathSci., Univ. of Nott'm, UK.
[email protected]

"guv" <[email protected]> wrote in message
news:[email protected]...
> On Sun, 11 Dec 2005 19:21:02 +0000, [email protected] wrote:
>
> <snip>
>
> >>> : If you are so ignorant of English grammar and/or *****ing you should
not
> >>> : post on Usenet.
> >>>
> >>> That should have had a comma after "*****ing".
> >
> >
> >Whilst we're doing picky stuff... your post should have been placed at
> >the bottom.
> >
> >In any case, a usenet grammar post isn't complete without a grammatical
> >error. I think it's in the handbook somewhere.
>
> Agreed. There's nothing worse than grammer cops - apart from top
> posters! ;-)

http://www.thefreedictionary.com/grammer

In sci.math Richard Smith <[email protected]> wrote:
> Wayne Brown wrote:
>
>> grep is a Unix utility that searches for character patterns in text
>> files. I assume Mr. Smith is using it in the allegorical sense of
>> "grepping" through the course material to gain the valuable knowledge and
>> understanding contained within it. (He also may be making a pun from
>> the similarity between the programming term "grep" and the pop-culture
>> term "grok," which was coined by Robert Heinlein in "Stranger in a
>> Strange Land" and is used to indicate deep understanding of a subject
>> or situation.)
>>
>
> Heh, I actually meant 'grok' but I had been up late doing a lot of unix
> scripting the night I wrote that ;-)

I know what you mean. After a long day (and/or night) of sysadmin work
I sometimes find myself thinking in "shell-scriptese". :-)

--
Wayne Brown (HPCC #1104) | "When your tail's in a crack, you improvise
[email protected] | if you're good enough. Otherwise you give
| your pelt to the trapper."
e^(i*pi) + 1 = 0 -- Euler | -- John Myers Myers, "Silverlock"

On Tue, 13 Dec 2005 10:00:52 +0000, Richard Smith
<[email protected]> wrote:

>Matthew Huntbach wrote:
>
>> In the case of self-taught programmers, I find many of them have some
>> quite naive ideas about programming, and it requires a lot of effort to
>> get them out of this and to think in a more structured and abstract style.
>> Indeed, there are some Computer Science educators, and I have some sympathy
>> for them, who warn against self-taught programming, feeling that it leads
>> into "bad habits" which are more difficult to teach people to get out of
>> than it is to teach progamming from scratch to someone who has never done
>> it before.
>
>When I said "self-taught by the age of ten" I only really meant Basic.
>And I agree with you that someone who only knows Basic is quite likely
>to have more problems when introduced to structured and object oriented
>programming.

But he's still quite right in general. I've said the same about math
that it's far more difficult to undo bad habits than to teach good
ones from scratch [check out my typing for example.] That underlying
problem is lack of patience. People want to call themselves
programmers NOW, only because they mastered the FOR-NEXT loop. They
don't want to do all of the necessary basic training, and so quickly
reach a limit because of that lack of understanding of basic
principles [that's small-letter 'basic'.] Some learn to add a column
of numbers in a spreadsheet and also think of that as programming.

On the lighter side, I had taught myself BASIC many years back [hence
my understanding of the problems], and had a few years ago decided to
get out of the house. So I signed up for a college night course in
Visual Basic. I told my wife that I was wondering if I'd remember any
of the stuff I had done so long ago [I did.] She said I'd be lucky if
I could remember where I'd put the car in the parking lot. ...Why
we're married.

On Tue, 13 Dec 2005 12:52:53 +0000, Matthew Huntbach
<[email protected]> wrote:

On the discussion of programming technique:

I can not help but agree with all that you say. That is for very
good reason. You are clearly someone who can program at a higher
level than the amateur, or at least understand that level of
programming. In particular, I understand the concept of being well
organised initially, and that being facilitated through a dicsciplined
approach.

Is it not the same in all studies these days? No-one wants to go
through the tough bits, and just get to the meat and potatoes. All
want to play Chopin, but not practice their scales. Well, the result
is that you will be employable as a programmer and others, self
included, will not. It's sort of like typing skills. A
well-disciplined start gives good results. An undiciplined
hunt-and-peck, allows one to type, but... In my own case, I'm
probably still stuck at around 5wpm if you count the time to go back
and find then correct the many small erors ...some devilishly tough to
fathom. After all, if I wrote that program it HAS TO work, right? Two
days later still trying to find what in H... I did wrong, then lots of
head slapping. Companies in business don't have time for that.

"Shmuel (Seymour J.) Metz" <[email protected]> wrote in
message news:[email protected]...
> In <[email protected]>, on 12/12/2005
> at 04:32 PM, [email protected] (Dr A. N. Walker) said:
>
>> Not so in maths.
>
> Indeed. The student who depends on memorization and rote is in for a
> shock the first time he encounters an open book or take home exam.

Anything you can take home makes preventing cheating difficult to say the
least.
To my knowledge, there are no open book exams in the UK examination system -
and I think that's very unfortunate.

> What may be confusing the OP is the classes in public[1] schools that
> are called Mathematics but have little or no Mathematical content.

So why isn't Mathematics taught in schools? Because it requires
*understanding* and that's harder to test.
BTW: The same applies for all the sciences.

Alun Harford

In article <[email protected]>,
Matthew Huntbach <[email protected]> wrote:

>On Tue, 13 Dec 2005, Richard Smith wrote:
[snip]

>[T]he biggest problem is because they're good hackers, it's hard to
>convince them of the benefit of switching to a more disciplined style.

And they tend towards arrogance, with the attitude that they are good
enough to hack *anything*. This comes from only ever having worked on
self-selected hack-able problems -- they haven't yet met "the program
with their name on it", meaning one that is just too complex to hack
without doing a decent design first.

I had the fortunate early experience (although it didn't feel fortunate
at the time) of having to do a lot of maintenance work on large messy
programs, which convinced me in my bones of the need for clean design.


>> Personally, I think this is the best way of doing it. If you understand
>> what
>> is really happening at the machine level, then when you are introduced to
>> objects at university you just shrug and say "oh that's a more convenient
>> higher level abstraction for what I'm already doing". The biggest problem I
>> saw with undergraduates was they couldn't understand the abstraction because
>> they hadn't experienced the problems of programming without objects, and
>> they
>> didn't know what was being abstracted.
>>
>> I realise that advocates of the 'objects first' approach that seems popular
>> lately will disagree with me here!
>
>My own experience is that constantly wanting to think of abstractions in
>terms of "what really goes on underneath" serves as a barrier to good
>use of them. So, yes, I am an objects first person - when I program in
>an OO language I want to think of it in terms of abstract objects passing
>messages between each other, and not as just one big block of code and one
>big block of memory where the OO constructs are just a way of organising it.

Yes, but.... The sad fact is that most students seem to be generally
hopeless at *anything* abstract. Of those students, the ones who have
some sort of concrete model of "what really goes on underneath" have a
big advantage over the ones who don't.


>A good example of the way in which wanting to see it in terms of what goes
>on at machine level is the difficulty I've often experienced in teaching
>self-taught hackers the use of recursion. Somehow they just can't get
>away from thinking of it as "this calls that then that calls this, then,
>oh woops, it's all too difficult, I'll cobble together something with
>a while loop and global variables".

Indeed. IMO, recursion is the /pons asinorum/ of introductory
programming, where the abstraction-challenged students visibly hit the
wall. But note that it can be taught in a less abstract manner, e.g. by
starting with recursive function patterns that are actually iterative in
structure (i.e., tail-recursion).

--
---------------------------
| BBB b \ Barbara at LivingHistory stop co stop uk
| B B aa rrr b |
| BBB a a r bbb | Quidquid latine dictum sit,
| B B a a r b b | altum viditur.
| BBB aa a r bbb |
-----------------------------

On Tue, 13 Dec 2005 20:27:33 +0000 (UTC), "Alun Harford"
<[email protected]> wrote:

>So why isn't Mathematics taught in schools? Because it requires
>*understanding* and that's harder to test.

The first may be right these days. I would have argued with you 35
years back. The second is not the reason for the first. The reason
is political, absolutely out of control of the teachers, who here are
by and large university graduates in the areas they teach.

On Tue, 13 Dec 2005, Alun Harford wrote:
> "Shmuel (Seymour J.) Metz" <[email protected]> wrote in

>> Indeed. The student who depends on memorization and rote is in for a
>> shock the first time he encounters an open book or take home exam.

> Anything you can take home makes preventing cheating difficult to say the
> least. To my knowledge, there are no open book exams in the UK examination
> system - and I think that's very unfortunate.

Where I teach, having the main exams as "open book" would be hard to
fit in with exam regulations, but I've set term-time tests which are
in effect mini-exams, and count as a proportion of the course mark,
as "open book". It's quite a good learning exercise for the students
as they start off thinking "Wow, this is going to make it really easy"
and sit down to do the exam and find it doesn't help them much at all.

Matthew Huntbach

No. No "should" about it. The issue of top or bottom posting is
an issue of personal preference.

[email protected] wrote:
> Whilst we're doing picky stuff... your post should have been placed at
> the bottom.