Oreily – 100 mistakes in Go and how to avoid them, video edition 2022–11 – Download

Description

Video course “100 mistakes in Go and how to avoid them.” The course is presented in video format, where the speaker reads the text of the book, and the content, drawings, code lists, diagrams and text are displayed on the screen. This course is like an audiobook, which you can also watch as a video. By taking this course, you’ll be able to identify common mistakes you make in your Go code and become more productive by avoiding them.

About technology: Understanding errors is the best way to improve the quality of your code. This unique book examines 100 common mistakes and inefficiencies in Go programs, along with tips and techniques to avoid them in your own projects.

About the book: This book shows you how to replace common Go programming problems with clean, expressive code. In this book, you will study dozens of interesting examples and cases and learn to identify errors that may appear in your own programs. Expert author Tiwa Harsani breaks down error prevention techniques into useful categories, from data types and strings to parallel execution and testing.

course content

• Identify and fix errors at the code level
• How to Avoid Problems with Program Structure and Design
• Improve your data and governance structures
• Optimizing your code by eliminating inefficiencies

What will you learn

• How to Avoid the Most Common Mistakes Go Programmers Make
• Structuring and Organizing Your Go Program
• Effective management of data and control structures
• Basic handling of errors
• Improve your timing skills
• Optimize your code
• Preparing the program for production and improving the quality of tests

This course is suitable for people who

This course is suitable for developers familiar with Go programming and syntax.

Characteristics of the course “100 Go mistakes and how to avoid them”, video release

• Publisher: Oreily
• Lecturer: Teiva Harsanyi
• Level of training: from beginner to advanced
• Duration of training: 12 hours 38 minutes

Course headings

• Chapter 1. Go: easy to learn, but difficult to master
• Chapter 1. 100 mistakes in Go
• Chapter 2. Code and Project Organization
• Chapter 2. No. 3: Incorrect use of initialization functions
• Chapter 2. No. 5: Interface contamination
• Chapter 2. Interface contamination
• Chapter 2. No. 7: Returning interfaces
• Chapter 2 #9: Misunderstanding When to Use Generics
• Chapter 2. No. 10: Ignorance of possible problems with type injection
• Chapter 2. No. 11: Do not use the functional options template
• Chapter 2. No. 12: Disorganization of the project
• Chapter 2 #14: Ignoring Package Name Conflicts
• Chapter 2. No. 16: Don’t use linters
• Chapter 3. Data Types
• Chapter 3. No. 19: Misunderstanding Floating Point Numbers
• Chapter 3. No. 20: Misunderstanding of cut length and capacity
• Chapter 3. No. 21: Inefficient slice initialization
• Chapter 3. No. 22: Confusion about nil vs. empty slices
• Chapter 3. No. 24: Incorrect copying of fragments
• Chapter 3. No. 26: Slices and memory leaks
• Chapter 3. No. 27: Ineffective card initialization
• Chapter 3. No. 28: Cards and memory leaks
• Chapter 3. No. 29: Incorrect comparison of values
• Chapter 4. Management structures
• Chapter 4 #31: Ignoring How Arguments are Evaluated in Range Loops
• Chapter 4 #32: Ignoring the Impact of Using Pointer Elements in Range Loops
• Chapter 4: Inserting a Map During an Iteration
• Chapter 5. Strings
• Chapter 5. No. 37: Imprecise String Iteration
• Chapter 5. No. 39: Insufficiently optimized string concatenation
• Chapter 5. No. 41: Substrings and Memory Leaks
• Chapter 6. Functions and Methods
• Chapter 6. #43: Never Use Named Result Parameters
• Chapter 6. No. 45: Returning a null recipient
• Chapter 6 #47: Ignoring How Deferred Arguments and Recipients are Evaluated
• Chapter 7. Error Management
• Chapter 7. No. 50: Inaccurate error type checking
• Chapter 7. No. 52: Double error handling
• Chapter 7. No. 54: Do not handle deferment errors
• Chapter 8. Parallelism: Basics
• Chapter 8. No. 56: Parallel thinking is always faster
• Chapter 8: Parallel Merge Sort
• Chapter 8. #58: Misunderstanding of Racial Issues
• Chapter 8. Go Memory Model
• Chapter 8 #59: Misunderstanding the Impact of Concurrency on Concurrency by Workload Type
• Chapter 8. #60: Misunderstanding Go Contexts
• Chapter 8: Catching context cancellation
• Chapter 9. Parallelism: Practice
• Chapter 9. No. 63: Carelessness with Goroutines and Loop Variables
• Chapter 9. No. 65: Do not use notification channels
• Chapter 9. No. 67: Confusion about the channel size
• Chapter 9. No. 68: Forgetting about the possible side effects of string formatting
• Chapter 9. No. 70: Inaccurate use of mutexes with slices and maps
• Chapter 9. No. 72: Forgetting about sync.Cond
• Chapter 9. No. 73: Don’t use errgroup
• Chapter 9. No. 74: Copying sync type
• Chapter 10. Standard Library
• Chapter 10. No. 77: Common JSON Processing Errors
• Chapter 10 #78: Common SQL Errors
• Chapter 10. No. 79: Do not close temporary resources
• Chapter 10. No. 80: Forget the return statement after responding to an HTTP request
• Chapter 10. HTTP Server
• Chapter 11. Testing
• Chapter 11. No. 83: Disabling the -race flag
• Chapter 11. No. 85: Don’t use spreadsheet tests
• Chapter 11. No. 87: Working ineffectively with the Time API
• Chapter 11. No. 88: Do not use testing utility packages
• Chapter 11. No. 89: Writing Imprecise Tests
• Chapter 11. Carelessness with compiler optimization
• Chapter 11.9 #90: Not Extracting All Go Testing Features
• Chapter 12. Optimizations
• Chapter 12. Slicing structures vs. slice structure
• Chapter 12: Cache Placement Policy
• Chapter 12 #92: Writing Parallel Code That Leads to False Sharing
• Chapter 12. No. 93: Ignore instruction-level parallelism
• Chapter 12. No. 94: Ignorance of Data Alignment
• Chapter 12. No. 95: Misunderstanding of Stack and Stack. a bunch
• Chapter 12. No. 96: Not knowing how to cut appropriations
• Chapter 12. No. 97: Don’t Rely on Embedding Part 1
• Chapter 12. No. 97: Don’t Rely on Embedding Part 2
• Chapter 12. No. 97: Don’t Rely on Embedding Part 3
• Chapter 12 #99: Misunderstanding How the Garbage Collector Works
• Chapter 12 #100: Misunderstanding the Impact of Using Go on Docker and Kubernetes

Photos of the course “100 mistakes in Go and how to avoid them”, video version

Example video course

Download link

Download file – 994 MB.

Password for file(s): www.downloadly.ir

size

994 MB