%{search_type} search results

• Introduction. Part I: Getting Started.
• Chapter 1: Programming Java for OS X.
• Chapter 2: Introducing the Environment.
• Chapter 3: Understanding Xcode.
• Chapter 4: Building Basic Projects.
• Chapter 5: Deploying Applications. Part II: Bringing Guidelines, APIs, and Languages Together.
• Chapter 6: Porting and Designing.
• Chapter 7: Integrating Windows, Menus, and Dialog Boxes.
• Chapter 8: Embedding Cocoa Components. Part III: Architecting Alternative Applications.
• Chapter 9: Understanding JNI.
• Chapter 10: Creating Screen Savers.
• Chapter 11: Creating Terminal Applications. Part IV: Appendixes. Appendix A: More Development Tools. Appendix B: JUnit on OS X. Glossary. Index.
• (source: Nielsen Book Data)

Learn the guidelines of integrating Java with native Mac OS X applications with this Devloper Reference book. Java is used to create nearly every type of application that exists and is one of the most required skills of employers seeking computer programmers. Java code and its libraries can be integrated with Mac OS X features, and this book shows you how to do just that. You'll learn to write Java programs on OS X and you'll even discover how to integrate them with the Cocoa APIs. Shows how Java programs can be integrated with any Mac OS X feature, such as NSView widgets or screen savers Reveals the requirements for integrating Java with native OS X applications Covers OS X libraries and behaviors unique to working with Java With this book, you will learn that creating Java-based applications that integrate closely with OS X is not a myth! Note: CD-ROM/DVD and other supplementary materials are not included as part of eBook file.
(source: Nielsen Book Data)

• Foundations
• Design
• Advanced topics
• Container security.

It's time to upgrade your container engine! The Podman container manager delivers flexible image layer control, seamless Kubernetes compatibility, and rootless containers that can be created, run, and managed by users without admin rights. Plus, its OCI-compliant support for the Cocker API lets you shift existing containers to Podman without breaking your scripts or changing the way you work. "Podman in action" introduced the Podman container manager. The easy-to-follow explanations and examples give you a clear view of what containers are, how they work, and how to manage them using Podman's powerful features. You'll get a deep look at the Linux components Podman uses and even learn more about Docker along the way. You'll especially appreciate author Dan Walsh's unique insights into container security.

• Chapter 1: Introduction to Uno Platform
• Chapter 2: File New Project
• Chapter 3: Your First PageChapter 4: Application Styles
• Chapter 5: Platform Specific Code and XAML
• Chapter 6: Master-Detail Menu and Dashboard
• Chapter 7: Custom Fonts
• Chapter 8: Model-View-ViewModel (MVVM)
• Chapter 9: Dependency Injection and Logging
• Chapter 10: Application Navigation
• Chapter 11: Authentication with Azure Active Directory
• Chapter 12: Converters
• Chapter 13: Microsoft Graph, Web APIs, and MyFilesPageChapter 14: Microsoft Graph and Dashboard Menu
• Chapter 15: Images and GridView
• Chapter 16: Selectors
• Chapter 17: OneDrive Navigation
• Chapter 18: Offline Data Access
• Chapter 19: Complete App.
• (source: Nielsen Book Data)

Get ready to build applications that can run anywhere using the Uno Platform and WinUI. Modern application development can be an intimidating and complex topic, especially when you are building cross-platform applications that need to support multiple operating systems and form factors. There are so many options when it comes to frameworks and selecting the right one for your enterprise is critical in delivering a successful product to market. For the developer who has zero experience building apps with Xamarin, UWP, WinUI, or the Uno Platform, this book deconstructs those complex concepts into tangible building blocks so that productivity gains are immediately recognized.You will start off learning basic concepts and get a bird's-eye view of the enabling technologies to ensure that you feel comfortable with the tools and terminology. From there, you will learn about some of the more popular options in the .NET ecosystem, understand their attributes and shortcomings, and learn why the Uno Platform is ideal for building a cross-platform application that targets Android, iOS, Windows, WASM (Web Assembly), Linux, and MacOS. Then, you will follow a product release timeline that takes you through building an application, introducing key concepts at every step of the way. Each section of the book is chock full of tips and edge case documentations for the different platforms. What You Will Learn Manage multi-targeting solutions: specifically, how to handle the different project heads Effectively write cross-platform software and handle the edge cases of the different platforms Understand the fundamentals of working with Uno Platform WinUI apps Explore enterprise-grade application architecture using MVVM Understand Dependency Injection and how it applies to application architecture Who This Book Is For Developers who understand some basics of C# and object-oriented programming.
(source: Nielsen Book Data)

• Table of Contents What Is React Native Understanding the Essentials of JavaScript and TypeScript Hello React Native Styling, Storage, and Navigation in React Native Managing States and Connecting Backends Working with Animations Handling Gestures in React Native JavaScript Engines and Hermes Essential Tools for Improving React Native Development Structuring Large-Scale, Multi-Platform Projects Creating and Automating Workflows Automated Testing of React Native Apps Tips and Outlook.
• (source: Nielsen Book Data)

Learn how React Native works under the hood and what this means for building large-scale, cross-platform, production-ready applications without compromising on the quality and performance Key Features Explore a modern approach to React Native, covering state management, animations, gestures, and more Implement best practices and practical techniques for creating large-scale, production-ready apps Create a development process including workflow automation with GitHub Actions, Fastlane, and Bitrise Book DescriptionThe React Native framework offers a range of powerful features that make it possible to efficiently build high-quality, easy-to-maintain frontend applications across multiple platforms such as iOS, Android, Linux, Mac OS X, Windows, and the web, helping you save both time and money. And this book is your key to unlocking its capabilities. Professional React Native provides the ultimate coverage of essential concepts, best practices, advanced processes, and tips for everyday developer problems. The book makes it easy to understand how React Native works under the hood using step-by-step explanations and practical examples so you can use this knowledge to develop highly performant apps. As you follow along, you'll learn the difference between React and React Native, navigate the React Native ecosystem, and revisit the basics of JavaScript and TypeScript needed to create a React Native application. What's more, you'll work with animations and even control your app with gestures. Finally, you'll be able to structure larger apps and improve developer efficiency through automated processes, testing, and continuous integration. By the end of this React native app development book, you'll have gained the confidence to build high-performance apps for multiple platforms, even on a bigger scale. What you will learn Become familiar with how React Native works under the hood Understand how to make the most of React Native for app development Explore different approaches to building apps across various platforms Become familiar with process automation and automated testing Contribute to open source code and structure your own code library Understand how to set up the architecture for bigger React Native projects Who this book is forThis book is for developers who want to get started with React Native as well as experienced React Native developers interested in building professional cross-platform applications. Familiarity with the basics of JavaScript (including its syntax) and general software engineering concepts, such as data types, control flows, and server/client structures, is required. Although useful, experience with React Native is not necessary.
(source: Nielsen Book Data)

