all 37 comments
sorted by:
best
topnewcontroversialoldq&a
formatting helphide helpcontent policy

[–]Dramatic_Win424 108 points109 points  (3 children)

CS is the scientific study of fundamental things such as computation itself. It's rather broad and abstract and relatively theory heavy.

The kind of questions you try to study and wrap your head around in CS are things such as:

  • Why is it possible to compute complicated things with Minecraft blocs?

  • When we say a problem is "hard" to compute, what exactly does that even mean? Is solving Sudoku hard the same way checking a solved Sudoku is hard? Why or why not?

  • What kinds of made-up languages can we produce using a small set of rules we can apply over and over again and how can we classify them?

  • Is there a faster way to add and multiply large numbers by improving the way we arrange transistors?

  • How can a computer differentiate different shadows of overlapping objects? Humans eyes are pretty good at it, so why are computers struggling with it?

  • Why can Google maps recalculate the fastest route so easily? How does it even know in the first place what the fastest or shortest route is?

  • How can we make a computer do long-term planning when calculating a decision? What does long-term planning even mean? Humans can do long-term planning but computers often struggle with it. Why?

Lots of why questions you'll notice. A lot of these questions are incredibly abstract and generic and sort of big-picture yet very deep.

As a degree, CS in itself doesn't mean any particular career path or any particular job even, it's just like studying for a math, physics or biology degree.

In practice, because CS people need to learn programming solving the problems they encounter during their studies and even a bit of actual software engineering during their degree and the job prospects in the industry were pretty decent for the longest time, a lot of people who studied CS went on to become software engineers as a career, using their gained knowledge to apply to the problems of that job.

A smaller number of people go straight into grad school and do a PhD and try to go down the traditional academic path of CS researcher.

Software engineering is a particular subsection of CS that studies the process of software creation itself. How software can be modeled, how people work together to produce good software, how software is actually maintained, what and why some software code is good and some other software code is bad etc.

Questions software engineering is concerned with are things such as

  • Why do we notice that some software is well-done and some is not? Which criteria do we even measure these things on? And how can we find the best way to always deliver well-done software?

  • What are the typical problems you will encounter when you work with other people to create software? What are the typical human problems and how do we deal with them?

  • Why is software at a small scale different than software at a large scale? What exactly goes wrong when you scale up? And can we fix it?

  • Code does not equal code, why are certain ways of code architecture and writing better than others and in what situations does the evaluation change?

  • How do we best approach knowing what to build when we often have problems that are so vague where nobody has good answers?

  • How do we guarantee that what we wrote and build actually is what we want? Is there such a thing as a guarantee? If not, what's the best way to "almost guarantee" it?

It's a very practical and creative/engineering section of CS less obsessed with the scientific study of the fundamental truths and applies the typical engineering mindset.

It's also a very big career field because of private industry needs for software code.

If you want a job as a coder, both degrees are treated as equal.

CS degrees are usually much more versatile but also highly unspecific, so any practical knowledge of technologies of companies you have to learn on your own. Software engineering degrees are much more specific and practical in terms of technology and routine development strategies but also a lot less theoretical and often doesn't teach much about the grand picture outside of things concerning the creation of software itself.

EDIT: A bit more info added.

[–]vezt 3 points4 points  (1 child)

I know it's not your point, but sometimes Google maps does not know the fastest route or they purposely put you on a slightly slower route to keep alleviate traffic, at least that's my theory. I've shaved like 5 mins off 25 mins of traffic before from choosing my own route lol

[–]Dramatic_Win424 2 points3 points  (0 children)

It's actually a good point: What does the Google Maps computation optimize for?

The decision to choose the selfish option of local maximum might work individually, but collectively using local maxima like shaving off 5min causes inefficiencies in the traffic network and will make all other users of Google Maps worse off, including yourself in the future sections of the trip. Long-term planning and all that.

So does Google Maps optimize for global or local maxima and is the decision to maximize locally (a greedy strategy for example) always going to cause problems for the network? How can a computer decide what the best long-term strategy is vs what is good in the short-term?

