MARC

 008260202s2022        xx            o                  0  eng  d
■001EBC30229305
■003MiAaPQ
■00520260202073946.0
■006m          o    d  |            
■007cr  cnu||||||||
■020    ▼a9781098105686▼q(electronic  bk.)
■020    ▼z9781098105716
■035    ▼a(MiAaPQ)EBC30229305
■035    ▼a(Au-PeEL)EBL30229305
■035    ▼a(OCoLC)1351200374
■040    ▼aMiAaPQ▼beng▼erda▼epn▼cMiAaPQ▼dMiAaPQ
■1001  ▼aPlotka,  Bartlomiej.
■24510▼aEfficient  Go
■250    ▼a1st  ed.
■264  1▼aSebastopol▼bO'Reilly  Media,  Incorporated▼c2022.
■264  4▼c?022.
■300    ▼a1  online  resource  (502  pages)
■336    ▼atext▼btxt▼2rdacontent
■337    ▼acomputer▼bc▼2rdamedia
■338    ▼aonline  resource▼bcr▼2rdacarrier
■5050  ▼aCover  --  Copyright  --  Table  of  Contents  --  Preface  --  Why  I  Wrote  This  Book  --  How  I  Gathered  This  Knowledge  --  Who  This  Book  Is  For  --  How  This  Book  Is  Organized  --  Conventions  Used  in  This  Book  --  Using  Code  Examples  --  Acknowledgments  --  Feedback  Is  Welcome!  --  O'Reilly  Online  Learning  --  How  to  Contact  Us  --  Chapter  1.  Software  Efficiency  Matters  --  Behind  Performance  --  Common  Efficiency  Misconceptions  --  Optimized  Code  Is  Not  Readable  --  You  Aren't  Going  to  Need  It  --  Hardware  Is  Getting  Faster  and  Cheaper  --  We  Can  Scale  Horizontally  Instead  --  Time  to  Market  Is  More  Important  --  The  Key  to  Pragmatic  Code  Performance  --  Summary  --  Chapter  2.  Efficient  Introduction  to  Go  --  Basics  You  Should  Know  About  Go  --  Imperative,  Compiled,  and  Statically  Typed  Language  --  Designed  to  Improve  Serious  Codebases  --  Governed  by  Google,  Yet  Open  Source  --  Simplicity,  Safety,  and  Readability  Are  Paramount  --  Packaging  and  Modules  --  Dependencies  Transparency  by  Default  --  Consistent  Tooling  --  Single  Way  of  Handling  Errors  --  Strong  Ecosystem  --  Unused  Import  or  Variable  Causes  Build  Error  --  Unit  Testing  and  Table  Tests  --  Advanced  Language  Elements  --  Code  Documentation  as  a  First  Citizen  --  Backward  Compatibility  and  Portability  --  Go  Runtime  --  Object-Oriented  Programming  --  Generics  --  Is  Go  "Fast"?  --  Summary  --  Chapter  3.  Conquering  Efficiency  --  Beyond  Waste,  Optimization  Is  a  Zero-Sum  Game  --  Reasonable  Optimizations  --  Deliberate  Optimizations  --  Optimization  Challenges  --  Understand  Your  Goals  --  Efficiency  Requirements  Should  Be  Formalized  --  Resource-Aware  Efficiency  Requirements  --  Acquiring  and  Assessing  Efficiency  Goals  --  Example  of  Defining  RAER  --  Got  an  Efficiency  Problem?  Keep  Calm!  --  Optimization  Design  Levels  --  Efficiency-Aware  Development  Flow  --  Functionality  Phase  --  Efficiency  Phase  --  Summary.
■5058  ▼aChapter  4.  How  Go  Uses  the  CPU  Resource  (or  Two)  --  CPU  in  a  Modern  Computer  Architecture  --  Assembly  --  Understanding  Go  Compiler  --  CPU  and  Memory  Wall  Problem  --  Hierachical  Cache  System  --  Pipelining  and  Out-of-Order  Execution  --  Hyper-Threading  --  Schedulers  --  Operating  System  Scheduler  --  Go  Runtime  Scheduler  --  When  to  Use  Concurrency  --  Summary  --  Chapter  5.  How  Go  Uses  Memory  Resource  --  Memory  Relevance  --  Do  We  Have  a  Memory  Problem?  --  Physical  Memory  --  OS  Memory  Management  --  Virtual  Memory  --  mmap  Syscall  --  OS  Memory  Mapping  --  Go  Memory  Management  --  Values,  Pointers,  and  Memory  Blocks  --  Go  Allocator  --  Garbage  Collection  --  Summary  --  Chapter  6.  Efficiency  Observability  --  Observability  --  Example:  Instrumenting  for  Latency  --  Logging  --  Tracing  --  Metrics  --  Efficiency  Metrics  Semantics  --  Latency  --  CPU  Usage  --  Memory  Usage  --  Summary  --  Chapter  7.  Data-Driven  Efficiency  Assessment  --  Complexity  Analysis  --  "Estimated"  Efficiency  Complexity  --  Asymptotic  Complexity  with  Big  O  Notation  --  Practical  Applications  --  The  Art  of  Benchmarking  --  Comparison  to  Functional  Testing  --  Benchmarks  Lie  --  Reliability  of  Experiments  --  Human  Errors  --  Reproducing  Production  --  Performance  Nondeterminism  --  Benchmarking  Levels  --  Benchmarking  in  Production  --  Macrobenchmarks  --  Microbenchmarks  --  What  Level  Should  You  Use?  --  Summary  --  Chapter  8.  Benchmarking  --  Microbenchmarks  --  Go  Benchmarks  --  Understanding  the  Results  --  Tips  and  Tricks  for  Microbenchmarking  --  Too-High  Variance  --  Find  Your  Workflow  --  Test  Your  Benchmark  for  Correctness!  --  Sharing  Benchmarks  with  the  Team  (and  Your  Future  Self)  --  Running  Benchmarks  for  Different  Inputs  --  Microbenchmarks  Versus  Memory  Management  --  Compiler  Optimizations  Versus  Benchmark  --  Macrobenchmarks  --  Basics  --  Go  e2e  Framework  --  Understanding  Results  and  Observations.
■5058  ▼aCommon  Macrobenchmarking  Workflows  --  Summary  --  Chapter  9.  Data-Driven  Bottleneck  Analysis  --  Root  Cause  Analysis,  but  for  Efficiency  --  Profiling  in  Go  --  pprof  Format  --  go  tool  pprof  Reports  --  Capturing  the  Profiling  Signal  --  Common  Profile  Instrumentation  --  Heap  --  Goroutine  --  CPU  --  Off-CPU  Time  --  Tips  and  Tricks  --  Sharing  Profiles  --  Continuous  Profiling  --  Comparing  and  Aggregating  Profiles  --  Summary  --  Chapter  10.  Optimization  Examples  --  Sum  Examples  --  Optimizing  Latency  --  Optimizing  bytes.Split  --  Optimizing  runtime.slicebytetostring  --  Optimizing  strconv.Parse  --  Optimizing  Memory  Usage  --  Moving  to  Streaming  Algorithm  --  Optimizing  bufio.Scanner  --  Optimizing  Latency  Using  Concurrency  --  A  Naive  Concurrency  --  A  Worker  Approach  with  Distribution  --  A  Worker  Approach  Without  Coordination  (Sharding)  --  A  Streamed,  Sharded  Worker  Approach  --  Bonus:  Thinking  Out  of  the  Box  --  Summary  --  Chapter  11.  Optimization  Patterns  --  Common  Patterns  --  Do  Less  Work  --  Trading  Functionality  for  Efficiency  --  Trading  Space  for  Time  --  Trading  Time  for  Space  --  The  Three  Rs  Optimization  Method  --  Reduce  Allocations  --  Reuse  Memory  --  Recycle  --  Don't  Leak  Resources  --  Control  the  Lifecycle  of  Your  Goroutines  --  Reliably  Close  Things  --  Exhaust  Things  --  Pre-Allocate  If  You  Can  --  Overusing  Memory  with  Arrays  --  Memory  Reuse  and  Pooling  --  Summary  --  Next  Steps  --  Appendix  A.  Latencies  for  Napkin  Math  Calculations  --  Index  --  About  the  Author  --  Colophon.
■588    ▼aDescription  based  on  publisher  supplied  metadata  and  other  sources.
■590    ▼aElectronic  reproduction.  Ann  Arbor,  Michigan  :  ProQuest  Ebook  Central,  2026.  Available  via  World  Wide  Web.  Access  may  be  limited  to  ProQuest  Ebook  Central  affiliated  libraries.  
■655  4▼aElectronic  books.
■77608▼iPrint  version▼aPlotka,  Bartlomiej▼tEfficient  Go▼dSebastopol  :  O'Reilly  Media,  Incorporated,c2022▼z9781098105716
■7972  ▼aProQuest  (Firm)
■85640▼uhttps://ebookcentral.proquest.com/lib/baekseok-ebooks/detail.action?docID=30229305▼zClick  to  View

미리보기

내보내기

chatGPT토론

Ai 추천 관련 도서