• Introduction. Traditional vs. Agile ApproachReview of the best known traditional models - waterfall, spiral, V -model - and alternative agile models - Scrum, SAFe, DAD, RUP/UP, DSDM, XP and introduction to DPAC Chapter 1. The DPAC ModelPresents the DPAC Model in a static view describing the Stages and Activity Cycles in generalized form. Shows where Test is included in the model in the backswing of the PDCA overlay for each cycle. Continuous testing.1.1 Intent and purpose 1.2 Phases of the DPAC activity cycles 1.3 DPAC is inherently a "shift left" model 1.4 DPAC Embraces Agile and DevOps1.5 Activities represented in the DPAC model
• 1.6 Roles and responsibilities 1.7 Stages of Application Development
• 1.8 The objective of this model Paradigms as a hindrance to understanding 1.9 SummaryChapter 2. Why Include Support in a Development Model? Offers quotes referring to the importance of including maintenance in the development cycles. Displays statistics regarding the cost of maintenance as a part of the overall lifecycle.Every project that succeeds, even if challenged becomes a Support project. Shows the consequences of types of error. Cites the top ten software development problems from the perspective of maintenance. Building political and social capital.2.1 Statement of the Problem 2.2 To put this in terms of total cost... 2.3 Putting Support in the Equation 2.4. Freeing the statue from the stone2.5 Factors supporting code reliability2.6 Measures during development to improve software system maintainability. 2.7 Ameliorative measures 2.8 Political and Social Capital What's Ahead Chapter 3. InceptionStresses the importance of a Vision Statement as a project charter. The role of the charter as a first step in creating "conceptual integrity." Introduces non-functional requirements. Planning for security including privacy concerns.3.1 Goal: Achieving Consensus
• 3.2 Nine Objectives
• 3.3 The importance of the Vision Statement 3.4 Introduction to the Traceability Matrix 3.5 Non-functional Requirements
• 3.6 Planning for Information Security and
• System Security
• 3.7 Privacy 3.7 Legacy data 3.8 Summary of Security requirements 3.9 Identification of security requirements
• is initiated in the Inception Stage Summary Chapter 4. ElaborationThe goal of Elaboration is to create an overall process model that will serve as a Functional Requirements Specification (FRS), the second step in preserving conceptual integrity. The FRS forms the basis of level of effort and cost estimation.Outlines the role of the system architecture and the system backbone. Introduces the Configuration Management Database (CMDB) and the Traceability Matrix.4.1 The goal of the Elaboration Stage4.2 Objectives 4.3 Activities during Elaboration4.4 Ongoing Activities4.5 Implement Quality Engineering Plan4.6 Additional responsibilities:4.7 Data Flow Diagrams (DFD)4.8 Functional Requirements Specification (FRS)4.9 Design Review4.10 Following design approval4.11 Determine staffing, roles and responsibilities. 4.12 Rules of the Road (staffing)4.13 Design, develop and document the system architecture 4.14 Demonstrate an operating backbone4.15 Application Design Requirements 4.16 Introduction to Configuration Management Data Base (CMDB)4.17 The CMDB includes tools4.18 The Traceability Matrix4.19 On Joint Application Development (JAD) 4.20 On Workshops (in general) Chapter 5 ConstructionDescribes activities in the Process Detail and Unit Development Cycles. Introduces the practice of iterative development. Includes measures to assure the quality of the code as developed. Technical review subcycle. The triad principle.5.1 Process Detail Cycle5.1.1 Approach 5.1.2 Phases 5.1.3 Roles and responsibilities 5.1.4 Business Rules Definition 5.1.5 Form of Business Rules 5.1.6 Business rule review 5.1.7 Summation 5.2 Unit Development Cycle 5.2.1 Overview 5.2.2 Changing requirements 5.2.3 Processing Change Reports (CRpt) 5.2.4 Configuration Management 5.2.5 Advancement 5.2.6 Unit development 5.3 "Mechanical" tests 5.4 Test plans 5.5 Iterative development 5.6 Code check 5.7 Technical review sub-cycle 5.8 Refactoring, Test driven development (TDD) 5.9 True to requirements 5.10 User review 5.11 Regarding tools 5.12 Automated testing 5.13 Power of three 5.14 Staffing 5.15 Summation Chapter 6. Assembly"Service" assembly and system assembly. Continuous Integration and Continuous Delivery. Role of the agile DBA. Role of automation.6.1 Definitions 6.2 Service Assembly6.3 Continuous Integration and Continuous Deployment 6.4 When to use Automation tools6.5 Automation is suited to following types 6.6 Roles and Responsibilities 6.7 Systems of Record (SOR)
• and Systems of Engagement (SOE) 6.8 Test Data Management 6.9 The Agile DBA6.10 DevOps and the Database 6.11 Staffing Chapter 7. EvolutionSupport defined. Bureaucratic impediments. Types of support. Limited understanding. Lehman's Laws. Software Support Lifecycle (SMLC). Tribal knowledge.7.1 Support Defined 7.2 Processes, activities, and practices that are
• applicable to software Support: 7.3 About software Support 7.4 Support Personnel 7.5 Error Correction7.6 Bureaucratic Impediments 7.7 On the difficulty of correcting an error
• during Support: 7.8 Types of Support 7.9 Another View 7.10 Software Support Effort 7.11 Limited Understanding 7.12 Technical Problems 7.13 Forces for evolution7.14 Lehman's Laws 7.15 Model of the Software Support Lifecycle (SMLC) 7.16 The importance of 'Tribal Knowledge'Chapter 8. Risk ManagementA personal accounting of risks encountered in 35 years of software development. "Man month" is a unit of cost, not progress. 8.1 General Mayhem 8.2 Loss of Key Personnel - Missing a window of opportunity 8.3 Software Development always has a political dimension 8.4. Unrealistic Expectations. 8.5 Lack of a competent Project "Champion." 8.6 Missing Man 8.7 Keep documentation up to date. 8.8 Missing Tools - Loss of "Tribal Knowledge." 8.9 Missing Overview. 8.10 Lack of Quality Engineering measures 8.11 Lack of proper tools. 8.12 Over optimistic level of effort 8.13 "Man Month" is a unit of cost, not progress. 8.14 No tool alone will "fix" gaps in the business model 8.15 Learning what a tool does NOT do 8.16 Lack of appropriate skills 8.17 "Round Up the Usual Suspects!" 8.18 Necessary elements Chapter 9. Engineering Software QualitySoftware quality defined. Sofwware quality assurance (SQA) Configuration management. Test - continuous testing. Test driven development (TDD). The sum and intent of Software Quality Engineering.Software Quality defined9.1 Software Quality Assurance (SQA) 9.1.1 Ongoing Documentation 9.1.2 Data Flow Diagram (DFD)9.2 Configuration Management (CM) 9.2.1 Identification of Configuration Items 9.2.2 CMDB 9.2.3 Change Reports (CRpt) and Discrepancy Reports (DR) 9.2.4 The Hardware Configuration Inventory (HWCI) 9.2.5 Change Control 9.2.6 Status Accounting
• 9.3 Test 9.3.1 Test Driven Development (TDD) 9.3.2 Perform Test 9.3.3 Audits9.4 Data Related Quality Engineering 9.4.1 Conversion Plan9.5 Software Quality Engineering for Programming 9.6 The Sum and Intent of Software Quality Engineering Chapter 10. Final Remarks tbd Appendix 1. Attributes of Quality: International Organization for Standardization (ISO)Appendix 2. Summary of Standards, Guidelines and Procedures Appendix 3. Data Flow Diagramming: Symbols and Rules, An example Resources.
• (source: Nielsen Book Data)

