Fulton course/instructor evaluations

Dear all:

Hope you are starting to have a good break and all your mental bruises are slowly healing.

I just received the results of the  teaching evaluations that you folks filled and enjoyed reading them.

Thanks to all of you who took time to fill the evaluations!

It is my somewhat quixotic custom to allow access to the evaluations to the class students for a limited time. It might give you a feel as to how your individual
views stacked up with the rest of the class (you know--sorrow desires company and all that).

In keeping with it, here are links to the full evaluations--warts and all--in case you are interested:

http://rakaposhi.eas.asu.edu/cse471/cse471-s09-ug.htm   (471 section)

http://rakaposhi.eas.asu.edu/cse471/cse471-s09-g.htm      (598 section)

Regarding the comments about the difficulty level of the course, the following is the link for a comparable course taught by the textbook author http://www.eecs.berkeley.edu/~russell/classes/cs188/f05/ 

So look at the bright side--you got almost all that, with a lower tuition, fewer projects, easier exams, *and*  a suaver accent! ;-)

cheers
Rao

sayanora...

Folks:

 I agonized for some three days and  just submitted your grades; you should be able to see them on the registrar's site.

 It has been fun teaching you folks; I hope to see some of you in other classes. Feel free to drop by if I can be of any help.

Good luck with your degree programs (or real life, if you were so unlucky as to graduate already :).
Hope you get to recall and use at least some of the things we talked about this semester
down the line somewhere.

cheers
Rao

Go Huygens! A new world record in a difficult game for computers

From the article:

At the Taiwan Open 2009, held in Taiwan from Feb. 10-13, the Dutch national supercomputer Huygens, which is located at SARA Computing and Networking Services in Amsterdam, defeated two human Go professionals in an official match.

Here's more:
http://www.sciencecodex.com/french_software_and_dutch_national_supercomputer_huygens_establish_a_new_world_record_in_go_0

specimen solutions for the final..

In case you are interested, here is a link to specimen solutions for the final (note that these are solutions written by the student
scoring the highest, but not perfect, on the final).

http://rakaposhi.eas.asu.edu/cse471/s09-final-soln.pdf

Rao

Full spreadsheet of the final gradebook

Someone wanted to have one last look at the final grade book I am operating with. Here it is...

Rao

Final cumulatives (with the final exam scores thrown in)

Folks:

 Here are the final cumulatives (with final exam scores thrown in). The highest for final in UG is 102 and in grad is 104 (out of 110).
The averages are 64 and 84 respectively.

The top students in CSE471 and the CSE598 categories are both guaranteed A+ grades (assuming their photo-finish holds up ;-)).
They both are welcome to offer me (non-binding) advice on where to put grade cutoffs for the rest of the class...

As for the rest, they shall find out their letter grades from the registrar come Tuesday.


regards
Rao

a brain aphorism based on the final..

There is a quote I used to like, and it goes like this:
 
 "If our brains are so simple that we can understand them,
    we will be so simple that we can't"