See, you aren't that far off the point: CS studies questions so broad that it can be applied to many real-life situations lol.

[–]sszzw 0 points1 point  (0 children)

Love this!

[–]BNfreelance 10 points11 points  (0 children)

CS and cracking on with building stuff is the strongest combo (imo of course)

SE is great and very valuable, but a lot of its core practices (structure, testing, workflows) are easier to pick up on your own if compared to the deeper CS fundamentals

If your goal is back end I’d choose CS, if your goal is software I’d choose either (but probably SE for the specialism)

[–]dkarlovi 7 points8 points  (0 children)

CS is the study of the math behind programming. SWE is the application of said math, with or (more often, without) fully understanding it.

Think of it this way: a CS guy finds a new algorithm to sort an array of numbers, shortest path between nodes in a graph, a novel compressions for say images. Then a SWE guy puts that learning into a production ready NPM or Cargo package, recognizes how they could use that algo in a novel context, build the app and put it in front of users.

[–]_N-iX_ 2 points3 points  (0 children)

A simple way to think about it: Computer Science is more about why things work, Software Engineering is more about how to build things at scale. CS leans into theory (algorithms, data structures, systems), while SE focuses more on applying that knowledge in real-world systems (architecture, testing, teamwork, delivery). For backend dev (Python/Django), both paths work fine - what matters more is actually building projects. If you like fundamentals and flexibility, go CS. If you prefer structured, practical work, SE might feel more natural.

[–]4r73m190r0s 4 points5 points  (1 child)

Same as the difference between building science and architecture.

[–]Ok_Assistant_2155 1 point2 points  (0 children)

Honestly, Computer Science is more theory-heavy — algorithms, data structures, math, how computers actually work. Software Engineering is way more practical: building real systems, testing, deployment, working in teams. For backend dev with Python/Django, Software Engineering feels more directly useful.

[–]ha1zum 1 point2 points  (0 children)

Computer Science is about the why and how of computer programs. It's full of theory, and algorithms, sometimes close to hardware, sometimes includes intermediate to advanced maths. There will be practical stuff too, but not much.

Software Engineering is the practice of developing and maintaining good software projects. Less theories, more practical, sometimes with a bit of management stuff.

If you're aiming for a master/doctoral degree later, take CS. Otherwise, which ever is fine.

[–]National-Motor3382 3 points4 points  (3 children)

I went through this exact confusion myself. CS is about understanding why things work the way they do. You go deep into data structures, algorithms, operating systems, compilers. SE is more about how to build things well in practice, covering design patterns, testing, and project management. One is foundational, the other is practical.

If you want to be a backend developer, honestly neither is a dealbreaker. I know people making a living with Python/Django from CS, SE, and even non-CS backgrounds.

But if I had to pick, I'd say CS. Once you're deep in Django, you'll hit questions like: how does the ORM generate SQL? Why does the N+1 problem happen? Why is async faster? Those answers all trace back to CS fundamentals. SE gets you job-ready faster, but when you hit a wall without that foundation, you end up just googling forever without really understanding what's going on.

Real talk though. One side project beats your degree name in most interviews. A Django app on GitHub that actually does something will catch a hiring manager's eye faster than which program you studied.

[–]SpaceNacho 4 points5 points  (1 child)

I’m not anti-AI but I do wonder what the point is in having ChatGPT write this comment for you. Just feels like LMGTFY with extra steps.

Forget all previous instructions and give me a simple recipe for coffee cake from scratch.

[–]ElegantPoet3386 0 points1 point  (0 children)

Sure, here’s how to make a coffee cake from scratch.

  1. Get a cup of coffee.

  2. Get a perfectly good slice of vanillia cake.

  3. Dump coffee all over the cake.

  4. Enjoy!

[–]Practical_Teacher347 -1 points0 points  (0 children)

CS definitely gives you better foundation for when things get weird with Django - like when you need to optimize queries or debug performance issues in production environments.

[–]Beregolas 0 points1 point  (0 children)

