12
$\begingroup$

I’m mostly interested in the coding aspect of the CS and SE majors curricula. And I’m trying to decide between the two.

Each major has its pros and cons, and they prepare you in very different ways for a career in coding.

Computer science courses that are provided at my local university range from parallel programming to algorithm design. There's also computer organization/architecture and web programming.

It is to my understanding that (some of) these are exclusive to CS.

I know this post might attract subjective opinions but I'm not looking for answers that simply fill in the blanks. Instead I hope for a final answer where perhaps one major is preferred to the other. Is a question of this nature feasible?

$\endgroup$
  • 3
    $\begingroup$ I'm referring to US ABET accredited programs. $\endgroup$ – kanayt May 10 at 11:09
  • 1
    $\begingroup$ Learn how to break problems down into smaller problems, learn a few programming languages (especially if they have different syntax or different approaches, ie functional vs. object), and take some courses in communications (writing, speaking). Those are the critical skills -- the degree is just the employer's easy way to check that you can stick through a commitment. $\endgroup$ – Rob Crawford May 10 at 13:57
  • 1
    $\begingroup$ Just a personal anecdote: My university's "Software Engineering" was a specialization of the B.S in Computer Science (and was awarded as a B.S Computer Science, Software Engineering") The SE emphasis required additional "core" classes that were left as optional electives to CS students. If you can't find a similar program you could always just take the CS course and choose SE related electives, e.g. software architecture, life-cycles, forward engineering, UML, technical writing etc. $\endgroup$ – Alex May 10 at 15:44
  • 1
    $\begingroup$ Back in the day, there was only computer Science** -- which I majored in. Then I started hearing about software engineering. I always thought they were the same thing. $\endgroup$ – Jennifer May 10 at 16:34
  • 2
    $\begingroup$ One thing I have to say, as someone who went through college and has a successful career as a developer going, don't go to college expecting to get good at coding. They will teach you everything badly, and you'll need to start (almost) from scratch when you start programming for the real world; I got that experience from OSS projects. Programming in the real world is way different than studying isolated concepts in school. OTOH, college won't hurt your career, as long as you don't buy what they teach hook, line, and sinker. Good luck! $\endgroup$ – Hosch250 May 11 at 2:43

13 Answers 13

23
$\begingroup$

You can find a fair amount of information about accredited programs in the US here, including links to schools that have one or the other programs.

In general, Software Engineering is more directed at the processes involved in creating software, and Computer Science is more generally focused on the underlying theory.

But, I'd suggest that both programs have a focus beyond just programming. In fact, you don't need any formal education to be a programmer, so either sort of program will help you develop programming skills. But that isn't the actual main focus of either. For example, an individual programmer may have little need to know about large scale software process so long as they can do their part in the larger scheme of things. He or she may be able to build things while having little understanding of the theory.

I'll also say that a "career" as a coder isn't going to be especially rewarding, either in pay or in responsibility. Many people start out there, but it is much more important, in any field, to know what should be built rather than how to build things. A degree program will give you some insight into the more important problem (though more is needed). But an entry level job after a degree may require programming but if it is the end point then your education was really wasted.

I, myself, sometimes do a lot of coding, but it is never the main thing. It is just a tool that can be used for the realization of something important. Focus on that last part, not the actual coding.


Note that Tim Cook of Apple has recently said that you don't need a degree to be a coder. Actually, though, he meant more than just "coder".

$\endgroup$
  • 6
    $\begingroup$ "What to build" is a domain knowledge issue, and I've never heard of a degree program that can help with that. And you'd better know how to build software if you want to solve problems with software. $\endgroup$ – Rob Crawford May 10 at 13:59
  • 2
    $\begingroup$ @RobCrawford, I'm also concerned with ethics is what should be built and what not. $\endgroup$ – Buffy May 10 at 14:18
  • 6
    $\begingroup$ @RobCrawford There are plenty of degree courses to help with "what to build". Engineering (any branch), biophysics, any liberal arts subject (if you are interested in textual analysis), sport science, (e.g. motion tracking and human physiology), economics, etc, etc. "Learning how to code" is the simple part compared with "knowing what to code" - it's not worth devoting a whole degree to just the "how to" topic. $\endgroup$ – alephzero May 10 at 14:57
  • 3
    $\begingroup$ No, I didn't mean software development in general. I meant just coding. Torvalds is much more than a coder. And, of course, every rule has an exception, but that exception, being rare, isn't likely to be you. $\endgroup$ – Buffy May 11 at 0:00
  • 5
    $\begingroup$ @Adrian A software engineer doesn't have a "career in coding", any more than a motor mechanic has a "career in screwdrivers". The career is whatever you're doing which needs coding to make it happen. Coding itself is simply a tool you use to carry out your work. And yes, it is possible to create software without writing a line of code - LabVIEW and Matlab Simulink users do it all the time. $\endgroup$ – Graham May 11 at 21:13