(Of course, I don't believe it, but I like the sound of it ;-)

Anyways, I was thinking about it, as I am grading the final and several of you wrote
"True" for the question which says that an agent has the best chance of success when
all the variables are independent.. yes you can do reasoning fast, but to what end? You
can't change a thing in the world...


----------

Another short-answer question that only a few people got right is the last one. The point there is that
if you add a random number to the h value, then you are likely to make the h-value of each node unique.
Which means there can be as many distinct f-values as there are nodes.  This is a death-knell of IDA*


Rao

We finally make it to Daily Show with Jon Stewart!

http://www.thedailyshow.com/video/index.jhtml?videoId=227327&title=arizona-state-snubs-obama

Project 4 and homework 4 can be picked up from in front of my office...

rao

Re: Regarding graph planning in Homework 5

First of all, since I discussed mutual exclusion propagation only briefly in the class, you are not responsible for that part.

Since you asked however, just because two actions are mutex doesn't mean that  their effects are mutex--since after all the effects may also have been given by other actions.

Consider for example a situation where p is given by m different actions, and q is given by n different actions.

In order for p and q to be mutex, it must be the case that every pair of actions in the cartesian product must be
mutex--ie there must be m*n mutexes.  If there exists even one pair--say ai giving p and bk giving q such that
ai and bk are not mutex, then p and q are not mutex.

[Suppose you started with the belief that you shouldn't hit people because god might punish you. If you then went on to become an atheist, it doesn't necessarily mean that you should now believe that hitting people is fine. You may have found other reasons why hitting people is not reasonable.]

[In contrast, if *any* pair of preconditions of two actions are mutex, then the actions themselves are mutex.
I.e. if action a has m precods and action b has n preconds, if any of the m*n precondition pairs are mutex, then the action a and b are mutex. ]

Rao

On Sat, May 9, 2009 at 3:05 PM, Sidharth Gupta <sgupta47@asu.edu> wrote:

The mutexes shown between variables at level 2  in the problem in planning graph for homework 5 solutions dont quite seem right.... Shouldnt there be a mutexes between all the pairs of variables whose actions were also having a mutex...? Many seem to be missing like between R and S whose actions o1 and o2 are also in mutex?

Regards
Sidharth Gupta

(yet another mail about) Undergraduate research opportunity...

Folks:

 I just learned that we will be getting a National Science Foundation grant to support some work on stochastic planning.
This is based on the ideas in the  paper  http://rakaposhi.eas.asu.edu/ffhop.pdf

This grant also has a "Research Experiences for Undergraduates" component (through which UG students can take part in research projects, and also get a modest stipend of about 4K/semester ).

If you are interested, let me know. This can start as early as this summer.

Rao

Final pep-rally.. (and anxiety amelioration)

Some of you have started wondering whether it makes sense to plan to stand in the interminable security checks in your nice polyester cookers (err graduation gowns) and get into the Obammencement given your worrisome cumulatives in this class.

My suggestion is that you quit worrying and  focus on the final and do that well.

As I said after the mid-term, I am much more interested in torturing (I mean educating)  you during the semester than in haunting your GPA after it.
I have  a lot of respect for students who had the perseverance to stay with what people tell me is a challenging course.

Good luck
Rao
----------
  "Not to make-up your minds, but to open them
     to make the agony of decision-making so intense
       that you can escape only by thinking"

Cumulatives for everything other than participation and final..

Folks:

 Here are the cumulatives for 75% of your grade (the participation credit and the final exam marks are missing).
Note that some of you still have project 4 points missing--this is because TA had contacted you for your source code and
has to complete grading after that.

Re: Final exam question

Yes. Sorry for the typo.

Sent from my iPod

On May 8, 2009, at 2:38 PM, cameronlarue@gmail.com wrote:

> On Qn VII (1), Given a database D and a fact f, if D does not entail
> p, then D entails ~p.
>
> Is fact f supposed to be fact p?
>
> Thanks,
> Cameron

Fwd: CSE Undergraduate Research Scholarship Fall 2009 - deadline today!

Let me know if any of you UG students are interested in being nominated.

Rao

---------- Forwarded message ----------
From: Amy Sever <Amy.Sever@asu.edu>
Date: Fri, May 8, 2009 at 7:55 AM
Subject: CSE Undergraduate Research Scholarship Fall 2009 - deadline today!
To: CSEFaculty@asu.edu

CSE Faculty,

 

I'm writing to remind you that today is the deadline to nominate a student or students for the CSE Undergraduate Research Scholarship for Fall 2009.  See details and get the application form at: http://sci.asu.edu/undergraduate/research.php.

 

Please consider supporting one of our top students!

 

Thanks,

 

 

Amy Sever

Assistant Director, Academic Services

School of Computing and Informatics

480-965-3199

http://sci.asu.edu   

 

 

 

 

 

From: Amy Sever
Sent: Tuesday, April 28, 2009 1:51 PM
To: 'CSEFaculty@asu.edu'
Cc: Sandra Hoeffer
Subject: CSE Undergraduate Research Scholarship - nominate a student for Fall 2009!

 

CSE Faculty,

It is time to nominate exceptional students for the CSE Undergraduate Research Scholarship! This program supports strong academic performance among our undergraduate students and to encourage interest in graduate studies. Please review the following guidelines.

1. Faculty must initiate all applications and turn them into department. These applications will not be accepted from students. However, if students find any potential opportunities on this site or elsewhere, they can come to you to initiate the application.
2. Faculty overseeing research must commit $1,000 to student support.
3. Students can work a maximum of ten hours per week in lab.
4. The department will award an additional $1,000 to the student based on a competitive process.
5. Monies will be awarded on a semester basis.
6. All applications must be received by May 8th for the Fall 2009 term.
7. All students must meet the qualifications listed below.

Student Qualifications:

• Grade Point Average of 3.25 or above
• Must be registered for at least 12 credit hours in the Fall 2009 term
• Junior/Senior level in program
• Every student receiving this award is expected to produce a poster at the end of the semester in which they received financial support through the FURI Symposium. Instructions for completing these posters will be provided.

The application can be downloaded at: http://sci.asu.edu/undergraduate/research.php.  Please share as much information as possible about the student you are nominating, as there are a limited number of awards and the selection process is competitive!

Please turn in the application for the Fall 2009 semester to me in the SCI Advising Center, BYENG 208, by May 8th. I've attached a query of students who are juniors and seniors with a 3.25 GPA or higher. Perhaps one of the names is of a promising student from one of your classes!  Please contact me if you know of a student that is not on this list that you believe is a junior or senior in the program.

Here are other ways students can engage in research:

1)      Mentor a student in Fulton Undergraduate Research Initiative (FURI).  Application deadline for Fall 2009 is May 15^th.   This is a student-initiated process. See http://www.fulton.asu.edu/fulton/departments/furi/ for more information.

