Programming Stream

Programming Stream | Market Demand | Course Content | Work in Progress | Members | Issues

Welcome to the Programming Stream Group at the School of Information and Communications Technology

Redirect to Curriculum Review 2012 Overview Page

Introduction

This wiki describes curriculum developments within the programming stream at the School of Information and Communications Technology

• The scope of the currently active projects is driven by
  • the general need to train professional programmers for direct entry into the workplace
  • the growing knowledge-based industries
    • digital game programming industry
    • open source communities for software developers
    • emergence of parallel computing
• The information reported here is being provided to
  • inform faculty members of the status quo
  • solicit comments and criticisms from faculty

What can I do right now?

• add your name to the list of active members and identify your interest here
• add your project(s) to the list of projects under development here if you have any
  • create your own project page describing your own contributions
  • add descriptions of your project(s) in detail to this wiki along with current status
  • list the work that remains to be done
• add any testimonials you have received here
• add information to any section of this wiki - quotes, data, testimonials, suggestions

Curriculum Development (2012, 2013, 2014)

The principal objectives of 2012's development were

• to align the programming stream courses with the C11 and C++11 standards
• to address the success rate of first semester students in the CPA program
• to move towards alignment with Java courses

The principal objectives of 2013's development were

• to complete the alignment of the programming stream courses with the C11 and C++11 standards
• to address the wide variation amongst faculty regarding the texts and web-sites developed by Chris S

The principal objectives of 2014's development are

• determine the content of 344/300 to be rolled out in the fall semester
• align 344/300 with successor courses and professional options to maximize the student success rates in the latter courses

Initially Resolved Issues

Cathy L, Danny A, Don F, Ron T, Ian T, Mary Lynn M, Chris S present

• Data Representation is now fully covered in ULI101
• OOP344 will be compulsory in CPA/CPAC from Fall 2013
• OOP344 and BAC344 are still optional in CPD

Course Specific

IPC144/BTP100

• https://scs.senecac.on.ca/~ipc144/
• https://scs.senecac.on.ca/~btp100/
• web site, workshops, and exercises have been completed by Chris S
• 2012 C11 agreed (see below) changes have been incorporated by Chris S
• Cathy L found Chris S' timeline left enough time to cover everything with time left over for review and sick days
• adding recursion was raised by several faculty last month - Cathy L and Danny A said that they cover it in detail in DSA555/BTP500 - the meeting decided to exclude this topic from the notes, web sites and subject outline but nevertheless leave instructors free to introduce it in 1st semester
• Cathy L does not like the new web site notes
• Cathy L has setup a wiki for faculty to collaborate on making their own notes as an alternative to Chris S' notes

  Cathy L has started uploading Evan W's notes to the wiki

  Chris S has added on each page of the web site a link to Cathy L's wiki on matrix

• Cathy L noted that not all faculty covered the agreed changes this semester
• Sorry I missed the meeting. Anyway FWIW I think we should add more content to IPC144 - such as structs malloc and all operators including bitwise. Just my 2¢....Selmys
• Cathy L wanted to add structs also
• Chris S produced a pdf that can be printed as a text to be sold in the Bookstore
• full changes and the new text are being introduced in Fall 2013
• Cathy L has developed videos up to selection constructs

OOP244/BTP200

• https://scs.senecac.on.ca/~oop244/pages.141/content/index.html
• Working Draft of the Standard (n3337)
• structs removed to IPC144/BTP100
• auto added
• nullptr replaces NULL
• keywords filled in
• first draft completed including file objects, function templates and abstract base classes
• standards history brought up to date
• a few more diagrams added
• outcomes and quotes reviewed
• Danny A disagreed to adding abstract base classes, function templates and file objects and voiced his concern that there was barely enough time to introduce inheritance - although there was no consensus reached on this point, Chris S will move forward with the additions and we will see what happens
• Sorry I am late to respond, generally I agree we should follow Chris S notes and I would like encourage newer practices found in C11 for IPC144/OOP344, and in C++0x for OOP244/OOP344. This means stuff like using auto to let compiler decipher type, nullptr to initialize pointers. Students should also learn how to debug programs that are not working based on error messages from compiler, crashes, incorrect programming practices. Making a mistake is ok but repeatedly not initializing pointers, local variables, etc. is a common reason for frustration. Just my thoughts - MF

