Categories
Bibliography Scala Software Engineering

Programming Scala, 3rd Edition – B095XLMMGC – ISBN-13: 978-1492077893

See: Programming Scala, 3rd Edition, by Dean Wampler, Publisher ‏ : ‎ O’Reilly Media; 3rd edition (May 26, 2021)

Fair Use Source:

Get up to speed on Scala–the JVM, JavaScript, and natively compiled language that offers all the benefits of functional programming, a modern object model, and an advanced type system. Packed with code examples, this comprehensive book shows you how to be productive with the language and ecosystem right away. You’ll learn why Scala is ideal for building today’s highly scalable, data-centric applications while maximizing developer productivity.

While Java remains popular and Kotlin has become popular, Scala hasn’t been sitting still. This third edition covers the new features in Scala 3 with updates throughout the book. Programming Scala is ideal for beginning to advanced developers who want a complete understanding of Scala’s design philosophy and features with a thoroughly practical focus.

  • Program faster with Scala’s succinct and flexible syntax
  • Dive into basic and advanced functional programming techniques
  • Build killer big data and distributed apps using Scala’s functional combinators and tools like Spark and Akka
  • Create concise solutions to challenging design problems with the sophisticated type system, mixin composition with traits, pattern matching, and more


Resources

Errata Page: http://oreilly.com/catalog/0636920365686/errata

Supplemental Content: https://github.com/deanwampler/programming-scala-book-code-examples

About the Author

Dean Wampler is an expert in data engineering for scalable streaming data systems and applications of machine learning and artificial intelligence. He is a principal software engineer at Domino Data Lab. Previously he worked at Anyscale and Lightbend, where he worked on scalable machine learning with Ray and distributed streaming data systems with Apache Spark, Apache Kafka, Kubernetes, and other tools. Besides Programming Scala, Dean is also the author of What Is Ray?, Distributed Computing Made Simple, Fast Data Architectures for Streaming Applications, and Functional Programming for Java Developers, as well as the coauthor of Programming Hive, all from O’Reilly. He is a contributor to several open source projects and a frequent conference speaker, and he co-organizes several conferences around the world and several user groups in Chicago. Dean has a PhD in physics from the University of Washington. Find Dean on Twitter: @deanwampler.

Table of Contents:

