Labs are where you will work on practical programming skills, under the guidance of experienced tutors.
Read the tasks for the week before you attend the labs, and make a plan on how to approach and solve the tasks ahead of time. The tutors will be are there to help and give you feedback for your ideas (not to do the job for you).
The lab documents are finalised by Monday morning, before the first lab of the week—otherwise they are just a sneak preview (and can still change).
Week 0: Before you start
It is essential that you use StReaMS to enroll in a lab session before Week 1 (this will be available from Week 0).
» read more
Week 1: ANU environment, Linux, Haskell
Welcome to the labs for Programming as Problem Solving! These exercises are for Week 1. They will help you get started in the lab computing environment and introduce tools you will use throughout the course. If you have questions you can ask your tutor for help. If your tutor is busy with another student feel free to work with one of your lab mates to figure things out.
» read more
Week 2: Tools, scripts, first functions
This lab introduces you to software development tools that you will use for the semester—our preferred Integrated Development Environment (IDE) IntelliJ, the Git version control system, and the GitLab Web-based manager for Git repositories. You will work with Haskell programs in IntelliJ and load them into GHCi, read somebody else’s code, and write your own first functions.
» read more
Week 3: Guards and patterns
In this week’s lab you will go beyond functions that compute results as simple mathematical calculations on their inputs, to writing more abstract conditional functions where the output changes according to properties of the inputs. Haskell guards are one way to express conditions on values. Another way is case expressions with pattern matching to dissect or deconstruct incoming data values according to their structure. We will look at both approaches in this lab. You will also learn how to read somebody else’s code, and to create more interesting Haskell scripts, completely from scratch.
» read more
|Mode of Delivery||on campus|
|Prerequisites||Mathematics comparable to at least ACT Maths Methods major or NSW 2 unit maths or equivalent.||Mathematics comparable to at least ACT Specialist Mathematics Major/Minor or NSW Mathematics Extension 1 or equivalent.|
|Co-taught Courses||COMP1130 (Semester 1)||COMP1100 (Semester 1)|
|Textbook||Simon Thompson, The Craft of Functional Programming, 3rd edition, Addison-Wesley, 2011. There are additional materials (including errata and useful links at the textbook Web-site.|
|Lecture 1||Monday, Llewellyn Hall, 8:00–9:30am||Monday, Llewellyn Hall, 8:00–9:30am|
|Lecture 2||Wednesday, Llewellyn Hall, 9:30–11:00am||Wednesday, Llewellyn Hall, 9:30–11:00am|
|Supplementary Lecture||Thursday, Barry Drive 7-11 Ground Floor, 10:00–11:00am|
|Course Convenor||Prof Tony Hosking||Prof Tony Hosking|
|Second Examiner||Dr Linda Postniece||Dr Linda Postniece|
|Office Hours||by appointment||by appointment|
This course is the first of three core computer science courses on programming. It introduces students to the field of computer science as a discipline for solving problems through computation and provides the foundation for more advanced courses on programming and software development. Data structures and algorithms, the key concepts at the core of computer science, receive their first treatment in this course. The course addresses both functional and imperative programming paradigms.
The course covers functional programming in depth, developing the core idea of functions operating on data structures. Students learn the organization of programming languages using types, how programs are evaluated (reduction), functional composition, recursive functions, algebraic data types, pattern matching, parametric polymorphism, higher-order functions. Students also gain exposure to structural induction and proof, introduction to asymptotic analysis of basic data structures, abstract data types, modules, laziness, and streams. The functional paradigm demonstrates elegant solutions to many programming problems.
The course also introduces imperative programming as an alternative paradigm to functional programming, highlighting similarities and contrasting differences. Students learn the basic ingredients of imperative programs: mutable variables, sequencing, conditionals, iteration, functions, eager evaluation, and side effects.
The course also introduces students to standard productivity tools for software development that will be used throughout the course and remainder of the computer science degree. These include distributed software revision control systems.
The Advanced version of this course covers these topics in more depth, allowing students to deepen their understanding and experience.
Upon successful completion of COMP1100, the student will be able to:
- Apply fundamental programming concepts, using a functional programming language, to solve simple problems.
- Understand basic types and the benefits of static typing.
- Distinguish language definition from implementation, syntax and parsing from semantics and evaluation.
- Describe, understand and evolve programs, via documentation, testing, and debugging.
- Discuss, use, and apply the fundamentals of data structures, algorithms, and design; create, implement, and debug algorithms for solving simple problems, including recursively, using divide-and-conquer, and via decomposition.
- Discuss basic algorithmic analysis for simple algorithms; determine appropriate algorithmic approaches to a problem (brute-force, greedy, divide-and-conquer, recursive backtracking, heuristic, dynamic programming).
- Describe and apply alternative computational paradigms to simple problems.
- Understand the legal context for protection of software as intellectual property.
Upon successful completion of COMP1130, students will also be able to:
- Use functional encapsulation mechanisms such as function closures and modular interfaces, and define and use higher-order functions operating over aggregate values.
- Explain how typing rules define legal operations of a type, and write down the type rules for use of compound types.
- Use big-O notation formally to give bounds on time and space complexity of algorithms.
- Describe various heuristic problemsolving methods.
Marks for COMP1100/1130 accrue from several assessment tasks throughout the course, weighted as follows, but subject to moderation:
|Task||Value||Due Dates||Date for Return of Assessment|
|Diversity module||0%, hurdle|
|First assignment||10%||Friday 23rd March||Friday 6th April|
|Second assignment||12%||Friday 4th May||Friday 18th May|
|Third assignment||15%||Friday 25th May||Friday 8th June|
|Mid-term exam||10%||Week 6||Week 7|
|Final exam||50%, hurdle||Examination Period||Thursday 28th June|
The marks for the first assignment , participation (in labs, on quiz questions, etc.), and the mid-term exam are redeemable via the final exam. Thus, your final mark prior to moderation will be calculated as follows:
where , , , are the percentage of the available marks achieved for each assessment item.
- Late assignments will not be accepted. There will be no extensions. Note that assignment due dates and return dates may vary from the schedule advertised above.
- Students must get a minimum final mark of 50% to pass the course and at least 40/100 on the final exam. Students not achieving a minimum final exam mark of 40/100 will receive a final grade of NCN (the final exam is a hurdle assessment). Final marks are moderated within the course and by a Research School of Computer Science examiners meeting. Students receiving a final mark of N45%-N49% will be offered supplementary assessment as per ANU rules.
- All exams are “closed books/closed notes”: no external materials will be permitted.
- The examinable material comprises the contents of lectures, labs, and assignments, as well as the relevant chapters of the textbook. Material covered in guest lectures (by other than course staff) is not examinable.
- COMP1130 extends COMP1100, with extra lectures (content is examinable) and extended requirements for assignments. Given the extra lectures, COMP1130 students will sit slightly different exams. Otherwise, the assessment scheme is identical to that of COMP1110.
- Participation is based on your demonstrated engagement with the course in lectures and labs, via interaction with your tutor and lecturer, on lab exercises and lecture quizzes.
- Plagiarism will be handled according to ANU’s policies and procedures.
All students must participate in the module (comprising 1 lecture and assessment) on diversity and professional ethics, which is an essential outcome of the course. For example, the ACM’s CS2013: Curriculum Guidelines for Undergraduate Programs in Computer Science has the following summary of curriculum for professional practice:
The education that undergraduates in computer science receive must adequately prepare them for the workforce in a more holistic way than simply conveying technical facts. Indeed, soft skills (such as teamwork, verbal and written communication, time management, problem solving, and flexibility) and personal attributes (such as risk tolerance, collegiality, patience, work ethic, identification of opportunity, sense of social responsibility, and appreciation for diversity) play a critical role in the workplace. Successfully applying technical knowledge in practice often requires an ability to tolerate ambiguity and to negotiate and work well with others from different backgrounds and disciplines. These overarching considerations are important for promoting successful professional practice in a variety of career paths.
Students will receive feedback in the following forms in this course:
- written comments
- verbal comments
- on-line (via Piazza and GitLab)
- via e-mail
- to the whole class
- to small groups (tutorials, individuals, study groups, focus groups)
ANU is committed to the demonstration of educational excellence and regularly seeks feedback from students. One of the key formal ways students can provide feedback is through Student Experience of Learning Support (SELS) surveys. The feedback given in these surveys is anonymous and provides the Colleges, University Education Committee and Academic Board with opportunities to recognise excellent teaching, and opportunities for improvement.
For more information on student surveys at ANU and reports on the feedback provided on ANU courses, go to http://unistats.anu.edu.au/surveys/selt/students and http://unistats.anu.edu.au/surveys/selt/results/learning.
Moreover, the course convenor and second examiner are always happy to hear feedback, whether anonymously, privately, or publicly, preferably via Piazza, but also personally in our offices.
ANU has educational policies, procedures and guidelines, which are designed to ensure that staff and students are aware of the University’s academic standards, and implement them. You can read the University’s education policies and an explanatory glossary at: http://policies.anu.edu.au/.
Other key policies include:
Students are expected to know their responsibilities with respect to academic integrity. Please read the ANU policies on academic honesty and plagiarism.
This course does allow for collaboration if you collaborators are mentioned in your submission and some additional rules are followed:
- The writing of code and documentation that you intend to submit must always be done entirely by you, and you only.
- You may exchange ideas on scrap paper, boards, and the like, but do not work together on documents (e.g. reports or code) that are intended for submission.
- Do not collaborate or communicate with other students about your submission right before you start writing your submission documents. After you discuss ideas with anybody else, wait a few hours before you start writing your own submission.
Detection is very likely (even though it might not always appear so from an individual perspective), and the consequences of plagiarism are harsh. Please help to make this a clean course which focuses entirely on the learning process and not on policing.
A student in this course is expected to be able to explain and defend any submitted assessment item. The course convener may conduct or initiate an additional interview about any submitted assessment item for any student in the course. Any significant discrepancy between the two forms of assessment may trigger an investigation for academic misconduct.
The late policy for this course is as follows:
- Late submissions will not be accepted (will incur a 100% penalty)
- There are no exceptions to this rule except under compelling circumstances
- If you believe your circumstances are compelling please contact the course convenor to discuss your options.
Examination material or equipment
No external materials are permitted in examination rooms.
The examinations are conducted in labs on laboratory machines, with answers submitted by Web form. You will login using your ANU id and password into a secure environment. The question paper will be made available in the form of an HTML form, in which to enter answers to the questions. All software development tools relevant to the couurse that have been available in the labs during the semester are also available in the exams. However, access to outside materials are blocked under closed exam conditions.
The primary source of information on the course will be the course Web page at https://cs.anu.edu.au/courses/comp1100.
The primary medium of communication among students and course staff will be the Piazza forum at https://piazza.com/anu.edu.au/fall2018/comp11001130.
This schedule is indicative. Students will be informed well in advance of any substantive changes to the schedule.
|Week||Summary of Activities||Assessment|
|0||Sign up for labs on Streams!|
|1||Foundations||Lab 1: ANU environment|
|2||Functions and abstraction||Lab 2: First functions|
|3||Types and problem solving||Lab 3: Functions & patterns|
|4||Aggregates: tuples and lists||Lab 4: Lists & patterns|
|5||List Functions and I/O||Lab 5: Recursion |
Assignment 1 due
|6||I/O||Lab 6: I/O |
|7||Algebraic types||Lab 7: Typeclasses & polymorphism|
|8||Patterns of computation||Lab 8: Trees|
|9||Higher-Order functions||Lab 9: Higher order functions |
Assignment 2 due
|10||Abstract data types||Lab 10: Functional decomposition|
|11||Complexity||Lab 11: Testing|
|12||Summary and Review||Lab 12: Complexity |
Assignment 3 due
|Examination Period||Final Exam|
Students will be assessed on their participation in labs and lectures, via questions, quizzes, and lab exercises.
There will be three Haskell programming assignments. Assigments are to be completed individually (all program source code submitted on the assignment must be authored individually by the student, or the origin and authorship acknowledged and properly cited). Assignments will be checked for originality using software tools for detecting program similarity.
Programs will be assessed for correctness and completeness against problem specifications, and for originality. Students will also be assessed on their coding style and algorithmic choices. Each student will write a report documenting their solution to the problem, citing all source materials in developing their solution, and attesting to the originality of that solution.
The course will have two formal examinations: a mid-semester examination and a final examination.
Assignments are submitted via the ANU CECS Teaching GitLab at https://gitlab.cecs.anu.edu.au.
Extensions and Penalties
Extensions and late submission of assessment pieces are covered by the Student Assessment (Coursework) Policy and Procedure.
The Course Convener may grant extensions for assessment pieces that are not examinations or take-home examinations. If you need an extension, you must request it in writing on or before the due date. If you have documented and appropriate medical evidence that demonstrates you were not able to request an extension on or before the due date, you may be able to request it after the due date.
No submission of assessment tasks without an extension after the due date will be permitted. If an assessment task is not submitted by the due date, a mark of 0 will be awarded.
Feedback on student work will be via Streams, GitLab, and e-mail.
Resubmission of Assignments
Students may not resubmit work after the due date.
Students must cite all sources of materials used in completing their assignments.
Support for Students
The University offers a number of support services for students. Information on these is available online from http://www.anu.edu.au/students.