Hugo Santos

Monolithic vs microservices

1

Understanding how the CPU works and how to write thread-efficient programs is very important. Thread Context Switching - When a program is executed in a single-core CPU, the CPU can work with and execute only one thread at any given time. Each thread gets its share of CPU time. For example, when a thread is writing something to the disk, and if it's consuming time, the CPU switches to another thread while the earlier thread is waiting. Threads are context-switched, and it looks like it is multitasking, and things are going on in parallel, which is not. Processing : Sequential processing is where programs are executed in a sequence, one by one, getting allocated with the CPU Concurrency: Parts of the program can be run independently and combined for the result and to speed up the execution on a single CPU Parallel: Each program can be run on each CPU independently and combined for the final results to speed up the execution Single Vs. Multi-thread - By running multiple threads vs. single threads to execute a program, the overall execution time can be reduced, and efficiency can be improved. Process Vs. Threads: A process uses CPU, memory, disk, and other resources to execute a program. A process can spin up one or multiple threads to complete the job. Sync Vs Asyn: Sync is executed in a sequence and cannot be skipped, but Asyn can run its block of the program separately from the main program and doesn't have to wait for completion to move on Thread Deadlock: When the resources required by a thread are being blocked by another one, and each one is waiting on another one, it leads to a deadlock state #cpu #development #technology #softwaredesign

458

35 Kommentare

The Iterator Pattern: A Peacekeeper in the Great Menu Conflict "Iterator Pattern defined... The Iterator Pattern provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation. This makes a lot of sense: the pattern gives you a way to step through the elements of an aggregate without having to know how things are represented under the covers. You've seen that with the two implementations of Menus. But the effect of using iterators in your design is just as important: once you have a uniform way of accessing the elements of all your aggregate objects, you can write polymorphic code that works with any of these aggregates just like the printMenu() method, which doesn't care if the menu items are held in an Array or ArrayList (or anything else that can create an Iterator), as long as it can get hold of an Iterator. The other important impact on your design is that the Iterator Pattern takes the responsibility of traversing elements and gives that responsibility to the iterator object, not the aggregate object. This not only keeps the aggregate interface and implementation simpler, it removes the responsibility for iteration from the aggregate and keeps the aggregate focused on the things it should be focused on (managing a collection of objects), not on iteration." ― Eric Freeman & Elisabeth Robson, Head First Design Patterns: Building Extensible and Maintainable Object-Oriented Software https://lnkd.in/dPYV-8jF #refactoring #extremeprogramming #modernagile #agility #tdd #testdrivendevelopment #legacycode #continuousimprovement #maintainability #softwarequality #codequality #softwaredesign #lean #oop #solid #designpatterns

2

How to build a Monolith that does its job well: * Create internal contracts and separation of concerns * Organize your code to allow for parts of the system to be worked on in isolation * Pay attention to application performance metrics and move expensive operations to the background * Figure out horizontal scaling early, before you need it * Watch your slow query log and keep your database healthy * Don't be afraid to use multiple data stores to avoid overloading a single one * Create strong conventions to keep the codebase consistent Oh, and make sure it's doing something people want because efficiently doing something no one cares about is pointless.

3

This is perfect to quickly understand Big O notation.

10