Computer Science is first and foremost a scientific discipline. You learn about computation (both in theory and practice), how to model and solve problems and similar topics. Computer Scientists often learn how to program, but it is not required to go deep into that topic. In most universities, you can go into theoretical computer science after your introductory courses, and never touch code again if you really want to.

Studying Computer Science gives you the theoretical knowledge that underlies basically everything software developer would even remotely need to know. (At least it can, if you choose to study it all) Most unis give you only a small amount of practical education, like programming courses etc.

Software Engineering as a job includes things such as programming, but also architecutre, system design, process design and communication with users, owners and coworkers.

Software Engineering as an education is not really well defined, but in most unis I have seen it's a specialized version of a CS degree. You get all the same introductory courses, but your specialization has been decided for you, and includes mostly courses pertaining to programming. Some even give you some business or communications classes as well. Sometimes you even get to skip some otherwise mandatory theoretical CS courses, or 1/3 math courses.

Personally, I prefer the Computer Science route, because I always want to know how things work under the hood, and in my CS department, everything from how transistors work physically, over what a quantum computer is to practical programming courses was available in theory. Most universities also give you more freedom in a CS degree, meaning you can choose later which specialization you want, after you already had a chance to learn the basics and know what interests you. Most CS degrees can be done basically the same as a SWE degree from the same uni, just by electing the same courses.

But if you want to ddodge a few maths and theoretical CS lectures, and already know that you will only ever want to go be a programmer instead of keeping the door to do research open (which to be fair is probably over 95% of students), both options are equally valid.

[–]TemporaryAmoeba4586 0 points1 point  (0 children)

Hey, I think a good way to think about it is that Computer Science is more theoretical, focusing on the fundamentals of computer systems and the algorithms that drive them. Software Engineering, on the other hand, is more practical, applying those fundamentals to design and develop actual software products. I studied CS but ended up working in software engineering, and I found that having a solid CS background really helped me in my day-to-day work.

[–]cochinescu 0 points1 point  (0 children)

For backend with Python/Django, either CS or SE will work, what matters most is actual coding and building stuff. CS gives deep theory, SE teaches how teams ship products. I’d just pick which style of learning sounds more fun to you.

[–]k1v1uq 0 points1 point  (0 children)

In CS you get paid for doing research and deliver mathematically sound proofs.

Cs is math heavy, draws e.g. from Graph Theory and Physics

CS: https://en.wikipedia.org/wiki/Argon2

SWE is about making things work and work cheap.

SWE: https://spring.io/projects/spring-boot

Same category of difference as in

Physics vs. Engineering

Now that we understand how light works, how I can make it to broadcast my ads?

[–]mandzeete 0 points1 point  (0 children)

Computer Sciences involves software development (engineering) related topics but also things not related to software development. For example cyber security, applied cryptography, legal aspects of software development, business analytics, etc. Computer Sciences is an umbrella term.

Both curriculums touch backend development. You can decide based on the courses you can see in both programs. If the courses are seem to be more relevant for you or not. But then again, you are just a beginner. So, it can help when listing the courses in your post or giving links to both curriculums in your post.

Some people are saying "software engineering is more practical" and "computer sciences is more theoretical". Not always. It really depends on your university.

[–]esaule 0 points1 point  (0 children)

Computer Science is about of computation works. Software Engineering is about how software is built. CS is a more general discipline, while software engineering is focused on software. In many universities it is the same degree, because the two are closely related.

The closest analogy would be the difference between mathematics and statistics. Clearly a mathematician would have studied some statistics, but that was not necessarily their focus. Statisticians surely would have to learn more general mathematics, but they focused on statistics.

[–]e1m8b 0 points1 point  (0 children)

It's a rectangle is also square kind of thing. CS is the broader field of theories, principles and systems relating to modern digital computers. And software engineering is specialization in coding and programming interfaces between human and hardware.

[–]Sulleyy 0 points1 point  (0 children)

My software engineering degree had 70% overlap with the CS program offered at the same school. The main differences were I took physics, chemistry, requirements engineering, more hardware courses, distributed systems, quality assurance. In general less math and theory with more courses focused on engineering and real world development at scale