By Dean Wampler

  1. Foreword
  2. Foreword, Third Edition
  3. Foreword, First and Second Edition
  4. Preface
  5. Welcome to Programming Scala, Third Edition
  6. How to Read This Book
  7. Welcome to Programming Scala, Second Edition
  8. Welcome to Programming Scala, First Edition
  9. Conventions Used in This Book
  10. Using Code Examples
  11. Getting the Code Examples
  12. O’Reilly Online Learning
  13. How to Contact Us
  14. Acknowledgments for the Third Edition
  15. Acknowledgments for the Second Edition
  16. Acknowledgments for the First Edition
  17. 1. Zero To Sixty: Introducing Scalaqueue
  18. Why Scala?
  19. The Appeal of Scala
  20. Why Scala 3?
  21. Migrating to Scala 3
  22. Installing the Scala Tools You Need
  23. Building the Code Examples
  24. More Tips
  25. Using sbt
  26. Running the Scala Command-Line Tools Using sbt
  27. A Taste of Scala
  28. A Sample Application
  29. Recap and What’s Next
  30. 2. Type Less, Do Morequeue
  31. New Scala 3 Syntax—Optional Braces
  32. Semicolons
  33. Variable Declarations
  34. Ranges
  35. Partial Functions
  36. Method Declarations
  37. Method Default and Named Parameters
  38. Methods with Multiple Parameter Lists
  39. Nesting Method Definitions and Recursion
  40. Inferring Type Information
  41. Repeated Parameter Lists
  42. Language Keywords
  43. Literal Values
  44. Numeric Literals
  45. Boolean Literals
  46. Character Literals
  47. String Literals
  48. Symbol Literals
  49. Function Literals
  50. Tuples
  51. Option, Some, and None: Avoiding Nulls
  52. When You Really Can’t Avoid Nulls
  53. Sealed Class Hierarchies and Enumerations
  54. Organizing Code in Files and Namespaces
  55. Importing Types and Their Members
  56. Package Imports and Package Objects
  57. Parameterized Types Versus Abstract Type Members
  58. Recap and What’s Next
  59. 3. Rounding Out The Basics
  60. Defining Operators
  61. Allowed Characters in Identifiers
  62. Methods with Empty Parameter Lists
  63. Operator Precedence Rules
  64. Enumerations and Algebraic Data Types
  65. Interpolated Strings
  66. Scala Conditional Expressions
  67. Conditional and Comparison Operators
  68. for Comprehensions
  69. for Loops
  70. Generators
  71. Guards: Filtering Values
  72. Yielding New Values
  73. Expanded Scope and Value Definitions
  74. Scala while Loops
  75. Using try, catch, and finally Clauses
  76. Call by Name, Call by Value
  77. Lazy Values
  78. Traits: Interfaces and Mixins in Scala
  79. When new Is Optional
  80. Recap and What’s Next
  81. 4. Pattern Matching
  82. Safer Pattern Matching with Matchable
  83. Values, Variables, and Types in Matches
  84. Matching on Sequences
  85. Pattern Matching on Repeated Parameters
  86. Matching on Tuples
  87. Parameter Untupling
  88. Guards in Case Clauses
  89. Matching on Case Classes and Enums
  90. Matching on Regular Expressions
  91. Matching on Interpolated Strings
  92. Sealed Hierarchies and Exhaustive Matches
  93. Chaining Match Expressions
  94. Pattern Matching Outside Match Expressions
  95. Problems in Pattern Bindings
  96. Pattern Matching as Filtering in for Comprehensions
  97. Pattern Matching and Erasure
  98. Extractors
  99. unapply Method
  100. Alternatives to Option Return Values
  101. unapplySeq Method
  102. Implementing unapplySeq
  103. Recap and What’s Next
  104. 5. Abstracting Over Context: Type Classes And Extension Methodsqueue
  105. Four Changes
  106. Extension Methods
  107. Build Your Own String Interpolator
  108. Type Classes
  109. Scala 3 Type Classes
  110. Alias Givens
  111. Scala 2 Type Classes
  112. Scala 3 Implicit Conversions
  113. Type Class Derivation
  114. Givens and Imports
  115. Givens Scoping and Pattern Matching
  116. Resolution Rules for Givens and Extension Methods
  117. The Expression Problem
  118. Recap and What’s Next
  119. 6. Abstracting Over Context: Using Clauses
  120. Using Clauses
  121. Context Bounds
  122. Other Context Parameters
  123. Context Functions
  124. Constraining Allowed Instances
  125. Implicit Evidence
  126. Working Around Type Erasure with Using Clauses
  127. Rules for Using Clauses
  128. Improving Error Messages
  129. Recap and What’s Next
  130. 7. Functional Programming In Scalaqueue
  131. What Is Functional Programming?
  132. Functions in Mathematics
  133. Variables That Aren’t
  134. Functional Programming in Scala
  135. Anonymous Functions, Lambdas, and Closures
  136. Purity Inside Versus Outside
  137. Recursion
  138. Tail Calls and Tail-Call Optimization
  139. Partially Applied Functions Versus Partial Functions
  140. Currying and Uncurrying Functions
  141. Tupled and Untupled Functions
  142. Partial Functions Versus Functions Returning Options
  143. Functional Data Structures
  144. Sequences
  145. Maps
  146. Sets
  147. Traversing, Mapping, Filtering, Folding, and Reducing
  148. Traversing
  149. Mapping
  150. Flat Mapping
  151. Filtering
  152. Folding and Reducing
  153. Left Versus Right Folding
  154. Combinators: Software’s Best Component Abstractions
  155. What About Making Copies?
  156. Recap and What’s Next
  157. 8. For Comprehensions In Depthqueue
  158. Recap: The Elements of for Comprehensions
  159. for Comprehensions: Under the Hood
  160. Translation Rules of for Comprehensions
  161. Options and Container Types
  162. Option as a Container?
  163. Either: An Alternative to Option
  164. Try: When There Is No Do
  165. Validated from the Cats Library
  166. Recap and What’s Next
  167. 9. Object-Oriented Programming In Scalaqueue
  168. Class and Object Basics: Review
  169. Open Versus Closed Types
  170. Classes Open for Extension
  171. Overriding Methods? The Template Method Pattern
  172. Reference Versus Value Types
  173. Opaque Types and Value Classes
  174. Opaque Type Aliases
  175. Value Classes
  176. Supertypes
  177. Constructors in Scala
  178. Calling Supertype Constructors
  179. Export Clauses
  180. Good Object-Oriented Design: A Digression
  181. Fields in Types
  182. The Uniform Access Principle
  183. Unary Methods
  184. Recap and What’s Next
  185. 10. Traitsqueue
  186. Traits as Mixins
  187. Stackable Traits
  188. Union and Intersection Types
  189. Transparent Traits
  190. Using Commas Instead of with
  191. Trait Parameters
  192. Should That Type Be a Class or Trait?
  193. Recap and What’s Next
  194. 11. Variance Behavior And Equalityqueue
  195. Parameterized Types: Variance Under Inheritance
  196. Functions Under the Hood
  197. Variance of Mutable Types
  198. Improper Variance of Java Arrays
  199. Equality of Instances
  200. The equals Method
  201. The == and != Methods
  202. The eq and ne Methods
  203. Array Equality and the sameElements Method
  204. Equality and Inheritance
  205. Multiversal Equality
  206. Case Objects and hashCode
  207. Recap and What’s Next
  208. 12. Instance Initialization And Method Resolutionqueue
  209. Linearization of a Type Hierarchy
  210. Initializing Abstract Fields
  211. Overriding Concrete Fields
  212. Abstract Type Members and Concrete Type Aliases
  213. Recap and What’s Next
  214. 13. The Scala Type Hierarchyqueue
  215. Much Ado About Nothing (and Null)
  216. The scala Package
  217. Products, Case Classes, Tuples, and Functions
  218. Tuples and the Tuple Trait
  219. The Predef Object
  220. Implicit Conversions
  221. Type Definitions
  222. Condition Checking Methods
  223. Input and Output Methods
  224. Miscellaneous Methods
  225. Recap and What’s Next
  226. 14. The Scala Collections Libraryqueue
  227. Different Groups of Collections
  228. Abstractions with Multiple Implementations
  229. The scala.collection.immutable Package
  230. The scala.collection.mutable Package
  231. The scala.collection Package
  232. The scala.collection.concurrent Package
  233. The scala.collection.convert Package
  234. The scala.collection.generic Package
  235. Construction of Instances
  236. The Iterable Abstraction
  237. Polymorphic Methods
  238. Equality for Collections
  239. Nonstrict Collections: Views
  240. Recap and What’s Next
  241. 15. Visibility Rulesqueue
  242. Public Visibility: The Default
  243. Visibility Keywords
  244. Protected Visibility
  245. Private Visibility
  246. Scoped Private and Protected Visibility
  247. Recap and What’s Next
  248. 16. Scala’s Type System, Part Iqueue
  249. Parameterized Types
  250. Abstract Type Members and Concrete Type Aliases
  251. Comparing Abstract Type Members Versus Parameterized Types
  252. Type Bounds
  253. Upper Type Bounds
  254. Lower Type Bounds
  255. Context Bounds
  256. View Bounds
  257. Intersection and Union Types
  258. Intersection Types
  259. Union Types
  260. Phantom Types
  261. Structural Types
  262. Refined Types
  263. Existential Types (Obsolete)
  264. Recap and What’s Next
  265. 17. Scala’s Type System, Part IIqueue
  266. Match Types
  267. Dependently Typed Methods
  268. Dependent Method and Dependent Function Types
  269. Dependent Typing
  270. Path-Dependent Types
  271. Using this
  272. Using super
  273. Stable Paths
  274. Self-Type Declarations
  275. Type Projections
  276. More on Singleton Types
  277. Self-Recursive Types: F-Bounded Polymorphism
  278. Higher-Kinded Types
  279. Type Lambdas
  280. Polymorphic Functions
  281. Type Wildcard Versus Placeholder
  282. Recap and What’s Next
  283. 18. Advanced Functional Programmingqueue
  284. Algebraic Data Types
  285. Sum Types Versus Product Types
  286. Properties of Algebraic Data Types
  287. Final Thoughts on Algebraic Data Types
  288. Category Theory
  289. What Is a Category?
  290. Functor
  291. The Monad Endofunctor
  292. The Semigroup and Monoid Categories
  293. Recap and What’s Next
  294. 19. Tools For Concurrencyqueue
  295. The scala.sys.process Package
  296. Futures
  297. Robust, Scalable Concurrency with Actors
  298. Akka: Actors for Scala
  299. Actors: Final Thoughts
  300. Stream Processing
  301. Recap and What’s Next
  302. 20. Dynamic Invocation In Scalaqueue
  303. Structural Types Revisited
  304. A Motivating Example: ActiveRecord in Ruby on Rails
  305. Dynamic Invocation with the Dynamic Trait
  306. DSL Considerations
  307. Recap and What’s Next
  308. 21. Domain-Specific Languages In Scalaqueue
  309. Internal DSLs
  310. External DSLs with Parser Combinators
  311. About Parser Combinators
  312. A Payroll External DSL
  313. Internal Versus External DSLs: Final Thoughts
  314. Recap and What’s Next
  315. 22. Scala Tools And Librariesqueue
  316. Scala 3 Versions
  317. Command-Line Interface Tools
  318. Coursier
  319. Managing Java JDKs with Coursier
  320. The scalac Command-Line Tool
  321. The scala Command-Line Tool
  322. The scaladoc Command-Line Tool
  323. Other Scala Command-Line Tools
  324. Build Tools
  325. Integration with IDEs and Text Editors
  326. Using Notebook Environments with Scala
  327. Testing Tools
  328. Scala for Big Data: Apache Spark
  329. Typelevel Libraries
  330. Li Haoyi Libraries
  331. Java and Scala Interoperability
  332. Using Java Identifiers in Scala Code
  333. Scala Identifiers in Java Code
  334. Java Generics and Scala Parameterized Types
  335. Conversions Between Scala and Java Collections
  336. Java Lambdas Versus Scala Functions
  337. Annotations for JavaBean Properties and Other Purposes
  338. Recap and What’s Next
  339. 23. Application Designqueue
  340. Recap of What We Already Know
  341. Annotations
  342. Using @main Entry Points
  343. Design Patterns
  344. Creational Patterns
  345. Structural Patterns
  346. Behavioral Patterns
  347. Better Design with Design by Contract
  348. The Parthenon Architecture
  349. Recap and What’s Next
  350. 24. Metaprogramming: Macros And Reflectionqueue
  351. Scala Compile Time Reflection
  352. Java Runtime Reflection
  353. Scala Reflect API
  354. Type Class Derivation: Implementation Details
  355. Scala 3 Metaprogramming
  356. Inline
  357. Macros
  358. Staging
  359. Wrapping Up and Looking Ahead
  360. A. Significant Indentation Versus Braces Syntaxqueue
  361. Bibliography
