Introduction

Upon completing my 4-year degree in Computer Science, exploring and reading a few articles and books in the field of Computer Science, I would say that the biggest abstract ideas that Stood up to me and considered them as an answer to the question " Summarize Computer Science in two Concepts" are Abstractions and Trade-offs.

Here is a hypothetical question answered by me in a Hypothetical interview

• Interviewer: Tell me honestly, How many times you've watched another one of those "System Design Interview" videos to write this article?

• Me: Yes.

  

Note: This is just my own opinion, I can be right or wrong. But this is just my observations.

Abstractions

Abstractions manifest in various forms, from Binary and Machine Code to Assembly Language to Programming Languages to Frameworks.... etc. Although I can't cover them all, I will focus on the general idea of software abstraction and make an example for each level.

High-Level Abstraction: Software Systems

At a high level, abstraction in computer science is essential to modern Software Systems. It involves simplifying complex components to enhance user interaction. Imagine using a smartphone – the focus is on apps and functions, not the internal circuits.

High-level abstraction involves creating layers upon layers that hide the technical details. Apps that operate on a higher abstraction layer than Operating systems are an example, also Operating systems provide a user-friendly interface while managing hardware resources like memory and processors behind the scenes. When you double-click an icon to open a program, you're benefiting from layers of abstraction that save you from dealing with hardware specifics.

Mid-Level Abstraction: Object-Oriented Programming

When going deeper a bit, we encounter abstraction in the field of programming. Object-Oriented Programming (OOP) is a powerful example. It lets developers create complex applications by breaking them into manageable, abstract pieces called objects. These objects bundle data and the operations that work on them.

Low-Level Abstraction: Building Blocks of Code

This our the final level of Abstraction. Here, abstraction is like using LEGO to build structures. In assembly language programming, you're working with instructions that directly correspond to hardware operations. But high-level programming languages abstract away these machine-level details.

Frameworks:

Frameworks are like pre-built structures that follow a certain blueprint. They're built on layers of abstraction.

Frameworks abstract away a ton of boilerplate code and complex interactions, allowing you to concentrate on your application's unique features. Think of it as if you're an interior designer, you're just focusing on the design while having the infrastructure and the construction building abstracted away.

By the way: It can be very helpful to re-invent the wheel sometimes. You can reinvent the wheel from this GitHub repository: build-your-own-x.

Trade-offs

Trade-off is a concept that says that everything in computer science has a tradeoff, every decision, every algorithm and every architecture has to have a tradeoff.

Whether you're thinking about choosing between, Trunk-based development or Git flow, Microservice or Monolithic Design or Modular Monolithic architecture, NoSQL or relational databases, or Using Kafka or RabbitMQ, Jenkins or Circle CI. The common thing is that each option involves a big time of consideration for the trade-offs.

Examples of Trade-offs

• Algorithmic Efficiency: Consider the trade-off between time and space complexity in algorithms. When designing an algorithm, optimizing it for faster execution might necessitate using more memory, or prioritizing memory efficiency could lead to longer processing times.

• Databases: Whether to go for a NOSQL or Relational Database is a huge deal and tradeoff. Consistency and Structured Data Vs Flexibility and Unstructured Data, Joins Vs limited joins...etc.

• Performance vs. Maintainability: Optimizing code for maximum performance can sometimes lead to complex and harder-to-maintain code. Balancing performance improvements with code maintainability is a classic trade-off in software development.

• Abstraction Levels: Even the choice of abstraction levels involves trade-offs. High-level abstractions simplify development but might limit fine-tuning, whereas low-level abstractions provide more control but often require more effort. For example, whether to use something that is built already as a SaaS solution or fine-tune it for your use case, or even build one completely from scratch like what Big Tech companies usually do internally. Or using Rust or C++ instead of a garbage-collected language like Python for better memory management control and performance optimizations.

Conclusion:

I think these two concepts can summarize what computer science is about from a high-level point of view.