Software Engineering Flashcards

Question

SQLite Weaknesses and Strengths

Answer 1

**Weaknesses**: Not suitable for high-concurrency environments, limited scalability. **Strengths**: Zero-configuration, lightweight, embedded, suitable for mobile and small-scale applications.

Answer 2

**What** It involves developing small, loosely coupled services that can be deployed independently. ** pros** include 1- scalability, 2- fault isolation, and 3- the ability to choose the best technology for each service. **cons** - security - latency - harder to access data -maintaining - complexity, logging (stack tace) **Design tips** 1- Avoid direct access to one database in services 2- Address service dependencies using API Gateways and Service Discovery tools. 4- Design services carefully to hide complexity and expose only necessary details.

Answer 3

Pros: - increase productivity - type-safty - auto-completion - less rigorous testing Cons: - missing DB features (leaky abstraction) - SQL stays the same, but ORMs have new abstraction which you need to learn - Vendor/library lock-in (making it difficult to switch to an alternative solution)

Answer 4

for storage, retrieval, serialization, validation A Data Transfer Object is an object that is used to encapsulate data, and send it from one subsystem to another

Answer 5

used of auth 1- header: type, hashing alg 2- payload: clams e.g a user 3- signature: encoded header/payload , signed with a secret tips: 1- should be shrort 2- not senstive data inside

Answer 6

Idempotency ensures that repeating an action yields the same result, regardless of how many times it's executed. It's crucial for reliability, scalability, and fault tolerance in distributed systems. Solution? Unique IDs: 1- Assign unique IDs to POST requests.Conditional Headers: 2- Use conditional headers to verify request conditions. 3- Consistent Modifications: Ensure API handles data modifications consistently.

Answer 7

Functional programming: 1. **Immutable Data**: Data is immutable, leading to fewer side effects. 2. **Higher-order Functions**: Functions can take functions as arguments or return functions. 3. **Pure Functions**: Functions produce the same output for the same input, without modifying external state. 5. **Concurrency**: Easier to reason about and implement concurrent systems due to immutability. 6. **Declarative Style**: Focuses on what to do rather than how to do it, leading to concise code. Inheritance: 1. **Code Reusability**: Allows classes to inherit attributes and methods from parent classes. 2. **Hierarchical Structure**: Supports the creation of class hierarchies for organizing code. 3. **Polymorphism**: Enables objects of different classes to be treated uniformly through inheritance. 4. **Encapsulation**: Encapsulates common behavior and attributes within parent classes. 5. **Extensibility**: Facilitates adding new functionality to existing classes without modifying their structure. 6. **Dependency**: Can lead to tight coupling between classes, making code harder to maintain and extend.

Answer 8

Try to understand 1- usecases 2- scalability requirements 3- technical constraints by **Scope and Requirements Clarification:** 1 **What are the specific requirements of the system?** Are there any constraints or limitations? What are the expected user interactions or use cases? Performance and Scalability: 2 **What are the expected load and scalability requirements?** Are there any performance benchmarks or expectations? What are the anticipated growth rates? Availability and Reliability: 3 **What are the uptime requirements?** How should the system handle failures or outages? Are there any disaster recovery or backup requirements? Data Management: 4 **What types of data will the system handle?** What are the read and write patterns? Are there any consistency or durability requirements? Security and Compliance:

Answer 9

**Redis:** Supports complex data types Offers persistence options Advanced features like pub/sub and transactions Versatile for various use cases **Memcached:** Stores data as key-value pairs No persistence mechanism Primarily for simple caching

Answer 10

enables organizations to **handle real-time** data effectively across various use cases. 1. **log** processing and **analysis** (integrate with ELK stack > kibana) 2. Data **streaming** for recommendations ( integrate with Flink > Machine learning) 3. system **monitoring** and **alerting** 4. changeed data capture (**CDC**) keeping sync data in multiple dbs 5. **system Migration** from v1 to v2

Answer 11

Domain-driven design (DDD) is an approach to software development that emphasizes understanding and modeling the core business domain, fostering collaboration between domain experts and developers, and creating a common language to describe the domain. **Strategic design** **-ubiquitous language ** **- Domains :** 1 - core domain: video streaming 2 - sub domains: recomandation/ billing **- key parts of each domain (billing)** Entities: subscriber / payment details, subscription plans **bounded context** subscribers in (billing/recommandation) **Context map** with anti corruption layer relationship and commiunication between domains/entities **Tactical design** domain objects: - entity (mutable but ID) <---> realworld counterpart - value objects (immutable) like email - aggreate (several entity/value) e.g. order **Repositories and Services**

Answer 12

* **Protocol**: publish-subscribe -- message queuing * **Scalability**: high throughput and horizontal scalability --- smaller-scale * **use cases**: real-time data streaming, analytics --- task distribution, async messaging * **consumer groups**: consumer groups support, parallel processing of messages ---- no builtin * **Message ordering**: multiple partitions , one queue * **Message Priority**: no priority, supports it * **Replication** with partition replication, with Mirrored Queue * **Message Delivery Guarantees**: atleast once and exactly once --- at least one *

Answer 13

Client-Side Storage - **HTTP-only Cookies:** stored in a cookie that is flagged as HTTP-only, making it inaccessible to JavaScript. Pros: Provides protection against cross-site scripting (XSS) attacks. Cons: May still be vulnerable to cross-site request forgery (CSRF) attacks. Server-Side Storage - **Session Storage:** stored on the server, typically in a database or an in-memory store like Redis, and linked to the user’s session. Pros: Enhances security by keeping the token out of the client’s hands. Cons: Requires additional server-side infrastructure and management

Answer 14

**Single Responsibility Principle (SRP)**: A class should have only one reason to change, meaning it should only have one job or responsibility. - example MVC, split in layers based on sRP **Open/Closed Principle (OCP)**: Software entities should be open for extension but closed for modification. You should be able to add new functionality without altering existing code. **Liskov Substitution Principle (LSP)**: Objects of a superclass should be replaceable with objects of a subclass without affecting the correctness of the program. **Interface Segregation Principle (ISP)**: Clients should not be forced to depend on interfaces they do not use. This means creating smaller, more specific interfaces rather than a single, general-purpose interface. **Dependency Inversion Principle (DIP)**: High-level modules should not depend on low-level modules. Both should depend on abstractions. Additionally, abstractions should not depend on details; details should depend on abstractions. - used a lot - testable - in construcure or function argument like s3client NestJs, sprint boot, scala by default

Answer 15

- how to distribute your team (conway law) - avoid single point of failure

Answer 16

**Sanity test:** A quick validation check after after minor changes like bug fixes, often involving a small set of unit tests or basic functionality checks. **Smoke Test**: Performed to verify that the overall system is stable enough for further testing. It checks the core functions of the entire system, often after a new build