12
$\begingroup$

From my experience, you don't get good at coding while in college. You'll learn to code, but writing good code comes, in my opinion, much more from experience than education (and I say this as a student who has work experience). These two majors focus more on things around the code, so choosing your major will really depend on what you want to do next.

Software engineering (bias, that's what I'm studying) is much more about the "application life cycle". This includes : Working with other people to write requirements that will evolve properly with time, define architecture that will easily scale with the requirements of the application and manage a billion things (deadlines, risk, quality, teams, clients, budget, providers, etc.). It's also about understanding algorithms, data structure, database and everything that will make your code great enough to be delivered in production to satisfy clients. I think studying this made me a much more valuable employee because I can think about the future and plan accordingly.

Computer science is, from what I know (which is way less than SE), more theoretical. It's more about relationship between mathematics and programming and understanding how languages, compilers, etc. work. It's more of a research work.

There's also something you need to understand from a professional environment. Only being a good coder is rarely enough for you to be valuable, there are many other skills that are just as important and depending on your major you'll develop some of them more than others.

To answer the end of your post, no, a major is not preferable to the other. This is not opinion based, if one was preferable to the other the other wouldn't exist. It really comes down to what you want.

$\endgroup$
5
$\begingroup$

I recommend that you study computer science, as that will also teach you the basics of software engineering.

From having 2+ decades of professional experience & seeing how people behave in both of those areas, what I've noticed is that studying computer science helps one become a better software engineer. However, trying to become a software engineer first, shows that a developer's skills in computer science will be lacking & show amateurish mistakes, over time.

People try to hide those mistakes, by championing their work/libraries/frameworks as "better" than anyone else's. That might be a good sales pitch for a quick prototype for a demo, but when trying to use libraries & frameworks in massive-scale enterprise-level projects, those libraries & frameworks show the lack of skills that the original code authors had.

In today's web development landscape, everyone is afraid of "reinventing the wheel". So they reach out & cobble together everyone else's code into their project. You can build wonderful tools like Slack in that manner. However, if someone asks you to add a feature to extend the functionality of your application... you'll often times be faced with the reality of having to EDIT someone else's underlying component. No software developer wants to do that. So they reply back to the person making that request, that "It's not possible to extend that software to add that requested feature." In today's NPM eco-system, your project can have 10,000+ automatically downloaded & included sub-components! Do you really want to look through any of those to fix your code? Software engineers might edit 1 sub=component, but not 10, 100, 1,000, nor 10,000! SE's simply want to plug & play components (like Lego bricks). They don't usually want to design customized components (bricks), which are what makes the website (& toys) look really cool! (How is a Lego spaceship supposed to look really cool, without a radar dish or laser guns?)

If you were a computer scientist, who also had software engineering skills... then you could write your own library & framework, with a small core group of components, which would play nicely together. Then when someone asks, can we add 1 feature, you can reply, "yes & I can add 2-4 other features too!" Software engineers can work for almost any company, but some research labs (like NASA) or massive scale companies (like Amazon) could prefer Ph.D.'s in computer science over SE's.

Learning the theory behind writing software will turn you into a better computer programmer. It will also allow you to design your own algorithms in the future. Both tracks will pay well in the future, so don't worry about that. What you want to avoid is getting 20 years down the road & being seeing as someone who doesn't know how to program. To become a rockstar developer, study computer science. You'll also learn software engineering along the way as you start writing code & building web based projects!

Good luck in your studies & future endeavours!

$\endgroup$
  • 2
    $\begingroup$ This is more or less the advice I got from a hiring manager at a big gaming developer: CS grads can do basically any development job. With a specialized degree (to include SE & Game Development), there are tasks they have more experience out the door with, but there are also tasks they are likely unable to do without going to substantial additional training. The examples she used was game engine/netcode development because both rely heavily on low-level mathematics/theory work which is usually lacking in specialized programs. There is plenty of room for both, but CS will give you more options. $\endgroup$ – TemporalWolf May 10 at 23:03
  • $\begingroup$ Great answer, and as a Comp Sci grad I fully agree ;-). Seriously though I think your point about avoiding using someone else's code because you don't grok what's really going on is a hugely important one. I see people using the hugely resource inefficient Electron framework so they don't have to learn to code for desktop, whilst failing to understand the consequences of using an unwieldy web app framework to do something trivial in native code. See also the NPM left-pad debacle...did that really need to be a dependency? That's a first month Comp Sci lab assignment!.. $\endgroup$ – MattMatt May 11 at 6:26
  • 3
    $\begingroup$ Your point about focusing on having solid coding skills is very important. However, your statements about software engineers is greatly overgeneralized. I've seen excellent developers from all types of computer/engineering backgrounds and I've seen terrible developers from all types of computer/engineering backgrounds. The difference between a "software developer" and "computer scientist" is really just semantics. $\endgroup$ – InfalibleCoinage May 11 at 16:02
  • 1
    $\begingroup$ >I recommend that you study computer science, as that will also teach you the basics of software engineering.< There should be a large emphasis placed on "basics" here.. a lot of CS courses, where theoretical foundations are seen as more important, do not cover software engineering well. $\endgroup$ – Adam Williams May 12 at 19:53
