Comp 524-Programming Languages:
Course Overview
Instructor: (FB 150,
Copyright By PowCoder代写 加微信 powcoder
Questions from Last Lecture?
Questions from Last Lecture?
Questions from Last Lecture? (Q/A Summary)
Syllabus Handout in Google Docs
All docs, including assignments, will be commentable Google Docs. May forget to give access for each file, so please send message if not commentable.
Multiple ways to succeed!
Exam nature and dates TBA (depends on proctoring support)
Diaries explained in Piazza post
Questions/Comments?
Grading (Q/A Interaction)
Multiple ways to succeed!
Exam nature and dates TBA (depends on proctoring support)
Diaries explained in Piazza post
Questions/Comments?
Grading (Q/A Summary)
Multiple ways to succeed!
Exam nature and dates TBA (depends on proctoring support)
Diaries explained in Piazza post
Questions/Comments?
Many Ways to Succeed (Fall 19 Grades)
No fixed mapping from scores to grades
Looked for gaps and other factors
May not be possible to get as high a score this time
3 real Fs, rest are drops Sakai did not know about
Q&A/Diaries?
Q&A Diaries? (Q/A Interaction)
Q&A Diaries? (Q/A Summary)
Instructor needs feedback
Learn to speak in public
Oral “exam” over whole semester
Retain material better, logical vs physical attendance
Recruiters regularly ask about oral and verbal skills
NSF Survey asked what was being done to improve these skills
Requires multitasking, writing down questions and answers during ongoing lecture can interfere with understanding, hence class Q/A is extra credit
Assignment Layering Themes
Social distancing application in different languages (Not done last time)
Java, Java + MVC/Factories, Java + Weka, Prolog, SML, Lisp
Extend a Java-based Lisp interpreter skeleton (includes parser) to support Lisp++
quote, list, eval, load, cond, <, >, <=, >=, and, or, not, setq, lambda expressions, function expressions, funcall, defun, let, curry, defCurry, eager evaluation, lazy evaluation, distributed evaluation
Common problem: Display of recursive Lists
Using Java and alternative paradigms in Lisp++
Layering? (Q/A Interaction)
Layering? (Q/A Summary)
“The whole is greater than the sum of its parts” (Aristotle)
Need an extendible/large solution, allows for extra credit
Future solutions depend on previous ones and often require modification to them
So auto grading of previous parts and ownership
Slip-ups in one assignment are not confined to it, can cost you the remainder of the semester
Late Penalty
Assignments build on each other so being more than 2 weeks late is not a good idea!
Those who have trouble remembering deadlines should form a social group for fault tolerance
Assignment dates may be postponed based on various factors
Early-Submission Extra Credit
If you submit by the early submission date of the assignment, you will get 5% extra credit., that is, your score will be multiplied by 1.05. Aiming for early submission extra credit will ensure you do not incur late penalty. On the other hand, submitting later does allow for more extra credit, and many students have chosen to do so.
Workload (Q/A Interaction?)
The time you spend on the course depends on many factors such as how difficult to track your specific programming mistakes are. The average student should spend 9 hours outside lectures on regular credit portions of the homework assignments. Many courses have a smaller workload. The amount of code you will write will be small but dense.
Scaffolding?
Lectures will be assignment centered, and give pseudo code for Lisp++ implementation that has to be translated into real code
Traditional Piazza-based help from instructors
Remote synchronous help during office hours
Homegrown tools to help with coding, identification of requirements and problems.
Assignment descriptions will be looooooong to reduce ambiguity and fill in gaps (in small print to be read if stuck) left by lectures – key to success is to read everything
Google doc comments another way to get asynchronous help
Asynchronous Communication: email! Private and public Piazza messages.
Any technical question is of interest to others should be a public message giving context to answer them.
Do not send code on Piazza in private or public messages, summarize code in English in public messages
Private Piazza technical questions will most probably not be answered
Synchronous Communication via Office Hours
Clarifications should be sough asynchronously or synchronously in class for scalability issues
Ask questions specific to your situation or solution in office hours (waiting room, closed door and non waiting room, open door options will probably be available)
Try to explain the question in open-door sessions without showing code to abstract and maybe share information with others
Home-Grown Tools
Localchecks: Runtime tests run in programming environment. Extended for Non Java languages this Summer.
UNC Checkstyle: Extension of Checkstyle Eclipse plugin. Extended for Comp524 assignments in Summer.
Eclipse Helper: Tries to detect programming difficulty and will probably provide automated and manual help within Eclipse
Non industrial strength, possibly buggy with possibly obscure messages (high priority to fixing them asap when they are identified)
Track partial work, stored in IBM cloud
Use of them as well as Eclipse is optional, but all students have used previous versions of them. Special hello world assignment 0 to help learn all tools you need.
Eclipse-specific (May create command-line alternatives)
Student Collaboration
Can discuss solutions with each other at a high level
Not at the code level
Sharing of code or diary text and of course exam solutions is probably easily caught honor code violation
Can and should help each other with debugging large code (Lisp++ implementation) as long as it does not lead to code sharing. Small code debugging (social distance app and display of recursive lists) may lead to code sharing.
In-Class Student Collaboration
In face to face classes, much spontaneous student collaboration occurred before and after class when students were at a common meeting place
To help simulate this virtually, lecture zoom session starts at 12:30 pm and ends at 4:30pm (can extend it)
Breakout rooms for smaller sessions defined by audience rather than host?
Instructor-Student Collaboration
We write assignments and tutorials, someone identifies ambiguities, students and instructors answer comments
Similar process in Piazza for problems and obscure error messages form tools
You find bugs in our tools, we fix them
Not a sterile, cast in stone, one way communication of information, but a course that will organically grow during the semester with contributions for future semesters
Scaffolding and other Questions?
Lectures will be assignment centered, and give pseudo code for Lisp++ implementation that has to be translated into real code
Traditional Piazza-based help from instructors
Remote synchronous help during office hours
Homegrown tools to help with coding, identification of requirements and problems.
Assignment descriptions will be looooooong to reduce ambiguity and fill in gaps (in small print to be read if stuck) left by lectures – key to success is to read everything
Google doc comments another way to get asynchronous help
Scaffolding and other Questions? (Q/A Interaction)
Lectures will be assignment centered, and give pseudo code for Lisp++ implementation that has to be translated into real code
Traditional Piazza-based help from instructors
Remote synchronous help during office hours
Homegrown tools to help with coding, identification of requirements and problems.
Assignment descriptions will be looooooong to reduce ambiguity and fill in gaps (in small print to be read if stuck) left by lectures – key to success is to read everything
Google doc comments another way to get asynchronous help
Scaffolding and other Questions? (Q/A Summary)
Lectures will be assignment centered, and give pseudo code for Lisp++ implementation that has to be translated into real code
Traditional Piazza-based help from instructors
Remote synchronous help during office hours
Homegrown tools to help with coding, identification of requirements and problems.
Assignment descriptions will be looooooong to reduce ambiguity and fill in gaps (in small print to be read if stuck) left by lectures – key to success is to read everything
Google doc comments another way to get asynchronous help
TOWARDS BEING THERE
Face-to-face Interaction
Computer Supported Interaction
Computer Supported < Face to Face BENEFIT: BEYOND BEING THERE Face-to-face Interaction Computer Supported Interaction Hollan & Stornetta Computer Supported > Face to Face