The principal benefit this book is to provide a holistic and comprehensible view of the entire software development process, including ongoing evolution and support. It treats development as a collaborative effort with triad communication between a tester, a programmer, and a representative from the user community or a Subject Matter Expert (SME). Progress is measured by user acceptance in each cycle before proceeding to the next step of an activity. There is no test stage in the DPAC model: continuous testing is represented in the backswing (Check Phase) of each activity cycle. This approach posits that there exists some "happy path" that represents the intent of the project as declared by the objectives of a Vision Statement, and that this path can be revealed by an iterative and incremental process of "freeing the statue from the stone." As the image of this path unfolds, more waste is removed while retaining conceptual integrity. The example presented herein walks the reader through an application of the model. This book should be of great interest to Product and Project Managers new to the concept of a lean agile development effort, and all practitioners of an agile methodology or those considering or just beginning an agile journey. What You'll Learn See how the various disciplines constituting the software development process come together Understand where in the development process management, you can exercise measurement of progress and control Review how a quality engineering program will positively affect the quality of the development process Examine how the quality of the development process profoundly affects the quality of the software system Who This Book Is For Managers, from the C-Suite (CEO, CXO, CIO) to line managers including project managers, and practitioners including programmers, testers, and mid-level managers (Technical Project Managers, Software Quality Engineers, and Coaches). Also, Agile enthusiasts who are looking for a software development methodology on which to place their hat. .
(source: Nielsen Book Data)

• Introduction xxi Part I: The Foundations of Flutter Programming
• Chapter 1: Introducing Flutter and Getting Started 3 Introducing Flutter 4 Defining Widgets and Elements 5 Understanding Widget Lifecycle Events 5 The StatelessWidget Lifecycle 6 The StatefulWidget Lifecycle 6 Understanding the Widget Tree and the Element Tree 8 Stateless Widget and Element Trees 9 Stateful Widget and Element Trees 10 Installing the Flutter SDK 13 Installing on macOS 13 System Requirements 13 Get the Flutter SDK 13 Check for Dependencies 14 iOS Setup: Install Xcode 14 Android Setup: Install Android Studio 14 Set Up the Android Emulator 15 Installing on Windows 15 System Requirements 15 Get the Flutter SDK 16 Check for Dependencies 16 Install Android Studio 16 Set Up the Android Emulator 17 Installing on Linux 17 System Requirements 17 Get the Flutter SDK 18 Check for Dependencies 19 Install Android Studio 19 Set Up the Android Emulator 19 Configuring the Android Studio Editor 20 Summary 20
• Chapter 2: Creating a Hello World App 25 Setting Up the Project 25 Using Hot Reload 30 Using Themes to Style Your App 33 Using a Global App Theme 33 Using a Theme for Part of an App 35 Understanding Stateless and Stateful Widgets 37 Using External Packages 38 Searching for Packages 39 Using Packages 40 Summary 41
• Chapter 3: Learning Dart Basics 43 Why Use Dart? 43 Commenting Code 44 Running the main() Entry Point 45 Referencing Variables 45 Declaring Variables 46 Numbers 47 Strings 47 Booleans 47 Lists 47 Maps 48 Runes 48 Using Operators 49 Using Flow Statements 51 if and else 51 ternary operator 52 for Loops 52 while and do-while 53 while and break 54 continue 54 switch and case 55 Using Functions 55 Import Packages 57 Using Classes 57 Class Inheritance 60 Class Mixins 60 Implementing Asynchronous Programming 61 Summary 62
• Chapter 4: Creating a Starter Project Template 65 Creating and Organizing Folders and Files 65 Structuring Widgets 69 Summary 74
• Chapter 5: Understanding the Widget Tree 77 Introduction to Widgets 77 Building the Full Widget Tree 79 Building a Shallow Widget Tree 85 Refactoring with a Constant 86 Refactoring with a Method 86 Refactoring with a Widget Class 91 Summary 99 Part II: Intermediate Flutter: Fleshing Out an App
• Chapter 6: Using Common Widgets 103 Using Basic Widgets 103 SafeArea 107 Container 108 Text 112 RichText 112 Column 114 Row 115 Column and Row Nesting 115 Buttons 119 FloatingActionButton 119 FlatButton 121 RaisedButton 121 IconButton 122 PopupMenuButton 123 ButtonBar 126 Using Images and Icons 130 AssetBundle 130 Image 131 Icon 132 Using Decorators 135 Using the Form Widget to Validate Text Fields 139 Checking Orientation 143 Summary 149
• Chapter 7: Adding Animation to an App 151 Using AnimatedContainer 152 Using AnimatedCrossFade 155 Using AnimatedOpacity 160 Using AnimationController 164 Using Staggered Animations 170 Summary 175
• Chapter 8: Creating an App's Navigation 177 Using the Navigator 178 Using the Named Navigator Route 188 Using Hero Animation 188 Using the BottomNavigationBar 193 Using the BottomAppBar 199 Using the TabBar and TabBarView 203 Using the Drawer and ListView 207 Summary 217
• Chapter 9: Creating Scrolling Lists and Effects 221 Using the Card 222 Using the ListView and ListTile 223 Using the GridView 230 Using the GridView.count 230 Using the GridView.extent 232 Using the GridView.builder 233 Using the Stack 237 Customizing the CustomScrollView with Slivers 243 Summary 250
• Chapter 10: Building Layouts 253 A High-Level View of the Layout 253 Weather Section Layout 256 Tags Layout 256 Footer Images Layout 257 Final Layout 257 Creating the Layout 257 Summary 265
• Chapter 11: Applying Interactivity 267 Setting Up GestureDetector: The Basics 267 Implementing the Draggable and Dragtarget Widgets 275 Using the GestureDetector for Moving and Scaling 278 Using the InkWell and InkResponse Gestures 289 Using the Dismissible Widget 296 Summary 303
• Chapter 12: Writing Platform-Native Code 307 Understanding Platform Channels 307 Implementing the Client Platform Channel App 309 Implementing the iOS Host Platform Channel 313 Implementing the Android Host Platform Channel 318 Summary 322 Part III: Creating Production-Ready Apps
• Chapter 13: Saving Data with Local Persistence 327 Understanding the JSON Format 328 Using Database Classes to Write, Read, and Serialize JSON 330 Formatting Dates 331 Sorting a List of Dates 332 Retrieving Data with the FutureBuilder 333 Building the Journal App 335 Adding the Journal Database Classes 339 Adding the Journal Entry Page 344 Finishing the Journal Home Page 359 Summary 371
• Chapter 14: Adding The Firebase and Firestore Backend 375 What are Firebase and Cloud Firestore? 376 Structuring and Data Modeling Cloud Firestore 377 Viewing Firebase Authentication Capabilities 380 Viewing Cloud Firestore Security Rules 381 Configuring the Firebase Project 383 Adding a Cloud Firestore Database and Implementing Security 391 Building the Client Journal App 395 Adding Authentication and Cloud Firestore Packages to the Client App 395 Adding Basic Layout to the Client App 403 Adding Classes to the Client App 406 Summary 409
• Chapter 15: Adding State Management to the Firestore Client App 411 Implementing State Management 412 Implementing an Abstract Class 414 Implementing the InheritedWidget 415 Implementing the Model Class 416 Implementing the Service Class 417 Implementing the BLoC Pattern 417 Implementing StreamController, Streams, Sinks, and StreamBuilder 419 Building State Management 421 Adding the Journal Model Class 422 Adding the Service Classes 424 Adding the Validators Class 430 Adding the BLoC Pattern 432 Adding the AuthenticationBloc 432 Adding the AuthenticationBlocProvider 435 Adding the LoginBloc 436 Adding the HomeBloc 441 Adding the HomeBlocProvider 443 Adding the JournalEditBloc 444 Adding the JournalEditBlocProvider 447 Summary 449
• Chapter 16: Adding Blocs to Firestore Client App Pages 453 Adding the Login Page 454 Modifying the Main Page 460 Modifying the Home Page 465 Adding the Edit Journal Page 472 Summary 484 Index 489.
• (source: Nielsen Book Data)

