I am looking to get into a software engineer role and I need some fundamental knowledge of Computer Science Engineering concepts. Will David Milan's basic Computer Science course from Harvard, CS50x, be enough to accomplish this?
No, not by a long shot, although Harvard's CS50x is an excellent introduction which provides around 10 hours of lectures then problem sets which support approximately 100 hours of practice at programming by solving Computer Science problems (not quite the same as software engineering problems).
Most typical entry-level software engineers (regardless of their background) will likely have spent several thousand hours learning their craft by the time they start their first job (Something roughly equivalent to the amount of time a typical graduate may have had after 3 years at university).
This obviously includes programming and core computer science concepts, but most importantly it involves having hands-on exposure to building some working software (Which is about far more than just writing code -- actually, writing code is only a small part of the total amount of work which goes into building working software).
While it's certainly true that Software Engineering is rooted in Computer Science, and computational thinking skills are an essential prerequisite, that capability is nowhere near enough on its own.
Generally speaking, most software engineering problems also have a degree of subjectivity built on top of that - i.e. they go beyond just needing to find solutions based on logic; most of the problems faced by software engineers are more about humanity - meaning that the vast majority of issues involved in building software can't be solved just by writing an algorithm.
Just to provide a few examples - this list is neither complete nor comprehensive, but hopefully illustrates the kinds of things that are learned through hands-on experience of working on software projects (even spare-time hobby projects and open-source software):
- Requirements gathering and analysis
- Software design principles and approaches to software design (e.g. consideration towards interfaces, modularity, and automated testing)
- Pragmatism and consideration towards real-world constraints (e.g. people's time, or their willingness to accept change, etc.)
- Communication, knowledge-sharing and collaboration with other developers (e.g. peer reviews, pairing)
- UI/UX Design
- Communication with users and stakeholders, including managing their expectations and seeking their feedback.
- Teamwork and being able to function within processes and procedures that allow many people to contribute to the same project/codebase.
On top of that, there's also the fact that software engineering often tends not to be about using code to solve every problem but to include a lot of effort reusing other people's existing/working/tested solutions to avoid re-inventing the wheel (For example, "devops" tools, app frameworks, cloud services, 3rd-party libraries, O/S capabilities etc.)
This often includes trying out tools/libraries/frameworks to check their capabilities, then figuring out how to integrate your code with those things (e.g. through programmatic APIs, configuration management, build/integration/deployment processes, automation/scripting, etc.)
This is not to say you need to be any kind of expert in these things for an entry-level Software Engineering position, however once you're confident in the core skills of computer science, programming and computational thinking, it'll be important to focus learning around building software - at which point a lot of issues around tools/APIs/libraries/frameworks start to crop up, and so should the issues around understanding software design, testing, pragmatism, and (ideally) a lot of interaction with other programmers.
The purpose of an introductory course is threefold:
- To lay out the field, and give the student a sense of what that field involves and entails.
- To provide the fundamental background knowledge one would need to proceed further into the field.
- To help students figure out whether this is a field they should pursue further.
I have only a passing familiarity with the CS50x courses, so someone with more intimate knowledge me jump into correct me, but my impression is that these courses focus mostly on goal number two. Goal number 1 is laudatory, but the truth is that the field is so broad, it would be impossible to do justice to even a small subset of the fields of knowledge within computer science and computer engineering in an introductory course.
That's not to say that it would be a bad idea to go through this course if you're looking to change fields. There's a reason that this material has been created as an introduction. This is fundamental knowledge that you'll need in order to learn more advanced concepts, and you will likely not have much success without approaching these fundamentals (whether in CS50 or elsewhere). But don't expect that the course alone will put you in good stead all by itself. More likely, it will simply help you get set up to learn further.
The course is broad and it is short. It is no more than an introduction. It would, I think, give you an idea about whether this is a good path for you to take. But it won't carry you very far along the path.
It's breadth precludes much depth. Several languages are discussed. Several core ideas, from algorithmic thinking to data structures. It is, of course, that breadth that makes it valuable as a first course, as you get to look at a lot of things that will be developed more completely in courses that follow this one.
However, a deep knowledge of all that and more is needed for a career. It is a worthwhile thing to do as a starter, but expect to need more. If it is successful, then you will wind up wanting more, actually.
And don't expect it to be easy, assuming you want to learn much from it.
Note also that an undergraduate "major" in CS in the US is normally 15 or more CS courses (in addition to math, etc), of which this would be the first. You probably don't need all of that knowledge from 15 courses, but they are what forms the "foundation".
Starting with CS50 is good, but it's just a beginning.
I'm a newbie in programming, and I started learning it with many sources including CS50. (As far as I know, CS50x is almost the same as CS50. if it's not, please comment me. CS50 is Harvard's computer science course for very beginners.)
CS50 is a very good course for a beginner, especially if you wanna grab the whole picture of programming but not going deeper too much.
It starts with learning C, so you can learn the basic concepts of memory address and pointer. And it covers modern languages such as Python(of course only basics though), and also you'll even learn some simple web development.
So, if you're a beginner and don't know what to learn first, then CS50 is a good way to go.
But I think you should dig much more to get some knowledge of CS undergrad. In CS undergrad, you learn algorithms, data structures, networks, operating systems, computer structures, etc. These are very very important if you wanna become a high-level software engineer.
Yes. It worked for me. I wrote about it on my blog: