GoLang Concurrency

Explore livelocks and deadlocks in Go concurrency, using a watchdog to reset the system and a main process refactor to show cycles that keep the system running or stall it.

Turn the main function into a little engine that runs periodic tasks every two seconds, then spawn additional engines to run tasks concurrently, exploring synchronous versus parallelism.

Explore the road map for learning Go concurrency, focusing on basic synchronization and four go routines to coordinate information. We cover weight groups, text pools, map, logger, and con.

Explore a practical go routine and wait group pattern by building a small web server where a long process runs concurrently and the handler waits for it before responding.

Demonstrates go using a conditional discharge with Sync.Cond, attaching three action listeners, broadcasting signals, coordinating goroutines with wait groups, and recursively reattaching handlers.

Create a cli utility that demonstrates channels by returning a string channel from a read function and routing input with a switch, including default and exit cases to practice concurrency.

Demonstrates non-blocking concurrent ports in Go by running three ports with separate goroutines, handling multiple connections per port, and refactoring to a handle data routine coordinated by a wait group.

Clarify the difference between a connection pool and a memory allocation pool in Go concurrency, explain when each is useful, and preview a small connection pool example.

Explore memory pool concepts by simulating a client that allocates 100 messages of about 1000 kilobytes each, showing memory usage and preparing for the project build.

This introductory video explains turning a client-server setup into a pool-based server approach, logging messages, sending json messages, and measuring response time to replace the pool implementation.

Explore Go's sync.Pool by implementing a memory allocation pool alongside a connection pool, compare allocations and reuse with atomic counters, and analyze behind-the-scenes behavior in a server-client setup.

Install and configure MongoDB on Ubuntu, set up private and public Go module configurations for cross-project access, enable authentication, bind to external IP, and manage the service.

Learn how to authenticate, switch databases, and create collections using Mongo shell commands. Discover how language drivers interface with Mongo and how to change a user's password.

Create a websocket pool in Go by building a master hub for connections. Use context and Mongo connectivity with a select statement to show how the pool handles connections.

Learn to set up a Go web server with websocket support by integrating third-party packages like google/uuid and gorilla/mux, upgrading http to websocket for stateful, message-driven communication.

Finish upgrading the websocket server and client to tls for a secure wss connection, handle client id exchange and acknowledgments, and implement insecure skip-verify for certificates from Let's Encrypt.

Develop and manage a websocket client pool in go by using channels and a select loop to register, track, and clean up connected clients with concurrent goroutines.

Explore Go concurrency by turning a Redis-backed task system into a public module for a websocket server, using a sink queue to schedule asynchronous tasks.

Learn how to launch tmux from Go using os/exec, attach to a new session, and pipe input and output while managing cancellation with signals and channels.

Learn to use context with cancel and background to manage cancellation and lifetimes, demonstrate the done channel, and control flow with select in a practical, hands-on example.

Go concurrency basics with channels, goroutines, and a select loop, demonstrating timeouts, buffered channels, and byte array input and output.

explore a go concurrency pattern using channels to stream integers, range over a channel, and defer closing the go func to gracefully shut the channel when work completes.

Explore safe cleanup of goroutines in Go using a done channel and select to signal completion, close channels properly, and prevent panics from sending on closed channels.

Explore channels with a range loop to process data through a buffer, close the channel, and flush output to standard out in Go.

Generate fake data for Mongo using a Node-based workflow, exporting a thousand-row mock dataset, and building a command interpreter to upload data to a server while practicing concurrent API calls.

Fix the deprecation warning in the GoLang concurrency project by applying the fix, verify the connection status, and continue building the client in the next video.

Implement a client–server workflow to insert a file via a websocket command, selecting database and collection, validating inputs, and packaging data for a MongoDB insert.

Demonstrate an insert many workflow by adding multiple documents to a playground collection. Build a reusable insert object, manage quotes, and verify results via client-server commands and console output.

Create and test a basic find command in Go that retrieves all documents from a database collection, iterating with a cursor and logging each result.

Explore the foreach command in GoLang concurrency by stacking commands, iterating documents with a cursor, and displaying document properties using template strings.

Generate a JSON array of mock data with fields like full name and date registered in ISO format, then import into API database, collection people, using Mongo import.

Learn to build and test complex queries using greater than, less than, and their inclusive variants, including counts and string comparisons, to retrieve and filter objects in GoLang.

Learn to use $gt, $lt, $gte, and $lte with strings in Go, combining comparisons to filter by full name and numeric ranges, and retrieve counts and results in Mongo.

Add a find with object command that accepts a sort field to sort by a field in the object. The lecture shows client-side and server-side integration with object-based sorts.

Explore adding a find with a filter command and a projection to return selected fields, like full name and email, and verify client-server results.

Learn to use gt and lt date filters with MongoDB to query records, combine date ranges with field filters, and return full names and emails sorted by date.

Experiment with the $nin operator to filter ages not in an array within the people collection and verify 25, 26, and 27 are excluded.

Explore element match to query a nested purchases array, filtering by name, product, price, and type, and observe the resulting document and count.

learn to add update many commands, compile and test, handle deprecation warnings, and ensure documents have an empty tags array by updating all relevant records.

Add and test the replaceOne command, replacing a specific object on the client and server sides, and practice integrating replace calls with find and update logic in GoLang concurrency.

Explore the replaceOne command to replace an entire document, compare it with set-based updates, and prepare for extensive update tests.

Learn to use update many to set an updated field to the current date and time across documents, applying the update when the field exists and is false.

Perform a combined update using updateOne with $set and $currentDate to modify field 1 and field 2, validating that time fields update correctly.

Learn how updateOne with $addToSet avoids duplicates when updating arrays, replacing push and each with a set-based approach that adds only new values.

Demonstrates using the updateOne operation and the $pop operator to remove first or last elements from an array in a document.

Learn to reference items by index, reset selections, and apply updates with the operator, observing changes without errors.

Update an array of documents by locating an item with a specific name using an element match, then set its price with a $ reference to 100.

Learn to use the $elemMatch operator to match and update elements within an array, referencing the specific element and changing its type.

GoLang Concurrency: increment the price by one hundred using the increment operation and element match in a query, then verify the updated value (102) in the playground.

Build and test an aggregation command with stage one, temp stage one, and subsequent stages, pushing objects into an agg array and logging stage one to verify data flow.

Explore the group operator in Go, building aggregation groups with age, country, and color, using the aggregate API and labeled identifiers to create multi-field groupings.

Demonstrates building and running a multi-stage aggregation pipeline using match and group, outputting results after the query and testing with multiple stages to group by color, country, and gender.

Explore aggregation in GoLang concurrency through aggregation 016, anchored by Dr. Al Salvador's documents. Gain a concise overview of how aggregation concepts fit into GoLang concurrency.

Explore aggregation in GoLang concurrency, focusing on how results are obtained and interpreted, and emphasize credible, honest assessment of outcomes.

Set up a public GitHub repository for go public modules, initialize the project folder, configure git user name and email, and prepare to use go mod across other packages.

Set up a Go module system with public models and a private repo, exporting functions for cross-package use and testing with go get, go run, and git push.

GoLang concurrency teaches building a standalone go web server to host a react app, with routing and a redirect back to the home page.

learn to serve a React app with Go by building a basic web server using gorilla mux, static file serving, and port configuration, plus routing considerations for client-side routing.

Master the art of serving a React app with Go by building a custom file server, implementing a not found handler, and routing static assets.

Set up a React front end by installing tools, configuring Nginx with sites-available and symbolic links, enabling sites, and securing with Let's Encrypt for a complete part 1 foundation.

Learn to obtain and install a Let's Encrypt certificate for multiple domains, configure a standalone server on port 80, and begin setting up a React front end.

Set up a React front-end by installing Babel and Parcel, configuring packages and nginx, and scaffolding a source tree with components, fonts, and a basic app.

Learn to implement a responsive sidebar layout and react routing to switch between dashboard, login, and register components, using a grid-based interface and authentication flow.

implement a key listener in the app context using useeffect to handle key up events, toggle display state on escape, and manage event listeners for clean re-renders.

Learn to build a tailored login interface with Facebook and Twitter buttons, using a reusable button component, custom props, styling, and icon assets while preparing for open id integration.