Build your first app in Flutter-no experience necessary! Beginning Flutter: A Hands-On Guide to App Development is the essential resource for both experienced and novice developers interested in getting started with Flutter-the powerful new mobile software development kit. With Flutter, you can quickly and easily develop beautiful, powerful apps for both Android and iOS, without the need to learn multiple programming languages or juggle more than one code base. This book walks you through the process step by step. In Flutter, you'll be working with Dart, the programming language of choice for top app developers. Even if you're just starting out in your development career, you can learn Dart quickly, eliminating the barrier to entry for building apps. This is a more efficient way to develop and maintain cross-platform mobile apps, and this book makes the process even easier with a teach-by-example approach. Focus on providing quality content by eliminating the need to switch between multiple coding languages Learn the ins and outs of Flutter, including all the frameworks, widgets, and tools available to developers Accelerate your app development pace, keeping all the code for your cross-platform app in a single code base Leapfrog barriers to entry to the mobile software market, creating your first app with no experience necessary The Flutter community is growing rapidly and transforming the way Android and iOS apps get made. Beginning Flutter allows you to get on board with the latest app development technology, giving your mobile development career a big head start.
(source: Nielsen Book Data)

• Table of Contents Introduction to patterns Singleton, Dependency injection, Lazy initialization, Object pool Factory method, Abstract factory, Prototype, Builder Composite, Flyweight, Marker interface, Bridge Adapter, Proxy, Decorator, Facade Nullable value, Template method, Command, State Iterator, Visitor, Observer, Memento Lock patterns Thread pool, Messaging, Future, Pipeline Designing Delphi programs Other kinds of patterns.
• (source: Nielsen Book Data)

Get up to speed with creational, structural, behavioral and concurrent patterns in Delphi to write clear, concise and effective code Key Features Delve into the core patterns and components of Delphi in order to master your application's design Brush up on tricks, techniques, and best practices to solve common design and architectural challenges Choose the right patterns to improve your program's efficiency and productivity Book DescriptionDesign patterns have proven to be the go-to solution for many common programming scenarios. This book focuses on design patterns applied to the Delphi language. The book will provide you with insights into the language and its capabilities of a runtime library. You'll start by exploring a variety of design patterns and understanding them through real-world examples. This will entail a short explanation of the concept of design patterns and the original set of the 'Gang of Four' patterns, which will help you in structuring your designs efficiently. Next, you'll cover the most important 'anti-patterns' (essentially bad software development practices) to aid you in steering clear of problems during programming. You'll then learn about the eight most important patterns for each creational, structural, and behavioral type. After this, you'll be introduced to the concept of 'concurrency' patterns, which are design patterns specifically related to multithreading and parallel computation. These will enable you to develop and improve an interface between items and harmonize shared memories within threads. Toward the concluding chapters, you'll explore design patterns specific to program design and other categories of patterns that do not fall under the 'design' umbrella. By the end of this book, you'll be able to address common design problems encountered while developing applications and feel confident while building scalable projects. What you will learn Gain insights into the concept of design patterns Study modern programming techniques with Delphi Keep up to date with the latest additions and program design techniques in Delphi Get to grips with various modern multithreading approaches Discover creational, structural, behavioral, and concurrent patterns Determine how to break a design problem down into its component parts Who this book is forHands-On Design Patterns with Delphi is aimed at beginner-level Delphi developers who want to build scalable and robust applications. Basic knowledge of Delphi is a must.
(source: Nielsen Book Data)

• Table of Contents Introduction to fastlane and Continuous Deployment Setting up fastlane and Our Sample Project Manage Provisioning Profiles with sigh Manage Code Signing Certificates with cert Sync Profiles and Certificates with match Manage Push Notification Profiles with pem Creating Our iOS and Android Apps with produce and supply Build and Package Apps for the App Store with gym Distribute to Testers with TestFlight and Crashlytics Review your App metadata with Precheck Taking Localized Screenshots with snapshot Put Our Screenshots Inside Frames with Frameit Upload Screenshots and Metadata with deliver Automate Unit Tests with scan Integrating Git into the Fastlane Workflow Creating and Using fastlane Action Plugins Integrating Slack into the fastlane Workflow Continuous Delivery Best Practices.
• (source: Nielsen Book Data)

Learn continuous deployment and automation with code-signing, continuous testing, building, deploying, and releasing of your app. Key Features A practical guide on automating your mobile development pipeline with Fastlane, Jenkins, and Slack. Build, test, run and deploy your mobile application release with this end to end guide. Implement Continuous Integration, delivery, and deployment practices to optimize your application development workflow for faster and efficient release builds. Book DescriptionCompetitive mobile apps depend strongly on the development team's ability to deliver successful releases, consistently and often. Although continuous integration took a more mainstream priority among the development industry, companies are starting to realize the importance of continuity beyond integration and testing. This book starts off with a brief introduction to fastlane-a robust command-line tool that enables iOS and Android developers to automate their releasing workflow. The book then explores and guides you through all of its features and utilities; it provides the reader a comprehensive understanding of the tool and how to implement them. Themes include setting up and managing your certificates and provisioning and push notification profiles; automating the creation of apps and managing the app metadata on iTunes Connect and the Apple Developer Portal; and building, distributing and publishing your apps to the App Store. You will also learn how to automate the generation of localized screenshots and mesh your continuous delivery workflow into a continuous integration workflow for a more robust setup. By the end of the book, you will gain substantial knowledge on delivering bug free, developer-independent, and stable application release cycle. What you will learn Harness the fastlane tools for the Continuous Deployment strategy Integrate Continuous Deployment with existing Continuous Integration. Automate upload of screenshots across all device screen-sizes Manage push notifications, provisioning profiles, and code-signing certificates Orchestrate automated build and deployments of new versions of your app Regulate your TestFlight users and on-board new testers Who this book is forThis book is intended for mobile developers who are keen on incorporating Continuous integration and deployment practices in their workflow.
(source: Nielsen Book Data)