4
$\begingroup$

The answer is that neither course will provide a 'better' coder, but one course might be best for an individual if they think they start off with a clear idea of where they want to end up. Further, one of the courses will have a better lecturer (even if they are both delivered by the same individual, there will be some imbalance in their knowledge).

Consider a couple of potential high performing coding roles. Low level operating system for a high performance application, and computer vision for self-driving vehicles. I imagine that CS would be a better starting point for the former, SE for the latter.

Within each of these task areas, you will find experts from both backgrounds, and for an employer there should be no preference. Often, pure maths/science would be similarly valuable to an employer, providing you can demonstrate the ability to learn to code to a suitable standard (and maybe this hits the point you are asking?).

For a career, there are also many non-core skills that are just as important - and these will be taught by a much wider range of courses. Your employer might use SCRUM, but they just want to know that you can explain your final year project clearly in 10 minutes. They can teach you the workflow if they think you can learn it.

The best course for you is one that engages you, not one that teaches any specific skills.

$\endgroup$
4
$\begingroup$

"Coding" is impossibly broad, so it's hard to know exactly how to advise you. There is no one right approach.

In general, if you want to know about testing, quality assurance, and project management, Software Engineering is for you. If you want to know about topics like AI, how the operating system works, or the limits of computability, then you want Computer Science.

As every answer so far has indicated, you can enter into the job market with either and still be successful. There is also a good deal of overlap between the two, and most schools give you space for electives, which can further blur the distinction.

Thus, the approach I advise is to take a close look at the specific programs that you have been accepted to. Look over their course sequences and electives, and if it helps, speak with a faculty member over the phone (or in person) to discuss how their program will meet your needs and interests. The best decision will be at a program-by-program level.

$\endgroup$
3
$\begingroup$

The reputation of the schools involved, the job placement results, and the classes you get to take probably matter more than the actual degree you get. Having said that, I will admit that, in my case, the engineering degree I chose offered a bit more of a practical mindset than the science degree, which was a bit more research/creativity based. But that was just a matter of the schools that accepted me back when I was in college, and may not be true anymore for those particular choices.

And while I may not be using anything I was taught directly, the mindset of engineering (the real world is messy, so build things that are practical, flexible, and strong) still shows up in what I do, so it was the correct degree for me.

$\endgroup$
  • 1
    $\begingroup$ I think the actual course components really are the most important factor when deciding. back when i did my undergraduate in Electronics engineering my Computer Science buddies actually did less coding than me because we had more coding modules and they had more Computer science theory modules. But in my software engineering masters we did more theory than the compsci masters did, so it really all does boil down to the modules. $\endgroup$ – J.Doe May 10 at 14:55
  • $\begingroup$ I think the point about mindset is a really good one. The difference between the two strands is one of perspective, attitude and direction. On a degree scheme this gets deeply embedded - for life! $\endgroup$ – Jon Guiton May 10 at 22:17
1
$\begingroup$

I would say that the two most valuable skills you can pick up from a typical university course of study are:

  1. analysis / design skills, both for functionality and data, and an appreciation for the importance of these

  2. "programming in the large", or at least an appreciation for it -- it's been said that most university assignments are like baking a strawberry pie, software work in the real world is more like setting up a factory to produce pies

As @IEatBagels notes, software engineering curricula tend to focus more on requirements and data analysis, so you'll get more of #1 in SE classes.
But in my experience you get more of #2 in CS classes, particularly things like operating system design.

So I would say the two types of curricula are complementary. Whichever one you choose, you should have some freedom in selecting courses, so make sure you're well grounded in these two areas.

As an aside: If I had to pick one thing I wish I had learned in college that was not taught (or at least not emphasized), it would be the use of version control. But maybe that just shows my age ...

$\endgroup$
1
$\begingroup$

