CR: COMP 1406 Learning Objectives - Revision history

Soma: /* Learning Objectives */

2012-12-11T23:11:12Z

Learning Objectives

← Older revision		Revision as of 23:11, 11 December 2012
Line 10:		Line 10:

	Object-oriented programming		Object-oriented programming
	* Given a set of requirements, be able to formulate an object-oriented solution, ~~identifying appropriate objects, attributes, behaviors, and associations between objects (inheritance, composition), and making appropriate use of~~ inheritance ~~and override in method implementations.~~		*
	* Understand the advantages of object-oriented programming for encapsulation and reuse.		* Given a set of requirements, be able to formulate an object-oriented solution, but without inheritance
			* Understand the advantages of object-oriented programming for encapsulation and reuse.
			* Understand mechanism of inheritance: fields and methods,
	* Be able to navigate a moderately sized existing class hierarchy, for example a GUI API.		* Be able to navigate a moderately sized existing class hierarchy, for example a GUI API.

Howe: /* Learning Objectives */

2011-05-02T14:41:59Z

Learning Objectives

← Older revision		Revision as of 14:41, 2 May 2011
Line 13:		Line 13:
	* Understand the advantages of object-oriented programming for encapsulation and reuse.		* Understand the advantages of object-oriented programming for encapsulation and reuse.
	* Be able to navigate a moderately sized existing class hierarchy, for example a GUI API.		* Be able to navigate a moderately sized existing class hierarchy, for example a GUI API.


	General programming		General programming
	* Be able to construct a complete application including user interaction and the file system.		* Be able to construct a complete application including user interaction and the file system.
	* Be able to build an application using the Model/View/Controller pattern.		* Be able to build an application using the Model/View/Controller pattern.
	* Have an ~~understanding~~ of scoping as an explicit concept.		* Have an u
			nderstanding of scoping as an explicit concept.


	Data structures		Data structures
	* Have experience with simple abstract data types such as stacks, lists, sets, and dictionaries, and an understanding why the abstractions are useful.		* Have experience with simple abstract data types such as stacks, lists, sets, and dictionaries, and an understanding why the abstractions are useful.
	* Be able to solve simple problems involving elementary singly and doubly-linked data structures such as lists and trees.		* Be able to solve simple problems involving elementary singly and doubly-linked data structures such as lists and trees.


	Recursion		Recursion
	* Understand the recursive view simple data structures such as trees, and be able to apply the corresponding recursion pattern.		* Understand the recursive view simple data structures such as trees, and be able to apply the corresponding recursion pattern.
	* Use recursion to devise divide-and-conquer solutions to problems without obvious iterative solutions, for example tree traversals and maze pathfinding		* Use recursion to devise divide-and-conquer solutions to problems without obvious iterative solutions, for example tree traversals and maze pathfinding


	Efficiency		Efficiency
	* Have an intuitive, operational understanding of basic asymptotic complexity, for example quadratic vs linear time, but without a formal definition of "big-O".		* Have an intuitive, operational understanding of basic asymptotic complexity, for example quadratic vs linear time, but without a formal definition of "big-O".


	Testing and debugging		Testing and debugging

Howe: /* Learning Objectives */

2011-05-02T14:41:15Z

Learning Objectives

← Older revision		Revision as of 14:41, 2 May 2011
Line 10:		Line 10:

	Object-oriented programming		Object-oriented programming
	* Given a set of requirements, be able to formulate an object-oriented		* Given a set of requirements, be able to formulate an object-oriented solution, identifying appropriate objects, attributes, behaviors, and associations between objects (inheritance, composition), and making appropriate use of inheritance and override in method implementations.
	solution, identifying appropriate objects, attributes, behaviors,		* Understand the advantages of object-oriented programming for encapsulation and reuse.
	and associations between objects (inheritance, composition), and		* Be able to navigate a moderately sized existing class hierarchy, for example a GUI API.
	making appropriate use of inheritance and override in method
	implementations.
	* Understand the advantages of object-oriented programming for
	encapsulation and reuse.
	* Be able to navigate a moderately sized existing class hierarchy,
	for example a GUI API.

	General programming		General programming
	* Be able to construct a complete application including user		* Be able to construct a complete application including user interaction and the file system.
	interaction and the file system.		* Be able to build an application using the Model/View/Controller pattern.
	* Be able to build an application using the Model/View/Controller
	pattern.
	* Have an understanding of scoping as an explicit concept.		* Have an understanding of scoping as an explicit concept.

	Data structures		Data structures
	* Have experience with simple abstract data types such as stacks,		* Have experience with simple abstract data types such as stacks, lists, sets, and dictionaries, and an understanding why the abstractions are useful.
	lists, sets, and dictionaries, and an understanding why the		* Be able to solve simple problems involving elementary singly and doubly-linked data structures such as lists and trees.
	abstractions are useful.
	* Be able to solve simple problems involving elementary singly and
	doubly-linked data structures such as lists and trees.

	Recursion		Recursion
	* Understand the recursive view simple data structures such as trees,		* Understand the recursive view simple data structures such as trees, and be able to apply the corresponding recursion pattern.
	and be able to apply the corresponding recursion pattern.		* Use recursion to devise divide-and-conquer solutions to problems without obvious iterative solutions, for example tree traversals and maze pathfinding
	* Use recursion to devise divide-and-conquer solutions to problems
	without obvious iterative solutions, for example tree traversals and
	maze pathfinding

	Efficiency		Efficiency
	* Have an intuitive, operational understanding of basic asymptotic		* Have an intuitive, operational understanding of basic asymptotic complexity, for example quadratic vs linear time, but without a formal definition of "big-O".
	complexity, for example quadratic vs linear time, but without a
	formal definition of "big-O".

	Testing and debugging		Testing and debugging
	* Have a repertoire of elementary techniques for locating bugs in		* Have a repertoire of elementary techniques for locating bugs in source code.
	source code.		* Know some of the common kinds of bugs that arise in object-oriented programs.
	* Know some of the common kinds of bugs that arise in object-oriented
	programs.

	=Topics=		=Topics=

