RFC: Replacement of Poor Software Engineering courses with NPTEL

[riceeatingmachine]

Problem:
Object Oriented Design, Design Patterns, Software Architecture teach their topics in roundabout ways by forcing students to use the android development toolkit. As such, they are not great for the purposes of the OSSU.

Software Engineering - Introduction is generally thought of as students here to be a poor course, which some people skipping it entirely.

(See this, #747, this, this, this)

Duration:
1 Month.

Background:
Splitting #1080

There are certain courses in the curriculum that aren't particularly great but have been kept due to lack of better courses. I've been scouring the internet and I found NPTEL (National Programme on Technology Enhanced Learning) which contains a lot of computer science courses from The Indian Institute of Technology - the highest tech universities in India. Think of it like OCW for the IITs.

They are generally though to be high quality courses in India, and this is the best university here. The downside is that there are not many practical assignments on NPTEL unlike their university counterparts.

Proposal:
Replace Object Oriented Design, Design Patterns, Software Architecture, and Software Engineering: Introduction with Software Engineering by IIT Kharagpur and Software Conceptual Design by IIT Bombay.

Alternatives:

1. We could look for alternative resources.

[riceeatingmachine]

Alternative (I think some of you might prefer these to the NPTEL videos):

Object Oriented Design: https://www.youtube.com/watch?v=fJW65Wo7IHI&list=PLGLfVvz_LVvS5P7khyR4xDp7T9lCk9PgE
Design Patterns: https://www.youtube.com/watch?v=v9ejT8FO-7I&list=PLrhzvIcii6GNjpARdnO4ueTUAVR9eMBpc
Software Architecture: https://www.youtube.com/watch?v=3bxAm3XIFmk&list=PLdsOZAx8I5umhnn5LLTNJbFgwA3xbycar&index=146 (Should be elective)
Agile: https://www.youtube.com/watch?v=dfR6UBEBVvo&list=PLWKjhJtqVAbm0gPNunWf4pr4xV8I3Geh-

This are highly regarded youtube series.

[aayushsinha0706]

What do you think of these resources

https://openlearninglibrary.mit.edu/courses/course-v1:MITx+6.005.1x+3T2016/about
https://openlearninglibrary.mit.edu/courses/course-v1:MITx+6.005.2x+1T2017/about

[riceeatingmachine]

Just a prima facie review: They overlap with HtC and some other courses. They don't cover design patterns and software engineering. As such they are not suitable replacement for the ones I proposed.

…

On Fri, 14 Oct, 2022, 22:41 Aayush SInha, ***@***.***> wrote: What do you think of these resources https://openlearninglibrary.mit.edu/courses/course-v1:MITx+6.005.1x+3T2016/about https://openlearninglibrary.mit.edu/courses/course-v1:MITx+6.005.2x+1T2017/about — Reply to this email directly, view it on GitHub <#1082 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AL6AMA2D7IRGO6X7VLI4MLTWDGH3TANCNFSM6AAAAAAQ7OYVVY> . You are receiving this because you authored the thread.Message ID: ***@***.***>

[aayushsinha0706]

my prime recommendations will be above two MIT courses with this newer Software engineering course by IIT KGP

https://nptel.ac.in/courses/106105182

[riceeatingmachine]

I had a deeper look into the MIT courses. Here is a comparison.

The topics covered by the courses we are removing:

Course	Topics Covered
Object-Oriented Design	Object-Oriented Design Object-Oriented Analysis And Design Unified Modeling Language (UML)
Design Patterns	Design Patterns
Software Architecture	Software Archetecture (subroutines, classes, functions, etc), evaluation and tradeoffs
Software Engineering - Introduction	Agile development, REST and Async programming, design, refactoring, information security

 

The topics covered by the MIT courses are:

Course	Topics Covered
6.005.1x Software Construction in Java	Java programming Software testing Code specifications Abstract data types
6.005.2x Advanced Software Construction in Java	(1) grammars, parsing, and recursive datatypes; (2) concurrent programming with threads.

 

They don't seem to be covering the same topics so it would not be productive to use them as replacements of the courses proposed to be removed.

[aayushsinha0706]

I would like to quote CS2013 requirements for software development fundamentals and software engineering.

CS2013 says following topics are tier 1 topics that needs to be covered
SDF/Algorithms and Design
SDF/Fundamental Programming Concepts
SDF/Fundamental Data Structures
SDF/Development Methods

while we already cover algorithms and data structures in core theory

SDF/Fundamental Programming Concepts
[10 Core-Tier1 hours]
This knowledge unit builds the foundation for core concepts in the Programming Languages Knowledge Area, most notably in the paradigm-specific units: Object-Oriented Programming, Functional Programming, and Event-Driven & Reactive Programming.
Topics:
• Basic syntax and semantics of a higher-level language
• Variables and primitive data types (e.g., numbers, characters, Booleans)
• Expressions and assignments
• Simple I/O including file I/O
• Conditional and iterative control structures
• Functions and parameter passing
• The concept of recursion

SDF/Development Methods
[10 Core-Tier1 hours]
This unit builds the foundation for core concepts in the Software Engineering knowledge area, most notably in the Software Processes, Software Design and Software Evolution knowledge units.
Topics:
• Program comprehension
• Program correctness
o Types of errors (syntax, logic, run-time)
o The concept of a specification
o Defensive programming (e.g. secure coding, exception handling)
o Code reviews
o Testing fundamentals and test-case generation
o The role and the use of contracts, including pre- and post-conditions o Unit testing
• Simple refactoring
• Modern programming environments
o Code search
o Programming using library components and their APIs
• Debugging strategies
• Documentation and program style

Using CS2013 guidelines we can say above two MIT courses will be best suited to cover these topics

Attaching syllabus of 6.005.1x and 6.005.2x for reference

[aayushsinha0706]

Lets talk about software engineering

cs2013 states following topics as absolute necessary

SE/Software Processes
Topics:
[Core-Tier1]
• Systems level considerations, i.e., the interaction of software with its intended environment (cross- reference IAS/Secure Software Engineering)
• Introduction to software process models (e.g., waterfall, incremental, agile) o Activities within software lifecycles
• Programming in the large vs. individual programming

SE/Software Design
[3 Core-Tier1 hours; 5 Core-Tier2 hours]
Topics:
[Core-Tier1]
• System design principles: levels of abstraction (architectural design and detailed design), separation of concerns, information hiding, coupling and cohesion, re-use of standard structures
• Design Paradigms such as structured design (top-down functional decomposition), object-oriented analysis and design, event driven design, component-level design, data-structured centered, aspect oriented, function oriented, service oriented
• Structural and behavioral models of software designs
• Design patterns

SE/Requirements Engineering
[1 Core-Tier1 hour; 3 Core-Tier2 hours]
The purpose of requirements engineering is to develop a common understanding of the needs, priorities, and constraints relevant to a software system. Many software failures arise from an incomplete understanding of requirements for the software to be developed or inadequate management of those requirements.
Specifications of requirements range in formality from completely informal (e.g., spoken) to rigorously mathematical (e.g., written in a formal specification language such as Z or first-order logic). In practice, successful software engineering efforts use requirements specifications to reduce ambiguity and improve the consistency and completeness of the development team’s understanding of the vision of the intended software. Plan-driven approaches tend to produce formal documents with numbered requirements. Agile approaches tend to favor less formal specifications that include user stories, use cases, and test cases.
Topics:
[Core-Tier1]
• Describing functional requirements using, for example, use cases or users stories
• Properties of requirements including consistency, validity, completeness, and feasibility

Now for software engineering I am offering this course by IIT KGP NPTEL
https://nptel.ac.in/courses/106105182

What this course covers
Week 01 : Introduction
Week 02 : Life Cycle Models I
Week 03 : Life Cycle Models II
Week 04 : Requirements analysis and specification
Week 05 : Basics of software design
Week 06 : Procedural design methodology
Week 07 : Object-oriented concepts
Week 08 : Introduction to UML: Class and Interaction Diagrams Week 09 : Object-oriented analysis and design
Week 10 : Testing I
Week 11 : Testing II
Week 12 : Testing III

The above course already covers topics like Requirements analysis, Object oriented design,Unified Modeling Language (UML) but also Procedural design methodology with software testing and secure programming. I guess this is best course that we have now to cover software engineering.

Not that I am against courses that you recommend its just that we dont really need them. Maybe an advanced software engineering section or advanced programming can get those courses.

[aayushsinha0706]

Also sorry to mention about RFC #933 was accepted without considering CS2013 document.

[waciumawanjohi]

Also sorry to mention about RFC #933 was accepted without considering CS2013 document.

???

[aayushsinha0706]

Also sorry to mention about RFC #933 was accepted without considering CS2013 document.

???

The RFC never made a reference to CS2013 doc also I did not find any course in CS2013 which was similar to software architecture although object oriented design and design patters were justified for SE/software design (might be a misunderstanding from my side , I apologise for it). The RFC just compared courses from original UBC software engineering courses.

[riceeatingmachine]

Using CS2013 guidelines we can say above two MIT courses will be best suited to cover these topics

Ah it looks like I should have been clearer in the earlier messages.

To elaborate on:

They overlap with HtC and some other courses. They don't cover design patterns and software engineering. As such they are not suitable replacement for the ones I proposed

What I meant to say was that the MIT courses don't teach the topics that are taught by the courses we are removing, and the topics they do teach are already covered by other courses in the curriculum.

I'll mark the course (in bold) in the curriculum that already covers the topic in the list:

SDF/Fundamental Programming Concepts
[10 Core-Tier1 hours]
This knowledge unit builds the foundation for core concepts in the Programming Languages Knowledge Area, most notably in the paradigm-specific units: Object-Oriented Programming, Functional Programming, and Event-Driven & Reactive Programming.
Topics:
• Basic syntax and semantics of a higher-level language PLABC
• Variables and primitive data types (e.g., numbers, characters, Booleans) PLABC
• Expressions and assignments PLABC
• Simple I/O including file I/O CS50/Nand2Tetris
• Conditional and iterative control structures PLABC, Nand2Tetris, Intro to CS
• Functions and parameter passing PLABC
• The concept of recursion HtC, PLABC

SDF/Development Methods
[10 Core-Tier1 hours]
This unit builds the foundation for core concepts in the Software Engineering knowledge area, most notably in the Software Processes, Software Design and Software Evolution knowledge units.
Topics:
• Program comprehension PLABC
• Program correctness Software Testing and Debugging
o Types of errors (syntax, logic, run-time) Software Testing and Debugging
o The concept of a specification Software Testing and Debugging
o Defensive programming (e.g. secure coding, exception handling) Core Security
o Code reviews Software Testing and Debugging
o Testing fundamentals and test-case generation HtC, Software Testing and Debugging
o The role and the use of contracts, including pre- and post-conditions o Unit testing Software Testing and Debugging
• Simple refactoring Software Testing and Debugging (if I remember correctly)
• Modern programming environments The missed Semester in CS (???)
o Code search Software Engineering (???)
o Programming using library components and their APIs HtC, Nand2Tetris
• Debugging strategiesSoftware Debugging
• Documentation and program style HtC, Software Testing and Debugging

As a result, by adding these two MIT courses, we are just making the curriculum redundant and longer but not covering any new topics.

Now for software engineering I am offering this course by IIT KGP NPTEL https://nptel.ac.in/courses/106105182

I agree with this change, it covers the same topics as the one I proposed as well.

If we go with this one, we need to mark week 10, 11, and 12 optional as we already have a full course on Testing in the curriculum (which is a really good one!)

[aayushsinha0706]

Well I didn't look that way

So it might raise the issue OSSU lists multiple courses that cover the same topics when fewer courses could suffice.
Well I'm not against the idea of reducing core programming requirements as many students in cohorts meeting mentioned that core programming is too long.

Software engineering as a course has been behind a paywall and lot of students are already reluctant towards it. The above course I mentioned is open to everyone with assignments as well.

Spam egg reviews also tried to skip the UBC course and did instead software architecture course but was again disappointed.

Software Architecture
https://www.coursera.org/learn/software-architecture
I decided to take this when I realized Software Engineering: Introduction is behind a pay-wall. I didn't know at the time but this is a repetition of Software Construction 1 and Udacity's Software Architecture and Design.
Another verbal course. It's like a literature class. Words, words, words, words, words. They hired a nice young acting or dance major student to read all the text from the teleprompter for a nice presentation. She clearly has no idea what she is saying.
This one makes you draw a ton of UML diagrams using some online tools. There are more than 20 kinds of UML diagrams. Oh my god. I felt like I was taking an art class. It was kinda fun at first. These assignments are all peer-graded. You get a free certificate at the end, no pay-wall, but it feels pretty meaningless.
Spam's recommendation: What do you think? Skip it, of course.

Also we will have to bring software debugging and testing which are currently in advanced programming to core applications.

Although he has some sweet reviews of software testing and debugging
https://github.com/spamegg1/reviews#debug
https://github.com/spamegg1/reviews#test

[riceeatingmachine]

The one you mentioned @aayushsinha0706 seems to only cover the topics covered by Software Engineering - Introduction.

The other one also covers design patterns, object oriented design, and architecture along with software engineering.

The only thing is it doesn't cover UML, so I also included Software Conceptual Design to cover that part of the curriculum. Although my friends in the industry tell me "no one uses UML anymore" so maybe we can do without it?

[aayushsinha0706]

I support the other one because it covers SE/Software Project Management which I didn't mentioned but it is a core-tier 2 topic that one I mentioned doesn't teach.

I guess final offering will be then:
Software Engineering IITB NPTEL
Software Testing and Software Debugging
in core-application

and removal of Object oriented design, design patterns and software architecture