Concorrência e Paralelismo (Parte 2) | Entendendo Back-end para Iniciantes (Parte 4)

New Section

In this section, Fabio Akita introduces the ninth episode of the series "Começando aos 40," focusing on back-end development with a specific emphasis on Concurrency and Parallelism. He highlights the complexity of these concepts and emphasizes the importance of understanding foundational principles for independent learning.

Understanding Performance and Scalability

• Fabio discusses the common question about which programming language is most performant and scalable, cautioning against being swayed by impressive numbers without context. He advises against blindly following technology choices based on popular blogs or talks by engineers from renowned companies like Netflix or Facebook.

• Emphasizes that aspiring developers should focus on understanding technologies rather than becoming brand enthusiasts or setting unrealistic goals. He challenges the obsession with massive scalability metrics, stressing that beginners' concerns should be far removed from handling thousands or millions of simultaneous connections.

Importance of Coordination in Programming

• Acknowledges the significance of coordination in concurrent and parallel programming, stating that effective task coordination is crucial for utilizing multiple threads efficiently. Fabio underscores that simplicity and cost-effectiveness in coordinating concurrent tasks are paramount for successful programming endeavors.

Fundamental Concepts in CPU Operations

• Highlights the critical role of coordination over sheer processing power, asserting that coordinating concurrent tasks is more vital than merely executing numerous threads simultaneously. He stresses the importance of grasping basic concepts related to processes, threads, forks, and memory optimization techniques like copy-on-write.

• Explains how CPUs operate at a fundamental level by executing instructions that manipulate data. Describes how instructions process input arguments stored in registers to generate output values, illustrating how CPUs transform external inputs into meaningful results through program execution.

Exploring Program Execution

This section delves into program execution processes, elucidating how binaries interact with operating systems to perform tasks such as downloading files from the web using commands like wget or curl in UNIX/Linux environments.

Data Transformation Through Instructions

• Defines programming as data transformation through instructions where functions receive input parameters, process them to produce outputs, which can further serve as inputs for subsequent functions. Illustrates how functions chain together to execute complex operations sequentially.

• Explores how operating systems handle program execution by creating isolated processes with standard input (STDIN), standard output (STDOUT), and error output (STDERR). Demonstrates how programs like curl can redirect downloaded content to STDOUT for further processing using tools like grep for text filtering.

Understanding Inter-Process Communication

In this section, the speaker delves into various forms of communication between processes in a system, highlighting the significance of pipes, signals, files, FIFOs (First In, First Out), and Named Pipes.

Exploring Process Communication Methods

• Named Pipes serve as a form of communication between processes. They function similarly to files but allow for inter-process communication.

• FIFOs operate on a First In, First Out basis. Processes can communicate by writing and reading from a shared file-like structure.

Communication Challenges in Web Environments

• While named pipes and files facilitate local process communication, they are not suitable for web environments due to network limitations.

Leveraging Sockets for Enhanced Communication

• Sockets offer bi-directional communication channels that enable servers to connect with multiple clients efficiently.

• Unix Sockets provide similar functionalities to IP sockets but are restricted to processes within the same machine.

Application in Web Servers and Microservices

• Web servers like NGINX utilize Unix Sockets for inter-process coordination between master and worker processes.

• Microservices rely on sockets for efficient communication, establishing connections through protocols like HTTP or Protobuf.

Efficiency of Binary Protocols vs. Text Protocols

This segment discusses the efficiency disparity between binary protocols like Protobuf and text-based protocols such as HTTP in terms of data representation and transmission.

Understanding Protocol Efficiency

• Binary protocols like Protobuf offer enhanced efficiency compared to text-based ones due to their compact representation in binary format.

• Text protocols require more space for data representation since each character may need multiple bytes based on encoding standards like Unicode or UTF-8.

Understanding Communication Between Processes

In this section, the speaker delves into the significance of different data formats in communication processes and explains the use of protocols like Protobuf over HTTP for efficient data transmission.

Different Data Formats in Communication

• In the past, when networks were slow, small differences in data size mattered significantly.

• Google uses Protobuf instead of HTTP for systems handling large amounts of data due to efficiency reasons.

Communication Efficiency and Protocols

• Explains marshalling or serialization needed for heavy protocols like HTTP to transmit data between processes.

• Discusses various options for inter-process communication, ranging from simple methods like pipes to more complex ones like Unix sockets.

