Oreilly – 100 Go Mistakes and How to Avoid Them, Video Edition 2022-11

در تاریخ: 1403/03/18 9:31:42

توضیحات

دوره 100 Go Mistakes and How to Avoid Them Video Edition. این دوره آموزشی به صورت ویدیویی ارائه می‌شود و در آن گوینده متن کتاب را می‌خواند، در همین حال محتوا، شکل‌ها، لیست کدها، نمودارها و متن روی صفحه نمایش داده می‌شود. این دوره شبیه کتاب صوتی است که می‌توانید به صورت ویدیویی نیز آن را دنبال کنید. با گذراندن این دوره می‌توانید اشتباهات رایج که در کد Go خود مرتکب می‌شوید را شناسایی کرده و با اجتناب از آن‌ها بهره‌وری خود را بالا ببرید.

درباره فناوری: درک اشتباهات بهترین راه برای بهبود کیفیت کد شماست. این کتاب منحصر به فرد با بررسی ۱۰۰ باگ و ناکارآمدی رایج در برنامه‌های Go، به همراه نکات و تکنیک‌هایی برای جلوگیری از بروز آن‌ها در پروژه‌های خودتان می‌پردازد.

درباره کتاب: این کتاب به شما نشان می‌دهد که چگونه مشکلات رایج برنامه‌نویسی در Go را با کد اصولی و رسا جایگزین کنید. در این کتاب، ده‌ها مثال و مورد جالب را بررسی خواهید کرد و یاد می‌گیرید که چگونه اشتباهاتی را که ممکن است در برنامه‌های خودتان ظاهر شوند، شناسایی کنید. نویسنده خبره، تیوا هارسانی، تکنیک‌های اجتناب از خطا را در دسته‌بندی‌های مفیدی مانند انواع داده‌ها و رشته‌ها تا همزمانی و تست سازماندهی می‌کند.

محتوای دوره

شناسایی و رفع اشکالات در سطح کد
اجتناب از مشکلات مربوط به ساختار و طراحی برنامه
بهبود ساختارهای داده و کنترلی خود
بهینه‌سازی کد خود با حذف ناکارآمدی‌ها

آنچه فرا خواهید گرفت

رد شدن از رایج‌ترین اشتباهات برنامه‌نویسان Go
ساختاردهی و سازماندهی برنامه Go خود
مدیریت کارآمد داده‌ها و ساختارهای کنترلی
برخورد با خطاها به روشی اصولی
بهبود مهارت‌های همزمانی خود
بهینه‌سازی کد خود
آماده‌سازی برنامه برای تولید و بهبود کیفیت تست

این دوره مناسب افرادی است که

این دوره برای توسعه‌دهندگانی مناسب است که با برنامه‌نویسی و سینتکس Go مهارت کافی دارند.

مشخصات دوره 100 Go Mistakes and How to Avoid Them Video Edition

ناشر: Oreilly
مدرس: Teiva Harsanyi
سطح آموزش: مبتدی تا پیشرفته
مدت زمان آموزش: 12 ساعت 38 دقیقه

سرفصل های دوره

Chapter 1. Go: Simple to learn but hard to master
Chapter 1. 100 Go mistakes
Chapter 2. Code and project organization
Chapter 2. #3: Misusing init functions
Chapter 2. #5: Interface pollution
Chapter 2. Interface pollution
Chapter 2. #7: Returning interfaces
Chapter 2. #9: Being confused about when to use generics
Chapter 2. #10: Not being aware of the possible problems with type embedding
Chapter 2. #11: Not using the functional options pattern
Chapter 2. #12: Project misorganization
Chapter 2. #14: Ignoring package name collisions
Chapter 2. #16: Not using linters
Chapter 3. Data types
Chapter 3. #19: Not understanding floating points
Chapter 3. #20: Not understanding slice length and capacity
Chapter 3. #21: Inefficient slice initialization
Chapter 3. #22: Being confused about nil vs. empty slices
Chapter 3. #24: Not making slice copies correctly
Chapter 3. #26: Slices and memory leaks
Chapter 3. #27: Inefficient map initialization
Chapter 3. #28: Maps and memory leaks
Chapter 3. #29: Comparing values incorrectly
Chapter 4. Control 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. Map insert during iteration
Chapter 5. Strings
Chapter 5. #37: Inaccurate string iteration
Chapter 5. #39: Under-optimized string concatenation
Chapter 5. #41: Substrings and memory leaks
Chapter 6. Functions and methods
Chapter 6. #43: Never using named result parameters
Chapter 6. #45: Returning a nil receiver
Chapter 6. #47: Ignoring how defer arguments and receivers are evaluated
Chapter 7. Error management
Chapter 7. #50: Checking an error type inaccurately
Chapter 7. #52: Handling an error twice
Chapter 7. #54: Not handling defer errors
Chapter 8. Concurrency: Foundations
Chapter 8. #56: Thinking concurrency is always faster
Chapter 8. Parallel merge sort
Chapter 8. #58: Not understanding race problems
Chapter 8. The Go memory model
Chapter 8. #59: Not understanding the concurrency impacts of a workload type
Chapter 8. #60: Misunderstanding Go contexts
Chapter 8. Catching a context cancellation
Chapter 9. Concurrency: Practice
Chapter 9. #63: Not being careful with goroutines and loop variables
Chapter 9. #65: Not using notification channels
Chapter 9. #67: Being puzzled about channel size
Chapter 9. #68: Forgetting about possible side effects with string formatting
Chapter 9. #70: Using mutexes inaccurately with slices and maps
Chapter 9. #72: Forgetting about sync.Cond
Chapter 9. #73: Not using errgroup
Chapter 9. #74: Copying a sync type
Chapter 10. The standard library
Chapter 10. #77: Common JSON-handling mistakes
Chapter 10. #78: Common SQL mistakes
Chapter 10. #79: Not closing transient resources
Chapter 10. #80: Forgetting the return statement after replying to an HTTP request
Chapter 10. HTTP server
Chapter 11. Testing
Chapter 11. #83: Not enabling the -race flag
Chapter 11. #85: Not using table-driven tests
Chapter 11. #87: Not dealing with the time API efficiently
Chapter 11. #88: Not using testing utility packages
Chapter 11. #89: Writing inaccurate benchmarks
Chapter 11. Not being careful about compiler optimizations
Chapter 11.9 #90: Not exploring all the Go testing features
Chapter 12. Optimizations
Chapter 12. Slice of structs vs. struct of slices
Chapter 12. Cache placement policy
Chapter 12. #92: Writing concurrent code that leads to false sharing
Chapter 12. #93: Not taking into account instruction-level parallelism
Chapter 12. #94: Not being aware of data alignment
Chapter 12. #95: Not understanding stack vs. heap
Chapter 12. #96: Not knowing how to reduce allocations
Chapter 12. #97: Not relying on inlining Part 1
Chapter 12. #97: Not relying on inlining Part 2
Chapter 12. #97: Not relying on inlining Part 3
Chapter 12. #99: Not understanding how the GC works
Chapter 12. #100: Not understanding the impacts of running Go in Docker and Kubernetes