• Table of Contents Kotlin - Data types, Objects and Classes Getting started with Functional Programming Immutability: Its Importance Functions - Function Types and Side Effects More on Functions - Lambda, Generics, Recursions, Correcursion Delegates in Kotlin Asynchronous processing with Coroutines Collections and Data Operations in Kotlin Functional Programming and OOP and Reactive Programming Monads, Functors and Applicatives Working with Streams Getting Started with funKTionale Deeper Dive into funKTionale Monads & various Types Appendix.
• (source: Nielsen Book Data)

Learn how to apply Functional Programming with Kotlin to real-life projects with popular libraries like Arrow. Key Features Focus on the functional aspects of Kotlin and identify the advantages that functional programming brings to the table and the associated coding benefits. Implement common functional programming design patterns and techniques. Learn to combine OOP and Reactive Programming with Functional Programming and how RxKotlin and funkTionale can help you implementing Functional Programming in Kotlin Book DescriptionFunctional programming makes your application faster, improves performance, and increases your productivity. Kotlin supports many of the popular and advanced functional features of functional languages. This book will cover the A-Z of functional programming in Kotlin. This book bridges the language gap for Kotlin developers by showing you how to create and consume functional constructs in Kotlin. We also bridge the domain gap by showing how functional constructs can be applied in business scenarios. We'll take you through lambdas, pattern matching, immutability, and help you develop a deep understanding of the concepts and practices of functional programming. If you want learn to address problems using Recursion, Koltin has support for it as well. You'll also learn how to use the funKtionale library to perform currying and lazy programming and more. Finally, you'll learn functional design patterns and techniques that will make you a better programmer.By the end of the book, you will be more confident in your functional programming skills and will be able to apply them while programming in Kotlin. What you will learn Learn the Concepts of Functional Programming with Kotlin Discover the Coroutines in Kotlin Uncover Using funkTionale plugin Learn Monads, Functiors and Applicatives Combine Functional Programming with OOP and Reactive Programming Uncover Using Monads with funkTionale Discover Stream Processing Who this book is forKotlin developers who have no functional programming experience, will benefit from this book.
(source: Nielsen Book Data)

• Cover; Copyright; Credits; About the Author; Acknowledgment; About the Reviewers; www.PacktPub.com; Customer Feedback; Table of Contents; Preface; Chapter 1: Data Characteristics; Questionnaire and its components; Understanding the data characteristics in an R environment; Experiments with uncertainty in computer science; Installing and setting up R; Using R packages; RSADBE
• the books R package; Python installation and setup; Using pip for packages; IDEs for R and Python; The companion code bundle; Discrete distributions; Discrete uniform distribution; Binomial distribution.

• Hypergeometric distributionNegative binomial distribution; Poisson distribution; Continuous distributions; Uniform distribution; Exponential distribution; Normal distribution; Summary; Chapter 2: Import/Export Data; Packages and settings
• R and Python; Understanding data.frame and other formats; Constants, vectors, and matrices; Time for action
• understanding constants, vectors, and basic arithmetic; What just happened?; Doing it in Python; Time for action
• matrix computations; What just happened?; Doing it in Python; The list object; Time for action
• creating a list object.

• What just happened?The data.frame object; Time for action
• creating a data.frame object; What just happened?; Have a go hero; The table object; Time for action
• creating the Titanic dataset as a table object; What just happened?; Have a go hero; Using utils and the foreign packages; Time for action
• importing data from external files; What just happened?; Doing it in Python; Importing data from MySQL; Doing it in Python; Exporting data/graphs; Exporting R objects; Exporting graphs; Time for action
• exporting a graph; What just happened?; Managing R sessions.

• Time for action
• session managementWhat just happened?; Doing it in Python; Pop quiz; Summary; Chapter 3: Data Visualization; Packages and settings
• R and Python; Visualization techniques for categorical data; Bar chart; Going through the built-in examples of R; Time for action
• bar charts in R; What just happened?; Doing it in Python; Have a go hero; Dot chart; Time for action
• dot charts in R; What just happened?; Doing it in Python; Spine and mosaic plots; Time for action
• spine plot for the shift and operator data; What just happened?

• Time for action
• mosaic plot for the Titanic datasetWhat just happened?; Pie chart and the fourfold plot; Visualization techniques for continuous variable data; Boxplot; Time for action
• using the boxplot; What just happened?; Doing it in Python; Histogram; Time for action
• understanding the effectiveness of histograms; What just happened?; Doing it in Python; Have a go hero; Scatter plot; Time for action
• plot and pairs R functions; What just happened?; Doing it in Python; Have a go hero; Pareto chart; A brief peek at ggplot2; Time for action
• qplot; What just happened?

• Time for action
• ggplot.

Software Implementation Illustrated with R and Python About This Book * Learn the nature of data through software which takes the preliminary concepts right away using R and Python. * Understand data modeling and visualization to perform efficient statistical analysis with this guide. * Get well versed with techniques such as regression, clustering, classification, support vector machines and much more to learn the fundamentals of modern statistics. Who This Book Is For If you want to have a brief understanding of the nature of data and perform advanced statistical analysis using both R and Python, then this book is what you need. No prior knowledge is required. Aspiring data scientist, R users trying to learn Python and vice versa What You Will Learn * Learn the nature of data through software with preliminary concepts right away in R * Read data from various sources and export the R output to other software * Perform effective data visualization with the nature of variables and rich alternative options * Do exploratory data analysis for useful first sight understanding building up to the right attitude towards effective inference * Learn statistical inference through simulation combining the classical inference and modern computational power * Delve deep into regression models such as linear and logistic for continuous and discrete regressands for forming the fundamentals of modern statistics * Introduce yourself to CART - a machine learning tool which is very useful when the data has an intrinsic nonlinearity In Detail Statistical Analysis involves collecting and examining data to describe the nature of data that needs to be analyzed. It helps you explore the relation of data and build models to make better decisions. This book explores statistical concepts along with R and Python, which are well integrated from the word go. Almost every concept has an R code going with it which exemplifies the strength of R and applications. The R code and programs have been further strengthened with equivalent Python programs. Thus, you will first understand the data characteristics, descriptive statistics and the exploratory attitude, which will give you firm footing of data analysis. Statistical inference will complete the technical footing of statistical methods. Regression, linear, logistic modeling, and CART, builds the essential toolkit. This will help you complete complex problems in the real world. You will begin with a brief understanding of the nature of data and end with modern and advanced statistical models like CART. Every step is taken with DATA and R code, and further enhanced by Python. The data analysis journey begins with exploratory analysis, which is more than simple, descriptive, data summaries. You will then apply linear regression modeling, and end with logistic regression, CART, and spatial statistics. By the end of this book you will be able to apply your statistical learning in major domains at work or in your projects. Style and approach Developing better and smarter ways to analyze data. Making better decisions/future predictions. Learn how to explore, visualize and perform statistical analysis. Better and efficient statistical and computational methods. Perform practical examples to master your learning.
(source: Nielsen Book Data)

• Table of Contents A Brief Introduction to C++ Modern C++ concepts Measuring performance Data structures A deeper look at iterators STL Algorithms and Beyond Memory management Meta programming and compile time evaluation Proxy objects and lazy evaluation Concurrency Parallell STL.
• (source: Nielsen Book Data)

Write code that scales across CPU registers, multi-core, and machine clusters Key Features Explore concurrent programming in C++ Identify memory management problems Use SIMD and STL containers for performance improvement Book DescriptionC++ is a highly portable language and can be used to write both large-scale applications and performance-critical code. It has evolved over the last few years to become a modern and expressive language. This book will guide you through optimizing the performance of your C++ apps by allowing them to run faster and consume fewer resources on the device they're running on without compromising the readability of your code base. The book begins by helping you measure and identify bottlenecks in a C++ code base. It then moves on by teaching you how to use modern C++ constructs and techniques. You'll see how this affects the way you write code. Next, you'll see the importance of data structure optimization and memory management, and how it can be used efficiently with respect to CPU caches. After that, you'll see how STL algorithm and composable Range V3 should be used to both achieve faster execution and more readable code, followed by how to use STL containers and how to write your own specialized iterators. Moving on, you'll get hands-on experience in making use of modern C++ metaprogramming and reflection to reduce boilerplate code as well as in working with proxy objects to perform optimizations under the hood. After that, you'll learn concurrent programming and understand lock-free data structures. The book ends with an overview of parallel algorithms using STL execution policies, Boost Compute, and OpenCL to utilize both the CPU and the GPU. What you will learn Benefits of modern C++ constructs and techniques Identify hardware bottlenecks, such as CPU cache misses, to boost performance Write specialized data structures for performance-critical code Use modern metaprogramming techniques to reduce runtime calculations Achieve efficient memory management using custom memory allocators Reduce boilerplate code using reflection techniques Reap the benefits of lock-free concurrent programming Perform under-the-hood optimizations with preserved readability using proxy objects Gain insights into subtle optimizations used by STL algorithms Utilize the Range V3 library for expressive C++ code Parallelize your code over CPU and GPU, without compromising readability Who this book is forIf you're a C++ developer looking to improve the speed of your code or simply wanting to take your skills up to the next level, then this book is perfect for you.
(source: Nielsen Book Data)

Optimize and boost your Linux-based system with Yocto Project and increase its reliability and robustness efficiently and cost-effectively. About This Book * Optimize your Yocto Project tools to develop efficient Linux-based projects * Practical approach to learning Linux development using Yocto Project * Demonstrates concepts in a practical and easy-to-understand way Who This Book Is For If you are an embedded Linux developer with a basic knowledge of Yocto Project and want to broaden your knowledge with examples of embedded development, then this book is for you. This book is also for professionals who want to find new insights into working methodologies for Linux development. What You Will Learn * Understand the basic concepts involved in Poky workflows along with configuring and preparing the Poky build environment. * Configure a build server and customize images using Toaster. * Generate images and fit packages into created images using BitBake. * Support the development process by setting up and using Package feeds. * Debug Yocto Project by configuring Poky. * Build an image for the BeagleBone Black, RaspberryPi 3, and Wandboard, and boot it from an SD card. In Detail Yocto Project is turning out to be the best integration framework for creating reliable embedded Linux projects. It has the edge over other frameworks because of its features such as less development time and improved reliability and robustness. Embedded Linux Development using Yocto Project starts with an in-depth explanation of all Yocto Project tools, to help you perform different Linux-based tasks. The book then moves on to in-depth explanations of Poky and BitBake. It also includes some practical use cases for building a Linux subsystem project using Yocto Project tools available for embedded Linux. The book also covers topics such as SDK, recipetool, and others. By the end of the book, you will have learned how to generate and run an image for real hardware boards and will have gained hands-on experience at building efficient Linux systems using Yocto Project. Style and approach A clear, concise, and straightforward book that will enable you to use and implement the latest features of Yocto Project.
(source: Nielsen Book Data)

Discover real world scenarios for Proxmox troubleshooting and become an expert cloud builder About This Book * Formulate Proxmox-based solutions and set up virtual machines of any size while gaining expertise even on the most complex multi-cluster setups * Master the skills needed to analyze, monitor, and troubleshoot real-world virtual environments * This is the most up-to-date title on mastering Proxmox, with examples based on the new Linux Kernel 4.10.15 and Debian Stretch (9.x) Who This Book Is For This book is for Linux and system administrators and professionals working in IT teams who would like to design and implement an enterprise-quality virtualized environment using Proxmox. Some knowledge of networking and virtualization concepts is assumed. What You Will Learn * Install basic Proxmox VE nodes and get to know the Proxmox GUI * Get to know Proxmox's internal structure and mechanics * Create and manage KVM or LXC-based virtual machines * Understand advanced virtual networks * Configure high availability Proxmox nodes * Integrate Ceph big data storage with the Proxmox hypervisor * Plan a large virtual environment for cloud-based services * Discover real-world scenarios for Proxmox troubleshooting In Detail Proxmox is an open source server virtualization solution that has enterprise-class features for managing virtual machines, for storage, and to virtualize both Linux and Windows application workloads. You'll begin with a refresher on the advanced installation features and the Proxmox GUI to familiarize yourself with the Proxmox VE hypervisor. Then, you'll move on to explore Proxmox under the hood, focusing on storage systems, such as Ceph, used with Proxmox. Moving on, you'll learn to manage KVM virtual machines, deploy Linux containers fast, and see how networking is handled in Proxmox. You'll also learn how to protect a cluster or a VM with a firewall and explore the new high availability features introduced in Proxmox VE 5.0. Next, you'll dive deeper into the backup/restore strategy and see how to properly update and upgrade a Proxmox node. Later, you'll learn how to monitor a Proxmox cluster and all of its components using Zabbix. Finally, you'll discover how to recover Promox from disaster strikes through some real-world examples. By the end of the book, you'll be an expert at making Proxmox work in production environments with minimal downtime. Style and approach This book walks you through every aspect of virtualization using Proxmox using a practical, scenario-based approach that features best practices and all the weaponry you need to succeed when building virtual environments with Proxmox 5.0.
(source: Nielsen Book Data)

• Overview of Mobile Apps and Mobile Interface. Mobile Embedded System and Architecture. Introduction of Android Framework, Key Concepts, User Interface, and Multimedia Deployment. Network Management in Mobile Cloud Computing and Adaptive Resource Allocations. 2-D Graphics and Mobile Image Processing Techniques. Mobile Optimization by Dynamic Programming. Big Data and Hybrid Memory Implementations. Exploring Mobile Hardware and Software Coding Techniques. Secure Bluetooth Connection and Near Field Communication. Data Storage, data security, and advanced data protection techniques. Efficient Data Synchronization on Mobile Devices. Mobile Apps on Wearable Devices.
• (source: Nielsen Book Data)

