Compsci 320 Introduction to Software Engineering Fundamentals

Author

Reads 332

Software Engineers Working on Computers
Credit: pexels.com, Software Engineers Working on Computers

Compsci 320 is a course that focuses on the fundamental principles of software engineering. This includes the design, development, testing, and maintenance of software systems.

The course covers various aspects of software engineering, such as requirements gathering, analysis, design, implementation, testing, and maintenance. These stages are crucial in developing high-quality software that meets the needs of users.

In Compsci 320, students learn about different software development methodologies, including the waterfall and agile approaches. The waterfall model involves a linear progression from requirements to implementation, whereas the agile model emphasizes flexibility and iterative development.

By the end of the course, students will be able to apply software engineering principles to real-world problems and develop well-structured, maintainable, and efficient software systems.

Additional reading: Compsci 230

Course Structure

The course structure of Compsci 320 is designed to be flexible and accommodating.

The course is divided into two main parts: theoretical foundations and practical applications.

You'll spend the first half of the course learning the theoretical underpinnings of computer science, including data structures and algorithms.

This will provide a solid foundation for the second half of the course, where you'll apply your knowledge to real-world problems through programming projects.

Each project will focus on a specific area of computer science, such as machine learning or web development.

Course Content

Credit: youtube.com, My Top Tips For Computer Science Students

In this course, you'll delve into the design and implementation of programming languages. The first part focuses on functional programming in OCaml, covering topics like inductive types, data abstraction, and polymorphism.

You'll learn to think functionally, viewing programs as compositions of pure functions that decompose and reorient data. This is a game-changer for problem-solving and code organization.

The second part of the course involves implementing an interpreter for a simple yet powerful programming language. You'll explore parsing, syntax, and semantics, as well as variable scope and binding, storage management, and infinite data types.

A fresh viewpoint: Compsci 61b

Grading

In this course, students are responsible for submitting all assignments on time. Each student who fails to participate in one or more of the exams, or whose group fails to submit one or more of the seven project assignments, will receive the grade F for the entire class.

The grading breakdown for the project is quite detailed, with several components making up the 50% total.

Credit: youtube.com, Make Grading Point-less: Eliminating Points to Foster Student Motivation | Jay Percell | TEDxNormal

The project's grading is broken down into several components, with the following weights: product idea (2%), requirements specification (6%), software design (8%), α release (5%), β release with presentation (10%), user report (4%), and 1.0 release with presentation (15%).

Students will have the opportunity to complete seven project assignments, with each one carrying the same weight of 6% of the total project grade.

Applied Algorithmics

Applied Algorithmics is a fundamental concept in computer science that deals with solving complex problems using efficient algorithms. This course, COMPSCI320, covers the basics of Applied Algorithmics.

In this course, students learn to solve problems in polynomial time, which means the solution can be found in a reasonable amount of time. This is achieved by avoiding repeating vertices and cycles in the path.

The LONGEST LPATH problem is one such problem that can be solved in polynomial time. The start vertex is set at (0,0) and the goal vertex is (i,j).

The weight used to calculate the shortest path is denoted as 𝜑. The length of the shortest path from (0,0) to (i,j) is represented by f(i,j).

Course Overview

Credit: youtube.com, How to outline and structure an online course (Make an AMAZING course)

This course is a deep dive into programming languages, focusing on their design and implementation. CAS CS 320 is not about learning to program, but rather about understanding the principles that govern programming languages.

The course is divided into two main parts, each with its own unique focus. The first part covers functional programming in OCaml, which involves learning to think functionally and compose pure functions to decompose and reorient data.

In this part of the course, you'll explore topics like inductive types, data abstraction, higher-order functions, combinators, and polymorphism. These concepts will help you view programs as compositions of functions rather than sequences of commands.

You'll also learn about parsing, syntax and semantics, variable scope and binding, storage management, and infinite data types in the second part of the course. This will enable you to implement your own interpreter for a programming language and write and run programs.

Assignments

There will be 8 graded assignments throughout the semester, made available on Thursdays and due the following Thursday by 11:59PM.

Credit: youtube.com, Best way to create assignments in Canvas [Beginner Guide]

You'll be submitting assignments via Gradescope, so be sure to check out their Get Started page if you're unfamiliar with the platform.

Roughly half of the assignments will be written, and the other half will be programming assignments.

We'll drop your lowest two assignment grades, so you can focus on doing your best on the other six that will count towards your final grade.

Don't even think about trying to submit late homework assignments - we won't accept them under any circumstances.

Comments

Comments on the course content reveal some interesting insights. None of the problems is NP-hard, as we can solve SHORTEST LPATH and LONGEST LPATH in polynomial time using dynamic programming.

The key here is that our graph is a simple path, meaning we don't have repeating vertices or cycles. This allows us to break down the problem into smaller, more manageable parts.

For example, when solving SHORTEST LPATH, we only have two directions to consider for each vertex: going left or going down. This makes it possible to solve the problem in polynomial time.

Credit: youtube.com, Course Accessibility: Comments

The Vertex Cover problem, on the other hand, is NP-hard. This is because it requires finding a subset of vertices that can cover all edges in the graph, which is a much more complex task.

In fact, the GRAPHICAL STEWER TREE problem is NP-hard due to a polynomial time reduction from the Vertex Cover problem. This means that solving one problem can help us solve the other, but it also means that the GRAPHICAL STEWER TREE problem is much harder to solve.

Related reading: Is Comp Sci a Hard Major

Landon Fanetti

Writer

Landon Fanetti is a prolific author with many years of experience writing blog posts. He has a keen interest in technology, finance, and politics, which are reflected in his writings. Landon's unique perspective on current events and his ability to communicate complex ideas in a simple manner make him a favorite among readers.

Love What You Read? Stay Updated!

Join our community for insights, tips, and more.