2)      Supervise a student in CSE 499 Independent Study: For CS and CSE seniors with a 3.0 GPA or higher in their major area. Form is at http://sci.asu.edu/forms/undergraduate.php.

3)      Supervise an honors student in CSE 492 Research and CSE 493 Thesis.  Form is at http://sci.asu.edu/forms/undergraduate.php.

4)      Post any available research positions for undergraduates (and graduate students) at: http://sci.asu.edu/employee/studentjobposting.php

Thanks for your help in supporting our students to engage in undergraduate research.

Sincerely,

 

Amy Sever

Assistant Director, Academic Services

480-965-3199

http://sci.asu.edu

 

 

 

Amy Sever

Assistant Director, Academic Services

School of Computing and Informatics

480-965-3199

http://sci.asu.edu 

 

 

 

What is the difference....?

A nice FAQ on the differences between functional, logic and procedural languages....

1. What makes a language functional, logic programming or procedural ?


A procedural or imperative language focuses on telling the computer
what to do, step by step. These are descended from Turing machines
and assembly language. You knew a lot about them before this course.

A logic programming language focuses on computation as constructive
proofs, i.e., proving a term that says that two employees or three
numbers are in a particular relationship. Typically unification and
backtracking are used to help efficiently construct the proofs, but
there are other possible strategies. These languages are descended
from Prolog, and you have been learning about them.

A functional language focuses on computation as the evaluation of
mathematical functions. These are descended from the lambda calculus
and Lisp. I'll say a little more below in answer to your questions.

In a purely functional language, a program simply defines a bunch of
functions, in the mathematical sense of "function." The return value
of a function depends only on its arguments; the function has no side
effects and is not sensitive to side effects, so it returns the same
value every time it's called.

Of course, you can program in this functional style in other
languages, too. But programming in a actual functional language
forces you to learn this style. :-) More important, compilers for a
functional language can take advantage of the guaranteed lack of side
effects to introduce optimizations -- including memoization and lazy
evaluation.

In a really pure functional language, the only thing that happens
within a function is to call other functions -- e.g., you would define
f(x,y) as g(h(x),f(x,minus(y,1))). This is just putting f,g,h, and
minus together by wiring the outputs of some functions into the inputs
of others. Note that minus is presumably a built-in function. So are
conditionals: if(condition, then-value, else-value).

Similarly, in a really pure logic language, the only thing that a
query can do is to combine other queries by unifying their arguments,
which is similar to the way that a function call in a functional
language combines other function calls by wiring their inputs and
outputs together. A query may also have nondeterminism, e.g., there
may be a choice of several ways to answer it (e.g., several clauses
with the same head). This is why constructing a proof may involve
backtracking.

So in both pure functional and pure logic programming languages, there
is no mechanism for modifying values. This rules out side effects,
but it actualy rules out more than that, because there's not even a
way to modify values privately within the definition of a function.
Objects can't be modified once they're created. Indeed, there is no
way even to change the value of a variable! (You can introduce a
LOCAL variable as a temporary name for something, but once you've
introduced it, its value will never change (except perhaps for being
specialized through unification), and it goes away once you leave the
scope where the variable was introduced.)