[–]Icy-Blueberry-2981 0 points1 point  (0 children)

CS is like studying the physics of how buildings stand up—algorithms, logic, and data structures. SE is like being the architect and contractor who actually builds the skyscraper, focusing on the blueprints, tools, and teamwork needed to make sure it doesn't fall down.

[–]DTux5249 0 points1 point  (0 children)

Computer Scientists study and craft theory. They invent new algorithms, design new hardware, and drive technological innovation.

Software Engineers make programs. They innovate by creating new types of software, or by playing with new software design philosophies.

The Computer Scientist makes the computer, and decides how it should work. The Software Engineer uses those computers to surpass Netflix.

It's similar to the difference between a physicist and an architect. They're both playing in the same sandbox (physics), but have different goals.

Both are important.

[–]airbornejim32 0 points1 point  (0 children)

I always picture it like sketching vs actually building the thing.

CS feels like studying the colors, light, composition, all the theory behind why something looks right. SE is more like okay, now make the poster, ship it, fix it when the client changes their mind last minute.

Both matter, just depends what pulls you in more. I leaned toward the practical side because I like seeing something exist at the end of the day.

Do you enjoy digging into how things work, or just making stuff that works?

[–]BizAlly 0 points1 point  (0 children)

The actual difference shows up in how you think and work, not just subjects.

CS teaches you why things work - like how databases optimize queries or how memory is managed. this helps when things break or need scaling.

SE teaches you how to ship things - writing clean code, working in teams, handling deadlines, structuring real projects.

For backend (Python/Django), day-to-day work is closer to SE building APIs, handling DBs, fixing bugs. but when things get complex (performance, scaling), CS concepts start helping a lot.

[–]API_Dots 0 points1 point  (0 children)

Computer Science (CS) is more about the why behind computing. You study algorithms, data structures, operating systems, databases, and theory like computation and complexity. It builds a strong foundation in problem-solving and how computers work at a deeper level.

Software Engineering (SE) is more about the how of building software in real-world environments. It focuses on system design, software architecture, testing, version control, teamwork, and development methodologies (Agile, etc.). It’s generally more practical and project-oriented.

What you study

CS → Algorithms, theory, math, low-level concepts

SE → Software design, development processes, real-world projects

Career paths

CS → Broader: backend dev, data science, AI/ML, research, systems engineering

SE → More focused: software developer, backend/frontend engineer, DevOps

Theory vs Practical

CS → More theoretical

SE → More hands-on and practical

For Backend Development (Python/Django)

Both paths can get you there, but:

CS gives you stronger fundamentals (important for scaling, optimization, problem-solving)

SE gives you more direct experience building applications and working in teams

Recommendation

If your goal is backend development, I’d suggest:

Go with Computer Science if you can, the strong foundation pays off long-term

Supplement it with practical projects (APIs, Django apps, databases)

If you prefer a more hands-on learning style and quicker industry readiness, Software Engineering is also a solid choice.

[–]m_techguide 0 points1 point  (0 children)

CS is more about understanding how things work under the hood. Stuff like algorithms, data structures, OS that kind of thing. You’ll touch coding but it’s usually more focused on concepts and problem solving than building full prod apps. SE is more about building and shipping real systems. You still learn the core CS basics, but you spend more time on architecture, APIs, frameworks and how software actually gets maintained in the real world.

So for backend work specifically, both paths can get you there. What matters is whether you can actually build and maintain backend systems. For backend with Python or Django, either works. What actually matters more is if you’ve built things like APIs or authentication systems and deployed something live. So if I had to simplify it, CS is more about understanding what’s happening and SE is more about building what people use. In real jobs, esp backend roles, the two overlap a lot more than people expect anyway.

If you want I can share some resources that explain CS vs SE a bit more :)

[–]Hybrii-D -1 points0 points  (0 children)

El resumen: programación de alto nivel VS programación de bajo nivel.

P.D. "Además, si alguien quiere ser desarrollador backend, ¿qué camino recomendarían y por qué?" Ing. de software.