• Mobile App Design and Development Skills
• Overview of Mobile App and Mobile Interface Mobile System Mobile Interface and Applications Mobile Cloud
• Quick Start on Android Installing Java nstalling Integrate Development Environment Installing Android SDK Creating an Android Application Android Virtual Device
• Introduction of Key Concepts of Android App Components App Resources App Mainfest
• 2D Graphics and Multimedia in Android Introduction of 2D Graphics Techniques Advanced UI Design Overview of Multimedia in Android Audio Implementations in Android Executing Video in Android
• Advanced Mobile App Optimizations
• Mobile Embedded System Architecture Embedded Systems Scheduling Algorithms Memory Technology Mobile Embedded Systems Messaging and Communication Mechanisms
• Data Storage and SQLite Operations Local Data SQLite Database Content Provider
• Mobile Optimization by Dynamic Programming Introduction of heterogeneous embedded systems and dynamic programming Fixed Time Model Probabilistic Time Model Nondeterministic Polynomial Time Problems
• Mobile Optimizations by Loop Scheduling Introduction Basic Graph Models and Techniques Fundamental Timing Optimizations Time and Power Optimizations with Loop Scheduling Conclusions
• Mobile Apps Techniques in Emerging Technologies
• Mobile Cloud Computing in Mobile Applications Deployment Introduction Concepts of Mobile Cloud Computing Main Techniques of Mobile Cloud Computing Mobile Cloud Computing Architecture
• Efficient Data Synchronization on Mobile Devices in Big Data Overview of Big Data Big Data Processing Mobile Big Data Storage Security and Privacy Issues Data Deduplication
• Appendices Appendix 1: Project 1 Appendix 2: Project 2 Appendix 3: BirthProvider.java. Codes.
• (source: Nielsen Book Data)

Mobile Applications Development with Android: Technologies and Algorithms presents advanced techniques for mobile app development, and addresses recent developments in mobile technologies and wireless networks. The book covers advanced algorithms, embedded systems, novel mobile app architecture, and mobile cloud computing paradigms. Divided into three sections, the book explores three major dimensions in the current mobile app development domain. The first section describes mobile app design and development skills, including a quick start on using Java to run an Android application on a real phone. It also introduces 2D graphics and UI design, as well as multimedia in Android mobile apps. The second part of the book delves into advanced mobile app optimization, including an overview of mobile embedded systems and architecture. Data storage in Android, mobile optimization by dynamic programming, and mobile optimization by loop scheduling are also covered. The last section of the book looks at emerging technologies, including mobile cloud computing, advanced techniques using Big Data, and mobile Big Data storage. About the Authors Meikang Qiu is an Associate Professor of Computer Science at Pace University, and an adjunct professor at Columbia University. He is an IEEE/ACM Senior Member, as well as Chair of the IEEE STC (Special Technical Community) on Smart Computing. He is an Associate Editor of a dozen of journals including IEEE Transactions on Computers and IEEE Transactions on Cloud Computing. He has published 320+ peer-reviewed journal/conference papers and won 10+ Best Paper Awards. Wenyun Dai is pursuing his PhD at Pace University. His research interests include high performance computing, mobile data privacy, resource management optimization, cloud computing, and mobile networking. His paper about mobile app privacy has been published in IEEE Transactions on Computers. Keke Gai is pursuing his PhD at Pace University. He has published over 60 peer-reviewed journal or conference papers, and has received three IEEE Best Paper Awards. His research interests include cloud computing, cyber security, combinatorial optimization, business process modeling, enterprise architecture, and Internet computing. .
(source: Nielsen Book Data)

• Cover
• Copyright
• Credits
• About the Author
• About the Reviewer
• www.PacktPub.com
• Customer Feedback
• Table of Contents
• Preface
• Chapter 1: Starting with the Protocol
• Protocol syntax
• Defining a protocol
• Property requirements
• Method requirements
• Optional requirements
• Protocol inheritance
• Protocol composition
• Using protocols as a type
• Polymorphism with protocols
• Type casting with protocols
• Associated types with protocols
• Delegation
• Designing with protocols

• Protocols in the Swift standard librarySummary
• Chapter 2: Our Type Choices
• Classes
• Structures
• Access controls
• Enumerations
• Tuples
• Protocols
• Value and reference types
• Recursive data types for reference types only
• Inheritance for reference types only
• Dynamic dispatch
• Swift's built-in types
• Copy-on-write
• Summary
• Chapter 3: Extensions
• Defining an extension
• Protocol extensions
• Text validation
• Extensions with the Swift standard library
• Conforming to the Equatable protocol
• Summary

• Chapter 4: GenericsGeneric functions
• Type constraints with Generics
• Generic types
• Associated types
• Generic subscripts
• Copy-on-write
• Generics in a protocol-oriented design
• Generics in the Swift standard library
• Summary
• Chapter 5: Object-Oriented Programming
• What is object-oriented programming?
• Requirements for the sample code
• Swift as an object-oriented programming language
• Issues with the object-oriented design
• Summary
• Chapter 6: Protocol-Oriented Programming
• Requirements for the sample code

• Swift as a protocol-oriented programming languageSummarizing protocol-oriented programming and object-oriented programming
• Differences between object-oriented programming and protocol-oriented programming
• Protocol and protocol extensions compared with superclasses
• Implementing vehicle types
• Using value and reference types
• The winner is ...
• Summary
• Chapter 7: Adopting Design Patterns in Swift
• What are design patterns?
• Creational patterns
• The singleton design pattern
• Understanding the problem
• Understanding the solution

• Implementing the singleton patternThe builder design pattern
• Understanding the problem
• Understanding the solution
• Implementing the builder pattern
• The factory method pattern
• Understanding the problem
• Understanding the solution
• Implementing the factory method pattern
• Structural design patterns
• The bridge pattern
• Understanding the problem
• Understanding the solution
• Implementing the bridge pattern
• The facade pattern
• Understanding the problem
• Understanding the solution
• Implementing the facade pattern

Build fast and powerful applications by harnessing the power of protocol-oriented programming in Swift 4 About This Book * Leverage the power of protocol-oriented programming in your applications and learn from real-world use cases * Create a flexible code base with protocols and protocol extensions * Leverage the power of generics in Swift 4 to create very flexible frameworks Who This Book Is For This book is for Swift developers who want to learn and implement protocol-oriented programming in their real-world applications.. What You Will Learn * Understand the differences between object-oriented programming and protocol-oriented programming * Explore the different types that Swift offers and what pitfalls to avoid * Delve into generics and generic programming * Learn how to implement Copy-On-Write within your custom types * Implement several design patterns in a protocol-oriented way * Design applications by prioritizing the protocol first and the implementation types second In Detail Swift has become the number one language used in iOS and macOS development. The Swift standard library is developed using protocol-oriented programming techniques, generics, and first-class value semantics; therefore, every Swift developer should understand these powerful concepts and how to take advantage of them in their application design. This book will help you understand the differences between object-oriented programming and protocol-oriented programming. It will demonstrate how to work with protocol-oriented programming using real-world use cases. You will gain a solid knowledge of the various types that can be used in Swift and the differences between value and reference types. You will be taught how protocol-oriented programming techniques can be used to develop very flexible and easy-to-maintain code. By the end of the book, you will have a thorough understanding of protocol-oriented programming and how to utilize it to build powerful and practical applications. Style and approach This book is written for developers who learn best by working with code, so every concept discussed in this book is reinforced with real code examples.
(source: Nielsen Book Data)