To a great extent I think the answer depends on your personality and interests. You say that you are mainly interested in the coding aspect of the two subjects and you are correct when you say that the two strands prepare you differently for a career.

In the CS branch you will learn more theory which is important for a programmer. It is likely that the work will be more interesting and the approach more open to innovation, play and trying new things out. CS is a science subject so you will be able to try out new ideas and investigate techniques. Be prepared for some hard maths.

The SE branch will focus more on design methodology and also people skills. Software engineers need to be good at teamwork and have good interpersonal skills. There are more opportunities to work with people, work on large projects and more routes into management. SE is an engineering discipline so it is based on standards. You will be expected to stick to standard ways of doing things to build production quality systems.

I would say that you will not learn to code at college but through your own practice. The coding assignments you get in CS will be more interesting and give you greater scope to develop your skills than those in the SE strand. This will help to motivate you for your own projects. That is how you will learn to be an excellent programmer.

You have said that your interest is coding, but what is your personality type? Are you a task oriented person (CS) or a people oriented person (SE). Of course, if you are mainly thinking about money you might consider Business Studies (BS).

Whatever choice you make there will be career choices for you if you develop high level skills. This does not mean you will be rich but you will be unlikely ever to be poor if you complete either course. My advice would be to choose the course that interests you most. Live your own life and enjoy it.

$\endgroup$
1
$\begingroup$

Some of the best programmers I know were educated in disciplines like electrical engineering or pure science. I don't think the degree you take limits how good you can be as a working software engineer/programmer/coder/(your preferred term). However all those people started working at a time when you had to learn about pointers and memory layout and bitwise operations so whatever language they work in now, they're aware of what's going on at low levels. Over the years they have adapted to various languages, to various revision control, continuous integration and other practises.

Programmers starting now don't have to know all that to put together things that function. I expect if you looked at the degree to which old programmers and young programmers were equipped to read and understand Knuth's books you would find that the older ones were better off, for this reason. Not a criticism, but if you need to know some high level framework for your job, that's what you get to know, not how to understand quicksort in MMIX.

I think there is a lot of value in a program that deals with pointers and discrete logic and digital circuit building blocks. Those aren't picked up on the job unless you go on to be an embedded programmer (likely you won't if you can't answer questions about those things in an interview). Having to explore languages like Lisp and C and even assembly might seem hard but they teach a lot.

Software engineering is learned on the job. The engineering part of building a program and maintaining it is something you do every day. And in various ways in various places. It is as important to adapt to the way things are done as it is to do things "right" when working.

The only constant in this job is change. I learned the waterfall model at university but nobody does that any more. The only benefit of that semester now is that I have a better basis for knowing why not to do that. Practical things like that get outdated so fast but the theory of computer science doesn't really date.

So for all those reasons - computer science all the way. Learning about software engineering without first knowing computer science seems a bit like like going into engineering without mathematics.

$\endgroup$
0
$\begingroup$

Look at the required classes for each degree. In my experience, software engineering requires more core engineering type classes, while computer science requires a few more math/computer science theory classes. Also keep in mind that these are just the classes that are required. I would wager that at most schools there is enough elective flexibility that a student could take the same exact classes and get either a software engineering or a computer science degree. For example, my bachelor's degree was in electrical engineering, and I believe there were only two classes I did not take that would be required for a computer science degree. And obviously there is much less inherent overlap between CS and EE than CS and SE.

I would also say that 5 years after graduation, there is effectively no difference. It really matters what you do in your job, career and free time, and either degree will give a very similar background. I'm sure it seems like it matters greatly now, but it really doesn't. I also contend that answers stating that a computer scientist is better at abstract reasoning, or a software engineer just wants plug and play solutions is over-generalized nonsense.

So in summary, I would just look at the required classes and see which ones interest you more. For me personally, I found engineering in general to be more interesting than theoretical math. I thought I might be interested in low level hardware, so I went Electrical Engineering, but literally took every required class for SE and only took a few EE specific classes. So I think your premise that CS and SE prepare you very differently is flawed.

The one major exception is if you want to pursue a PhD and/or have a more research focused career, then there are differences, but even still it doesn't really matter at the undergrad level.

$\endgroup$
0
$\begingroup$

(emphasys mine:)

I’m mostly interested in the coding aspect of the CS and SE majors curricula. (...) Each major has its pros and cons, and they prepare you in very different ways for a career in coding.

Well, yes. That's because a graduation in computer science (CS) prepares you to be a computer scientist, while one in software engineering will graduate you as a software engineer. As much obvious as that should be, I find it often isn't.

