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 | ||
| ||
Build talking apps : develop voice-first applications for Alexa / / Craig Walls
| Build talking apps : develop voice-first applications for Alexa / / Craig Walls |
| Autore | Walls Craig |
| Edizione | [First edition.] |
| Pubbl/distr/stampa | [Raleigh, North Carolina] : , : The Pragmatic Programmers, LLC, , [2022] |
| Descrizione fisica | 1 online resource (385 pages) |
| Disciplina | 005.3 |
| Soggetto topico | Application software - Development |
| ISBN |
1-68050-986-1
1-68050-987-X |
| 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 -- Online Resources -- 1. Alexa, Hello -- How Alexa Works -- Dissecting Skills -- Installing the ASK CLI -- Creating Your First Alexa Skill -- Deploying the Skill -- Wrapping Up -- 2. Testing Alexa Skills -- Considering Skill Testing Styles -- Semi-Automated Testing -- Automated Testing with Alexa Skill Test Framework -- Automated Testing with Bespoken's BST -- Wrapping Up -- 3. Parameterizing Intents with Slots -- Adding Slots to an Intent -- Fetching Entity Information -- Creating Custom Types -- Extending Built-In Types -- Enabling Flexibility with Synonyms -- Handling Multi-Value Slots -- Wrapping Up -- 4. Creating Multi-Turn Dialogs -- Adding Dialogs and Prompts in the Interaction Model -- Eliciting Missing Slot Values -- Validating Slot Values -- Confirming Slots -- Explicitly Handling Dialog Delegation -- Wrapping Up -- 5. Integrating User Data -- Accessing a User's Amazon Info -- Linking with External APIs -- Wrapping Up -- 6. Embellishing Response Speech -- Getting to Know SSML -- Testing SSML with the Text-to-Speech Simulator -- Changing Alexa's Voice -- Adjusting Pronunciation -- Inserting Breaks in Speech -- Adding Sound Effects and Music -- Applying SSML in Skill Responses -- Escaping Reserved Characters -- Writing Responses with Markdown -- Wrapping Up -- 7. Mixing Audio -- Introducing APL for Audio -- Authoring APL-A Templates -- Making a Sound -- Combining Sounds -- Applying Filters -- Defining Custom Components -- Returning APL-A Responses -- Wrapping Up -- 8. Localizing Responses -- Translating the Interaction Model -- Localizing Spoken Responses -- Testing Localization -- Fixing Language Pronunciation -- Using Language-Specific Voices -- Wrapping Up -- 9. Complementing Responses with Cards.
Embellishing Responses with Cards -- Returning Simple Cards -- Rendering Images on Cards -- Wrapping Up -- 10. Creating Visual Responses -- Introducing the Alexa Presentation Language -- Creating a Rich APL Document -- Applying Styles -- Defining Resource Values -- Injecting Model Data -- Handling Touch Events -- Wrapping Up -- 11. Sending Events -- Publishing Proactive Events -- Sending Reminders -- Wrapping Up -- 12. Selling Stuff -- Creating Products -- Handling Purchases -- Upselling Products -- Refunding a Purchase -- Wrapping Up -- 13. Publishing Your Skill -- Tying Up Loose Ends -- Completing the Skill Manifest -- Submitting for Certification and Publication -- Promoting Your Skill with Quick Links -- Gathering Usage Metrics -- Wrapping Up -- 14. Defining Conversational Flows -- Introducing Alexa Conversations -- Starting a New Alexa Conversations Project -- Getting to know ACDL -- Defining the Conversation Model -- Simplifying the Conversation Model -- Defining Response Templates -- Handling the Action Request -- Deploying and Testing the Conversation -- Wrapping Up -- A1. Running and Debugging Skill Code Locally -- Deploy Your Skill -- Running Skill Code Locally -- Debugging Skill Code -- A2. Troubleshooting Your Skill -- "Hmmm. I don't know that one." or "Hmmm. I have a few skills that can help." -- A Skill Other Than the One You Expect Is Launched -- An Utterance Is Handled by the Wrong Intent Handler -- You See "< -- Audio Only> -- " in the Response -- "There was a problem with the requested skill's response." -- "You just triggered {Some Intent}." -- Skill ID Not Found when Deploying a Skill -- "Sorry, I had trouble doing what you asked. Please try again." -- 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 - -- - X - -- - Y -. |
| Record Nr. | UNINA-9911008450703321 |
|
Walls Craig
|
||
| [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 | ||
| ||
Design and build great web APIs / / Mike Amundsen
| Design and build great web APIs / / Mike Amundsen |
| Autore | Amundsen Michael |
| Edizione | [First edition.] |
| Pubbl/distr/stampa | Raleigh, NC : , : The Pragmatic Programmers, LLC, , [2020] |
| Descrizione fisica | 1 online resource (346 pages) |
| Disciplina | 005.3 |
| Soggetto topico | Application program interfaces (Computer software) |
| ISBN |
9781680508130
168050813X 9781680508147 1680508148 |
| Formato | Materiale a stampa |
| Livello bibliografico | Monografia |
| Lingua di pubblicazione | eng |
| Nota di contenuto |
Cover -- Table of Contents -- Acknowledgments -- Preface -- Your API Journey -- Who Should Read This Book -- How This Book Is Organized -- What's Covered (And What's Not) -- About the BigCo, Inc., Sample Project -- Online Resources -- Part I-Getting Started -- 1. Getting Started with API First -- Adopting the API-First Principle -- Exploring APIs with curl -- What's Next? -- Chapter Exercise -- 2. Understanding HTTP, REST, and APIs -- Understanding Web API Protocols, Practices, and Styles -- Managing Files with Git -- What's Next? -- Chapter Exercise -- Part II-The Design Phase -- 3. Modeling APIs -- Understanding Norman's Action Lifecycle -- Modeling Our Onboarding API Lifecycle -- Managing Your Project with npm -- What's Next? -- Chapter Exercise -- 4. Designing APIs -- The Power of Design -- The API Design Method -- Identifying Your API Descriptors -- Creating Your Sequence Diagram -- What's Next? -- Chapter Exercise -- 5. Describing APIs -- Learning the Role of Description Formats -- Describing Your API with ALPS -- Updating Your API Project -- What's Next? -- Chapter Exercise -- Part III-The Build Phase -- 6. Sketching APIs -- Learning from Frank Gehry's Sketches -- API Sketching Example -- The Advantages of Sketching -- Sketching APIs with Apiary Blueprint -- API Sketching Tips and Tricks -- What's Next? -- Chapter Exercise -- 7. Prototyping APIs -- What Is an API Prototype? -- API Prototyping with OpenAPI -- Translating Your API Design into HTTP -- Creating Your OpenAPI Document with SwaggerHub -- Saving and Exporting Your API -- Mocking Your API -- Generating Your API Documentation -- What's Next? -- Chapter Exercise -- 8. Building APIs -- Defining the API Build Process -- Relying on a Repeatable Process -- Coding APIs with NodeJS and DARRT -- Putting It All Together -- What's Next? -- Chapter Exercise -- Part IV-The Release Phase.
9. Testing APIs -- The Goals of API Testing -- Testing with SRTs -- Using Postman for API Testing -- Running Tests Locally with Newman -- What's Next? -- Chapter Exercise -- 10. Securing APIs -- Understanding Security Basics -- Implementing API Security with Auth0 -- Supporting Machine-to-Machine Security -- What's Next -- Chapter Exercise -- 11. Deploying APIs -- The Basics of Deployment Pipelines -- The Role of DevOps -- Deploying with Heroku -- What's Next? -- Chapter Exercise -- 12. Modifying APIs -- Going Beyond Versioning -- The Three Rules for Safely Modifying APIs -- The Recommended Pattern for Testing for API Changes -- The Process for Safely Deploying APIs -- Shutting Down an Existing API -- What's Next? -- 13. Some Parting Thoughts -- Getting Started -- The Design Phase -- The Build Phase -- The Release Phase -- What's Next? -- Part V-Appendixes -- A1. Installation Hints -- curl -- Git -- GitHub and SSH -- NodeJS and npm -- Postman -- Newman -- Heroku Client -- Installing the Local Utiltities -- A2. Exercise Solutions -- Where's the Code? -- Solution for Chapter 1: Getting Started with API First -- Solution for Chapter 2: Understanding HTTP, REST, and APIs -- Solution for Chapter 3: Modeling APIs -- Solution for Chapter 4: Designing APIs -- Solution for Chapter 5: Describing APIs -- Solution for Chapter 6: Sketching APIs -- Solution for Chapter 7: Prototyping APIs -- Solution for Chapter 8: Building APIs -- Solution for Chapter 9: Testing APIs -- Solution for Chapter 10: Securing APIs -- Solution for Chapter 11: Deploying APIs -- A3. API Project Assets Checklist -- Using the API Project Assets Checklist -- Notes on the Assets Checklist -- Your API Project Assets Checklist -- 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 - -- - Y - -- - Z -. |
| Record Nr. | UNINA-9911008403203321 |
|
Amundsen Michael
|
||
| Raleigh, NC : , : The Pragmatic Programmers, LLC, , [2020] | ||
| Materiale a stampa | ||
| Lo trovi qui: Univ. Federico II | ||
| ||
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 Remote Work / / James Stanier
| Effective Remote Work / / James Stanier |
| Autore | Stanier James |
| Edizione | [First edition.] |
| Pubbl/distr/stampa | Raleigh, North Carolina : , : The Pragmatic Programmers, LLC, , [2022] |
| Descrizione fisica | 1 online resource (338 pages) |
| Disciplina | 331.4 |
| Collana | The Pragmatic programmers |
| Soggetto topico |
Home labor
Telecommuting Virtual work teams Work-life balance |
| ISBN |
9781680509601
1680509608 9781680509595 1680509594 |
| Formato | Materiale a stampa |
| Livello bibliografico | Monografia |
| Lingua di pubblicazione | eng |
| Nota di contenuto |
Cover -- Table of Contents -- Acknowledgments -- Introduction -- The Biggest Remote-Working Experiment in History -- Where You're Headed -- The Outline of This Book -- What's Next? -- Part I-Getting Oriented for Remote Work -- 1. A Remote Future -- A Brief History of the Future -- Lockdown -- Remote Is Here to Stay -- Time to Get Set Up -- 2. Getting Set Up -- The Office: What We Want and What We Don't -- The Basics, Briefly -- In the Real World -- Installing Mental Scaffolding -- The Golden Rule -- Part II-Building Effective Remote Teams -- 3. Treat Everyone as Remote -- Out of Sight, Out of Mind -- A Principle for Cultural Change -- Taking Practical Action -- Let's Build a Model! -- 4. The Spectrum of Synchronousness -- Synchronousness -- Permanence -- Restoring Your Humanity -- Onward to Hyrule -- 5. The Same but Different -- A Normal Day in the Office -- Through the Magic Mirror -- Conquering the Dark World -- Let's Discover Some Artifacts -- 6. Artifacts for a Better Future -- Comparing Artifacts -- Written Artifacts -- Codebase Artifacts -- Recorded Artifacts -- Getting on Board with Onboarding -- 7. Onboarding and Orientation -- The Contribution Curve -- The Onboarding Equation -- And Here's the Trick -- Coming Up: Considering Communication -- 8. Effective Communication Techniques -- Why Humans Communicate -- Principles for Better Remote Communication -- Techniques to Improve Interactions -- The Right Tools and When to Use Them -- Turning Inward -- 9. Managing Yourself -- An Organizational Bedrock -- On Being Unobserved -- Riding Peaks and Troughs -- From Yourself to Teams -- 10. Managing Teams -- The Output Equation Revisited -- Shrinking the Scale Factor -- Supercharging the Scale Factor -- Time to Take It up a Level -- Part III-Creating a World-Class Remote Culture -- 11. The Remote Working Test -- The Joel Test.
Twelve Questions about Remote Working -- Making Changes in Your Company -- Something to Guide Us -- 12. Creating a Handbook -- The GitLab Handbook -- Creating a Handbook for Your Team -- A Handbook for the Company -- Fully Making the Shift -- 13. Becoming Fully Remote -- The Spectrum of Remoteness -- The Challenge of Retrofitting Fully Remote Culture -- The Triangle of Transition -- Learning from Trailblazers -- Now the Difficult Stuff -- 14. The Hard Parts -- Walking the Curves -- The Physical and Mental Impact of Working Remotely -- Supporting Others Remotely -- And Breathe … -- 15. The Path to Equality Is Remote -- Diversity and Inclusion -- Remote: The Great Leveler -- This Is Just the Beginning -- And That's It -- 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 - -- - Y - -- - Z -. |
| Record Nr. | UNINA-9911009188703321 |
|
Stanier James
|
||
| Raleigh, North Carolina : , : The Pragmatic Programmers, LLC, , [2022] | ||
| Materiale a stampa | ||
| Lo trovi qui: Univ. Federico II | ||
| ||
Explore software defined radio : use SDR to receive satellite images and space signals / / Wolfram Donat
| Explore software defined radio : use SDR to receive satellite images and space signals / / Wolfram Donat |
| Autore | Donat Wolfram |
| Edizione | [First edition.] |
| Pubbl/distr/stampa | [Raleigh, North Carolina] : , : The Pragmatic Programmers, LLC, , [2021] |
| Descrizione fisica | 1 online resource (77 pages) |
| Disciplina | 621.384 |
| Collana | Pragmatic exPress |
| Soggetto topico | Software radio |
| ISBN |
9781680508345
1680508342 9781680508369 1680508369 |
| Formato | Materiale a stampa |
| Livello bibliografico | Monografia |
| Lingua di pubblicazione | eng |
| Nota di contenuto | Cover -- Table of Contents -- Acknowledgments -- Introduction -- Materials Needed -- 1. Installing the Required Bits and Pieces -- Hardware -- Software -- 2. Your First SDR Reception -- Attaching the Antenna -- Windows -- Linux -- Troubleshooting -- Try This -- 3. Antenna Theory and Design -- How Antennas Transmit -- How Antennas Receive -- Antenna Design for SDR Hobbyists -- 4. Digital Speech Decoding -- Hardware -- Software -- Things to Try -- 5. Listening to Satellites -- Hardware -- Software -- Troubleshooting -- Try This -- Conclusion -- A1. Running SDR on the Raspberry Pi -- Try This. |
| Record Nr. | UNINA-9911008398703321 |
|
Donat Wolfram
|
||
| [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 objects to functions : build your software faaster and safer with functional programming and kotlin / / Uberto Barbini
| From objects to functions : build your software faaster and safer with functional programming and kotlin / / Uberto Barbini |
| Autore | Barbini Uberto |
| Edizione | [First edition.] |
| Pubbl/distr/stampa | [Raleigh, North Carolina] : , : The Pragmatic Programmers, LLC, , [2023] |
| Descrizione fisica | 1 online resource (473 pages) |
| Disciplina | 005.1 |
| Soggetto topico | Application software - Development |
| ISBN |
9798888650462
9798888650479 |
| Formato | Materiale a stampa |
| Livello bibliografico | Monografia |
| Lingua di pubblicazione | eng |
| Nota di contenuto |
Cover -- Table of Contents -- Acknowledgments -- Preface -- About This Book -- Introduction: Why Functional Programming? -- Why Kotlin? -- What Functional Programming Is Really About -- Unlearning Object-Oriented Programming -- Recap -- 1. Preparing a New Application -- Defining the Sample Application -- Zettai: An Innovative To-Do List Application -- Letting Tests Guide Development -- Setting Up the Project -- Making Unit Tests Functional -- Recap -- Exercises -- 2. Handling HTTP Using Functions -- Kicking Off the Project -- Serving HTML Pages Functionally -- Starting Zettai -- Designing with Arrows -- Serving Lists from a Map -- Recap -- Exercises -- 3. Defining the Domain and Testing It -- Improving the Acceptance Tests -- Using Higher-Order Functions -- Separating the Domain from the Infrastructure -- Driving the Tests from the Domain -- Converting DDT to Pesticide -- Recap -- Exercises -- 4. Modeling the Domain and the Adapters -- Starting a New Story to Modify a List -- Using Functional Dependency Injection -- Debugging Functional Code -- Functional Domain Modeling -- Recap -- Exercises -- 5. Using Events to Modify the State -- Creating and Displaying To-Do Lists -- Storing the State Changes -- Unleashing the Power of Recursion -- Folding Events -- Discovering the Monoid -- Recap -- Exercises -- 6. Executing Commands to Generate Events -- Creating a New List -- Using Commands to Change the State -- Modeling the Domain with States and Events -- Writing Functional State Machines -- Connecting the Hub -- Understanding Commands and Events Better -- Recap -- Exercises -- 7. Handling Errors Functionally -- Handling Errors Better -- Learning Functors and Categories -- Using Functors to Handle Errors -- Working with Outcomes -- Recap -- Exercises -- 8. Using Functors to Project Events -- Projecting Our Events -- Running Queries on Functors.
Thinking in Terms of Functors -- Command and Query Responsibility Segregation (CQRS) -- Recap -- Exercises -- 9. Using Monads to Persist Data Safely -- Persisting Safely -- Connecting to the Database with Kotlin -- Accessing Remote Data in a Functional Way -- Exploring the Power of Monads -- Recap -- Exercises -- 10. Reading Context to Handle Commands -- Accessing the Database with Monads -- Handling Commands with Context Reader -- Querying Projections from Database -- Modeling the Domain with Event Sourcing -- Recap -- Exercises -- 11. Validating Data with Applicatives -- Renaming a List -- Transforming Functions with Two Parameters -- Validating with Validations -- Combining Applicative Functors -- Improving the User Interface -- Recap -- Exercises -- 12. Monitoring and Functional JSON -- Monitoring Our Application -- Structured Logging -- Making JSON Functional -- Meeting Profunctors -- Logging Database Calls -- Recap -- Exercises -- 13. Designing a Functional Architecture -- Chasing Simplicity -- Designing a Whole System -- Translating to Code -- Final Considerations -- Exercises -- A1. What Is Functional Programming? -- The Origins -- Achieving Referential Transparency -- Think in Morphisms -- Recap -- A2. About Functional Kotlin -- Setting Up Kotlin -- Kotlin 101 -- Exploring the Kotlin Type System -- A3. A Pinch of Theory -- Category Theory -- It's All About Morphisms -- Types over Types -- Functors Are Mappers -- The Mysterious Monad -- Connecting Everything with Yoneda -- Conclusion -- A4. Additional Resources -- Programming -- Category Theory -- 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 - -- - Y - -- - Z -. |
| Record Nr. | UNINA-9911008927003321 |
|
Barbini Uberto
|
||
| [Raleigh, North Carolina] : , : The Pragmatic Programmers, LLC, , [2023] | ||
| 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 | ||
| ||