Issues Raised and Resolved - First Draft

• method or member functions - revert to member functions for C++
• start with using namespace std; and cout - then switch to std::cout once header file requires iostream - header file should not include using namespace std
• unit tests - two sections added - in Modular Programming (week 1) - in Abstract Base Classes (week 11)

Issues Raised and Resolved - Final Draft

• optional sections for 244 decided
• copy ctors and = ops moved just after Current Object
• virtual functions and abstract base classes moved ahead of templates
• appendix on library functions added

OOP344/BTP300

• Gathering requests to be considered for inclusion in 344/300 until Feb 21 2014
• Requests will be classed under 3 categories - mandatory, optional, excluded
• Discussions on requested items closing date April 4

Suggested Topics for Inclusion (not decided)

• pthreads - CMS
• rvalue references and move constructors - CMS
• constexpr - CMS
• extern template - CMS
• initializer lists - CMS
• range based for - CMS
• function objects, lambda expressions - CMS
• Makefiles - CMS
• assertions - CMS
• message passing amongst objects - CMS
• event handling - CMS
• reflection - CMS

Proposed Learning Outcomes

aligned with C# and Java follow up courses - deadline for feedback Feb 28

• describe and implement inheritance using abstract base classes, interfaces, and multiple base classes
• describe and implement polymorphism using templates and virtual functions
• describe and implement data management using linked lists
• apply established algorithms to programming solutions using standard libraries
• describe separation of concerns using patterns, encapsulation, and closures
• describe and implement programming solutions for multi-processor hardware using multi-threading
• describe and implement persistent storage of objects using file streams

this initial draft was accepted in principle by the program coordinators

no feedback received from faculty regarding scope by the Feb 28 deadline

feedback from new hires on the phrasing itself

• CAE has strong opinions about the structure of learning outcomes, which are incompatible with the outcomes pr4oposed above

second draft in response

• implement/demonstrate inheritance relationships between objects using abstract base classes, interfaces, and multiple base classes
• implement/demonstrate polymorphic types using virtual functions and templates
• implement/demonstrate separation of concerns in object design using encapsulation, closures, and patterns
• implement multi-threaded solutions for multi-processor hardware using pThreads
• implement persistent storage of objects using file streams
• implement memory management using dynamic allocation and linked lists
• apply established algorithms to programming solutions using standard libraries

CMS subsequently found and distributed the following article by the ITiCSE Workgroup, which speaks to the uniqueness of computer science education with respect to generic educational taxonomies

• Developing a Computer-Science-specific Learning Taxonomy

March 5 2014

Pre-Meeting Notes

• preliminary stats results under old curriculum:
  • students in MAP523, DSA555 and GPU610 tend to do poorly relative to their performance in OOP344
  • students in other pro options tend to do better than they did in OOP344
• faculty meeting scheduled for March 5 to review current state and steps forward

Attendance 3 Sessions 10:00-11:35, 11:40-13:30, 14:00-15:00

Cathy Leung, Elliott Coleshill, Peter McIntyre, Mark Fernandes, Ian Tipson, Marcel Silva, Danny Abesdris, John Selmys, Andrew Smith, Sunny Shi, Peter Liu, Chris Szalwinski

General Topics Discussed