As an example, you can't write loops since you can't change the loop
variable. You use recursion instead. This introduces new local
variables on every recursive call rather than changing the value of
your loop variable. The compiler may secretly turn the recursive
calls back into loops where it can, of course.

As another example, you can't write a destructive function to append
two lists A and B, i.e., changing the last pointer of A to point to
the start of B, because this would be a side effect. You have to
write a function that leaves A and B intact and returns a new list C,
which is basically the list that you would get if you made a copy of A
and changed the last pointer of the copy to point to the start of B.
(There is no need to copy B.)

As another example, you can't easily memoize the result of a function,
because it would be a side effect to store the result in an global
array that would be accessible to future calls of that function. To
avoid handling this as a side effect, you would have to pass the array
as an argument to the function, and the function would return a
modified array that you could pass to the next call of the function.
Some functional or logic languages do have memoization built in,
however -- the lack of side effects means that the memo will remain
valid.

Many functional and logic languages are not pure, though -- they are
extended with some ability to have side effects. In Prolog, there are
"assert" and "retract" predicates which actually modify the program as
it's running (e.g., adding new facts to the database) if you query
them. The original functional language Lisp allows modification fo
both local and global variables. Several recently developed
functional languages like OCaml and Haskell have more principled or
careful ways to let side effects into the language in restricted
circumstances.

Is it ability to use functions as arguments to other functions ?


No, but this is indeed a feature commonly found in functional
languages. That is because the feature is useful, and because those
languages are mainly descended from the lambda calculus, in which
functions are the only objects in the language.

A language "has first-class functions" if functions can be treated
like any other object, e.g.,
* as the argument to another function
* as the return value of another function
* as the value of a variable
* as fair game for type checking (i.e., if there is a strong type
system, then it must distinguish different types of functions, e.g.,
by their input and output types)

A "higher-order function" is a particular function that has other
functions as arguments or return values. A language that has
first-class functions obviously allows higher-order functions.

If it is then what is python ?


Python is a procedural, object-oriented language that has first-class
functions, recursion, and other things that make it easy to program in
a functional style if you choose not to use any side effects.

2. How important is the concept of immutability to any functional
programming language ?


Immutability means that objects can be created but not subsequently
modified. In pure functional languages, everything is immutable, as
noted above.

3. How is functional programming different from logic programming ?


Logic programming usually has nondeterminism (backtracking) and
unification as built-in features. Few functional programming
languages have this.

Logic programming doesn't have return values; it describes relations
like times(A,B,C) (which is either provable or not) rather than
functions like times(A,B).

Logic programming generally does *not* have higher-order functions,
since it doesn't have functions. But there are logic programming
languages that do, like lambda-Prolog.

*FINAL EXAM RELEASED**

Folks:

 Here is the URL for the final exam. Please read the instructions on the front page carefully. You can return the exam to either the front office
or push it under my door.

Please note that giving the fianl exam as a  take-home is a mark of trust I have in your academic honesty. Please don't give me any reason to regret it.

regards
Rao


Final (Word document) http://rakaposhi.eas.asu.edu/cse471/s09-final-jm.doc
(pdf form)    http://rakaposhi.eas.asu.edu/cse471/s09-final-jm.pdf

My availability this week

Folks:

 I should be in my office much of the day tomorrow (Thursday) as well as before noon on Friday.  If you have questions related to the course and exam
feel free to stop by. If you want to make sure I am in my office before you come, call 965-0113 to confirm.

rao

Solutions for the final homework posted online

FYI

Chess game showing which moves the computer is considering

I stumbled across this chess game this morning
http://transition.turbulence.org/spotlight/thinking/chess.html
Every time you make a move, it shows you what moves the program is considering. The brighter the lines are, the better the move.

On the "About" page, they say this:

The chess engine we built is simple and uses only basic algorithms from the 50s (alpha-beta pruning and quiescence search). The program's unconventional initial moves may raise eyebrows among experts: we did not give it an "opening book" of standard lines since we wanted it to think through every position.

Although I wouldn't recommend using this if you actually wanted to complete an entire game in less than a couple of hours, it's pretty cool seeing all of the moves being analyzed in real time.