Data Architect | ML Engineer | Quantum Computing Enthusiast https://teapaw.org/t.co/bkk0Xg7cOQ
Barranquilla, Colombia
Joined February 2010
- Tweets511
- Following254
- Followers147
- Likes1.9K
Pinned Tweet
Día 10 de #66daysofdata con .@KenJee_DS: Exploré la librería #OpenCV para realizar detección de rostro y ojos usando el clasificador Haar Cascade. En esta oportunidad lo implementé en tiempo real a través de la cámara web. #computervision #MachineLearning #DeepLearning
Carlos Barros retweeted
Top 9 Architectural Patterns for Data and Communication Flow
🔹 Peer-to-Peer
The Peer-to-Peer pattern involves direct communication between two components without the need for a central coordinator.
🔹 API Gateway
An API Gateway acts as a single entry point for all client requests to the backend services of an application.
🔹 Pub-Sub
The Pub-Sub pattern decouples the producers of messages (publishers) from the consumers of messages (subscribers) through a message broker.
🔹 Request-Response
This is one of the most fundamental integration patterns, where a client sends a request to a server and waits for a response.
🔹 Event Sourcing
Event Sourcing involves storing the state changes of an application as a sequence of events.
🔹 ETL
ETL is a data integration pattern used to gather data from multiple sources, transform it into a structured format, and load it into a destination database.
🔹 Batching
Batching involves accumulating data over a period or until a certain threshold is met before processing it as a single group.
🔹 Streaming Processing
Streaming Processing allows for the continuous ingestion, processing, and analysis of data streams in real-time.
🔹 Orchestration
Orchestration involves a central coordinator (an orchestrator) managing the interactions between distributed components or services to achieve a workflow or business process.
–
Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): bit.ly/3KCnWXq
Carlos Barros retweeted
Iterative, Agile, Waterfall, Spiral Model, RAD Model... What are the differences?
The Software Development Life Cycle (SDLC) is a framework that outlines the process of developing software in a systematic way. Here are some of the most common ones:
1 - Waterfall Model:
- A linear and sequential approach.
- Divides the project into distinct phases: Requirements, Design, Implementation, Verification, and Maintenance.
2 - Agile Model:
- Development is done in small, manageable increments called sprints.
- Common Agile methodologies include Scrum, Kanban, and Extreme Programming (XP).
3 - V-Model (Validation and Verification Model):
- An extension of the Waterfall model.
- Each development phase is associated with a testing phase, forming a V shape.
4 - Iterative Model:
- Focuses on building a system incrementally.
- Each iteration builds upon the previous one until the final product is achieved.
5 - Spiral Model:
- Combines iterative development with systematic aspects of the Waterfall model.
- Each cycle involves planning, risk analysis, engineering, and evaluation.
6 - Big Bang Model:
- All coding is done with minimal planning, and the entire software is integrated and tested at once.
7 - RAD Model (Rapid Application Development):
- Emphasizes rapid prototyping and quick feedback.
- Focuses on quick development and delivery.
8 - Incremental Model:
- The product is designed, implemented, and tested incrementally until the product is finished.
Each of these models has its advantages and disadvantages, and the choice of which to use often depends on the specific requirements and constraints of the project at hand.
Carlos Barros retweeted
What are the differences among database locks?
In database management, locks are mechanisms that prevent concurrent access to data to ensure data integrity and consistency.
Here are the common types of locks used in databases:
1. Shared Lock (S Lock)
It allows multiple transactions to read a resource simultaneously but not modify it. Other transactions can also acquire a shared lock on the same resource.
2. Exclusive Lock (X Lock)
It allows a transaction to both read and modify a resource. No other transaction can acquire any type of lock on the same resource while an exclusive lock is held.
3. Update Lock (U Lock)
It is used to prevent a deadlock scenario when a transaction intends to update a resource.
4. Schema Lock
It is used to protect the structure of database objects.
5. Bulk Update Lock (BU Lock)
It is used during bulk insert operations to improve performance by reducing the number of locks required.
6. Key-Range Lock
It is used in indexed data to prevent phantom reads (inserting new rows into a range that a transaction has already read).
7. Row-Level Lock
It locks a specific row in a table, allowing other rows to be accessed concurrently.
8. Page-Level Lock
It locks a specific page (a fixed-size block of data) in the database.
9. Table-Level Lock
It locks an entire table. This is simple to implement but can reduce concurrency significantly.
–
Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): bit.ly/3KCnWXq
Carlos Barros retweeted
10 Good Coding Principles to improve code quality.
Software development requires good system designs and coding standards. We list 10 good coding principles in the diagram below.
🔹 01 Follow Code Specifications
When we write code, it is important to follow the industry's well-established norms, like “PEP 8”, “Google Java Style”, adhering to a set of agreed-upon code specifications ensures that the quality of the code is consistent and readable.
🔹 02 Documentation and Comments
Good code should be clearly documented and commented to explain complex logic and decisions, and comments should explain why a certain approach was taken (“Why”) rather than what exactly is being done (“What”). Documentation and comments should be clear, concise, and continuously updated.
🔹 03 Robustness
Good code should be able to handle a variety of unexpected situations and inputs without crashing or producing unpredictable results. Most common approach is to catch and handle exceptions.
🔹 04 Follow the SOLID principle
“Single Responsibility”, “Open/Closed”, “Liskov Substitution”, “Interface Segregation”, and “Dependency Inversion” - these five principles (SOLID for short) are the cornerstones of writing code that scales and is easy to maintain.
🔹 05 Make Testing Easy
Testability of software is particularly important. Good code should be easy to test, both by trying to reduce the complexity of each component, and by supporting automated testing to ensure that it behaves as expected.
🔹 06 Abstraction
Abstraction requires us to extract the core logic and hide the complexity, thus making the code more flexible and generic. Good code should have a moderate level of abstraction, neither over-designed nor neglecting long-term expandability and maintainability.
🔹 07 Utilize Design Patterns, but don't over-design
Design patterns can help us solve some common problems. However, every pattern has its applicable scenarios. Overusing or misusing design patterns may make your code more complex and difficult to understand.
🔹 08 Reduce Global Dependencies
We can get bogged down in dependencies and confusing state management if we use global variables and instances. Good code should rely on localized state and parameter passing. Functions should be side-effect free.
🔹 09 Continuous Refactoring
Good code is maintainable and extensible. Continuous refactoring reduces technical debt by identifying and fixing problems as early as possible.
🔹 10 Security is a Top Priority
Good code should avoid common security vulnerabilities.
Over to you: which one do you prefer, and with which one do you disagree?
--
Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): bit.ly/3KCnWXq
Carlos Barros retweeted
You're Good at Linux if You Know What All Those Directories Mean.
The Linux file system used to resemble an unorganized town where individuals constructed their houses wherever they pleased. However, in 1994, the Filesystem Hierarchy Standard (FHS) was introduced to bring order to the Linux file system.
By implementing a standard like the FHS, software can ensure a consistent layout across various Linux distributions. Nonetheless, not all Linux distributions strictly adhere to this standard. They often incorporate their own unique elements or cater to specific requirements.
To become proficient in this standard, you can begin by exploring. Utilize commands such as "cd" for navigation and "ls" for listing directory contents. Imagine the file system as a tree, starting from the root (/). With time, it will become second nature to you, transforming you into a skilled Linux administrator.
Have fun exploring!
Over to you: which directory did you use most frequently?
–
Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): bit.ly/3KCnWXq