{"text_format":"2","workbook":"xls","n_sheets":1,"sheets":["report2"],"not_rendered":{"charts":0,"images":0,"macros":0,"external_links":1,"defined_names":1,"comments":0,"pivot_tables":0},"unopened":[],"bounds":{"document_bytes":16777216,"sheet_cells":100000,"run_cost":"one","rows_first":2000,"rows_last":500,"rows_between":2000,"halvings":0,"cell_chars":16384,"cell_head_chars":4096},"cells_cut":0,"cells_raw":0,"read":"whole","date_system":"1900","formulas":"cached_only"}

{"sheet":"report2","index":0,"n_rows":19,"n_cols":5,"rows_kept":19,"cut":false,"hidden":false,"merged":[[0,2,0,3],[0,4,0,5],[1,2,1,3],[1,4,1,5],[2,2,2,3],[2,4,2,5],[3,2,3,3],[5,2,5,3],[7,2,7,3],[8,2,8,3],[9,2,9,3],[10,2,10,3],[11,2,11,3],[12,2,12,3],[15,2,15,3]],"flags":["formulas_cached_only"]}
[null,"1.","Record Nr.",null,"UNINA9911008927003321"]
[null,null,"Autore",null,"Barbini Uberto"]
[null,null,"Titolo",null,"From objects to functions : build your software faaster and safer with functional programming and kotlin / / Uberto Barbini"]
[null,null,"Pubbl/distr/stampa",null,"[Raleigh, North Carolina] : , : The Pragmatic Programmers, LLC, , [2023]"]
[{"$nulls":4},"©2023"]
[null,null,"ISBN",null,"9798888650462"]
[{"$nulls":4},"9798888650479"]
[null,null,"Edizione",null,"[First edition.]"]
[null,null,"Descrizione fisica",null,"1 online resource (473 pages)"]
[null,null,"Disciplina",null,"005.1"]
[null,null,"Soggetti",null,"Application software - Development"]
[null,null,"Lingua di pubblicazione",null,"Inglese"]
[null,null,"Formato",null,"Materiale a stampa"]
[null,null,null,"Livello bibliografico","Monografia"]
[null,null,null,"Nota di bibliografia","Includes bibliographical references."]
[null,null,"Nota di contenuto",null,"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 "]
[{"$nulls":4},"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."]
[{"$nulls":4},"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 -."]
[null,null,null,"Sommario/riassunto","From Objects to Functions by Uberto Barbini is a comprehensive guide to functional programming, particularly using Kotlin. The book explores the integration of functional programming concepts into real-world applications, emphasizing the benefits of functional patterns such as referential transparency, immutability, and reusability. It provides insights into practical application development, utilizing technologies like http4k and PostgreSQL, and covers topics like functional state machines, error handling, and domain modeling. The author aims to bridge the gap between objects and functions, offering a detailed study for developers interested in enhancing their programming practices. The book is targeted at software developers seeking to expand their understanding of functional programming and its application in modern software development."]