• Intro
• Table of Contents
• About the Author
• About the Technical Reviewer
• Source Code
• Acknowledgments
• Chapter 1: Introduction
• 1.1 A Brief History of Web Service Hosting
• 1.1.1 The Old Way
• 1.1.2 The Virtual Private Server
• 1.1.3 From Virtual Private Servers to Containers
• 1.1.4 Cloud Native Infrastructure
• 1.2 An Overview of This Book
• 1.3 Prerequisites
• 1.4 Typographical Conventions
• Part I: An Introduction to Containers
• Chapter 2: Containers Under the Hood
• 2.1 Answering Basic Questions About Containers
• 2.1.1 What Are Containers?

• 2.1.2 What Problems Do Containers Solve?
• 2.1.3 Does It Use a Lot of Disk Space?
• 2.1.4 What Is the Relationship Between "Docker" and "Containers"?
• 2.2 A Short History of Container Technology
• 2.2.1 From Emulators to Virtual Machines
• 2.2.2 Increasing Isolation Inside the Operating System
• 2.2.3 The Birth of Containers
• 2.2.4 The Union Filesystem
• 2.2.5 The Rise of Docker
• 2.3 Summary
• Chapter 3: A Docker Interactive Tutorial
• 3.1 Registries, Repositories, and Tags
• 3.2 Running Your First Container
• 3.3 Running a Docker Service
• 3.4 Running a Whole Operating System

• 3.5 Copying Files to and from the Container
• 3.6 Creating a New Docker Image
• 3.7 Creating Docker Images Using a Recipe
• 3.8 Pushing the Image to Docker Hub
• 3.9 Logging into a Running Docker Container
• 3.10 Summary
• Chapter 4: Best Practices for Building Containers
• 4.1 How Not to Build a Container
• 4.1.1 Don't Make a Container Perform Multiple Tasks
• 4.1.2 Don't Include an Entire Operating System
• 4.2 Base Images
• 4.3 Alpine Distributions
• 4.4 Avoid Bloated Images from Deleted Files
• 4.5 Make Your Containers Configurable
• 4.6 Be Clear About Your Statefulness

• 4.7 Final Tips
• 4.8 Summary
• Part II: Introducing Kubernetes
• Chapter 5: The Cloud Native Philosophy
• 5.1 Cloud-Level Operating System
• 5.2 Declarative Infrastructure
• 5.3 Containers Are "Cattle" Not "Pets"
• 5.4 A Note on Costs
• 5.5 Summary
• Chapter 6: Getting Started with Kubernetes
• 6.1 Setting Up Your First Cluster
• 6.2 Deploying Your First Application
• 6.3 Looking Around the Kubernetes Dashboard
• 6.4 Summary
• Chapter 7: Managing Kubernetes with kubectl
• 7.1 Setting Up Your Connection
• 7.2 Basic kubectl Commands
• 7.3 Playing with kubectl

• 7.4 Creating Another Deployment with kubectl
• 7.5 Accessing Multiple Clusters
• 7.6 Summary
• Chapter 8: An Overview of the Kubernetes Environment
• 8.1 Basic Kubernetes Components
• 8.1.1 The Control Plane
• 8.1.2 Nodes and Pods
• 8.1.3 Workloads
• 8.1.4 Kubernetes Services
• 8.1.5 CoreDNS
• 8.1.6 The Structure of a Pod
• 8.2 Kubernetes Storage
• 8.3 Configuring a Kubernetes Cluster
• 8.4 Application Interaction with Kubernetes
• 8.5 Summary
• Chapter 9: Basic Kubernetes Management
• 9.1 Infrastructure as Code
• 9.2 A Short Introduction to YAML

This book takes developers on a journey into the cloud with Docker and Kubernetes. It walks you through the basics of Docker containers, how they are built, run, and published, and how the Kubernetes system allows you to use containers to better manage a cloud native application. Additionally, it walks you through various issues in cloud architecture, and how to design a cloud architecture that will work with your application and your team. The book takes a unique approach, getting you immersed in each subject with tutorials, then building up your technical knowledge, and finally backing up and thinking about more big-picture issues. Part one introduces Docker, building and working with Docker images, and covering best practices for Docker Containers. Part two covers the practicalities of "cloud native" and managing a Kubernetes application, including a full working example. The last part covers the design of cloud and microservice architectures, including the use of enterprise message queues, multi-site configurations and the common values that such architectures follow. This approach accelerates learning and keeps you moving forward without leaving you behind. The appendices also contain a wealth of worthwhile reference material for routine cloud application management.

• Preface
• Chapter 1 - The Dawning of Digital Era
• Chapter 2 - Leveraging the Cloud-Native Computing Model for the Digital Era
• Chapter 3 - Kubernetes Architecture, Best Practices and Patterns
• Chapter 4 - The Resiliency and Observability Aspects of Cloud-native Applications
• Chapter 5 - Creating Kubernetes Clusters on Private Cloud (VMware vSphere)
• Chapter 6: Creating Kubernetes Clusters on Public Cloud (Microsoft Azure)
• Chapter 7: Design, Development and Deployment of Event-driven Microservices Practically
• Chapter 8 - Serverless Computing for the Cloud-native Era
• Chapter 9 - Demonstrating a Serverless Application using Knative on a Kubernetes Cluster
• Chapter 10 - Delineating Cloud-native Edge Computing
• Chapter 11 - Setting up a Kubernetes Cluster using Azure Kubernetes Service (AKS)
• Chapter 12 - Reliable Cloud-native Applications through Service Mesh
• Chapter 13 - Cloud-native Computing: The Security Challenges and the Solution Approaches
• Chapter 14 - Microservices Security: The Concerns and the Solution Approaches
• Chapter 15 - Apache Kafka: Setup, Monitor and Secure Kubernetes cluster.
• (source: Nielsen Book Data)

Explore the cloud-native paradigm for event-driven and service-oriented applications In Cloud-Native Computing: How to Design, Develop, and Secure Microservices and Event-Driven Applications, a team of distinguished professionals delivers a comprehensive and insightful treatment of cloud-native computing technologies and tools. With a particular emphasis on the Kubernetes platform, as well as service mesh and API gateway solutions, the book demonstrates the need for reliability assurance in any distributed environment. The authors explain the application engineering and legacy modernization aspects of the technology at length, along with agile programming models. Descriptions of MSA and EDA as tools for accelerating software design and development accompany discussions of how cloud DevOps tools empower continuous integration, delivery, and deployment. Cloud-Native Computing also introduces proven edge devices and clouds used to construct microservices-centric and real-time edge applications. Finally, readers will benefit from: Thorough introductions to the demystification of digital transformation Comprehensive explorations of distributed computing in the digital era, as well as reflections on the history and technological development of cloud computing Practical discussions of cloud-native computing and microservices architecture, as well as event-driven architecture and serverless computing In-depth examinations of the Akka framework as a tool for concurrent and distributed applications development Perfect for graduate and postgraduate students in a variety of IT- and cloud-related specialties, Cloud-Native Computing also belongs in the libraries of IT professionals and business leaders engaged or interested in the application of cloud technologies to various business operations.
(source: Nielsen Book Data)