東華大學圖書館 |

Language: English

Help

回圖書館首頁

手機版館藏查詢

Back

Switch To: Labeled | MARC Mode | ISBD

Linked to FindBook

Google Book

Amazon

博客來

The art of immutable architecture = theory and practice of data management in distributed systems /

Record Type:	Electronic resources : Monograph/item
Title/Author:	The art of immutable architecture/ by Michael L. Perry.
Reminder of title:	theory and practice of data management in distributed systems /
Author:	Perry, Michael L.
Published:	Berkeley, CA :Apress : : 2024.,
Description:	xxvi, 480 p. :ill., digital ;24 cm.
[NT 15003449]:	Part I: Definition -- Chapter 1: Why Immutable Architecture? -- Chapter 2: Forms of Immutable Architecture -- Chapter 3: How to Read an Historical Model -- Part II: Application -- Chapter 4: Analysis -- Chapter 5: Location Independence -- Chapter 6: Immutable Runtimes -- Chapter 7: Structural Patterns -- Chapter 8: State Transitions -- Chapter 9: Security -- Part III: Implementation -- Chapter 10: SQL Databases -- Chapter 11: Communication -- Chapter 12: Feeds -- Chapter13: Inversion.
Contained By:	Springer Nature eBook
Subject:	Database management. -
Online resource:	https://doi.org/10.1007/979-8-8688-0288-1
ISBN:	9798868802881

The art of immutable architecture = theory and practice of data management in distributed systems /
Perry, Michael L.

The art of immutable architecturetheory and practice of data management in distributed systems /[electronic resource] :by Michael L. Perry. - Second edition. - Berkeley, CA :Apress :2024. - xxvi, 480 p. :ill., digital ;24 cm.

Part I: Definition -- Chapter 1: Why Immutable Architecture? -- Chapter 2: Forms of Immutable Architecture -- Chapter 3: How to Read an Historical Model -- Part II: Application -- Chapter 4: Analysis -- Chapter 5: Location Independence -- Chapter 6: Immutable Runtimes -- Chapter 7: Structural Patterns -- Chapter 8: State Transitions -- Chapter 9: Security -- Part III: Implementation -- Chapter 10: SQL Databases -- Chapter 11: Communication -- Chapter 12: Feeds -- Chapter13: Inversion.

This book teaches you how to evaluate a distributed system from the perspective of immutable objects. You will understand the problems in existing designs, know how to make small modifications to correct those problems, and learn to apply the principles of immutable architecture to your tools. Most software components focus on the state of objects. They store the current state of a row in a relational database. They track changes to state over time, making several basic assumptions: there is a single latest version of each object, the state of an object changes sequentially, and a system of record exists. This is a challenge when it comes to building distributed systems. Whether dealing with autonomous microservices or disconnected mobile apps, many of the problems we try to solve come down to synchronizing an ever-changing state between isolated components. Distributed systems would be a lot easier to build if objects could notchange. After reading The Art of Immutable Architecture, you will come away with an understanding of the benefits of using immutable objects in your own distributed systems. You will learn a set of rules for identifying and exchanging immutable objects, and see a collection of useful theorems that emerges and ensures that the distributed systems you build are eventually consistent. Using patterns, you will find where the truth converges, see how changes are associative, rather than sequential, and come to feel comfortable understanding that there is no longer a single source of truth. Practical hands-on examples reinforce how to build software using the described patterns, techniques, and tools. By the end of the book, you will possess the language and resources needed to analyze and construct distributed systems with confidence. The assumptions of the past were sufficient for building single-user, single-computer systems. But as we expand to multiple devices, shared experiences, and cloud computing, they work against us. It is time for a new set of assumptions. Start with immutable objects, and build better distributed systems. What You Will Learn Evaluate a distributed system from the perspective of immutable objects Recognize the problems in existing designs, and make small modifications to correct them Start a new system from scratch, applying patterns Apply the principles of immutable architecture to your tools, including SQL databases, message queues, and the network protocols that you already use Discover new tools that natively apply these principles.

ISBN: 9798868802881

Standard No.: 10.1007/979-8-8688-0288-1doiSubjects--Topical Terms:

527442
Database management.

LC Class. No.: QA76.9.D3

Dewey Class. No.: 005.74

The art of immutable architecture = theory and practice of data management in distributed systems /
LDR:04086nmm a2200337 a 4500 001 2371867
003 DE-He213
005 20240529125451.0
006 m d
007 cr nn 008maaau
008 241127s2024 cau s 0 eng d
020 $a 9798868802881 $q (electronic bk.)
020 $a 9798868802874 $q (paper)
024 7 $a 10.1007/979-8-8688-0288-1 $2 doi
035 $a 979-8-8688-0288-1
040 $a GP $c GP
041 0 $a eng
050 4 $a QA76.9.D3
072 7 $a UMZ $2 bicssc
072 7 $a COM051230 $2 bisacsh
072 7 $a UMZ $2 thema
082 0 4 $a 005.74 $2 23
090 $a QA76.9.D3 $b P464 2024
100 1 $a Perry, Michael L. $3 3461932
245 1 4 $a The art of immutable architecture $h [electronic resource] : $b theory and practice of data management in distributed systems / $c by Michael L. Perry.
250 $a Second edition.
260 $a Berkeley, CA : $b Apress : $b Imprint: Apress, $c 2024.
300 $a xxvi, 480 p. : $b ill., digital ; $c 24 cm.
505 0 $a Part I: Definition -- Chapter 1: Why Immutable Architecture? -- Chapter 2: Forms of Immutable Architecture -- Chapter 3: How to Read an Historical Model -- Part II: Application -- Chapter 4: Analysis -- Chapter 5: Location Independence -- Chapter 6: Immutable Runtimes -- Chapter 7: Structural Patterns -- Chapter 8: State Transitions -- Chapter 9: Security -- Part III: Implementation -- Chapter 10: SQL Databases -- Chapter 11: Communication -- Chapter 12: Feeds -- Chapter13: Inversion.
520 $a This book teaches you how to evaluate a distributed system from the perspective of immutable objects. You will understand the problems in existing designs, know how to make small modifications to correct those problems, and learn to apply the principles of immutable architecture to your tools. Most software components focus on the state of objects. They store the current state of a row in a relational database. They track changes to state over time, making several basic assumptions: there is a single latest version of each object, the state of an object changes sequentially, and a system of record exists. This is a challenge when it comes to building distributed systems. Whether dealing with autonomous microservices or disconnected mobile apps, many of the problems we try to solve come down to synchronizing an ever-changing state between isolated components. Distributed systems would be a lot easier to build if objects could notchange. After reading The Art of Immutable Architecture, you will come away with an understanding of the benefits of using immutable objects in your own distributed systems. You will learn a set of rules for identifying and exchanging immutable objects, and see a collection of useful theorems that emerges and ensures that the distributed systems you build are eventually consistent. Using patterns, you will find where the truth converges, see how changes are associative, rather than sequential, and come to feel comfortable understanding that there is no longer a single source of truth. Practical hands-on examples reinforce how to build software using the described patterns, techniques, and tools. By the end of the book, you will possess the language and resources needed to analyze and construct distributed systems with confidence. The assumptions of the past were sufficient for building single-user, single-computer systems. But as we expand to multiple devices, shared experiences, and cloud computing, they work against us. It is time for a new set of assumptions. Start with immutable objects, and build better distributed systems. What You Will Learn Evaluate a distributed system from the perspective of immutable objects Recognize the problems in existing designs, and make small modifications to correct them Start a new system from scratch, applying patterns Apply the principles of immutable architecture to your tools, including SQL databases, message queues, and the network protocols that you already use Discover new tools that natively apply these principles.
650 0 $a Database management. $3 527442
650 0 $a Electronic data processing $x Distributed processing. $3 548601
650 0 $a Computer programming. $3 527209
650 1 4 $a Software Engineering. $3 890874
650 2 4 $a Programming Techniques. $3 892496
710 2 $a SpringerLink (Online service) $3 836513
773 0 $t Springer Nature eBook
856 4 0 $u https://doi.org/10.1007/979-8-8688-0288-1
950 $a Professional and Applied Computing (SpringerNature-12059)