This is a proposal for a theoretical undergraduate Software Engineering degree track(referenced classes are SUNY Binghamton Classes). It has not had a large amount of thought put into it, it is nothing formal and will have mistakes, be badly organized and potentially have fundamental flaws.
This proposal ignores gen-eds because I don't think they do anything useful, the idea of making people more well rounded is respectable but gen-eds fail at that. I'm not going to add so many classes that gen-eds aren't possible in this proposal but I do think that it would be preferable to do so.
This proposal will focus on a theoretical software engineering degree which has been split off of Computer Science, if implemented CS would also need to be reworked to focus on theory but I'm ignoring that here.
Basically what CS 101 is now but more explicit about what it is. This course would go over various jobs involving software dev/engineering, specifically what they tend to look like and how they differentiate. The campus resources part is there because BU offers a bunch of resources like the career center, library, etc and getting info on the existence of those and how to navigate them would be useful for a freshman.
Pick one language as the standard language to use for all classes across the degree (barring performance/OS class(es) and web class(es)) and teach it here. I like the idea of it being a ML descendant but it could be Python. It doesn't matter what matters is that all other classes will use this lang. This cannot be skipped unlike CS 110. This class should also teach how to use git as a solo dev, including being able to navigate git history and encourage it's use.
This class is going to be pretty overloaded. My idea with this class is to go over a bunch of common situations that cause performance bottle necks such as network, cache misses, etc. Ways to try and opt into more performance like making your own cache, writing lower level langs etc. The class will mostly be surface level on these things but planting the ideas can potentially be useful for the future.
This class would describe various kinds of abstractions and how to build them. Going over things like dependency injection, first order functions, inheritence, interfaces, etc.
Basically WRIT 111 but with stuff specific to SE.
Basically CS 375.
Going more in depth with performance focusing on assembly, memory allocation and the costs of various abstractions to performance.
Going over, generating code programatically (macros or just writing a program source file with a different program), reflection, types as values (basically Zig comptime types) and probably other stuff I'm unaware of.
How to write, review and improve a resume, how to interview, how to apply to jobs. This course tries to give students as much as possible as they go into trying to get an internship and/or job.
Going over what a Finite state machine is, properties and things you can infer with finite state machines, when you should make a finite state machine and when you shouldn't. In particular this class should make it clear that oftentimes a regex is not a good choice even if it's the easy choice.
Basically CS 350.
This class would go over SQL, how databases work and when various databases are useful for certain problems. In addition it would go over some transit data formats like JSON, Protobut, XML etc and making your own either with those or completely custom.
Basically CS 471.
This class would go over standard procedure for working on software as part of an organization or team. This would include git branches, pull requests etc. I have no idea how you'd grade or test this class, maybe a group project where the result is ignored in favor of the process?
No comments I don't wanna go through all the electives to comment on this
classes I think are important but I don't have a good spot to place atm.
This class would go over various ways of structuring software at a macroscopic level, why that's important and how to deal with software that's poorly structured.
Thought this would be useful due to having recently read Big Ball of Mud
This class would go over various methods of verifying that software behaves the way it's supposed to. Methods including various forms of testing, formal verification among others.
Thought this would be useful due to vibes gained from reading Hillel Wayne's blog
This class is very important, it is very easy for a software engineer to hurt many people intentionally or unintentionally. See the military industrial complex for intentional harm and this tom scott video for unintentional harm.
This class would go over how to make software that is resilient for various forms of error. Including End-user error, devops error, developer error, software error and hardware error.
definitions:
- End-user error: User interacts with the software in a way they didn't intend
- devops error: Whoever or whatever deploys the software deploys it incorrectly
- developer error: A developer pushes a change which introduces relatively catastrophic behavior into the software.
- Software error: Software encounters a situation it wasn't built to handle.
- Hardware error: Hard drive failure, ram failure, cosmic rays, etc.
This class would go over various concurrency models in software including the actor model and mutexes. Maybe with a bit of dipping into distributed systems at the end of the course.
This class would go over various ways in which users can interact with software and conventions of those various ways and how to make it easier to discover aspects of and use aspects of software.