• IPC144 - CL - we should compress the list of topics covered in depth by all instructors in the course - CS asked CL to create a list of the key topics (variables, control flow, pointers, functions, arrays, structs, files) - CL students should be directed to other topics without spending too much time
• IPC144/BTP100 - JS, AS, IT, CS - malloc and free should be introduced in IPC144/BTP100 - would precede new and delete in second semester and set a better groundwork for understanding memory management and manipulation in third semester
• OOP244/BTP200 - Test 1 results show good distribution of grades - problem with high DNAs needs to be investigated
• ICA - CL - a non-credit pre-course should be created for students to learn basic tools and skills such as git at their own discretion - no objections
• CDOT - MF, CS, IT - skills specifically required for working in CDOT should be taught separately in a non-credit course run and taught by CDOT faculty - students who wish to work in CDOT should be encouraged to take these courses to improve their chances of getting hired at CDOT (no objection)
• Best Practices - DA, IT - a set of best teaching practices should be collected to assist faculty in the programming courses
• Fresh Assignments - CL, IT, MF - a culture of creating fresh assignments should encouraged - many faculty simply recycle old assignments (no objections, some skepticism)
• Stacked Assignments - IT, CL - students who have not completed one part of a stacked assignment should receive an object version of that assignment so as not to be held back relative to other students in the class
• Content Heavy - DA - DA noted that programming courses are still content heavy
• unit testing - AS - should be introduced gradually - several standard tools are available

• Data Management - MF, EC - students have very little understanding of memory - this needs to be improved

OOP344/BTP300

Outcomes discussed:

• comfort with inheritance (abstract base classes, multiple inheritance), polymorphism (interfaces, virtual functions, templates), data management, data structures (linked lists and multi-dimensional arrays), standard template library, function objects, lambda expressions, collections of objects and containers, file streams
• remove cross-platform coding, variadic functions
• develop new assignments

Phrasing Outcomes: what is to be assessed must be clear (CS). Students learn Computer Science through thorough mastery of progressively more abstract schemas built on more fundamental ones (CS)

Learning Taxonomy

Third Draft Learning Outcomes

synthesis of input and exclusions recommended to March 11 2014:

1. model collections of objects using sequential containers
2. implement allocation, access and deallocation of dynamic memory using multi-dimensional arrays and linked lists of objects
3. model the hiding of information using function objects and closures
4. model generalization and specialization of object properties using inheritance hierarchies, which include both single and multiple base classes
5. implement polymorphic types using interfaces, virtual functions and templates (generics)
6. implement solution artifacts using algorithms from the standard template library
7. implement asynchronous execution within programming solutions using multi-threading
8. implement persistent storage of objects and collections of objects using file stream objects

Fourth Draft Learning Outcomes

feedback: may have too many outcomes to cover (content bloat) - MF

revision to reduce the number of topics that must be tested (March 14 2014):

OOP344:

1. model collections of objects using sequential containers, multi-dimensional arrays and linked lists
2. model the hiding of information using function objects and closures
3. model generalization and specialization of object properties using inheritance hierarchies
4. model polymorphic types using interfaces, virtual functions and templates (generics)
5. implement solution artifacts using algorithms from the standard template library
6. implement asynchronous execution within programming solutions using multi-threading

BTP300:

1. model collections of objects using sequential containers, multi-dimensional arrays and linked lists
2. model the hiding of information using function objects and closures
3. model generalization and specialization of object properties using inheritance hierarchies, including single and multiple base classes
4. model polymorphic types using interfaces, virtual functions and templates (generics)
5. implement solution artifacts using algorithms from the standard template library
6. implement asynchronous execution within programming solutions using multi-threading
7. implement persistent storage of objects and collections of objects using file stream objects

Centre for Academic Excellence