Howe: /* Learning Objectives */

2011-05-02T14:38:48Z

Learning Objectives

← Older revision		Revision as of 14:38, 2 May 2011
Line 11:		Line 11:
	Object-oriented programming		Object-oriented programming
	* Given a set of requirements, be able to formulate an object-oriented		* Given a set of requirements, be able to formulate an object-oriented
	solution, identifying appropriate objects, attributes, behaviors,		solution, identifying appropriate objects, attributes, behaviors,
	and associations between objects (inheritance, composition), and		and associations between objects (inheritance, composition), and
	making appropriate use of inheritance and override in method		making appropriate use of inheritance and override in method
	implementations.		implementations.
	* Understand the advantages of object-oriented programming for		* Understand the advantages of object-oriented programming for
	encapsulation and reuse.		encapsulation and reuse.
	* Be able to navigate a moderately sized existing class hierarchy,		* Be able to navigate a moderately sized existing class hierarchy,
	for example a GUI API.		for example a GUI API.

	General programming		General programming
	* Be able to construct a complete application including user		* Be able to construct a complete application including user
	interaction and the file system.		interaction and the file system.
	* Be able to build an application using the Model/View/Controller		* Be able to build an application using the Model/View/Controller
	pattern.		pattern.
	* Have an understanding of scoping as an explicit concept.		* Have an understanding of scoping as an explicit concept.

	Data structures		Data structures
	* Have experience with simple abstract data types such as stacks,		* Have experience with simple abstract data types such as stacks,
	lists, sets, and dictionaries, and an understanding why the		lists, sets, and dictionaries, and an understanding why the
	abstractions are useful.		abstractions are useful.
	* Be able to solve simple problems involving elementary singly and		* Be able to solve simple problems involving elementary singly and
	doubly-linked data structures such as lists and trees.		doubly-linked data structures such as lists and trees.

	Recursion		Recursion
	* Understand the recursive view simple data structures such as trees,		* Understand the recursive view simple data structures such as trees,
	and be able to apply the corresponding recursion pattern.		and be able to apply the corresponding recursion pattern.
	* Use recursion to devise divide-and-conquer solutions to problems		* Use recursion to devise divide-and-conquer solutions to problems
	without obvious iterative solutions, for example tree traversals and		without obvious iterative solutions, for example tree traversals and
	maze pathfinding		maze pathfinding

	Efficiency		Efficiency
	* Have an intuitive, operational understanding of basic asymptotic		* Have an intuitive, operational understanding of basic asymptotic
	complexity, for example quadratic vs linear time, but without a		complexity, for example quadratic vs linear time, but without a
	formal definition of "big-O".		formal definition of "big-O".

	Testing and debugging		Testing and debugging

Howe: /* Learning Objectives */

2011-05-02T14:36:29Z

Learning Objectives

← Older revision		Revision as of 14:36, 2 May 2011
Line 8:		Line 8:
	=Learning Objectives=		=Learning Objectives=

	~~Objectives for the whole course~~

			Object-oriented programming
			* Given a set of requirements, be able to formulate an object-oriented
			solution, identifying appropriate objects, attributes, behaviors,
			and associations between objects (inheritance, composition), and
			making appropriate use of inheritance and override in method
			implementations.
			* Understand the advantages of object-oriented programming for
			encapsulation and reuse.
			* Be able to navigate a moderately sized existing class hierarchy,
			for example a GUI API.

			General programming
			* Be able to construct a complete application including user
			interaction and the file system.
			* Be able to build an application using the Model/View/Controller
			pattern.
			* Have an understanding of scoping as an explicit concept.

			Data structures
			* Have experience with simple abstract data types such as stacks,
			lists, sets, and dictionaries, and an understanding why the
			abstractions are useful.
			* Be able to solve simple problems involving elementary singly and
			doubly-linked data structures such as lists and trees.

			Recursion
			* Understand the recursive view simple data structures such as trees,
			and be able to apply the corresponding recursion pattern.
			* Use recursion to devise divide-and-conquer solutions to problems
			without obvious iterative solutions, for example tree traversals and
			maze pathfinding

			Efficiency
			* Have an intuitive, operational understanding of basic asymptotic
			complexity, for example quadratic vs linear time, but without a
			formal definition of "big-O".

			Testing and debugging
			* Have a repertoire of elementary techniques for locating bugs in
			source code.
			* Know some of the common kinds of bugs that arise in object-oriented
			programs.

	=Topics=		=Topics=

Soma: Created page with "=Calendar Description= =Assumed Background= Learning objectives completed before this course. =Learning Objectives= Objectives for the whole course =Topics= ==Topic 1== …"

2011-03-02T16:37:43Z

Created page with "=Calendar Description= =Assumed Background= Learning objectives completed before this course. =Learning Objectives= Objectives for the whole course =Topics= ==Topic 1== …"

New page

=Calendar Description=

=Assumed Background=

Learning objectives completed before this course.

=Learning Objectives=

Objectives for the whole course

=Topics=

==Topic 1==

Learning objectives for topic 1

==Topic 2==

Learning objectives for topic 2