Course                             Course                                                                                             Course                                                                                            L    T    P    C
18CSC202J                                  OBJECT ORIENTED DESIGN AND PROGRAMMING                                                    C                                 Professional Core
   Code                               Name                                                                                             Category                                                                                           3    0    2    4
 Pre-requisite                                                Co-requisite                                                                 Progressive
                 18CSS101J                                                        Nil                                                                  18CSC207J
   Courses                                                      Courses                                                                     Courses
Course Offering Department              Computer Science and Engineering                       Data Book / Codes/Standards                Nil
Course Learning Rationale (CLR): The purpose of learning this course is to:                                                                     Learning                                     Program Learning Outcomes (PLO)
CLR-1 :     Utilize class and build domain model for real-time programs                                                                     1      2       3           1     2     3     4     5     6   7     8     9    10    11        12   13   14   15
CLR-2 :     Utilize method overloading and operator overloading for real-time application development programs
CLR-3 :     Utilize inline, friend and virtual functions and create application development programs
CLR-4 :     Utilize exceptional handling and collections for real-time object oriented programming applications
CLR-5 :     Construct UML component diagram and deployment diagram for design of applications
CLR-6 :     Create programs using object oriented approach and design methodologies for real-time application development
Course Learning Outcomes (CLO): At the end of this course, learners will be able to:
CLO-1 :     Identify the class and build domain model                                                                                       3     80   70              H    H      M     -     -    -    -     -    H     H      -        -    M    H    H
CLO-2 :     Construct programs using method overloading and operator overloading                                                            3     85   75              H    H      H     H     H    -    M     -    H     H      -        -    M    H    H
CLO-3 :     Create programs using inline, friend and virtual functions, construct programs using standard templates                         3     75   70              H    H      M     H     H    -    M     -    H     H      -        -    M    H    H
CLO-4 :     Construct programs using exceptional handling and collections                                                                   3     85   80              H    H      H     -     -    -    -     -    H     M      -        -    M    H    H
CLO-5 :     Create UML component diagram and deployment diagram                                                                             3     85   75              H    M      M     M     M    M    M     -    H     H      -        M    M    H    H
CLO-6 :     Create programs using object oriented approach and design methodologies                                                         3     80   70              H    H      M     -     -    -    -     -    H     H      -        -    M    H    H
Duration (hour)                       15                                           15                                            15                                                 15                                               15
                  Comparison of Procedural and Object
          SLO-1                                               Types of constructor (Default, Parameter)    Feature Inheritance: Single and Multiple            Generic - Templates : Introduction
                  Oriented Programming                                                                                                                                                                       STL: Containers: Sequence and
 S-1
                                                                                                                                                                                                             Associative Container
          SLO-2 OOPS and its features                         Static constructor and copy constructor      Inheritance: Multilevel                             Function templates
                  I/O Operations, Data Types, Variables,      Feature Polymorphism: Constructor
          SLO-1                                                                                            Inheritance: Hierarchical                           Example programs Function templates           Sequence Container: Vector, List
                  static                                      overloading
 S-2
          SLO-2 Constants, Pointers, Type Conversions         Method Overloading                           Inheritance: Hybrid                                 Class Templates                               Sequence Container: Deque, Array
          SLO-1 Features: Class and Objects                   Example for method overloading                                                                   Class Templates
 S-3                                                          Method Overloading: Different parameter      Inheritance: Example Programs                       Example programs for Class and Function STL : Stack
          SLO-2 UML Diagrams Introduction
                                                              with different return values                                                                     templates
  S       SLO-1                                               Lab 4: Constructor and Method
                Lab 1: I/O operations                                                                      Lab 7: Inheritance and its types                    Lab 10: Templates                             Lab 13: STL Containers
 4-5      SLO-2                                               overloading
          SLO-1 Feature :Class and Objects                    Operator Overloading and types               Advanced Functions: Inline, Friend                  Exceptional Handling: try and catch
 S-6                                                                                                                                                           Exceptional Handling: Multilevel              Associative Containers: Map, Multimap
          SLO-2 Examples of Class and Objects                 Overloading Assignment Operator              Advanced Functions: Virtual, Overriding
                                                                                                                                                               exceptional
          SLO-1 UML Class Diagram and its components          Overloading Unary Operators                  Advanced Function: Pure Virtual function            Exceptional Handling: throw and throws        Iterator and Specialized iterator
 S-7
                                                                                                           Example for Virtual and pure virtual
          SLO-2 Class Diagram relations and Multiplicity      Example for Unary Operator overloading                                                           Exceptional Handling: finally                 Functions of iterator
                                                                                                           function
                                                                                                                                                               Exceptional Handling: User defined
          SLO-1    Feature Abstraction and Encapsulation      Overloading Binary Operators                 Abstract class and Interface                                                                      Algorithms: find(), count(), sort()
                                                                                                                                                               exceptional
 S-8
                  Application of Abstraction and
          SLO-2                                               Example for Binary Operator overloading      Example Program                                     Example Programs using C++                    Algorithms: search(), merge()
                  Encapsulation
                                                   SRM Institute of Science & Technology Academic Curricula (2018 Regulations) - Control copy
                                                                                                                       188
 S        SLO-1 Lab 2: Classes and Objects, Class            Lab 5: Polymorphism : Operators                                                                                                   Lab 15: STL Associative containers and
                                                                                                        Lab 8: Virtual Function and Abstract class Lab 11: Exceptional Handling