Categories
Bibliography Scala Software Engineering

Scala Cookbook: Recipes for Object-Oriented and Functional Programming, 2nd Edition – ISBN-13: 978-1492051541, 2021

See: Scala Cookbook: Recipes for Object-Oriented and Functional Programming, 2nd Edition, Publisher ‏ : ‎ O’Reilly Media; 2nd edition (August 31, 2021)

Fair Use Source:

Save time and trouble building object-oriented, functional, and concurrent applications with Scala 3. The latest edition of this comprehensive cookbook is packed with more than 250 ready-to-use recipes and 700 code examples to help you solve the most common problems when working with Scala and its popular libraries.

Whether you’re working on web, big data, or distributed applications, this cookbook provides recipes based on real-world scenarios for experienced Scala developers and for programmers just learning to use this JVM language. Author Alvin Alexander includes practical solutions from his experience using Scala for highly scalable applications that support concurrency and distribution.

Recipes cover:

  • Strings, numbers, and control structures
  • Classes, methods, objects, traits, packaging, and imports
  • Functional programming in a variety of situations
  • Building Scala applications with sbt
  • Collections covering Scala’s wealth of classes and methods
  • Actors and concurrency
  • List, array, map, set, and more
  • Files, processes, and command-line tasks
  • Web services and interacting with Java
  • Databases and persistence, data types and idioms