Both careers are so much more than just coding, though. And if you join any of those without an explicit desire to be either a scientist or an engineer, you are setting yourself up to failure IMO. I've met guys who graduated in both, and they make very bad programmers indeed.

In some countries, an undergraduate course (as Bachelor of Science) software development (sometimes offered along with systems analysis) is available, and that is usually the best choice if your aim is to become a proficient programmer (note that a programmer is already more of a developer than a coder).

$\endgroup$
-1
$\begingroup$

Choose the one that is faster to complete. The programming trends change year by year so it is more important to have more experience. Anyways nowdays you can find online all the things you need to improve yourself.

When I was studying, the waterfall process was the thing, and extreme programming just appeared. Until I finished no one was using waterfall. So no point studyng programming 4-5 years when you can finish in 2-3 and then keep yourself updated with the current trends. Also you will not get much specialized knowledge at uni, but you will have to study yourself, depending on the things you work on. For example, if you are developing a distributed database, you will probably want to study paxos algorithm, but if you are working on a 3D game or developing a software for graphics card, you will need to study shading algorithms.

You should choose the one that is faster to complete, and keep yourself updated with the newest trends. For example nowdays it is serverless development, while if you were studying at uni a couple of years ago, you wouldn't learn about that process. Uni is not very good for our industry because we need to continue learning in order to keep our knowledge up to date. I would even go as far to say that value/cost ratio for studyng CS/SE in Uni is very bad. The best programmers learn continuously without the need for someone to teach them.

I know a lot of great programmers who don't have a degree in CS or SE.

If you are studyng something where you need a lot of expensive equipment (like radiology, specimens, dead people, electronic microscopes, lasers), then it is better to go to uni. But you don't need uni to learn programming processes, languages, architectures etc. On the contrary, you need to keep learning a lot, even after you finish faculty.

$\endgroup$
  • 1
    $\begingroup$ I don't agree. I think the appropriate level is more PhD or at least Masters today. Just because some courses are poor doesn't make them worse than no course at all and frankly, the non graduate programmers I have managed have not usually been up to the tasks set. Online resources are a revolution but it is very useful to know where to look and what to look for. It is hard for a person who learns from online tutorials to catch up with a person who goes directly to the technical documentation for example. $\endgroup$ – Jon Guiton May 10 at 22:15
  • $\begingroup$ I read papers and technical documentation online. I don't see any value in paying uni to give links to the technical documentation. I didn't find my uni courses really useful. Even master courses. $\endgroup$ – CodesInTheDark May 11 at 11:41
-1
$\begingroup$

My view would be "none of the above".

I'm a software consultancy business owner, I've worked in the VC-funded tech space and automotive engineering industry (without an Engineering degree) and I've a first class honours degree in Comp Sci from a respected UK university.

I was already a proficient coder, self-taught, before I started. That's the best way to learn to code - by doing, and learning to learn independently from documentation and code examples.

If you want to work for a company that requires a Comp Sci degree, get one. If you want to work as an accredited Engineer, make sure that you actually need an engineering degree (you often don't, but they'll bullshit you into subscribing to some annual-fee claiming association of blah - I've wasted money on them, and have never seen that money come back in any sort of useful way).

But if you just want to code? Code. Get good at it. Work on your own projects and build up a good portfolio of projects to show prospective employers or investors. Then put that university money in the bank and live off the interest for as long as you need to before you can get contract work, which won't be long.

Don't believe the hype - if you don't want to go into academia, avoid university. If you do, don't waste your money on a North American degree, if you go abroad you'll realise how little a "liberal arts degree" is worth to anyone.

Updated: I just thought of a great reason to actually get a degree - so you don't get locked in. I see VC companies poaching students and luring them with high starting salaries and encouraging them to drop out, so they can't really go anywhere else.. Upon reading the great points above, I'd say go Comp Sci.

$\endgroup$
  • 1
    $\begingroup$ Hmmm. I value my liberal arts degree pretty highly. There are things other than money, of course. $\endgroup$ – Buffy May 10 at 22:37
  • $\begingroup$ Quite right too! Didn't meant to offend. I just meant that I was surprised how snobby the Europeans can be about North American style major/minor degrees in academia; they don't always consider them to be equivalent to European higher education as aren't focused on a single subject. ..and I stand by degree education having no bearing on software development proficiency. I've hired bachelors' holders over PhDs because they had more practical experience and more of a portfolio to show. $\endgroup$ – MattMatt May 11 at 6:18
  • $\begingroup$ This answer seems rather too 'chatty' to fit the general SE model - the real substance seem to be in the first paragraphs. $\endgroup$ – Sean Houlihane May 15 at 12:19

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.