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.
Build a Weather Station with Elixir and Nerves / / Alexander Koutmos, Bruce Tate, and Frank Hunleth
| Build a Weather Station with Elixir and Nerves / / Alexander Koutmos, Bruce Tate, and Frank Hunleth |
| Autore | Koutmos Alexander |
| Edizione | [First edition.] |
| Pubbl/distr/stampa | Raleigh, North Carolina : , : The Pragmatic Programmers, LLC, , [2022] |
| Descrizione fisica | 1 online resource (90 pages) |
| Disciplina | 551.6 |
| Soggetto topico |
Meteorological stations
Elixir (Computer program language) |
| ISBN |
9781680509489
1680509489 9781680509472 1680509470 |
| Formato | Materiale a stampa  |
| Livello bibliografico | Monografia |
| Lingua di pubblicazione | eng |
| Nota di contenuto | Cover -- Table of Contents -- Acknowledgments -- Alexander Koutmos -- Bruce Tate -- Frank Hunleth -- Introduction -- What You Will Build -- How to Read This Book -- Running the Code Exercises -- Online Resources -- 1. Elixir and Nerves for IoT -- Why Nerves for IoT? -- Time-Series Sensor Hub -- Laying Out the Architecture -- Organizing Your Nerves Project -- Assembling the Weather Station -- Your Turn -- 2. Wirelessly Reading Sensor Data -- Creating a Network-Enabled Sensor Hub Project -- Getting on to the Network -- Capturing Sensor Data -- Your Turn -- 3. Aggregating Sensor Data -- Wrapping Sensors in GenServers -- Build the Firmware Project -- Managing the Life Cycle -- Your Turn -- 4. Publishing Sensor Data -- Setting up Docker Compose -- Creating the Phoenix Application -- Publishing Metrics -- Your Turn -- 5. Pulling It All Together -- Adding Grafana to Docker Compose -- Exploring the Data with SQL -- Creating a Weather Dashboard -- Your Turn. |
| Record Nr. | UNINA-9911009192503321 |
Koutmos Alexander
|
||
| Raleigh, North Carolina : , : The Pragmatic Programmers, LLC, , [2022] | ||
| Materiale a stampa | ||
| Lo trovi qui: Univ. Federico II | ||
| ||
Concurrent data processing in Elixir : fast, resilient applications with OTP, GenStage, Flow, and Broadway / / Svilen Gospodinov
| Concurrent data processing in Elixir : fast, resilient applications with OTP, GenStage, Flow, and Broadway / / Svilen Gospodinov |
| Autore | Gospodinov Svilen |
| Edizione | [First edition.] |
| Pubbl/distr/stampa | [Raleigh, North Carolina] : , : The Pragmatic Programmers, LLC, , [2021] |
| Descrizione fisica | 1 online resource (171 pages) |
| Disciplina | 005.133 |
| Soggetto topico |
Elixir (Computer program language)
Application software - Development |
| ISBN |
9781680508970
1680508970 9781680508963 1680508962 |
| Formato | Materiale a stampa |
| Livello bibliografico | Monografia |
| Lingua di pubblicazione | eng |
| Nota di contenuto | Cover -- Table of Contents -- Foreword -- Acknowledgments -- Introduction -- Who Should Read This Book? -- About This Book -- About the Code -- Online Resources -- 1. Easy Concurrency with the Task Module -- Introducing the Task Module -- Creating Our Playground -- Starting Tasks and Retrieving Results -- Managing Series of Tasks -- Linking Processes -- Meeting the Supervisor -- Understanding Let It Crash -- Wrapping Up -- 2. Long-Running Processes Using GenServer -- Starting with a Basic GenServer -- GenServer Callbacks In Depth -- Building a Job-Processing System -- Introducing DynamicSupervisor -- Implementing a Supervisor -- Naming Processes Using the Registry -- Inspecting Supervisors at Runtime -- Wrapping Up -- 3. Data-Processing Pipelines with GenStage -- Understanding Back-Pressure -- Introducing GenStage -- Building Your Data-Processing Pipeline -- Adding Concurrency with ConsumerSupervisor -- Creating Multi-Stage Data Pipelines -- Choosing the Right Dispatcher -- Wrapping Up -- 4. Processing Collections with Flow -- Analyzing Airports Data -- Creating Flows and Reading Files -- Performing Reduce Concurrently with Partitions -- Using Windows and Triggers -- Adding Flow to a GenStage Pipeline -- Wrapping Up -- 5. Data-Ingestion Pipelines with Broadway -- Processing Ticketing Events -- Broadway Callbacks In Depth -- Batching Messages -- Using GenStage Producers -- Wrapping Up -- Bibliography -- Index -- - SYMBOLS - -- - A - -- - B - -- - C - -- - D - -- - E - -- - F - -- - G - -- - H - -- - I - -- - J - -- - K - -- - L - -- - M - -- - N - -- - O - -- - P - -- - R - -- - S - -- - T - -- - U - -- - W -. |
| Record Nr. | UNINA-9911009289703321 |
|
Gospodinov Svilen
|
||
| [Raleigh, North Carolina] : , : The Pragmatic Programmers, LLC, , [2021] | ||
| Materiale a stampa | ||
| Lo trovi qui: Univ. Federico II | ||
| ||
Exploring graphs with Elixir : connect data with native graph libraries and graph databases / / Tony Hammond
| Exploring graphs with Elixir : connect data with native graph libraries and graph databases / / Tony Hammond |
| Autore | Hammond Tony |
| Edizione | [First edition.] |
| Pubbl/distr/stampa | [Raleigh, North Carolina] : , : The Pragmatic Programmers, LLC, , [2022] |
| Descrizione fisica | 1 online resource (285 pages) |
| Disciplina | 511.5 |
| Soggetto topico |
Graph theory - Data processing
Elixir (Computer program language) |
| ISBN |
9798888650066
9798888650073 |
| Formato | Materiale a stampa |
| Livello bibliografico | Monografia |
| Lingua di pubblicazione | eng |
| Nota di contenuto |
Cover -- Table of Contents -- Acknowledgments -- Introduction -- Who This Book Is For -- How to Read This Book -- About the Code -- About the Software -- Online Resources -- Part I-Graphs Everywhere -- 1. Engaging with Graphs -- First Contact -- Coding a Hello World Graph -- Modeling a Book Graph -- Our Plan of Action -- Wrapping Up -- 2. Getting Started -- General Project Outline -- Creating the Umbrella and Child Projects -- Packaging Graphs and Queries -- Building a Graph Store -- Defining a Graph Service API -- Wrapping Up -- Part II-Getting to Grips with Graphs -- 3. Managing Graphs Natively with Elixir -- Creating the NativeGraph Project -- Basic Workout -- Storing Graphs in the Graph Store -- Visualizing Graphs -- Wrapping Up -- 4. Exploring Graph Structures -- A Worked Example -- Modeling the Book Graph -- Generating Graphs -- Wrapping Up -- 5. Navigating Graphs with Neo4j -- Property Graph Model -- Creating the PropertyGraph Project -- Querying with Cypher and APOC -- Trying Out the Bolt Driver -- Setting Up a Graph Service -- Wrapping Up -- 6. Querying Neo4j with Cypher -- Getting Started with Cypher -- Modeling the Book Graph -- Recalling the ARPANET -- Passing Parameters to Queries -- Schemas and Types in Cypher -- Wrapping Up -- 7. Graphing Globally with RDF -- What's Different About RDF? -- RDF Model -- Creating the RDFGraph Project -- Modeling the Book Graph -- Building an RDF Graph -- Setting Up a Graph Service -- Wrapping Up -- 8. Querying RDF with SPARQL -- Getting Started with SPARQL -- Querying the Local RDF Service -- Case #1: Tokyo Metro -- Querying a Remote RDF Service -- Case #2: Graph Walk (Querying) -- Browsing Linked Data -- Case #3: Graph Walk (Browsing) -- Wrapping Up -- 9. Traversing Graphs with Gremlin -- Using Gremlin -- Creating the TinkerGraph Project -- Querying with Gremlin -- Setting Up a Graph Service.
Creating the Book Graph -- Wrapping Up -- 10. Delivering Data with Dgraph -- GraphQL and DQL -- Dgraph Model -- Creating the DGraph Project -- Setting Up a Graph Service -- Modeling the Book Graph -- Reaching Back to the ARPANET -- Wrapping Up -- Part III-Graph to Graph -- 11. Transforming Graph Models -- Serializing Graphs -- Importing RDF with n10s-A Neo4j Plugin -- A Graph-to-Graph Example -- Stage 1: Getting RDF into an LPG Store -- Stage 2: Getting RDF out of an LPG Store -- Federated Querying -- Wrapping Up -- 12. Processing the Graph -- Creating the GraphCompute Project -- Adding a Supervision Tree (or Two) -- Building a Dynamic Process Graph -- Restoring the State for a Node -- Recovering the Graph -- Simulating a Network -- Wrapping Up -- A1. Project Setups -- A2. Database Setups -- Installing Neo4j -- Installing GraphDB -- Installing Gremlin Server -- Installing Dgraph -- Starting the Databases -- A3. Graph Anatomy -- Structural Elements -- Semantic Elements -- Bibliography -- Index -- - SYMBOLS - -- - A - -- - B - -- - C - -- - D - -- - E - -- - F - -- - G - -- - H - -- - I - -- - J - -- - K - -- - L - -- - M - -- - N - -- - O - -- - P - -- - Q - -- - R - -- - S - -- - T - -- - U - -- - V - -- - W - -- - Z -. |
| Record Nr. | UNINA-9911008446703321 |
|
Hammond Tony
|
||
| [Raleigh, North Carolina] : , : The Pragmatic Programmers, LLC, , [2022] | ||
| Materiale a stampa | ||
| Lo trovi qui: Univ. Federico II | ||
| ||
From Ruby to Elixir : unleash the full potential of functional programming / / Stephen Bussey
| From Ruby to Elixir : unleash the full potential of functional programming / / Stephen Bussey |
| Autore | Bussey Stephen |
| Edizione | [1st ed.] |
| Pubbl/distr/stampa | [Place of publication unknown] : , : The Pragmatic Programmers, LLC, , [2024] |
| Descrizione fisica | 1 online resource (213 pages) |
| Disciplina | 005.13 |
| Soggetto topico |
Functional programming languages
Elixir (Computer program language) Object-oriented programming languages Ruby (Computer program language) |
| ISBN | 9798888650745 |
| Formato | Materiale a stampa |
| Livello bibliografico | Monografia |
| Lingua di pubblicazione | eng |
| Nota di contenuto |
Cover -- Table of Contents -- Acknowledgments -- Introduction -- Who Should Read This Book? -- About This Book -- About the Code -- Online Resources -- Part I-Fundamentals of Elixir -- 1. Why Elixir? Why Now? -- The Joy of Ruby -- The Case for Elixir -- Erlang, OTP, Elixir, and Friends -- Install Elixir on Your Computer -- Write Your First Elixir Code -- Wrapping Up -- 2. New Language, New Syntax -- The Big Picture -- Data Types -- Operators -- Module and Function Basics -- Fun with Functions -- Capturing Functions -- Advanced Module Keywords -- Compile Time vs. Runtime -- Wrapping Up -- 3. Working with Data -- Lists-Not Arrays -- Maps-Your Data Layer Foundation -- Implementing Data Structures -- Enumerating Data Structures -- Wrapping Up -- 4. Pattern Matching Your Way to Success -- Pattern Matching Basics -- Use Patterns for Control Flow -- Level Up Your Functions -- Wrapping Up -- 5. GenServers: Build Cities, Not Skyscrapers -- Parallelism vs. Concurrency -- Explore Elixir Processes -- Go Parallel with GenServers -- Be Parallel, Be Cautious -- Build Cities, Not Skyscrapers -- Wrapping Up -- Part II-Tools of the Trade -- 6. Persisting Data with Ecto -- What Will We Build? -- The Foundations of Ecto -- Write an Ecto Schema -- Use Migrations to Create Database Tables -- Use Changesets to Persist Data -- Query Data with Ecto.Query -- Put Everything in a Context -- Wrapping Up -- 7. Serving Requests with Phoenix -- Explore the Foundations of Phoenix -- Route Requests Through Phoenix -- Serve Requests with Phoenix Controllers -- Manage Static Assets -- Use Components to Keep Your User Interface Clean -- Phoenix Is More Than Controllers -- Wrapping Up -- 8. Outbound HTTP Requests with Req -- Decide on Which HTTP Client to Use -- Prep Your Project for Req -- Use Req to Make Requests -- See Your App in Action -- Wrapping Up.
9. Asynchronous Jobs with Oban -- Understand Async Job Systems -- Explore Asynchronous Jobs in Elixir -- Implement an Oban Worker -- More About Oban -- Wrapping Up -- 10. Testing Elixir -- Create Your First Test -- Test an Ecto Query -- Test External API Requests -- Test Phoenix Requests -- Test Oban Jobs -- Wrapping Up -- 11. The Future of Elixir -- Deployment and Observability -- Real-Time Apps with LiveView -- GraphQL with Absinthe -- Machine Learning with Nx and Bumblebee -- Type Systems -- Wrapping Up -- The End of Our Journey -- Bibliography -- Index -- - SYMBOLS - -- - A - -- - B - -- - C - -- - D - -- - E - -- - F - -- - G - -- - H - -- - I - -- - K - -- - L - -- - M - -- - N - -- - O - -- - P - -- - Q - -- - R - -- - S - -- - T - -- - U - -- - V - -- - W -. |
| Record Nr. | UNINA-9911009256303321 |
|
Bussey Stephen
|
||
| [Place of publication unknown] : , : The Pragmatic Programmers, LLC, , [2024] | ||
| Materiale a stampa | ||
| Lo trovi qui: Univ. Federico II | ||
| ||
Machine learning in Elixir : learning to learn with Nx and Axon / / Sean Moriarity
| Machine learning in Elixir : learning to learn with Nx and Axon / / Sean Moriarity |
| Autore | Moriarity Sean |
| Edizione | [First edition.] |
| Pubbl/distr/stampa | [Raleigh, North Carolina] : , : The Pragmatic Programmers, LLC, , [2024] |
| Descrizione fisica | 1 online resource (359 pages) |
| Disciplina | 006.31 |
| Soggetto topico |
Machine learning
Elixir (Computer program language) |
| ISBN |
9798888651261
9798888651278 |
| Formato | Materiale a stampa |
| Livello bibliografico | Monografia |
| Lingua di pubblicazione | eng |
| Nota di contenuto |
Cover -- Table of Contents -- Disclaimer -- Acknowledgments -- Preface -- Why Elixir for Machine Learning? -- Who This Book Is For -- What's in This Book -- How to Use This Book -- Part I-Foundations of Machine Learning -- 1. Make Machines That Learn -- Classifying Flowers -- Learning with Elixir -- Wrapping Up -- 2. Get Comfortable with Nx -- Thinking in Tensors -- Using Nx Operations -- Representing the World -- Going from def to defn -- Wrapping Up -- 3. Harness the Power of Math -- Understanding Machine Learning Math -- Speaking the Language of Data -- Thinking Probabilistically -- Tracking Change -- Wrapping Up -- 4. Optimize Everything -- Learning with Optimization -- Regularizing to Generalize -- Descending Gradients -- Peering into the Black Box -- Wrapping Up -- 5. Traditional Machine Learning -- Learning Linearly -- Learning from Your Surroundings -- Using Clustering -- Making Decisions -- Wrapping Up -- Part II-Deep Learning -- 6. Go Deep with Axon -- Understanding the Need for Deep Learning -- Breaking Down a Neural Network -- Creating Neural Networks with Axon -- Wrapping Up -- 7. Learn to See -- Identifying Cats and Dogs -- Introducing Convolutional Neural Networks -- Improving the Training Process -- Going Beyond Image Classification -- Wrapping Up -- 8. Stop Reinventing the Wheel -- Identifying Cats and Dogs Again -- Fine-Tuning Your Model -- Understanding Transfer Learning -- Taking Advantage of the Machine Learning Ecosystem -- Wrapping Up -- 9. Understand Text -- Classifying Movie Reviews -- Introducing Recurrent Neural Networks -- Understanding Recurrent Neural Networks -- Wrapping Up -- 10. Forecast the Future -- Predicting Stock Prices -- Using CNNs for Single-Step Prediction -- Using RNNs for Time-Series Prediction -- Tempering Expectations -- Wrapping Up -- 11. Model Everything with Transformers -- Paying Attention.
Going from RNNs to Transformers -- Using Transformers with Bumblebee -- Wrapping Up -- 12. Learn Without Supervision -- Compressing Data with Autoencoders -- Learning a Structured Latent -- Generating with GANs -- Learning Without Supervision in Practice -- Wrapping Up -- Part III-Machine Learning in Practice -- 13. Put Machine Learning into Practice -- Deciding to Use Machine Learning -- Setting Up the Application -- Integrating Nx with Phoenix -- Seeding Your Databases -- Building the Search LiveView -- Wrapping Up -- 14. That's a Wrap -- Learning from Experience -- Diffusing Innovation -- Talking to Large Language Models -- Compressing Knowledge -- Moving Forward -- Bibliography -- Index -- - DIGITS - -- - A - -- - B - -- - C - -- - D - -- - E - -- - F - -- - G - -- - H - -- - I - -- - J - -- - K - -- - L - -- - M - -- - N - -- - O - -- - P - -- - Q - -- - R - -- - S - -- - T - -- - U - -- - V - -- - W - -- - X - -- - Y - -- - Z -. |
| Record Nr. | UNINA-9911046653703321 |
|
Moriarity Sean
|
||
| [Raleigh, North Carolina] : , : The Pragmatic Programmers, LLC, , [2024] | ||
| Materiale a stampa | ||
| Lo trovi qui: Univ. Federico II | ||
| ||
Phoenix web development : create rich web applications using functional programming techniques with Phoenix and Elixir / / Brandon Richey
| Phoenix web development : create rich web applications using functional programming techniques with Phoenix and Elixir / / Brandon Richey |
| Autore | Richey Brandon J. |
| Edizione | [First edition] |
| Pubbl/distr/stampa | Birmingham : , : Packt, , 2018 |
| Descrizione fisica | 1 online resource (406 pages) |
| Disciplina | 005.276 |
| Soggetto topico |
Web site development
Elixir (Computer program language) Web applications - Programming |
| Formato | Materiale a stampa |
| Livello bibliografico | Monografia |
| Lingua di pubblicazione | eng |
| Record Nr. | UNINA-9910794631503321 |
|
Richey Brandon J.
|
||
| Birmingham : , : Packt, , 2018 | ||
| Materiale a stampa | ||
| Lo trovi qui: Univ. Federico II | ||
| ||
Phoenix web development : create rich web applications using functional programming techniques with Phoenix and Elixir / / Brandon Richey
| Phoenix web development : create rich web applications using functional programming techniques with Phoenix and Elixir / / Brandon Richey |
| Autore | Richey Brandon J. |
| Edizione | [First edition] |
| Pubbl/distr/stampa | Birmingham : , : Packt, , 2018 |
| Descrizione fisica | 1 online resource (406 pages) |
| Disciplina | 005.276 |
| Soggetto topico |
Web site development
Elixir (Computer program language) Web applications - Programming |
| Formato | Materiale a stampa |
| Livello bibliografico | Monografia |
| Lingua di pubblicazione | eng |
| Record Nr. | UNINA-9910807777403321 |
|
Richey Brandon J.
|
||
| Birmingham : , : Packt, , 2018 | ||
| Materiale a stampa | ||
| Lo trovi qui: Univ. Federico II | ||
| ||
Real-Time Phoenix / / Bussey, Stephen
| Real-Time Phoenix / / Bussey, Stephen |
| Autore | Bussey Stephen |
| Edizione | [1st edition] |
| Pubbl/distr/stampa | Pragmatic Bookshelf, , 2020 |
| Descrizione fisica | 1 online resource (328 pages) |
| Disciplina | 005.276 |
| Collana | The Pragmatic programmers |
| Soggetto topico |
Phoenix (Web framework)
Web site development Elixir (Computer program language) Web applications Application software - Development |
| ISBN |
9781680507744
1680507745 |
| Formato | Materiale a stampa |
| Livello bibliografico | Monografia |
| Lingua di pubblicazione | eng |
| Nota di contenuto |
Cover -- Table of Contents -- Acknowledgments -- Introduction -- Who Should Read This Book? -- About This Book -- About the Code -- Online Resources -- 1. Real-Time is Now -- The Case for Real-Time Systems -- The Layers of a Real-Time System -- Types of Scalability -- Achieving Real-Time in Elixir -- Building Real-Time Systems -- Wrapping Up -- Part I-Powering Real-Time Applications with Phoenix -- 2. Connect a Simple WebSocket -- Why WebSockets? -- Connecting our First WebSocket -- WebSocket Protocol -- Long Polling, a Real-Time Alternative -- WebSockets and Phoenix Channels -- Wrapping Up -- 3. First Steps with Phoenix Channels -- What are Phoenix Channels? -- Understanding Channel Structure -- PubSub -- Send and Receive Messages -- Channel Clients -- Wrapping Up -- 4. Restrict Socket and Channel Access -- Why Restrict Access? -- Add Authentication to Sockets -- Add Authorization to Channels -- Use Authentication from JavaScript -- When to Write a New Socket -- Wrapping Up -- 5. Dive Deep into Phoenix Channels -- Design for Unreliable Connections -- Use Channels in a Cluster -- Customize Channel Behavior -- Write Tests -- Wrapping Up -- 6. Avoid Performance Pitfalls -- Measure Everything -- Keep Your Channels Asynchronous -- Build a Scalable Data Pipeline -- Wrapping Up -- Part II-Building a Real-Time Application -- 7. Build a Real-Time Sneaker Store -- From Product Requirements to a Plan -- Set Up the Project -- Render Real-Time HTML with Channels -- Update a Client with Real-Time Data -- Run Multiple Servers -- Wrapping Up -- 8. Break Your Application with Acceptance Tests -- The Power of Acceptance Testing -- Break Your App Like a User -- Break Your App Like a Server -- Automate Acceptance Tests With Hound -- Wrapping Up -- 9. Build a Real-Time Shopping Cart -- Plan Your Shopping Cart -- Scaffold Your Shopping Cart Channel.
Build Your Shopping Cart Channel -- Add Real-Time Out-Of-Stock Alerts -- Acceptance Test the Shopping Cart -- Wrapping Up -- 10. Track Connected Carts with Presence -- Plan Your Admin Dashboard -- On Track with Phoenix Tracker -- Use Tracker in an Application -- Phoenix Tracker Versus Presence -- Scaffold the Admin Dashboard -- Track Shopping Carts in Real-Time -- Assemble the Admin Dashboard -- Load Test the Admin Dashboard -- Wrapping Up -- Part III-Bringing Real-Time Applications to Production -- 11. Deploy Your Application to Production -- The Lay of the Land -- Achieve Scalability with Load Balancing -- Push New Code Safely -- Cluster Your BEAM Nodes Together -- Advanced Phoenix Channel Configuration -- Wrapping Up -- 12. Manage Real-Time Resources -- Getting Comfortable with Elixir's Scheduler -- Manage Your Application's Memory Effectively -- Inspect a Running Application -- Wrapping Up -- Part IV-Exploring Front-End Technologies -- 13. Hands-On with Phoenix LiveView -- Getting Started with LiveView -- Build a LiveView Product Page -- Write Tests for a LiveView -- Wrapping Up -- 14. Single-Page Apps with React -- Manage Channel State in React -- Write Channels as Components -- Hands-On with React -- React Native Channels -- Wrapping Up -- The End of Our Journey -- Bibliography -- Index -- - SYMBOLS - -- - DIGITS - -- - A - -- - B - -- - C - -- - D - -- - E - -- - F - -- - G - -- - H - -- - I - -- - J - -- - K - -- - L - -- - M - -- - N - -- - O - -- - P - -- - Q - -- - R - -- - S - -- - T - -- - U - -- - V - -- - W - -- - Y -. |
| Record Nr. | UNINA-9911008404803321 |
|
Bussey Stephen
|
||
| Pragmatic Bookshelf, , 2020 | ||
| Materiale a stampa | ||
| Lo trovi qui: Univ. Federico II | ||
| ||
Testing Elixir : effective and robust testing for Elixir and its ecosystem / / Andrea Leopardi and Jeffrey Matthias
| Testing Elixir : effective and robust testing for Elixir and its ecosystem / / Andrea Leopardi and Jeffrey Matthias |
| Autore | Leopardi Andrea |
| Edizione | [First edition.] |
| Pubbl/distr/stampa | [Raleigh, North Carolina] : , : The Pragmatic Programmers, LLC, , [2021] |
| Descrizione fisica | 1 online resource (256 pages) |
| Disciplina | 005.14 |
| Soggetto topico |
Debugging in computer science
Elixir (Computer program language) |
| ISBN |
9781680508925
168050892X 9781680508932 1680508938 |
| Formato | Materiale a stampa |
| Livello bibliografico | Monografia |
| Lingua di pubblicazione | eng |
| Nota di contenuto |
Cover -- Table of Contents -- Acknowledgments -- Andrea Leopardi -- Jeffrey Matthias -- Introduction -- Why Do We Need a Book for Testing in Elixir? -- Who This Book Is For -- How to Read This Book -- About the Code -- Online Resources -- 1. Unit Tests -- Defining the Unit in Unit Test -- Testing with ExUnit -- Organizing Your Tests -- Creating Comprehensive Test Coverage -- Testing Pure Functions -- Refactoring Toward Pure Functions -- Isolating Code -- Wrapping Up -- 2. Integration and End-to-End Tests -- What Is an Integration Test? -- Testing Against Real External Dependencies -- Dependency Doubles -- Interfacing to External Dependencies with Behaviours -- Test Doubles: Stubs, Mocks, and Fakes -- The Hidden Benefits of Dependency Doubles -- Testing the Actual Interaction with Services -- End-to-End Tests -- Wrapping Up -- 3. Testing OTP -- Testing a GenServer -- Controlling the Life Cycle of OTP Processes in Tests -- Testing Periodic Actions -- Testing Singleton Resources -- Testing Resiliency -- Wrapping Up -- 4. Testing Ecto Schemas -- Testing Your Schema Through Changesets -- Refactoring to Increase Test Maintainability -- Creating a SchemaCase for Shared Test Code -- Testing an Ecto Schema as a Data Validator -- Testing an Ecto Schema for Database Interactions -- Testing Your Schema Through Database Calls -- Setting Up Sandbox Mode -- Wrapping Up -- 5. Testing Ecto Queries -- Creating a Factory to Help with Setup -- Adding a DataCase to Help with Setup -- Testing Create -- Testing Read -- Testing Update -- Testing Delete -- Wrapping Up -- 6. Testing Phoenix -- The Role of Phoenix in Your Application -- Testing JSON-Based APIs -- Testing Server-Rendered HTML Applications -- Testing Phoenix Channels -- Wrapping Up -- 7. Property-Based Testing -- Property-Based Testing in Practice in the Elixir Standard Library -- Example-Based Tests.
Introducing Randomness and Property-Based Testing -- Data Generation -- Writing Properties -- Shrinking -- Strategies for Designing Properties -- Stateful Property-Based Testing -- Wrapping Up -- A1. When To Randomize Test Data -- A2. Test Life Cycle -- The Life Cycle of an ExUnit Suite -- Test Cases -- Executing Tests -- An Example and a Drawing -- A3. Test Coverage -- Built-In Test Coverage -- Coveralls and the Excoveralls Library -- Bibliography -- Index -- - A - -- - B - -- - C - -- - D - -- - E - -- - F - -- - G - -- - H - -- - I - -- - J - -- - L - -- - M - -- - N - -- - O - -- - P - -- - Q - -- - R - -- - S - -- - T - -- - U - -- - V - -- - W -. |
| Record Nr. | UNINA-9911008920403321 |
|
Leopardi Andrea
|
||
| [Raleigh, North Carolina] : , : The Pragmatic Programmers, LLC, , [2021] | ||
| Materiale a stampa | ||
| Lo trovi qui: Univ. Federico II | ||
| ||