Resources

Errata Page: http://oreilly.com/catalog/0636920252702/errata

Categories
Bibliography Java Kotlin Software Engineering

Modern Java Recipes: Simple Solutions to Difficult Problems in Java 8 and 9, 1st Edition – B074R6B13N ISBN-13: 978-1491973172

See: Modern Java Recipes: Simple Solutions to Difficult Problems in Java 8 and 9, 1st Edition, Publisher ‏ : ‎ O’Reilly Media; 1st edition (August 11, 2017)

Fair Use Source:

The introduction of functional programming concepts in Java SE 8 was a drastic change for this venerable object-oriented language. Lambda expressions, method references, and streams fundamentally changed the idioms of the language, and many developers have been trying to catch up ever since. This cookbook will help. With more than 70 detailed recipes, author Ken Kousen shows you how to use the newest features of Java to solve a wide range of problems.

For developers comfortable with previous Java versions, this guide covers nearly all of Java SE 8, and includes a chapter focused on changes coming in Java 9. Need to understand how functional idioms will change the way you write code? This cookbook—chock full of use cases—is for you.

Recipes cover:

  • The basics of lambda expressions and method references
  • Interfaces in the java.util.function package
  • Stream operations for transforming and filtering data
  • Comparators and Collectors for sorting and converting streaming data
  • Combining lambdas, method references, and streams
  • Creating instances and extract values from Java’s Optional type
  • New I/O capabilities that support functional streams
  • The Date-Time API that replaces the legacy Date and Calendar classes
  • Mechanisms for experimenting with concurrency and parallelism

