Info
- Utilizzare la checkbox di selezione a fianco di ciascun documento per attivare le funzionalità di stampa, invio email, download nei formati disponibili del (i) record.
Distributed services with Go : your guide to reliable, scalable, and maintainable systems / / Travis Jeffery
| Distributed services with Go : your guide to reliable, scalable, and maintainable systems / / Travis Jeffery |
| Autore | Jeffery Travis |
| Edizione | [First edition.] |
| Pubbl/distr/stampa | [Raleigh, North Carolina] : , : The Pragmatic Programmers, LLC, , [2021] |
| Descrizione fisica | 1 online resource (245 pages) |
| Disciplina | 005.2762 |
| Soggetto topico |
Go (Computer program language)
Electronic data processing - Distributed processing |
| ISBN |
9781680508383
1680508385 9781680508390 1680508393 |
| Formato | Materiale a stampa  |
| Livello bibliografico | Monografia |
| Lingua di pubblicazione | eng |
| Nota di contenuto | Part 1: Get started. 1. Let's go -- 2. Structure data with protocol buffers -- 3. Write a log package -- Part 2: Network. 4. Serve requests with gRPC -- 5. Secure your services -- 6. Observe your systems -- Part 3: Distribute. 7. Server-to-server service discovery -- 8. Coordinate your services with consensus -- 9. Discover servers and load balance from the client -- Part 4: Deploy. 10. Deploy applications with Kubernetes locally -- 11. Deploy applications with Kubernetes to the cloud. |
| Record Nr. | UNINA-9911008897003321 |
Jeffery Travis
|
||
| [Raleigh, North Carolina] : , : The Pragmatic Programmers, LLC, , [2021] | ||
| Materiale a stampa | ||
| Lo trovi qui: Univ. Federico II | ||
| ||
Effective Concurrency in Go : Develop, Analyze, and Troubleshoot High Performance Concurrent Applications with Ease
| Effective Concurrency in Go : Develop, Analyze, and Troubleshoot High Performance Concurrent Applications with Ease |
| Autore | Serdar Burak |
| Edizione | [1st ed.] |
| Pubbl/distr/stampa | Birmingham : , : Packt Publishing, Limited, , 2023 |
| Descrizione fisica | 1 online resource (212 pages) |
| Disciplina | 005.133 |
| Soggetto topico |
Go (Computer program language)
Computer multitasking |
| ISBN |
9781804615980
1804615986 |
| Formato | Materiale a stampa |
| Livello bibliografico | Monografia |
| Lingua di pubblicazione | eng |
| Nota di contenuto |
Cover -- Title Page -- Copyright and Credit -- Dedicated -- Contributors -- Table of Contents -- Preface -- Chapter 1: Concurrency - A High-Level Overview -- Technical Requirements -- Concurrency and parallelism -- Shared memory versus message passing -- Atomicity, race, deadlocks, and starvation -- Summary -- Question -- Further reading -- Chapter 2: Go Concurrency Primitives -- Technical Requirements -- Goroutines -- Channels -- Mutex -- Wait groups -- Condition variables -- Summary -- Questions -- Chapter 3: The Go Memory Model -- Why a memory model is necessary -- The happened-before relationship between memory operations -- Synchronization characteristics of Go concurrency primitives -- Package initialization -- Goroutines -- Channels -- Mutexes -- Atomic memory operations -- Map, Once, and WaitGroup -- Summary -- Further reading -- Chapter 4: Some Well-Known Concurrency Problems -- Technical Requirements -- The producer-consumer problem -- The dining philosophers problem -- Rate limiting -- Summary -- Chapter 5: Worker Pools and Pipelines -- Technical Requirements -- Worker pools -- Pipelines, fan-out, and fan-in -- Asynchronous pipeline -- Fan-out/fan-in -- Fan-in with ordering -- Summary -- Questions -- Chapter 6: Error Handling -- Error handling -- Pipelines -- Servers -- Panics -- Summary -- Chapter 7: Timers and Tickers -- Technical Requirements -- Timers - running something later -- Tickers - running something periodically -- Heartbeats -- Summary -- Chapter 8: Handling Requests Concurrently -- Technical Requirements -- The context, cancelations, and timeouts -- Backend services -- Distributing work and collecting results -- Semaphores - limiting concurrency -- Streaming data -- Dealing with multiple streams -- Summary -- Chapter 9: Atomic Memory Operations -- Technical Requirements -- Memory guarantees -- Compare and swap.
Practical uses of atomics -- Counters -- Heartbeat and progress meter -- Cancellations -- Detecting change -- Summary -- Chapter 10: Troubleshooting Concurrency Issues -- Technical Requirements -- Reading stack traces -- Detecting failures and healing -- Debugging anomalies -- Summary -- Further reading -- Index -- Other Books You May Enjoy. |
| Record Nr. | UNINA-9911008982603321 |
|
Serdar Burak
|
||
| Birmingham : , : Packt Publishing, Limited, , 2023 | ||
| Materiale a stampa | ||
| Lo trovi qui: Univ. Federico II | ||
| ||
Generic data structures and algorithms in Go : an applied approach using concurrency, genericity and heuristics / / Richard Wiener
| Generic data structures and algorithms in Go : an applied approach using concurrency, genericity and heuristics / / Richard Wiener |
| Autore | Wiener Richard <1941-> |
| Pubbl/distr/stampa | Berkeley, California : , : Apress, , [2022] |
| Descrizione fisica | 1 online resource (590 pages) |
| Disciplina | 005.133 |
| Soggetto topico |
Go (Computer program language)
Data structures (Computer science) Algorithms |
| ISBN | 1-4842-8191-8 |
| Formato | Materiale a stampa |
| Livello bibliografico | Monografia |
| Lingua di pubblicazione | eng |
| Nota di contenuto | 1. A Tour Of Generics and Concurrency In Go 2. Algorithm Efficiency Sorting and Searching 3. Abstract Data Types: OOP Without Classes in Go 4. ADT In Action: Game Of Life 5. Stacks 6. Queues and Lists 7. Hash Tables 8. Binary Trees 9. Binary Search Tree 10. AVL Trees 11. Heap Trees 12. Red Black Trees 13. Expression Trees 14. Ecological Simulation With Concurrency 15. Dynamic Programming 16. Graph Structures 17. Travelling Salesperson Problem 18. Branch and Bound Solution to TSP 19. Simulated Annealing Heuristic Solution to TSP 20. Genetic Algorithm for TSP 21. Neural Networks and Machine Learning |
| Record Nr. | UNINA-9910584476403321 |
|
Wiener Richard <1941->
|
||
| Berkeley, California : , : Apress, , [2022] | ||
| Materiale a stampa | ||
| Lo trovi qui: Univ. Federico II | ||
| ||
Go for Java programmers : learn the Google Go programming language / / Barry Feigenbaum
| Go for Java programmers : learn the Google Go programming language / / Barry Feigenbaum |
| Autore | Feigenbaum Barry A. |
| Pubbl/distr/stampa | Berkeley, California : , : Apress Media LLC, , [2022] |
| Descrizione fisica | 1 online resource (596 pages) |
| Disciplina | 005.133 |
| Soggetto topico |
Go (Computer program language)
Java (Computer program language) |
| ISBN | 1-4842-7199-8 |
| Formato | Materiale a stampa |
| Livello bibliografico | Monografia |
| Lingua di pubblicazione | eng |
| Nota di contenuto |
Intro -- Table of Contents -- About the Author -- About the Technical Reviewer -- Acknowledgments -- Introduction -- Assessments -- Part I: First Look at Go -- Chapter 1: A Brief Look at Go vs. Java -- Go Is a Compiled (vs. Interpreted, As Java Is) Language -- Go and Java Share Similar Program Structure -- Go and Java Have Some Code Style Differences That Influence How Code Is Structured -- Both Go and Java Are Procedural Languages -- Java Is an Object-Oriented (OO) Language, While Go Is Not Fully OO -- Java Is a Highly Functional Language, Go Is Less So -- Java Is a Highly Declarative Language, Go Is Less So -- Many Java Features Are Annotation Driven -- Go Does Not Support Exceptions -- Both Java and Go Use Managed Memory (Garbage Collectors) -- Go and Java Both Support Concurrency but in Different Ways -- Go's Runtime Is Simpler Than the JRE -- The Go Program Build Process Is Different -- Go and Java Have Similar Release Cycles -- Chapter 2: What Java Has That Go Does Not -- Multiple Assignments -- Statements and Operators -- Assert Statement -- While and Do Statements -- Throw Statement/Throws Clause -- Strictfp, transient, volatile, synchronized, abstract, static -- Objects and Classes (OOP) and Inner Classes, Lambdas, this, super, Explicit Constructors -- Generic Types and Methods -- Extensive Functional Programming Capabilities -- Boxing of Primitive Values -- Source Annotations -- Multiple Visibilities -- Overloaded/Overridden Functions -- Formal Enums -- Built-in Binary Data Self-Serialization -- Concurrent Collections -- Chapter 3: A Deeper Comparison of Go and Java -- Part II: The Go Language -- Chapter 4: Key Go Aspects -- Simple Go Program Example -- Go Packages -- Go Comments -- Go Build/Run Process -- Go Playground -- Go Integrated Development Environments -- Running Go Programs -- Building Go Programs -- Bytecode vs. Real Code.
Go Command-Line Tools -- Tools Bundled in the Go Command -- Other Tools -- Go Runs Programs Instead of Classes -- Go Memory Management -- Go Identifiers -- Go Scopes -- Go Scopes vs. Go Source Files -- Initializing Go Variables -- Lifetimes of Go Identifiers -- Go Module Summary -- Go Assignments and Expressions -- Text Formatting in Go -- Goroutines -- Issues with Concurrency -- Go Concurrency -- Goroutines by Example -- Chapter 5: Go Basic Features -- Language Keywords -- Operators and Punctuation -- Go Operator Precedence -- Go Built-in Functions -- Chapter 6: Go Types -- Primitive/Built-in Types -- Numbers -- Characters and Strings -- Reference vs. Pointer Types -- Drill Down on Basic Data Types -- Boolean Type -- Integer Types -- Floating-Point Types -- When nil Can Go Wrong -- Programmer-Defined Types -- Arrays -- Slices -- Maps -- Functions -- Methods As Functions -- Any Declared Type Can Have Custom Functions -- Functions As Values -- Structs -- Structure Fields -- Structure Literals -- Nested Structures -- Structure Field Alignment -- Interfaces -- Application of Interfaces -- Composite Interfaces -- Channels -- Variable Declarations -- Constant Declarations -- Type Casting -- Type Testing -- Derived Type Declarations -- Chapter 7: Errors and Panics -- Go Errors -- Go Panics -- Errors and Panics Illustrated -- Chapter 8: Go Statements -- Package and Import Statements -- Assignment Statements -- Declaring Variables -- Declaring Named Constants -- If/Else Statements -- Switch Statement -- While Statement -- Do-While Statement -- For with Index Statement -- For over a Collection Statement -- Forever Statement -- Break and Continue Statements -- Goto Statement -- Return Statement -- Defer Statement -- Go Statement -- Select Statement -- Chapter 9: Applications for Interfaces -- An Interface Is the Key -- On Dependency Injection. On Aspect-Oriented Programming -- Chapter 10: Go Unit Tests and Benchmarks -- Test Cases and Benchmarks in Go -- Test Cases in Java -- Chapter 11: Going into the Future -- Improved Error Handling -- Go Generics -- Capstone Game of Life Example -- Game of Life Go Source -- Capstone Project in Java -- Main.java -- Server.java -- Game.java -- Utility.java -- Formatter.java -- ParameterProvider.java -- AnnimatedGifWriter.java -- Logger.java -- Capstone Project in Go -- Main.go -- Server.go -- Game.go -- Utility.go -- Go Doc Output -- API Outputs -- Game Outputs -- Part III: Go Library Survey -- Chapter 12: Key Package Comparison -- Java Lang Packages -- Java IO Package -- Java Text Package -- Java Time Packages -- Java Util Packages -- Chapter 13: Key Method/Function Comparison -- Chapter 14: Go Package Survey -- File Access with Go -- Compression Services -- Archive Packages -- Compression Packages -- Image -- Input/Output (I/O) -- Bytes Package -- Format Package -- Data Collections -- Sorting -- Context Package -- Cryptography and Hashing and Data Encoding -- Encoding Packages -- Unicode Encoding Packages -- Chapter 15: SQL Database Access -- Chapter 16: Client and Server Support -- MIME Packages -- Network Packages -- The Net Package -- The HTTP Template Package -- The Net.HTTP Package -- URL Package -- Chapter 17: Go Runtime -- Errors Package -- Flag Package -- Log Package -- Math Package -- Operating System Support Packages -- Reflection Package -- Regular Expression Package -- Go Runtime Packages -- String Processing Packages -- Concurrency and Goroutines -- Testing Package -- Time and Date Package -- Appendix A: Installing Go -- Appendix B: Some Go FAQs -- Appendix C: Go Gotchas to Look Out For -- Appendix D: Mark-Sweep Pseudocode -- Appendix E: ASCII vs. UTF-8 -- Index. |
| Record Nr. | UNINA-9910523890303321 |
|
Feigenbaum Barry A.
|
||
| Berkeley, California : , : Apress Media LLC, , [2022] | ||
| Materiale a stampa | ||
| Lo trovi qui: Univ. Federico II | ||
| ||
Go programming blueprints : build real-world, production-ready solutions in Go using cutting-edge technology and techniques / / Mat Ryer
| Go programming blueprints : build real-world, production-ready solutions in Go using cutting-edge technology and techniques / / Mat Ryer |
| Autore | Ryer Mat |
| Edizione | [Second edition.] |
| Pubbl/distr/stampa | Birmingham, England ; ; Mumbai, India : , : Packt Publishing, , 2016 |
| Descrizione fisica | 1 online resource (385 pages) : illustrations |
| Disciplina | 005.133 |
| Soggetto topico |
Go (Computer program language)
Computer programming |
| Formato | Materiale a stampa |
| Livello bibliografico | Monografia |
| Lingua di pubblicazione | eng |
| Nota di contenuto |
Cover -- Credits -- About the Author -- Acknowledgments -- About the Reviewer -- www.PacktPub.com -- Table of Contents -- Preface -- Chapter 1: Chat Application with Web Sockets -- A simple web server -- Separating views from logic using templates -- Doing things once -- Using your own handlers -- Properly building and executing Go programs -- Modeling a chat room and clients on the server -- Modeling the client -- Modeling a room -- Concurrency programming using idiomatic Go -- Turning a room into an HTTP handler -- Using helper functions to remove complexity -- Creating and using rooms -- Building an HTML and JavaScript chat client -- Getting more out of templates -- Tracing code to get a look under the hood -- Writing a package using TDD -- Interfaces -- Unit tests -- Red-green testing -- Implementing the interface -- Unexported types being returned to users -- Using our new trace package -- Making tracing optional -- Clean package APIs -- Summary -- Chapter 2: Adding User Accounts -- Handlers all the way down -- Making a pretty social sign-in page -- Endpoints with dynamic paths -- Getting started with OAuth2 -- Open source OAuth2 packages -- Tell the authorization providers about your app -- Implementing external logging in -- Logging in -- Handling the response from the provider -- Presenting the user data -- Augmenting messages with additional data -- Summary -- Chapter 3: Three Ways to Implement Profile Pictures -- Avatars from the OAuth2 server -- Getting the avatar URL -- Transmitting the avatar URL -- Adding the avatar to the user interface -- Logging out -- Making things prettier -- Implementing Gravatar -- Abstracting the avatar URL process -- The auth service and the avatar's implementation -- Using an implementation -- The Gravatar implementation -- Uploading an avatar picture -- User identification -- An upload form.
Handling the upload -- Serving the images -- The Avatar implementation for local files -- Supporting different file types -- Refactoring and optimizing our code -- Replacing concrete types with interfaces -- Changing interfaces in a test-driven way -- Fixing the existing implementations -- Global variables versus fields -- Implementing our new design -- Tidying up and testing -- Combining all three implementations -- Summary -- Chapter 4: Command-Line Tools to Find Domain Names -- Pipe design for command-line tools -- Five simple programs -- Sprinkle -- Domainify -- Coolify -- Synonyms -- Using environment variables for configuration -- Consuming a web API -- Getting domain suggestions -- Available -- Composing all five programs -- One program to rule them all -- Summary -- Chapter 5: Building Distributed Systems and Working with Flexible Data -- The system design -- The database design -- Installing the environment -- Introducing NSQ -- NSQ driver for Go -- Introducing MongoDB -- MongoDB driver for Go -- Starting the environment -- Reading votes from Twitter -- Authorization with Twitter -- Extracting the connection -- Reading environment variables -- Reading from MongoDB -- Reading from Twitter -- Signal channels -- Publishing to NSQ -- Gracefully starting and stopping programs -- Testing -- Counting votes -- Connecting to the database -- Consuming messages in NSQ -- Keeping the database updated -- Responding to Ctrl + C -- Running our solution -- Summary -- Chapter 6: Exposing Data and Functionality through a RESTful Data Web Service API -- RESTful API design -- Sharing data between handlers -- Context keys -- Wrapping handler functions -- API keys -- Cross-origin resource sharing -- Injecting dependencies -- Responding -- Understanding the request -- Serving our API with one function -- Using handler function wrappers -- Handling endpoints. Using tags to add metadata to structs -- Many operations with a single handler -- Reading polls -- Creating a poll -- Deleting a poll -- CORS support -- Testing our API using curl -- A web client that consumes the API -- Index page showing a list of polls -- Creating a new poll -- Showing the details of a poll -- Running the solution -- Summary -- Chapter 7: Random Recommendations Web Service -- The project overview -- Project design specifics -- Representing data in code -- Public views of Go structs -- Generating random recommendations -- The Google Places API key -- Enumerators in Go -- Test-driven enumerator -- Querying the Google Places API -- Building recommendations -- Handlers that use query parameters -- CORS -- Testing our API -- Web application -- Summary -- Chapter 8: Filesystem Backup -- Solution design -- The project structure -- The backup package -- Considering obvious interfaces first -- Testing interfaces by implementing them -- Has the filesystem changed? -- Checking for changes and initiating a backup -- Hardcoding is OK for a short while -- The user command-line tool -- Persisting small data -- Parsing arguments -- Listing the paths -- String representations for your own types -- Adding paths -- Removing paths -- Using our new tool -- The daemon backup tool -- Duplicated structures -- Caching data -- Infinite loops -- Updating filedb records -- Testing our solution -- Summary -- Chapter 9: Building a Q& -- A Application for Google App Engine -- The Google App Engine SDK for Go -- Creating your application -- App Engine applications are Go packages -- The app.yaml file -- Running simple applications locally -- Deploying simple applications to Google App Engine -- Modules in Google App Engine -- Specifying modules -- Routing to modules with dispatch.yaml -- Google Cloud Datastore -- Denormalizing data -- Entities and data access. Keys in Google Cloud Datastore -- Putting data into Google Cloud Datastore -- Reading data from Google Cloud Datastore -- Google App Engine users -- Embedding denormalized data -- Transactions in Google Cloud Datastore -- Using transactions to maintain counters -- Avoiding early abstraction -- Querying in Google Cloud Datastore -- Votes -- Indexing -- Embedding a different view of entities -- Casting a vote -- Accessing parents via datastore.Key -- Line of sight in code -- Exposing data operations over HTTP -- Optional features with type assertions -- Response helpers -- Parsing path parameters -- Exposing functionality via an HTTP API -- HTTP routing in Go -- Context in Google App Engine -- Decoding key strings -- Using query parameters -- Anonymous structs for request data -- Writing self-similar code -- Validation methods that return an error -- Mapping the router handlers -- Running apps with multiple modules -- Testing locally -- Using the admin console -- Automatically generated indexes -- Deploying apps with multiple modules -- Summary -- Chapter 10: Micro-services in Go with the Go kit Framework -- Introducing gRPC -- Protocol buffers -- Installing protocol buffers -- Protocol buffers language -- Generating Go code -- Building the service -- Starting with tests -- Constructors in Go -- Hashing and validating passwords with bcrypt -- Modeling method calls with requests and responses -- Endpoints in Go kit -- Making endpoints for service methods -- Different levels of error -- Wrapping endpoints into a Service implementation -- An HTTP server in Go kit -- A gRPC server in Go kit -- Translating from protocol buffer types to our types -- Creating a server command -- Using Go kit endpoints -- Running the HTTP server -- Running the gRPC server -- Preventing a main function from terminating immediately -- Consuming the service over HTTP. Building a gRPC client -- A command-line tool to consume the service -- Parsing arguments in CLIs -- Maintaining good line of sight by extracting case bodies -- Installing tools from the Go source code -- Rate limiting with service middleware -- Middleware in Go kit -- Manually testing the rate limiter -- Graceful rate limiting -- Summary -- Chapter 11: Deploying Go Applications Using Docker -- Using Docker locally -- Installing Docker tools -- Dockerfile -- Building Go binaries for different architectures -- Building a Docker image -- Running a Docker image locally -- Inspecting Docker processes -- Stopping a Docker instance -- Deploying Docker images -- Deploying to Docker Hub -- Deploying to Digital Ocean -- Creating a droplet -- Accessing the droplet's console -- Pulling Docker images -- Running Docker images in the cloud -- Accessing Docker images in the cloud -- Summary -- Appendix: Good Practices for a Stable Go Environment -- Installing Go -- Configuring Go -- Getting GOPATH right -- Go tools -- Cleaning up, building, and running tests on save -- Integrated developer environments -- Sublime Text 3 -- Visual Studio Code -- Summary -- Index. |
| Record Nr. | UNINA-9910148748303321 |
|
Ryer Mat
|
||
| Birmingham, England ; ; Mumbai, India : , : Packt Publishing, , 2016 | ||
| Materiale a stampa | ||
| Lo trovi qui: Univ. Federico II | ||
| ||
Go programming in easy steps : discover Google's go language (golang) / / Mike McGrath
| Go programming in easy steps : discover Google's go language (golang) / / Mike McGrath |
| Autore | McGrath Mike <1956-> |
| Pubbl/distr/stampa | London, England : , : In Easy Steps Limited, , [2021] |
| Descrizione fisica | 1 online resource (267 pages) |
| Disciplina | 005.133 |
| Collana | In Easy Steps |
| Soggetto topico |
Go (Computer program language)
Computer programming |
| Formato | Materiale a stampa |
| Livello bibliografico | Monografia |
| Lingua di pubblicazione | eng |
| Record Nr. | UNINA-9910795658003321 |
|
McGrath Mike <1956->
|
||
| London, England : , : In Easy Steps Limited, , [2021] | ||
| Materiale a stampa | ||
| Lo trovi qui: Univ. Federico II | ||
| ||
Go programming in easy steps : discover Google's go language (golang) / / Mike McGrath
| Go programming in easy steps : discover Google's go language (golang) / / Mike McGrath |
| Autore | McGrath Mike <1956-> |
| Pubbl/distr/stampa | London, England : , : In Easy Steps Limited, , [2021] |
| Descrizione fisica | 1 online resource (267 pages) |
| Disciplina | 005.133 |
| Collana | In Easy Steps |
| Soggetto topico |
Go (Computer program language)
Computer programming |
| Formato | Materiale a stampa |
| Livello bibliografico | Monografia |
| Lingua di pubblicazione | eng |
| Record Nr. | UNINA-9910813500003321 |
|
McGrath Mike <1956->
|
||
| London, England : , : In Easy Steps Limited, , [2021] | ||
| Materiale a stampa | ||
| Lo trovi qui: Univ. Federico II | ||
| ||
The go workshop : a new, interactive approach to learning go / / Delio D'Anna [and five others]
| The go workshop : a new, interactive approach to learning go / / Delio D'Anna [and five others] |
| Autore | D'Anna Delio |
| Edizione | [1st edition] |
| Pubbl/distr/stampa | Birmingham, England ; ; Mumbai : , : Packt, , [2019] |
| Descrizione fisica | 1 online resource (821 pages) |
| Disciplina | 005.133 |
| Soggetto topico | Go (Computer program language) |
| ISBN | 1-83864-015-0 |
| Formato | Materiale a stampa |
| Livello bibliografico | Monografia |
| Lingua di pubblicazione | eng |
| Record Nr. | UNINA-9910795256603321 |
|
D'Anna Delio
|
||
| Birmingham, England ; ; Mumbai : , : Packt, , [2019] | ||
| Materiale a stampa | ||
| Lo trovi qui: Univ. Federico II | ||
| ||
The go workshop : a new, interactive approach to learning go / / Delio D'Anna [and five others]
| The go workshop : a new, interactive approach to learning go / / Delio D'Anna [and five others] |
| Autore | D'Anna Delio |
| Edizione | [1st edition] |
| Pubbl/distr/stampa | Birmingham, England ; ; Mumbai : , : Packt, , [2019] |
| Descrizione fisica | 1 online resource (821 pages) |
| Disciplina | 005.133 |
| Soggetto topico | Go (Computer program language) |
| ISBN | 1-83864-015-0 |
| Formato | Materiale a stampa |
| Livello bibliografico | Monografia |
| Lingua di pubblicazione | eng |
| Record Nr. | UNINA-9910811328203321 |
|
D'Anna Delio
|
||
| Birmingham, England ; ; Mumbai : , : Packt, , [2019] | ||
| Materiale a stampa | ||
| Lo trovi qui: Univ. Federico II | ||
| ||
Learning Go programming : an insightful guide to learning the Go programming language / / Vladimir Vivien
| Learning Go programming : an insightful guide to learning the Go programming language / / Vladimir Vivien |
| Autore | Vivien Vladimir |
| Edizione | [1st edition] |
| Pubbl/distr/stampa | Birmingham, England ; ; Mumbai, India : , : Packt Publishing, , 2016 |
| Descrizione fisica | 1 online resource (340 pages) : illustrations |
| Disciplina | 005.133 |
| Soggetto topico |
Go (Computer program language)
Computer programming |
| ISBN | 1-78439-233-2 |
| Formato | Materiale a stampa |
| Livello bibliografico | Monografia |
| Lingua di pubblicazione | eng |
| Nota di contenuto |
Cover -- Copyright -- Credits -- About the Author -- About the Reviewers -- www.PacktPub.com -- Table of Contents -- Preface -- Chapter 1: A First Step in Go -- The Go programming language -- Playing with Go -- No IDE required -- Installing Go -- Source code examples -- Your first Go program -- Go in a nutshell -- Functions -- Packages -- The workspace -- Strongly typed -- Composite types -- The named type -- Methods and objects -- Interfaces -- Concurrency and channels -- Memory management and safety -- Fast compilation -- Testing and code coverage -- Documentation -- An extensive library -- The Go Toolchain -- Summary -- Chapter 2: Go Language Essentials -- The Go source file -- Optional semicolon -- Multiple lines -- Go identifiers -- The blank identifier -- Muting package imports -- Muting unwanted function results -- Built-in identifiers -- Types -- Values -- Functions -- Go variables -- Variable declaration -- The zero-value -- Initialized declaration -- Omitting variable types -- Short variable declaration -- Restrictions for short variable declaration -- Variable scope and visibility -- Variable declaration block -- Go constants -- Constant literals -- Typed constants -- Untyped constants -- Assigning untyped constants -- Constant declaration block -- Constant enumeration -- Overriding the default enumeration type -- Using iota in expressions -- Skipping enumerated values -- Go operators -- Arithmetic operators -- The increment and decrement operators -- Go assignment operators -- Bitwise operators -- Logical Operators -- Comparison operators -- Operator precedence -- Summary -- Chapter 3: Go Control Flow -- The if statement -- The if statement initialization -- Switch statements -- Using expression switches -- The fallthrough cases -- Expressionless switches -- Switch initializer -- Type switches -- The for statements -- For condition.
Infinite loop -- The traditional for statement -- The for range -- The break, continue, and goto statements -- The label identifier -- The break statement -- The continue statement -- The goto statement -- Summary -- Chapter 4: Data Types -- Go types -- Numeric types -- Unsigned integer types -- Signed integer types -- Floating point types -- Complex number types -- Numeric literals -- Boolean type -- Rune and string types -- The rune -- The string -- Interpreted and raw string literals -- Pointers -- The pointer type -- The address operator -- The new() function -- Pointer indirection - accessing referenced values -- Type declaration -- Type conversion -- Summary -- Chapter 5: Functions in Go -- Go functions -- Function declaration -- The function type -- Variadic parameters -- Function result parameters -- Named result parameters -- Passing parameter values -- Achieving pass-by-reference -- Anonymous Functions and Closures -- Invoking anonymous function literals -- Closures -- Higher-order functions -- Error signaling and handling -- Signaling errors -- Error handling -- The error type -- Deferring function calls -- Using defer -- Function panic and recovery -- Function panic -- Function panic recovery -- Summary -- Chapter 6: Go Packages and Programs -- The Go package -- Understanding the Go package -- The workspace -- Creating a workspace -- The import path -- Creating packages -- Declaring the package -- Multi-File packages -- Naming packages -- Use globally unique namespaces -- Add context to path -- Use short names -- Building packages -- Installing a package -- Package visibility -- Package member visibility -- Importing package -- Specifying package identifiers -- The dot identifier -- The blank identifier -- Package initialization -- Creating programs -- Accessing program arguments -- Building and installing programs -- Remote packages. Summary -- Chapter 7: Composite Types -- The array type -- Array initialization -- Declaring named array types -- Using arrays -- Array length and capacity -- Array traversal -- Array as parameters -- The slice type -- Slice initialization -- Slice representation -- Slicing -- Slicing a slice -- Slicing an array -- Slice expressions with capacity -- Making a slice -- Using slices -- Slices as parameters -- Length and capacity -- Appending to slices -- Copying slices -- Strings as slices -- The map type -- Map initialization -- Making Maps -- Using maps -- Map traversal -- Map functions -- Maps as parameters -- The struct type -- Accessing struct fields -- Struct initialization -- Declaring named struct types -- The anonymous field -- Promoted fields -- Structs as parameters -- Field tags -- Summary -- Chapter 8: Methods, Interfaces, and Objects -- Go methods -- Value and pointer receivers -- Objects in Go -- The struct as object -- Object composition -- Field and method promotion -- The constructor function -- The interface type -- Implementing an interface -- Subtyping with Go interfaces -- Implementing multiple interfaces -- Interface embedding -- The empty interface type -- Type assertion -- Summary -- Chapter 9: Concurrency -- Goroutines -- The go statement -- Goroutine scheduling -- Channels -- The Channel type -- The send and receive operations -- Unbuffered channel -- Buffered channel -- Unidirectional channels -- Channel length and capacity -- Closing a channel -- Writing concurrent programs -- Synchronization -- Streaming data -- Using for…range to receive data -- Generator functions -- Selecting from multiple channels -- Channel timeout -- The sync package -- Synchronizing with mutex locks -- Synchronizing access to composite values -- Concurrency barriers with sync.WaitGroup -- Detecting race conditions -- Parallelism in Go -- Summary. Chapter 10: Data IO in Go -- IO with readers and writers -- The io.Reader interface -- Chaining readers -- The io.Writer interface -- Working with the io package -- Working with files -- Creating and opening files -- Function os.OpenFile -- Files writing and reading -- Standard input, output, and error -- Formatted IO with fmt -- Printing to io.Writer interfaces -- Printing to standard output -- Reading from io.Reader -- Reading from standard input -- Buffered IO -- [Buffered writers and readers] -- Buffered writers and readers -- Scanning the buffer -- In-memory IO -- Encoding and decoding data -- Binary encoding with gob -- Encoding data as JSON -- Controlling JSON mapping with struct tags -- Custom encoding and decoding -- Summary -- Chapter 11: Writing Networked Services -- The net package -- Addressing -- The net.Conn Type -- Dialing a connection -- Listening for incoming connections -- Accepting client connections -- A TCP API server -- Connecting to the TCP server with telnet -- Connecting to the TCP server with Go -- The HTTP package -- The http.Client type -- Configuring the client -- Handling client requests and responses -- A simple HTTP server -- The default server -- Routing requests with http.ServeMux -- The default ServeMux -- A JSON API server -- Testing the API server with cURL -- An API server client in Go -- A JavaScript API server client -- Summary -- Chapter 12: Code Testing -- The Go test tool -- Test file names -- Test organization -- Writing Go tests -- The test functions -- Running the tests -- Filtering executed tests -- Test logging -- Reporting failure -- Skipping tests -- Table-driven tests -- HTTP testing -- Testing HTTP server code -- Testing HTTP client code -- Test coverage -- The cover tool -- Code benchmark -- Running the benchmark -- Skipping test functions -- The benchmark report -- Adjusting N. Comparative benchmarks -- Summary -- Index. |
| Record Nr. | UNINA-9910148734903321 |
|
Vivien Vladimir
|
||
| Birmingham, England ; ; Mumbai, India : , : Packt Publishing, , 2016 | ||
| Materiale a stampa | ||
| Lo trovi qui: Univ. Federico II | ||
| ||