9-10      SLO-2 Diagram                                      Overloading                                                                                                                       algorithms
          SLO-1 Access specifiers public, private            UML Interaction Diagrams                   UML State Chart Diagram                    Dynamic Modeling: Package Diagram           Function Object : for_each(), transform()
S-11
          SLO-2 Access specifiers - protected, friend, inline Sequence Diagram                          UML State Chart Diagram                    UML Component Diagram                       Example for Algorithms
                  UML use case Diagram, use case,
          SLO-1                                              Collaboration Diagram                      Example State Chart Diagram                UML Component Diagram                       Streams and Files: Introduction
                  Scenario
S-12
          SLO-2 Use case Diagram objects and relations       Example Diagram                            UML Activity Diagram                       UML Deployment Diagram                      Classes and Errors
          SLO-1 Method, Constructor and Destructor           Feature: Inheritance                       UML Activity Diagram                       UML Deployment Diagram
                                                                                                                                                                                               Disk File Handling Reading Data and
S-13
                                                                                                                                                                                               Writing Data
          SLO-2 Example program for constructor              Inheritance and its types                  Example Activity Diagram                   Example Package, Deployment, Package
  S   SLO-1                                                                                                                                        Lab12 : UML Component, Deployment,
            Lab 3: Methods and Constructor, Usecase Lab 6: UML Interaction Diagram                      Lab 9: State Chart and Activity Diagram                                                Lab15: Streams and File Handling
14-15 SLO-2                                                                                                                                        Package diagram
                  1.     Grady Booch, Robert A. Maksimchuk, Michael W. Engle, Object-Oriented Analysis and Design with Applications,
                                                                                                                                        4.   Robert Lafore, Object-Oriented Programming in C++, 4 th ed., SAMS Publishing, 2008
Learning                 3rd ed., Addison-Wesley, May 2007
                                                                                                                                        5.
Resources         2.     Reema Thareja, Object Oriented Programming with C++, 1 st ed., Oxford University Press, 2015
                                                                                                                                        6.   Craig Larmen, Applying UML and Patterns, 3rd ed., Prentice Hall, 2004
                  3.     Sourav Sahay, Object Oriented Programming with C++, 2 nd ed., Oxford University Press, 2017
Learning Assessment
                                                                                            Continuous Learning Assessment (50% weightage)
                                                                                                                                                                                                    Final Examination (50% weightage)
                                                   CLA 1 (10%)                            CLA 2 (15%)                         CLA 3 (15%)                            CLA 4 (10%)#
                       Level of Thinking
                                              Theory         Practice                Theory           Practice          Theory             Practice              Theory        Practice                 Theory               Practice
                    Remember
Level 1                                       20%                20%                 15%              15%              15%                15%                 15%                     15%                 15%                    15%
                    Understand
                    Apply
Level 2                                       20%                20%                 20%              20%              20%                20%                 20%                     20%                 20%                    20%
                    Analyze
                    Evaluate
Level 3                                       10%                10%                 15%              15%              15%                15%                 15%                     15%                 15%                    15%
                    Create
                    Total                             100 %                                    100 %                          100 %                                        100 %                                     100 %
# CLA 4 can be from any combination of these: Assignments, Seminars, Tech Talks, Mini-Projects, Case-Studies, Self-Study, MOOCs, Certifications, Conf. Paper etc
# For the laboratory component the students are advised to take an application and apply the concepts
Course Designers
Experts from Industry                                                                          Experts from Higher Technical Institutions                                                   Internal Experts
Mr. Girish Raghavan, Senior DMTS Member, Wipro Ltd.                                            1. Dr. Srinivasa Rao Bakshi, IITM Chennai, sbakshi@iitm.ac.in                                1. Ms. C.G.Anupama, SRMIST
Ms. Thamilchelvi, Solutions Architect, Wipro Ltd                                               2. Dr. Ramesh Babu, N, IITM Chennai, nrbabu@iitm.ac.in                                       2. Mr. C.Arun, SRMIST
                                                                                                                                                                                            3. Mr. Geogen George, SRMIST
                                                                                                                                                                                            4. Mr. Muthukumaran, SRMIST
                                                 SRM Institute of Science & Technology Academic Curricula (2018 Regulations) - Control copy
                                                                                                                   189
  Course                            Course                                                                                         Course                                                                                         L       T    P    C
                 18CSC203J                                  COMPUTER ORGANIZATION AND ARCHITECTURE                                                  C                                 Professional Core
   Code                              Name                                                                                         Category                                                                                        3       0    2    4
 Pre-requisite                                               Co-requisite                                                                Progressive
                 Nil                                                              Nil                                                                18CSC207J
   Courses                                                     Courses                                                                    Courses
Course Offering Department             Computer Science and Engineering                        Data Book / Codes/Standards             Nil
Course Learning Rationale (CLR): The purpose of learning this course is to:                                                                  Learning                                       Program Learning Outcomes (PLO)
CLR-1 :    Utilize the functional units of a computer                                                                                    1      2       3           1     2     3     4      5    6   7     8    9    10    11    12      13   14   15
CLR-2 :    Analyze the functions of arithmetic Units like adders, multipliers etc.
CLR-3 :    Understand the concepts of Pipelining and basic processing units
CLR-4 :    Study about parallel processing and performance considerations.
CLR-5 :    Have a detailed study on Input-Output organization and Memory Systems.
CLR-6 :    Simulate simple fundamental units like half adder, full adder etc
Course Learning Outcomes (CLO): At the end of this course, learners will be able to:
CLO-1 :    Identify the computer hardware and how software interacts with computer hardware                                              2     80   70              H     H     -     -      -    -   -     -    M    L      -        M   -    -    -
CLO-2 :    Apply Boolean algebra as related to designing computer logic, through simple combinational and sequential logic circuits      3     85   75              H     H     H     -      H    -   -     -    M    L      -        M   -    -    -
CLO-3 :    Analyze the detailed operation of Basic Processing units and the performance of Pipelining                                    2     75   70              H     H     H     H      -    -   -     -    M    L      -        M   -    -    -
CLO-4 :    Analyze concepts of parallelism and multi-core processors.                                                                    3     85   80              H     -     -     H      -    -   -     -    M    L      -        M   -    -    -
CLO-5 :    Identify the memory technologies, input-output systems and evaluate the performance of memory system                          3     85   75              H     -     H     H      -    -   -     -    M    L      -        M   -    -    -
CLO-6 :    Identify the computer hardware, software and its interactions                                                                 3     85   75              H     H     H     H      H    -   -     -    M    L      -        M   -    -    -
  Duration                                                                        15                                         15                                                  15                                              15
                                     15
   (hour)
                                                             Addition and subtraction of Signed          Fundamental concepts of basic processing
       SLO-1 Functional Units of a computer                                                                                                       Parallelism                                             Memory systems -Basic Concepts
                                                             numbers                                     unit
 S-1
       SLO-2 Operational concepts                            Problem solving                             Performing ALU operation                           Need, types of Parallelism                    Memory hierarchy
                                                                                                         Execution of complete instruction, Branch
       SLO-1 Bus structures                                  Design of fast adders                                                                          applications of Parallelism                   Memory technologies
                                                                                                         instruction
 S-2
                                                             Ripple carry adder and Carry look ahead                                                        Parallelism in Software
       SLO-2 Memory locations and addresses                                                              Multiple bus organization                                                                        RAM, Semiconductor RAM
                                                             adder
       SLO-1 Memory operations                               Multiplication of positive numbers          Hardwired control                                  Instruction level parallelism                 ROM,Types
 S-3
       SLO-2 Memory operations                               Problem Solving                             Generation of control signals                      Data level parallelism                        Speed,size cost
       SLO-1 Lab 1: To recognize various components of Lab4:Study of TASM                                                                                                                                 Lab-13: Study of Carry Save Multiplication
  S                                                                                                      Lab-7: Design of Half Adder                        Lab-10: Study of Array Multiplier
             PC- Input Output systems                                                                                                                                                                     Program to carry out Carry Save
 4-5   SLO-2 Processing and Memory units               Addition and Subtraction of 8-bit number          Design of Full Adder                               Design of Array Multiplier
                                                                                                                                                                                                          Multiplication
       SLO-1 Instructions, Instruction sequencing            Signed operand multiplication               Micro-programmed control-                          Challenges in parallel processing             Cache memory
 S-6                                                                                                                                                        Architectures of Parallel Systems -
       SLO-2 Addressing modes                                Problem solving                             Microinstruction                                   classification                                Mapping Functions
                                                             Fast multiplication- Bit pair recoding of                                                      SISD,SIMD
 S-7   SLO-1 Problem solving                                                                             Micro-program Sequencing                                                                         Replacement Algorithms
                                                             Multipliers
                                                SRM Institute of Science & Technology Academic Curricula (2018 Regulations) - Control copy
                                                                                                                     190