About the Author

Ken Kousen is an independent consultant and trainer specializing in Spring, Hibernate, Groovy, and Grails. He holds numerous technical certifications, along with degrees in Mathematics, Mechanical and Aerospace Engineering, and Computer Science.



Resources

Errata Page: http://oreilly.com/catalog/0636920056669/errata

Categories
Bibliography Kotlin Software Engineering

Java to Kotlin: A Refactoring Guidebook, 1st Edition – ISBN-13: 978-1492082279

See: Java to Kotlin: A Refactoring Guidebook, 1st Edition, Publisher ‏ : ‎ O’Reilly Media; 1st edition (September 14, 2021)

Fair Use Source:

See also: Kotlin

Kotlin has raised the bar for programming languages on the Java Virtual Machine with its compatibility, readability, efficiency, and tool support. But adopting a new language can be daunting, especially when you’re working with business-critical Java code that must meet changing requirements.

This book takes a novel approach to introducing Kotlin to Java programmers: showing you how to gradually refactor Java code to idiomatic Kotlin while continuing to evolve its functionality. But converting Java to Kotlin is just the starting point. Kotlin has many features beyond Java.

Using worked examples, authors Duncan McGregor and Nat Pryce guide you through honing the converted code to make it simpler, more efficient, more expressive, and easier to change. You’ll learn how to take advantage of functional constructs to improve program structure, reliability, and error handling.

Once you finish this book, you’ll be confident writing Kotlin from scratch, converting your existing Java when appropriate, and managing a mixed Java-Kotlin codebase as it evolves over time.



Resources

Errata Page: http://oreilly.com/catalog/0636920453178/errata

Categories
Bibliography Kotlin Software Engineering

Head First Kotlin: A Brain-Friendly Guide – B07NPZ21QP ISBN-13: 978-1491996690

See: Head First Kotlin: A Brain-Friendly Guide, 1st Edition, Publisher ‏ : ‎ O’Reilly Media; 1st edition (February 13, 2019)

Fair Use Source:

See also: Kotlin

What will you learn from this book?

Head First Kotlin is a complete introduction to coding in Kotlin. This hands-on book helps you learn the Kotlin language with a unique method that goes beyond syntax and how-to manuals and teaches you how to think like a great Kotlin developer. You’ll learn everything from language fundamentals to collections, generics, lambdas, and higher-order functions. Along the way, you’ll get to play with both object-oriented and functional programming. If you want to really understand Kotlin, this is the book for you.

Why does this book look so different?

Based on the latest research in cognitive science and learning theory, Head First Kotlin uses a visually rich format to engage your mind rather than a text-heavy approach that puts you to sleep. Why waste your time struggling with new concepts? This multisensory learning experience is designed for the way your brain really works.



