{"text_format":"2","workbook":"xls","n_sheets":1,"sheets":["report2"],"not_rendered":{"charts":0,"images":0,"macros":0,"external_links":1,"defined_names":3,"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":59,"n_cols":5,"rows_kept":59,"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],[4,2,4,3],[5,2,5,3],[6,2,6,3],[7,2,7,3],[8,2,8,3],[9,2,9,3],[10,2,10,3],[12,2,12,3],[12,4,12,5],[13,2,13,3],[13,4,13,5],[14,2,14,3],[14,4,14,5],[15,2,15,3],[17,2,17,3],[18,2,18,3],[19,2,19,3],[20,2,20,3],[22,2,22,3],[23,2,23,3],[26,2,26,3],[35,2,35,3],[35,4,35,5],[36,2,36,3],[36,4,36,5],[37,2,37,3],[37,4,37,5],[38,2,38,3],[39,2,39,3],[41,2,41,3],[42,2,42,3],[43,2,43,3],[44,2,44,3],[45,2,45,3],[52,2,52,3],[53,2,53,3],[56,2,56,3]],"flags":["formulas_cached_only"]}
[null,"1.","Record Nr.",null,"UNINA990006831520403321"]
[null,null,"Autore",null,"Falzone, Maria Teresa"]
[null,null,"Titolo",null,"Giacomo Cusmano : la diaconia del povero e la \"carità cittadina\" / Maria Teresa Falzone.duto da O. Capitani e da F. Bocchi ; introduz. e premessa di O. Capitani ; indice dei nomi a cura di A. Ivan Pini e di A.L. Trombetti Budriesi ; postfazione di G. Fasoli"]
[null,null,"Pubbl/distr/stampa",null,"Torino : Società Editrice Internazionale, 1995"]
[null,null,"Descrizione fisica",null,"VIII, 288 p. ; 21 cm"]
[null,null,"Collana",null,"I cattolici nella società siciliana. Storia e testi "]
[null,null,"Disciplina",null,"271.79"]
[null,null,"Locazione",null,"FSPBC"]
[null,null,"Collocazione",null,"IX A 905"]
[null,null,"Lingua di pubblicazione",null,"Italiano"]
[null,null,"Formato",null,"Materiale a stampa"]
[null,null,null,"Livello bibliografico","Monografia"]
[null,"2.","Record Nr.",null,"UNINA9910148748303321"]
[null,null,"Autore",null,"Ryer Mat"]
[null,null,"Titolo",null,"Go programming blueprints : build real-world, production-ready solutions in Go using cutting-edge technology and techniques / / Mat Ryer"]
[null,null,"Pubbl/distr/stampa",null,"Birmingham, England ; ; Mumbai, India : , : Packt Publishing, , 2016"]
[{"$nulls":4},"©2016"]
[null,null,"Edizione",null,"[Second edition.]"]
[null,null,"Descrizione fisica",null,"1 online resource (385 pages) : illustrations"]
[null,null,"Disciplina",null,"005.133"]
[null,null,"Soggetti",null,"Go (Computer program language)"]
[{"$nulls":4},"Computer programming"]
[null,null,"Lingua di pubblicazione",null,"Inglese"]
[null,null,"Formato",null,"Materiale a stampa"]
[null,null,null,"Livello bibliografico","Monografia"]
[null,null,null,"Note generali","Includes index."]
[null,null,"Nota di contenuto",null,"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 "]
[{"$nulls":4},"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."]
[{"$nulls":4},"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."]
[{"$nulls":4},"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&amp -- A Application for Google App Engine -- The Google App Engine SDK for Go -- Creating your application -- App Engine applications are Go packages "]
[{"$nulls":4},"-- 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."]
[{"$nulls":4},"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."]
[{"$nulls":4},"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."]
[null,null,null,"Sommario/riassunto","Build real-world, production-ready solutions in Go using cutting-edge technology and techniques About This Book Get up to date with Go and write code capable of delivering massive world-class scale performance and availability Learn to apply the nuances of the Go language, and get to know the open source community that surrounds it to implement a wide range of start-up quality projects Write interesting and clever but simple code, and learn skills and techniques that are directly "]
[{"$nulls":4},"transferrable to your own projects Who This Book Is For If you are familiar with Go and are want to put your knowledge to work, then this is the book for you. Go programming knowledge is a must. What You Will Learn Build quirky and fun projects from scratch while exploring patterns, practices, and techniques, as well as a range of different technologies Create websites and data services capable of massive scale using Go’s net/http package, exploring RESTful patterns as well as low-latency WebSocket APIs Interact with a variety of remote web services to consume capabilities ranging from authentication and authorization to a fully functioning thesaurus Develop high-quality command-line tools that utilize the powerful shell capabilities and perform well using Go’s in-built concurrency mechanisms Build microservices for larger organizations using the Go Kit library Implement a modern document database as well as high-throughput messaging queue technology to put together an architecture that is truly ready to scale Write concurrent programs and gracefully manage the execution of them and communication by smartly using channels Get a feel for app deployment using Docker and Google App Engine In Detail Go is the language of the Internet age, and the latest version of Go comes with major architectural changes. Implementation of the language, runtime, and libraries has changed significantly. The compiler and runtime are now written entirely in Go. The garbage collector is now concurrent and provides dramatically lower pause times by running in parallel with other Go routines when possible. This book will show you how to leverage all the latest features and much more. This book shows you how to build powerful systems and drops you into real-world situations. You will learn to develop high-quality command-line tools that utilize the powerful shell capabilities and perform well using Go’s in-built concurrency mechanisms. Scale, performance, and high availability lie at the heart ..."]
[null,"3.","Record Nr.",null,"UNINA9910255054003321"]
[null,null,"Autore",null,"Larsson Mats"]
[null,null,"Titolo",null,"Finance and the Welfare State : Banking Development and Regulatory Principles in Sweden, 1900-2015 / / by Mats Larsson, Gabriel Söderberg"]
[null,null,"Pubbl/distr/stampa",null,"Cham : , : Springer International Publishing : , : Imprint : Palgrave Macmillan, , 2017"]
[null,null,"ISBN",null,"9783319618517"]
[{"$nulls":4},"3319618512"]
[null,null,"Edizione",null,"[1st ed. 2017.]"]
[null,null,"Descrizione fisica",null,"1 online resource (149 pages) : illustrations, tables"]
[null,null,"Collana",null,"Palgrave Studies in the History of Finance, , 2662-5172"]
[null,null,"Disciplina",null,"336"]
[null,null,"Soggetti",null,"Finance"]
[{"$nulls":4},"History"]
[{"$nulls":4},"Financial services industry"]
[{"$nulls":4},"Finance, Public"]
[{"$nulls":4},"Financial History"]
[{"$nulls":4},"Financial Services"]
[{"$nulls":4},"Public Finance"]
[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 at the end of each chapters and index."]
[null,null,"Nota di contenuto",null,"Chapter 1: Introduction -- Chapter 2: The transition from the Classical Regime to the Statist Regime: 1900-1950 -- Chapter 3: The introduction of the Riksbank regulation: 1950-1955 -- Chapter 4: Tensions mount in the Statist Regime: 1955-1960 -- Chapter 5: International turmoil and regulatory changes: 1960-1979 -- Chapter 6. A new regime emerges: 1980-1995 -- Chapter 7: Banking development, the global financial crisis and the Basel regulations: 1995-2015 -- Chapter 8: Finance and the welfare state: what have we learned?"]
[null,null,null,"Sommario/riassunto","This book explores the Swedish experience of banking development, regulation and financial crisis from 1900 to 2015. It puts the experiences of the past in the context of today's debate on the future of banking, and argues that the experiences of the Global Financial Crisis that started in 2007 warrants new understandings of the role of bank regulation. The book also analyses how shifts in bank regulations are usually part of more general policy shifts in society, which are in "]
[{"$nulls":4},"turn connected to both pragmatic and ideological considerations. In the case of Sweden the shift towards more extensive bank regulations after World War II was closely related to the development of the welfare state. Such shifts in policy and regulations are generally international, and the book also explores how the Swedish national policy has interacted with international developments. Mats Larsson is Professor ofEconomic History at Uppsala University, and Head of Uppsala Centre for Business History, Sweden. He is a member of the editorial board of the Business History journal. Gabriel Söderberg is a researcher in the Department of Economic History at Uppsala University, Sweden."]