Exploring Threads Within a Process

This part focuses on threads within a process, highlighting their memory sharing capabilities and efficiency compared to inter-process communication.

Thread Communication and Memory Sharing

• Threads can communicate by sharing the same data structures within a process's memory space.

• Threads accessing shared memory directly enhance efficiency compared to external mechanisms like named pipes or sockets.

Challenges and Considerations with Threads

The discussion shifts towards challenges associated with thread programming, emphasizing issues such as mutexes, race conditions, and deadlocks.

Thread Programming Challenges

• Coordination issues arise in multi-threaded environments due to simultaneous access to shared memory locations.

• Highlights coordination complexities between CPU cores running real threads and those managed by the operating system scheduler.

Memory Usage and System Overhead with Threads

This segment delves into memory consumption related to thread creation, context switching overhead, and potential bugs in thread-safe programming.

Memory Management and Context Switching

• Each thread consumes memory for context storage; excessive threads lead to increased memory usage and context switching workload.

• Creating threads incurs system overhead through kernel involvement via system calls (syscalls).

Kernel Authority and System Permissions

The speaker elaborates on kernel authority versus user permissions within a system environment, emphasizing the kernel's pivotal role in managing system resources.

Kernel Control and User Permissions

• Kernel holds ultimate control over system resources; user programs operate within restricted permission levels (Ring 3).

Understanding Operating System Rings and Concurrency in Programming

In this section, the speaker delves into the concept of operating system rings and how they impact program execution. Additionally, the discussion extends to the importance of minimizing system calls for efficient program performance.

Operating System Rings and Their Functions

• The speaker explains that in a processor, Rings 1 and 2 handle drivers and virtualization tasks like loading the kernel of an OS for emulation. Ring 3 restricts certain machine instructions such as changing rings or halting the machine.

• In ARM processors, the numbering of rings is reversed compared to Intel processors. EL0 in ARM corresponds to user land (Ring 3 in Intel), while EL1 runs the kernel similar to Ring 1 in Intel.

Impact of System Calls on Performance

• Function calls within a process are cost-effective, whereas syscalls incur a context switch akin to calling functions across processes.

• Excessive syscalls lead to increased costs due to memory consumption, context switches, and privilege escalation between rings, emphasizing the importance of minimizing syscalls for optimal performance.

Concurrency Challenges in Programming Languages

• JavaScript's single-threaded nature limits concurrency options; asynchronous I/O operations serve as a workaround but are insufficient for heavy computational tasks.

• Python and Ruby utilize real threads but face challenges with Global Interpreter Lock (GIL), hindering true parallelism despite mapping to system threads.

Solutions for Concurrency Issues

• Event loops like those in Node.js or Twisted offer rudimentary concurrency by managing asynchronous I/O calls efficiently within a single thread.

New Section

In this section, the speaker discusses the evolution of coding practices from older methods to more modern concepts like callbacks and Deferreds in Python's Twisted framework.

Evolution of Coding Practices

• The speaker criticizes old coding styles as archaic and mentions passing pointers or references of functions as parameters (callbacks) in languages like C.

• Introduces the concept of Deferreds in Python's Twisted framework, allowing for chaining asynchronous calls by encapsulating them in objects.

• Explains how frameworks like JQuery adopted similar structures with Deferreds for handling asynchronous calls, improving code readability and maintainability.

• Discusses the benefits of using Deferreds and avoiding callback hells by encapsulating asynchronous calls into objects for easier manipulation within the code.

• Introduces the concept of coroutines, highlighting their ability to pause a function's execution, allowing other functions to run within the same process without context switching.

New Section

This section delves deeper into coroutines, specifically focusing on Fibers or Generators and their role in enhancing code readability and concurrency.

Understanding Coroutines

• Explores how Fibers or Generators act as special cases of coroutines, enabling multiple suspension points within a function for resumption later.

• Compares coroutines to cooperative multitasking akin to Windows 3.1, emphasizing their presence across various programming languages like Python, Ruby, Javascript, Swift, and Kotlin.

• Highlights that while coroutines resemble threads in terms of accessing process data structures but differ by requiring manual pausing and resuming control mechanisms for simplicity compared to threads.

New Section

This segment focuses on utilizing Fibers to simplify complex callback-based codes into sequential operations through yield statements.

Leveraging Fibers for Simplicity

• Contrasts traditional callback-heavy code with Fiber-based implementations using yield statements that block until a call returns before resuming from that point.

Understanding Concurrency and Parallelism in Programming

In this section, the speaker delves into the concepts of concurrency and parallelism in programming, highlighting how different languages handle these aspects.

Thread Pools and Task Abstraction

• : Java and C# utilize Thread Pools to manage threads efficiently, limiting the number of concurrent threads. Task abstraction allows for better control over thread usage.

Importance of Thread Pools

• : Thread Pools act as load balancers for threads, ensuring a controlled number of threads are active at any given time. This concept is crucial in managing system resources effectively.

Utilizing Pools and Queues

• : The analogy of a bank agency illustrates the function of pools and queues in managing tasks efficiently. These concepts play a vital role in controlling thread execution within an operating system.

Distributed Computing Solutions

• : Various programming languages offer solutions like Parallel (in .NET), Celery or RQ (in Python), Kue (in Node.js) for distributed computing using queues and workers. Background Jobs are integral to handling real-world application challenges effectively.

Optimizing Performance with Green Threads

The discussion shifts towards optimizing performance through green threads, exploring their role in enhancing efficiency within a single process.

Leveraging Green Threads for Concurrency

• : Green threads provide a means to achieve concurrency without true parallelism. They allow for managing multiple functions simultaneously within user space, contributing to enhanced performance.

Distinction Between Concurrency and Parallelism

New Section

In this section, the speaker discusses the concept of green threads and their advantages over real threads in terms of memory usage and efficiency.

Green Threads vs. Real Threads

• Green threads are significantly lighter in memory usage compared to real threads, costing around 2 kilobytes versus 1 MB for a real thread.

• They operate within the same process in user land, eliminating the need for syscalls and context switching by the kernel.

• By utilizing thread pools and a user-land scheduler, green threads can achieve parallelism when executed on a pool of real threads.

• Languages like Scala, Clojure, Go, Erlang, and Elixir leverage green threads effectively for efficient concurrency.

New Section

This segment delves into Erlang's innovative approach to concurrency through its virtual machine (VM) Beam and unique handling of processes.

Erlang's Concurrency Model

• Erlang's VM Beam seizes machine resources upon startup, including I/O, memory, and actual system threads.

• It employs a user-land scheduler for each real thread and utilizes true coroutines rather than just fibers.

• Each Erlang coroutine operates as an isolated "process," ensuring no shared memory among processes to prevent system destabilization.

• Communication between Erlang processes occurs through message passing via channels similar to Unix Sockets but with non-shared data structures.

New Section

This part emphasizes how Erlang's design ensures robustness by isolating processes and preventing potential system crashes due to individual process failures.

Process Isolation in Erlang

• Each Erlang process functions as a green-thread with its own allocated memory space protected by the VM.

• Processes receive messages in a mailbox structure for asynchronous communication without shared memory concerns.

• A dedicated garbage collector per process manages memory cleanup independently upon process termination or failure.

• The isolation of processes prevents one faulty process from affecting or corrupting other parts of the system.

New Section

Here, the discussion shifts towards comparing resource consumption between traditional threading models and Erlang's lightweight green-thread approach.

Resource Efficiency Comparison

• Traditional threading models require substantial memory allocation per thread (e.g., 1 MB), leading to high RAM consumption for large-scale applications like network connections handling.

• In contrast, Erlang's green-thread model consumes minimal resources (e.g., 2 KB per process), enabling efficient handling of numerous connections with minimal RAM usage.

• The scalability advantage of green threads allows for creating a new green-thread per connection without overwhelming resource demands compared to traditional threading approaches.

New Section

This section highlights how leveraging green-thread architectures with dedicated schedulers enables true parallelism in languages like Scala and Clojure built on top of Java.

Green Threads in Scala and Clojure

• Languages such as Scala implement frameworks like Akka that embrace actor-based concurrency akin to Erlang's processes.

• Actors in Scala exhibit characteristics similar to coroutines with multiple suspension points facilitated by mailboxes for inter-process communication without shared memory risks.

• The architectural similarities between Erlang and Scala stem from direct inspiration where concepts align despite language differences.

Understanding Concurrency in Programming Languages

In this section, the speaker discusses the concepts of processes, goroutines, and channels in programming languages like Erlang and Go, highlighting their differences and similarities.

Processes vs. Goroutines

• Erlang's processes are akin to Go's goroutines.

• Goroutines are lower-level than Scala's Actors.

• Processes in Erlang have a unique Process ID (PID) for communication.

Channels in Go

• Go utilizes channels for communication between goroutines.

• Channels allow sharing of data, including memory pointers.

Comparison with Other Languages

• Go's scheduler is cooperative compared to Erlang's preemptive scheduler.

• Schedulers in user-land for coroutines are favored over reactors in some languages.

Optimizing Concurrency with Different Language Runtimes

This section delves into the runtime environments of various programming languages like Java, Scala, Clojure, Kotlin, C#, and their approaches to concurrency optimization.

Runtime Environments

• Java-based languages run on virtual machines designed for resource management.

• Erlang stands out for its concurrency abstractions.

Language Features

• Scala and Clojure introduce user-land schedulers for enhanced concurrency handling.

Concurrency Models in Modern Programming Languages

The discussion shifts towards modern programming languages such as Go, Rust, Crystal, and JavaScript concerning their concurrency models and runtime implementations.

Language Comparisons

• Go compiles native binaries with a runtime supporting green threads via channels.

Limitations of Some Languages

• Rust and Crystal lack advanced concurrency features like user-land schedulers.

Challenges Faced by JavaScript in Concurrency

The challenges encountered by JavaScript regarding parallelism and its event-driven nature are explored.

JavaScript Constraints

New Section

In this section, the speaker discusses the intricacies of handling synchronization and coordination in programming languages like Java, C#, and Go, emphasizing the need for developers to manage these aspects due to the nature of threading and channel operations.

Handling Synchronization in Programming Languages

• The speaker highlights that in languages such as Java or C#, which expose real threads, developers still need to be mindful of synchronization concerns. Similarly, in Go, where pointers are transported through channels between goroutines, developers must also address synchronization issues.

• Unlike Erlang or Elixir, which do not share data between processes, Go requires manual intervention from developers for synchronization and coordination tasks.

• Creating a deadlock in a Go channel can lead to program crashes, showcasing the importance of understanding and managing synchronization mechanisms within the language.

New Section

This segment delves into design decisions within programming languages regarding concepts like pointers and their visibility. It also touches on historical perspectives related to language features such as GOTO statements and Null references.

Design Decisions in Programming Languages

• The discussion revolves around how certain programming languages like C or C++ provide access to low-level features including pointers, highlighting that hiding pointers is a deliberate design choice within a language.

• Drawing parallels with historical shifts such as the deprecation of GOTO statements and Null references being considered problematic today, the speaker reflects on similar trends concerning pointer usage.

• Reference is made to Node.js popularizing callback-driven programming styles initially around 2010, followed by frameworks like Twisted and JQuery introducing abstractions like Deferreds. Additionally, Scala played a role in popularizing terms like Future as an evolution over Deferreds.

New Section

This part explores advancements in asynchronous programming paradigms through concepts like Futures and Promises across different programming languages.

Advancements in Asynchronous Programming

• The discussion introduces Futures as encapsulations for future executions within objects akin to placeholders for uncertain outcomes from asynchronous calls.

• Evolution from Deferreds to Futures culminated in Promises becoming prevalent particularly with frameworks like Promise/A+ standardizing their usage across languages such as JavaScript.

• Promises offer chainable and customizable objects with methods like then and catch for adding callbacks similar to Deferred's addCallback function from Twisted framework.

New Section

Here, the focus shifts towards syntactic enhancements known as "syntactic sugar" that streamline working with Promise objects without directly manipulating them via specific methods.

Syntactic Enhancements for Promises

• Various programming languages have introduced syntactic enhancements such as async/await syntax pioneered by Microsoft for C#, simplifying Promise handling by abstracting complexities behind asynchronous operations.

• Async/await functions operate similarly to join operations but extend beyond traditional thread-based synchronizations into green threads or coroutines contexts.

New Section

This segment elucidates similarities between traditional thread management functions like join with modern async/await constructs facilitating concurrency control across diverse execution environments.

Thread Management Functions vs. Async/Await Constructs

• Drawing parallels between traditional thread management functions (e.g., join) found in threaded environments with async/await constructs prevalent in modern asynchronous programming paradigms.

• Async/await serves as a semantic tool enabling synchronization not only within threads but also extending its utility to green threads or coroutines contexts effectively enhancing code readability and maintainability.