Resources

Errata Page: http://oreilly.com/catalog/0636920102786/errata

Categories
Bibliography DevOps Java Software Engineering Spring Framework

B074R4B7LY ISBN-13: 978-1449374648

See: Cloud Native Java: Designing Resilient Systems with Spring Boot, Spring Cloud, and Cloud Foundry, 1st Edition, Publisher ‏ : ‎ O’Reilly Media; 1st edition (September 19, 2017)

See also: Spring Bibliography, Spring Framework and Cloud Native

Fair Use Source:

Categories
Bibliography DevOps DevSecOps-Security-Privacy Java Kubernetes Software Engineering Spring Framework

DevOps Tools for Java Developers: Best Practices from Source Code to Production Containers, 1st Edition – ISBN-13: 978-1492084020, 2022

See: DevOps Tools for Java Developers: Best Practices from Source Code to Production Containers, 1st Edition, Publisher ‏ : ‎ O’Reilly Media; 1st edition (January 18, 2022)

Fair Use Source:

With the rise of DevOps, low-cost cloud computing, and container technologies, the way Java developers approach development today has changed dramatically. This practical guide helps you take advantage of microservices, serverless, and cloud native technologies using the latest DevOps techniques to simplify your build process and create hyperproductive teams.

Stephen Chin, Melissa McKay, Ixchel Ruiz, and Baruch Sadogursky help you evaluate an array of options. The list includes source control with Git, build declaration with Maven and Gradle, CI/CD with CircleCI, package management with Artifactory, containerization with Docker and Kubernetes, and much more. Whether you’re building applications with Jakarta EE, Spring Boot, Dropwizard, MicroProfile, Micronaut, or Quarkus, this comprehensive guide has you covered.

  • Explore software lifecycle best practices
  • Use DevSecOps methodologies to facilitate software development and delivery
  • Understand the business value of DevSecOps best practices
  • Manage and secure software dependencies
  • Develop and deploy applications using containers and cloud native technologies
  • Manage and administrate source control repositories and development processes
  • Use automation to set up and administer build pipelines
  • Identify common deployment patterns and antipatterns
  • Maintain and monitor software after deployment

About the Author

Stephen Chin is Head of Developer Relations at JFrog and author of The Definitive Guide to Modern Client Development, Raspberry Pi with Java, and Pro JavaFX Platform. He has keynoted numerous Java conferences around the world including Devoxx, JNation, JavaOne, Joker, and Open Source India. Stephen is an avid motorcyclist who has done evangelism tours in Europe, Japan, and Brazil, interviewing hackers in their natural habitat. When he is not traveling, he enjoys teaching kids how to do embedded and robot programming together with his teenage daughter. You can follow his hacking adventures at: http://steveonjava.com/.

Melissa McKay is currently a Developer Advocate with the JFrog Developer Relations team. She has been active in the software industry 20 years and her background and experience spans a slew of technologies and tools used in the development and operation of enterprise products and services. Melissa is a mom, software developer, Java geek, huge promoter of Java UNconferences, and is always on the lookout for ways to grow, learn, and improve development processes. She is active in the developer community, has spoken at CodeOne, Java Dev Day Mexico and assists with organizing the JCrete and JAlba Unconferences as well as Devoxx4Kids events.

Ixchel Ruiz has developed software applications and tools since 2000. Her research interests include Java, dynamic languages, client-side technologies, and testing. She is a Java Champion, Groundbreaker Ambassador, Hackergarten enthusiast, open source advocate, JUG leader, public speaker, and mentor.

Baruch Sadogursky (a.k.a JBaruch) is the Chief Sticker Officer @JFrog (also, Head of DevOps Advocacy) at JFrog. His passion is speaking about technology. Well, speaking in general, but doing it about technology makes him look smart, and 19 years of hi-tech experience sure helps. When he’s not on stage (or on a plane to get there), he learns about technology, people and how they work, or more precisely, don’t work together.

He is a co-author of the Liquid Software book, a CNCF ambassador and a passionate conference speaker on DevOps, DevSecOps, digital transformation, containers and cloud-native, artifact management and other topics, and is a regular at the industry’s most prestigious events including DockerCon, Devoxx, DevOps Days, OSCON, Qcon, JavaOne and many others. You can see some of his talks at jfrog.com/shownotes