• CS unable to reach initial agreement with CAE - telephone conversation
  • VL (Valerie Lopes)'s opinion
    • finds verbs 'model' and 'implement' questionable
    • third part of outcome should answer the question why learn this
    • thinks that CVS (Credential Validation Service) would not accept these outcomes
    • thinks that PEQAB (Post-Secondary Education Quality Assessment Board) would not accept these outcomes
    • finds insufficient difference between OOP344 and BTP300 outcomes
  • CS's response
    • proposed learning outcomes are in the three-part format outlined by CAE - action verb | field of knowledge | assessment criteria
    • verbs of the two-dimensional matrix shown above express learning taxonomy for programming subjects notably better than popular generic verbs of hierarchical taxonomies
    • 'model' and 'implement' are ComSci jargon that differentiate productive activity in the construction of artifacts and have well-understood and specific meanings to subject experts
    • assessment criteria trump the question 'why learn this' as the third part of the outcome statement
    • there is agreement between diploma and degree coordinators regarding differences between OOP344 and BTP300
• IT spoke with Kevin Pitts of CAE and received the following clarifications
  • the audience for approving learning outcomes is ministry employees who wish to know the purpose of each outcome (in addition to what we have proposed)
  • the learning outcomes for diploma and degree must not be identical - the ministry is watching for this

Fifth Draft of the Learning Outcomes

• CL objected to the wholesale removal of linked lists from OOP344
• CS and IT propose adding tracing of a linked list

CAE requirements are underlined, additions and changes are in bold

OOP344:

1. design collections of model objects using sequential containers and multi-dimensional arrays to solve a systems or business problem
2. model information hiding using function objects and closures to specialize a programming solution for a particular application
3. model generalization and specialization of object properties using inheritance hierarchies to minimize the duplication of code
4. model polymorphic behavior using interfaces, virtual functions and templates (generics) to amplify the reusability of code
5. implement solution artifacts using algorithms and iterators of the standard template library to utilize existing technologies
6. implement concurrency within a programming solution using multi-threading libraries to improve the performance of a program
7. trace the execution of a program that includes a linked list to debug an application

BTP300:

1. design collections of model objects using sequential containers, multi-dimensional arrays and linked lists to solve a complex systems or business problem
2. model information hiding using function objects and closures to specialize a programming solution for a particular application
3. model generalization and specialization of object properties using inheritance hierarchies, including single and multiple base classes to minimize the duplication of code in complex hierarchies
4. model polymorphic behavior using interfaces, virtual functions and templates (generics) to amplify the reusability of code
5. implement solution artifacts using algorithms and iterators of the standard template library to utilize existing technologies
6. implement concurrency within a programming solution using multi-threading libraries to improve the performance of a program
7. implement persistence of objects and collections of objects using file stream objects to backup data for future restoration
8. trace the execution of program instructions that include a linked list

Sixth Draft of the Learning Outcomes

• April 2 2014
  • CL, IP and CS agreed to move linked lists to DSA555, move STL from DSA555 to OOP344, and add outcomes to OOP344 that address quadratic complexity and memory addressing
  • CL, IP and CS also edited the wording of the fifth draft

OOP344:

1. design collections of model objects using sequential containers and multi-dimensional arrays to solve a systems or business problem
2. create function objects and closures to customize a programming solution for a particular application
3. model generalization and specialization using inheritance hierarchies to minimize the duplication of code
4. model polymorphic behavior using interfaces, virtual functions and templates (generics) to amplify the reusability of code
5. implement design components using algorithms of the standard template library to utilize existing technologies
6. create program components of quadratic complexity to solve non-linear problems
7. design program components using raw pointers and pointer arithmetic to access data in program memory
8. design multi-tasked solutions using threading libraries to improve the performance of a program

BTP300:

1. design collections of model objects using sequential containers and multi-dimensional arrays to solve a complex systems or business problem
2. create function objects and closures to customize a programming solution for a particular application
3. model generalization and specialization using single and multiple inheritance to minimize the duplication of code in complex hierarchies
4. model polymorphic behavior using interfaces, virtual functions and templates (generics) to amplify the reusability of code
5. implement design components using algorithms of the standard template library to utilize existing technologies
6. create program components of quadratic complexity to solve non-linear problems
7. design program components using raw pointers, pointer arithmetic, and smart pointers to access data in program memory
8. design multi-tasked solutions using threading libraries to improve the performance of a program
9. design file stream objects to backup text and binary data for future restoration
10. trace the execution of program code that includes a linked list to debug an application

To Be Done

• IPC144/BTP100
  • fix selection sort example
  • replace sorting applets with alternatives
  • revise chapter on structs so that it can be covered immediately following arrays and before strings
• OOP244/BTP200
  • Chris S to upgrade the web site to include the agreed C++11 changes by mid-October 2013 - first draft is complete - done
  • Chris S to produce pdf by mid-October 2013 - done
  • full changes and notes will be introduced in Winter 2014 - done
• OOP344/BTP300
  • Chris S to prepare full subject outlines by end of the semester
  • full changes and notes will be introduced in Fall 2014
  • Chris S and Fardad to agree on all changes
  • Fardad requests lab tutor for 2 + 2 to succeed - lab assistants will be available (MLM)
• JAC444/MAP524 for CPA
  • Selmys suggests replacing JAC444 with MAP524 OR allowing students to choose one, because
    • Both JAC444 and MAP524 are introductions to Java for C++ programmers. The essential difference is that MAP524 uses the Android/Google API while JAC444 uses the older Java APIs (eg Swing/AWT).
    • Introduces students to Android development earlier (4th semester instead of 5th).
    • Android is the world's most popular mobile platform.

Resolved Allocation Issues

• Data Representation needs to be taught in first semester in another stream

binary - hex | hex - decimal

• IPC144/BTP100

add variable length arrays - done

add const - done

add pointer - array equivalence - done

trivial additions to align with standard (see detail page)

remove gets() - done

assign a problem that requires the application of integer data rep knowledge taught in another course in the first half

• OOP244/BTP200

move namespace definition to start - done

add inline functions - done

add parameter defaults - done

add simple file objects

move type safe casting nearer start

add simple function templates to polymorphism

add abstract base classes

trivial additions to align with standard (see detail page)

• OOP344/BTP300

full exposure to the standard template library

conceptual-level introduction to linked lists

add multi-threading

add rvalues and move constructors

trivial additions to align with standard (see detail page)

• Beyond OOP344/BTP300

DSA555/BTP500 to implement and model linked lists

trivial additions to align with standard (see detail page)

Delivery Issues

• Committee for IPC144 has been struck - held first meeting - will reconvene
• Danny, Sunny, and Mark will try applying Chris' timeline over the summer 2012 to enable the introduction of inheritance earlier in the semester

To Be Done

• update learning outcomes to suit

OOP244 Proposed Subject Outline

BTP200 Proposed Subject Outline

• decide which sections to make optional and which to relegate to appendices
• update 244/200 course notes to reflect these changes
• prepare 144/100 course notes to reflect these changes - done
• agree timeline for implementing changes - done

Proposed Timeline for Implementation

Ongoing Issues

marketing

• what is the market saying
• what do we market now and how
• how do we attract the best and the brightest to our programs

employability

• why do top employers reject our top students

faculty education

• a need exists for internal faculty professional development
• a birds of a feather group to discuss Visual Studio

impact of social media

• how will we interface with social media
• personal learning environments

delivery

techniques and tools

• which platforms should we be using

  gnu - which version

  clang as an alternate compiler for C/C++ (might need a separate installation request to ITS each time)

  visual studio

• how early should students be exposed to open source tools

  using open source, instead of teaching open source? (repos, wikis, blogging, online collaboration tools)

• how early should students work with repositories

  1. in early semesters, using repos as individual drop box, and versioning and then move to collaboration features in later semesters
  2. which repositories should be introduced?

collaboration

• should students work in teams in OOP344, BTP300

  teamwork requires significantly more effort on the part of the instructor

Archives

should CPD include a professional option

• for example, to take introductory game programming GAM666/DPS901
  • brings together programming and systems for the first time
  • top CPD students who enroll often do well in this course
• faculty decided to keep the professional option