Categories
Bibliography DevOps Java Kotlin Software Engineering Spring Framework

Spring Boot: Up and Running: Building Cloud Native Java and Kotlin Applications, 1st Edition – B08W2QRQGQ ISBN-13: 978-1492076988

See: Spring Boot: Up and Running: Building Cloud Native Java and Kotlin Applications, 1st Edition, Publisher ‏ : ‎ O’Reilly Media; 1st edition (March 2, 2021)

See also: Spring Bibliography, Spring Framework, Kotlin and Cloud Native

Fair Use Source:

With over 75 million downloads per month, Spring Boot is the most widely used Java framework available. Its ease and power have revolutionized application development from monoliths to microservices. Yet Spring Boot’s simplicity can also be confounding. How do developers learn enough to be productive immediately? This practical book shows you how to use this framework to write successful mission-critical applications.

Mark Heckler from VMware, the company behind Spring, guides you through Spring Boot’s architecture and approach, covering topics such as debugging, testing, and deployment. If you want to develop cloud native Java or Kotlin applications with Spring Boot rapidly and effectively–using reactive programming, building APIs, and creating database access of all kinds–this book is for you.

  • Learn how Spring Boot simplifies cloud native application development and deployment
  • Build reactive applications and extend communication across the network boundary to create distributed systems
  • Understand how Spring Boot’s architecture and approach increase developer productivity and application portability
  • Deploy Spring Boot applications for production workloads rapidly and reliably
  • Monitor application and system health for optimal performance and reliability
  • Debug, test, and secure cloud-based applications painlessly

About the Author

Mark Heckler is a Spring Developer & Advocate at VMware, conference speaker, published author, & Java Champion focusing upon developing innovative production-ready software at velocity for the Cloud. He has worked with key players in the manufacturing, retail, medical, scientific, telecom, and financial industries and various public sector organizations to develop and deliver critical capabilities on time and on budget. Mark is an open source contributor and author/curator of a developer-focused blog (https://www.thehecklers.com) and an occasionally interesting Twitter account (@mkheck).

For the past 5+ years, Mark has worked with various Spring projects within VMware (including Framework, Boot, Data, Integration, Cloud, Security, & more) and has contributed code and guides toward their improvement and ease of use, as well has having delivered countless sessions, deep dives, and workshops to Spring customers and developer community members worldwide.

Categories
Bibliography Data Science - Big Data DevOps Software Engineering

B06XPJML5D ISBN-13: 978-1449373320

See: Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems, 1st Edition, Publisher ‏ : ‎ O’Reilly Media; 1st edition (April 18, 2017)

Fair Use Source:

Categories
Bibliography Cloud DevOps Software Engineering

B082FPZFND

See: Cloud Native Transformation: Practical Patterns for Innovation 1st Edition, Publisher ‏ : ‎ O’Reilly Media; 1st edition (December 31, 2019)

Fair Use Source:

Categories
Bibliography DevOps Software Engineering

B00PJ8YKRM ISBN-13: 978-1449331924

See: Learning Agile: Understanding Scrum, XP, Lean, and Kanban 1st Edition

Fair Use Source:

Categories
Bibliography DevOps Software Engineering

B0849MPK73 ISBN-13: 978-1492043454

See: Fundamentals of Software Architecture: An Engineering Approach 1st Edition, January 2020

Fair Use Source:

Categories
Bibliography Python Software Engineering

B0792LM8Q9 ISBN-13: 978-1491958865

See: Head First Learn to Code: A Learner’s Guide to Coding and Computational Thinking 1st Edition,

Fair Use Source:

Categories
Bibliography DevOps Python Software Engineering

B085KB31X3 ISBN-13: 978-1492052203

See: Architecture Patterns with Python: Enabling Test-Driven Development, Domain-Driven Design, and Event-Driven Microservices 1st Edition

Fair Use Source:

Categories
Bibliography Flask Web Framework Python Software Engineering

B07B8DCCN7 ISBN-13: 978-1491991732

See: Flask Web Development: Developing Web Applications with Python 2nd Edition, Kindle Edition

Fair Use Source: