%{search_type} search results

• Introduction xix Acknowledgments xxvii About the Author xxix
• Part I: An App Engine Overview 1
• Chapter 1: Setting Up a Development Environment 3 Working with Eclipse Tools 3 Deploying from the Command Line 14 Summary 16
• Chapter 2: Improving App Engine Performance 17 Performing in the Cloud 17 Measuring the Cost of Class Loading 18 Avoiding Cold Startups 24 Improving Performance in General 25 Summary 27
• Part II: Application Design Essentials 29
• Chapter 3: Understanding the Anatomy of a Google App Engine Application 31 Uploading Files for Dynamic Deployment 31 Setting Up the Directory Structure 33 Configuring the Administration Panel 41 Summary 44
• Chapter 4: Data Modeling for the Google App Engine Datastore 45 Moving Away from Relational Storage 45 Modeling Data 47 Working with Data 52 Summary 55
• Chapter 5: Designing Your Application 57 Gathering Requirements 57 Choosing a Toolkit 58 Making Design Choices 61 Summary 65
• Part III: User Interface Design Essentials 67
• Chapter 6: Presenting the User Interface with HTML5 69 Introducing HTML5 69 Using Basic HTML5 Elements 70 Drawing Images Using the Canvas 72 Dragging and Dropping Items into Pages 74 Improving Form Elements 76 Detecting a User's Geolocation 77 Storing Data on the Client Side 78 Summary 83
• Chapter 7: Fine-Tuning the Layout Using CSS3 85 Selecting Elements Using CSS3 85 Using New Graphical Effects in CSS3 92 Summary 98
• Chapter 8: Adding Static Interactions Using JavaScript 99 Setting Up a Simplistic Example 99 Cleaning Up HTML Using Unobtrusive JavaScript 102 Reducing JavaScript Dependence by Progressively Enhancing the HTML 106 Optimizing Performance Using Event Delegation 109 Avoiding Global Variables 110 Summary 112
• Chapter 9: Adding Dynamic Interactions Using AJAX 113 Using Classic AJAX without Frameworks 113 Using Google App Engine's Channel API 120 Summary 125
• Part IV: Using Common App Engine APIs 127
• Chapter 10: Storing Data in the Datastore and Blobstore 129 Processing Data Synchronously 129 Processing Data Asynchronously 136 Setting Up Transactions 141 Using Multitenancy to Introduce Namespaces 144 Storing and Retrieving Large Files 146 Uploading Bulk Data Using the Remote API 151 Summary 153
• Chapter 11: Sending and Receiving E-Mail 155 Sending Confirmation E-Mails with HTML and Attachments 155 Receiving E-Mail 161 Considering Performance and Quota 167 Summary 169
• Chapter 12: Running Background Work with the Task Queue API and Cron 171 Task Queuing 171 Scheduling Tasks Using Cron 180 Reading HTTP Headers 182 Summary 185
• Chapter 13: Manipulating Images with the App Engine Image Service 187 Minimizing the Use of the Image API 187 Reading and Writing Images 187 Performing Simple Manipulations 195 Performing Advanced Manipulations 198 Summary 201
• Chapter 14: Optimizing Performance Using the Memory Cache 203 Using the Cache API for Basic Purposes 203 Implementing a Caching Strategy 206 Working with Fine-Grained Cache 209 Maintaining a Cache 210 Using Other Cache Utility Methods 213 Using JSR 107 as an Alternative API 214 Summary 214
• Chapter 15: Retrieving External Data Using URL Fetch 215 Reading URLs Using GET Requests 215 Reading Results 218 Adding Options to URL Fetch 219 Posting Form Data 223 Fetching URLs Asynchronously 224 Consuming Web Services 226 Considering Security 226 Summary 227
• Chapter 16: Securing a Web Application Using Google Accounts, OpenID, and OAuth 229 Authenticating Users with Google Accounts 229 Authenticating Users with OpenID 232 Providing Access to Third Parties Using OAuth 235 Securing URLs in web.xml 237 Security Considerations 239 Summary 240
• Chapter 17: Sending and Receiving Messages Using XMPP 241 Sending Messages Using XMPP 241 Receiving Messages Using XMPP 244 Receiving Subscriptions 246 Receiving Presence 249 Summary 251
• Part V: Application Deployment 253
• Chapter 18: Improving the Development Process 255 Optimizing the Development Process for the Internet 255 Thinking Like a Project Manager 256 Reducing Overhead 256 Improving Functionality 258 Measuring Quality 260 Optimizing Developer Productivity 261 Summary 262
• Chapter 19: Assuring Quality Using Measuring Tools 263 Testing on a Production Environment 263 Thinking Differently about Usability 265 Checking Availability with the Capabilities API 265 Logging Unexpected Behavior 269 Profiling Continuously on Production 271 Measuring User Response to Your Interface 273 Summary 275
• Chapter 20: Selling Your Application 277 Determining How to Approach Sales 277 Knowing Your Audience 277 Reaching Your Audience 278 Converting Prospects into Paying Customers 286 Handling the Payment Process 286 Summary 287
• Index 289.
• (source: Nielsen Book Data)

In Essential App Engine, Adriaan de Jonge shows Java developers how to rapidly build complex, productionquality, performance-driven cloud applications with Google App Engine. Using a start-to-finish case study and extensive Java example code, De Jonge covers the entire lifecycle, from application design and data modeling through security, testing, and deployment. De Jonge introduces breakthrough techniques for creating applications that respond within two seconds, even on cold startup, and allow server responses in hundreds of milliseconds or less throughout the rest of the session. He also demonstrates how to avoid common mistakes that can dramatically reduce cloud application performance and scalability. He thoroughly covers state-of-the-art user interface development and shows how to make the most of Google App Engine's extensive set of APIs. Coverage includes Setting up a development environment that makes it easy to continually address performance Understanding the anatomy of a Google App Engine application Making the right technical setup and design choices for each new application Efficiently modeling data for App Engine's NoSQL data storage Recognizing when to avoid OR-mapping and pass datastore entities directly to HTML templates Finding alternatives to frameworks and libraries that impair App Engine performance Using JavaScript and AJAX on the client side of your cloud applications Improving browser performance and reducing resource consumption via better use of HTML5 and CSS3 Taking advantage of key App Engine APIs: datastore, blobstore, mail, task scheduling, memory caching, URL retrieval, and messaging Securing cloud-based Web applications with Google Accounts, OpenID, and OAuth Improving your cloud development, quality assurance, and deployment processes Targeting, marketing, and selling cloud solutions, from planning to payment handling.
(source: Nielsen Book Data)

This IBM Redbook will help you plan and execute the migration of J2EE 1.3 applications developed for BEA WebLogic Server 8.1, JBoss 3.2.7 and Apache Tomcat 5.5.9, so that they will run on WebSphere Application Server V6. This redbook provides detailed information to help you plan migrations, best practices for developing portable applications as well as migration working examples for each of the platforms from which we migrated. It is not our intention to provide a feature-by-feature comparison of BEA WebLogic Server 8.1, JBoss 3.2.7 and Apache Tomcat 5.5.9 versus WebSphere Application Server V6, nor to argue the relative merits of the products, but to produce practical technical advice for developers who have to migrate applications from these vendors to WebSphere Application Server V6.

What will you learn from this book? If you have an idea for a killer Android app, this fully revised and updated edition will get you up and running in a jiffy. You'll go beyond syntax and how-to manuals and learn how to think like a great Android developer. This hands-on book teaches you everything from designing layouts to the latest features of Android Jetpack, including the Room persistence library, LiveData and the Navigation component. It's like having an experienced Android developer sitting right next to you! If you have some Kotlin know-how, you're ready to get started. Why does this book look so different? Based on the latest research in cognitive science and learning theory, Head First Android Development 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.
(source: Nielsen Book Data)

• 1. The Mise en Place Philosoph
• y2. Configuring Our Workspac
• e3. Our First Storybook Storie
• s4. Creating Reusable Component
• s5. Stylin
• g6. Ensuring the Quality of Our Component
• s7. Interacting with API Dat
• a8. Building Our Applicatio
• n9. Automating Repetitive Task
• s10. Communicating Our Components.
• (source: Nielsen Book Data)

Learn how to build front-end applications that can help you ship applications faster with fewer defects. Many software projects fail because they are not planned well, or lack organization. Applying strategies from other industries can help you create better software. This book explores the "mise en place" technique from cooking and reveals how you can apply it to the art of creating software. In many professional kitchens, the work of preparing a meal is divided and performed in workstations to help create the whole. You'll review the philosophy behind this and see how to leverage this approach in your code. You'll also learn to visualize your applications as a series of components and build parts of your application in isolation - just like a professional chef crafting each part of the meal. The book describes to how to structure your code base for reuse, and how to communicate the code's intent to other developers. You'll develop your components in isolation and test these building blocks for quality at a granular level. Then compose these components as building blocks in increasingly complicated features. Finally, you'll apply some strategies not directly related to code to ensure maximum quality and efficiency. With Modern Front-end Architecture, developers of all levels will learn strategies that they and their teams can leverage to be more productive. What You'll Learn Structure an application as a series of components Build a component library that others in an organization can leverage Ensure quality and accessibility at a component level rather than a page or app level Test code in a way that gives the maximum amount of confidence while providing an excellent developer experience Automate repeatable tasks Who This Book Is For Front end developers looking to maximize their code for reuse, quality, and shipping features quickly. Experienced developers will pick up new techniques that they can apply to their code base. Less experienced developers will be able to start applications off on the right foot. .
(source: Nielsen Book Data)

• Intro
• inside front cover
• Pipeline as Code
• Copyright
• brief contents
• contents
• front matter
• preface
• acknowledgments
• about this book
• Who should read this book
• How this book is organized
• About the code
• liveBook discussion forum
• Other online resources
• about the author
• about the cover illustration
• Part 1. Getting started with Jenkins
• 1 What's CI/CD?
• 1.1 Going cloud native
• 1.1.1 Monolithic
• 1.1.2 Microservices
• 1.1.3 Cloud native
• 1.1.4 Serverless
• 1.2 Defining continuous integration
• 1.3 Defining continuous deployment

• 1.4 Defining continuous delivery
• 1.5 Embracing CI/CD practices
• 1.6 Using essential CI/CD tools
• 1.6.1 Choosing a CI/CD tool
• 1.6.2 Introducing Jenkins
• Summary
• 2 Pipeline as code with Jenkins
• 2.1 Introducing the Jenkinsfile
• 2.1.1 Blue Ocean plugin
• 2.1.2 Scripted pipeline
• 2.1.3 Declarative pipeline
• 2.2 Understanding multibranch pipelines
• 2.3 Exploring the GitFlow branch model
• 2.4 Test-driven development with Jenkins
• 2.4.1 The Jenkins Replay button
• 2.4.2 Command-line pipeline linter
• 2.4.3 IDE integrations
• Summary

• Part 2. Operating a self-healing Jenkins cluster
• 3 Defining Jenkins architecture
• 3.1 Understanding master-worker architecture
• 3.2 Managing Jenkins workers
• 3.2.1 SSH
• 3.2.2 Command line
• 3.2.3 JNLP
• 3.2.4 Windows service
• 3.3 Architecting Jenkins for scale in AWS
• 3.3.1 Preparing the AWS environment
• 3.3.2 Configuring the AWS CLI
• 3.3.3 Creating and managing the IAM user
• Summary
• 4 Baking machine images with Packer
• 4.1 Immutable infrastructure
• 4.2 Introducing Packer
• 4.2.1 How does it work?
• 4.2.2 Installation and configuration

• 4.2.3 Baking a machine image
• 4.3 Baking the Jenkins master AMI
• 4.3.1 Configuring Jenkins upon startup
• 4.3.2 Discovering Jenkins plugins
• 4.4 Baking the Jenkins worker AMI
• Summary
• 5 Discovering Jenkins as code with Terraform
• 5.1 Introducing infrastructure as code
• 5.1.1 Terraform usage
• 5.2 Provisioning an AWS VPC
• 5.2.1 AWS VPC
• 5.2.2 VPC subnets
• 5.2.3 VPC route tables
• 5.2.4 VPC bastion host
• 5.3 Setting up a self-healing Jenkins master
• 5.4 Running Jenkins with native SSL/HTTPS
• 5.5 Dynamically autoscaling the Jenkins worker pool

• 5.5.1 Launch configuration
• 5.5.2 Auto Scaling group
• 5.5.3 Autoscaling scaling policies
• 5.5.4 Workers CPU utilization load
• Summary
• 6 Deploying HA Jenkins on multiple cloud providers
• 6.1 Google Cloud Platform
• 6.1.1 Building Jenkins VM images
• 6.1.2 Configuring a GCP network with Terraform
• 6.1.3 Deploying Jenkins on Google Compute Engine
• 6.1.4 Launching automanaged workers on GCP
• 6.2 Microsoft Azure
• 6.2.1 Building golden Jenkins VM images in Azure
• 6.2.2 Deploying a private virtual network
• 6.2.3 Deploying a Jenkins master virtual machine

"Don't setup the build pipeline with clicks, read this bookinstead and thank me later!" - Michal Rutka Learn how to think about your development pipeline as amission-critical application, with techniques for implementing code-driven infrastructure and CI/CD systems using Jenkins, Docker, Terraform, andcloud-native services. In Pipeline as Code, you will master: * Building and deploying a Jenkins cluster from scratch * Writing pipeline as code for cloud native applications * Automating the deployment of Dockerized and Serverless applications * Containerizing applications with Docker and Kubernetes * Deploying Jenkins on AWS, GCP and Azure * Managing, securing and monitoring a Jenkins cluster in production * Key principles for a successful DevOps culture Pipeline as Code is a practical guide to automating your development pipeline in a cloud-native, service-driven world. You'll use the latest infrastructure-as-code tools like Packer and Terraform to develop reliable CI/CD pipelines for numerous cloud-native applications. Follow thisbook's insightful best practices, and you'll soon be delivering software that's quicker to market, faster to deploy, and with less last-minute production bugs. about the technology A good deployment pipeline is the backbone of successful DevOps. Using tools such as Jenkins, CI/CD can seamlessly manage the code of multiple developers, with early accuracy checks and error spotting thanks to automated testing. about the book Pipeline as Code teaches you to build your very first CI/CDpipeline with new automation technologies, modern cloud-hosted services, andclassic tools like Jenkins. It's filled with techniques that author and Jenkins contributor Mohamed Labouardy has developed maintaining thousands of production services. Each chapter includes relevant hands-on examples, including writing a CI/CD workflow for serverless AWS Lambda-based applications, and deploying a centralized logging platform based on the ELK stack. You'll explore cutting-edge methods of running Jenkins inside Kubernetes, and packaging Kubernetes applications within CI/CD pipelines. By the time you're done, you'llbe able to deploy a self-healing Jenkins cluster on cloud and take advantage ofyour new pipeline with essential DevOps practices. about the reader For developers familiar with Jenkins and Docker. Examples in Go. about the author Mohamed Labouardy is the CTO and co-founder of Crew.work, and aDevSecOps evangelist. He is the founder of Komiser.io, an author, open-source contributor, and regular conference speaker.
(source: Nielsen Book Data)

• 1. Getting Ahead in React
• 2. Getting Started with Node Package Manager
• 3. Getting Started with React Function Components and Typescript
• 4. Setting Up an Enterprise-level App
• 5. Navigating the React Router
• 6. Writing Local State, Sending HTTP Requests, & ApexCharts
• 7. Writing Data Tables, Formik Forms, and Yup Validations
• 8. Writing Data Tables, Formik Forms, and Yup Validations
• Part 2
• 9. Managing State Using Redux with Redux Toolkit
• 10. Setting Up Redux Toolkit and Dispatching an Asynchronous Action
• 11. Creating, Deleting, and Updating Events on FullCalendar Using RTK
• 12. Protecting Routes and Authentication in React
• 13. Writing Profile Form and Syncing Profile to Components
• 14. Updating the Dashboard Sidebar Navigation
• 15. Creating the Notifications, Security, and Subscription Pages
• 16. Making the App Mobile-Friendly
• 17. Styling Methods for React Components
• 18. Deploying React in Netlify and in Docker
• 19. Reusing React Skills in Other Platforms and Frameworks.

Learn to write a real-world enterprise app using the fundamentals of React and the most popular React libraries. Knowing the basics of React is important, but what is more important is knowing the common third-party libraries and how to use them. The book is perfect for intermediate to experienced React developers or busy React developers who would like to get things done and have maintainable React code. Practical Enterprise React features popular libraries such as React Router v6 for route navigation, Redux with Saga and Thunk for state management, and Formik with Yup for form and input validations. You'll also work with Material UI 5 (the next major version of the most popular UI component library in React), Axios as the HTTP client library, JWT auth for client app authentication, and TypeScript. Finally, you'll learn to deploy the app to Netlify, and containerize the React app to ship it as a standalone container instance or in a Kubernetes cluster. Become a more effective React developer by using what is available out there instead of trying to reinvent the wheel. This book reveals how to save time and money, and build better apps for your clients. Get practical with React enterprise app development and enhance your career. You will: Use TypeScript in React and React Hooks Work with Redux Toolkit, and TypeScript Build an inventory dashboard, charts, and calendar Write forms with Formik Validate inputs with Yup Use Material UI for fast user interface building Secure your React app by building a login form and protecting the routes.

• 1. Learn the Basics
• 2. Starter React Project & Friends
• 3. React Components
• 4. React Router and Material-UI
• 5. State Management
• 6. MERN Stack- Part I
• 7. MERN Stack-Part II
• 8. React Deployment- MERN Stack
• 9. Testing Part I- Unit Test Your React App
• 10. Testing Part II- Development & Deployment Cycle
• 11. Debug & Profile Your React App
• 12. Optimize Your React App.
• (source: Nielsen Book Data)

Harness the power of React and the related libraries that you need to know to deliver successful front-end implementations. Whether you are a beginner getting started or an existing React developer, this book will provide you with the must-have knowledge you need in your toolbox to build a complete app. Start by learning how to create and style your own components, add state management, and manage routing. You'll also learn how to work with the backend using the MERN stack (MongoDB, Express, React, and Node.js). Once you have completed building your app you will learn how to deliver quality software by conducting unit testing, integration testing, and end-to-end (E2E) testing, as well as learn techniques to debug, profile, and optimize your React app. Libraries and tools covered include TypeScript, Material-UI, Styled Components, SCSS, React Router, Redux Toolkit, Recoil, Jest, Enzyme, Sinon, MongoDB, NodeJS, Express, Serve, Grunt, Puppeteer, ESLint, Prettier and many others. And, you'll get access to bonus material and learn how to conduct and nail React interview questions. Each chapter in this book can be used independently so you can pick and choose the information you'd like to learn. Use it to get deep into your React development world and find out why React has been rated the most loved framework by front-end developers for three years in a row. What You'll Learn Review the basics of DOM, React Virtual DOM, JSX, Babel, ES5/ES6, CRA, package manager, Yarn, Webpack, and build tools Write your own custom React components and learn about hooks and props. Apply routing and state management with React Route, Recoil, and Redux Toolkit Deliver quality software and reduce QA load by learning unit testing integration testing and end-to-end testing with libraries such as Jest, Jest-dom, Enzyme, Sinon, and Puppeteer Set an ultimate React automated development and CI cycle with ESLint, Prettier, Husky, Jest, Puppeteer, GitHub Actions, Codecov.io, Coveralls, Travis, and DeepScan Publish your code on Ubuntu Server with the help of Grunt Optimize your React app with pure components, lazy loading, prerender, precache, code splitting, tree shaking, reduce media size, and prefetching Who This Book Is For? This book is for new developers looking to start working on React applications, and React developers looking to expand on their existing knowledge. It is also suitable for developers coming from other front-end frameworks such as Angular and Vue who would like to add React to their toolbox.
(source: Nielsen Book Data)

• Part 1: Introduction to Flutter
• Chapter 1: Hello Flutter
• Chapter 2: How do I develop in Flutter?- Part 2: Foundational Flutter
• Chapter 3: Everything is Widgets
• Chapter 4: Value Widgets
• Chapter 5: Responding to Gestures
• Chapter 6: Laying out Your Widgets
• Chapter 7: Navigation and Routing
• Chapter 8: Styling your Widgets
• Chapter 9: Maintaining State
• Part 3: Above and Beyond
• Chapter 10: Your Flutter App Can Work with Files
• Chapter 11: Making RESTful API calls with Ajax
• Chapter 12: Using Firebase with Flutter
• Appendix A: Dart Language Intro. .

Create iOS and Android apps with Flutter using just one codebase. App development on multiple platforms has historically been difficult and complex. This book breaks down complex concepts and tasks into easily digestible segments with examples, pictures, and hands-on labs with starters and solutions. In doing so, you'll develop a basic understanding of the Dart programming language; the entire Flutter development toolchain; the differences between stateful and stateless widgets; and a working knowledge of the architecture of apps. All the most important parts of app development with Flutter are covered in this book. Work with themes and styles. Develop custom widgets. Teach your app to respond to gestures like taps, swipes, and pinches. Design, create and control the layout of your app. Create tools to handle form data entry from users. And ultimately create killer multiscreen apps with navigation, menus, and tabs. Flutter is Google's new framework for creating mobile apps that run on iOS and Android phones both.You had to be a super-developer to write apps for iOS or Android alone. But writing for both? Forget about it! You had to be familiar with Swift, Java/Kotlin, Xcode, Eclipse, and a bunch of other technologies simultaneously. Beginning App Development with Flutter simplifies the entire process.

• Table of Contents A New Challenger Approaches Programmer's Multi-Tool: Flexible, Expressive, and Concise Understanding Programming Paradigms in Kotlin First Class Functions Modelling Real World Data Interoperability As a Design Goal Crossing Over: Working Across Java and Kotlin Controlling the Story Baby Steps: Integration Through Testing Practical Concurrency Building Your Own Tools: Domain-Specific Languages (DSLs) Fully Functional: Embracing Functional Programming Kotlin on Android Kotlin and Web Development Introducing Multiplatform Kotlin Taming the Monolith with Microservices Practical Design Patterns.
• (source: Nielsen Book Data)

Explore popular language features, Java to Kotlin interoperability, advanced topics, and practical applications by building a variety of sample projects Key Features Understand and leverage the syntax, tools, and patterns by writing code in Kotlin Explore practical topics such as Java interop, concurrency with coroutines, and functional programming Discover how to use Kotlin for build targets like Android, iOS, JavaScript, and backend service Book DescriptionUsing Kotlin without taking advantage of its power and interoperability is like owning a sports car and never taking it out of the garage. While documentation and introductory resources can help you learn the basics of Kotlin, the fact that it's a new language means that there are limited learning resources and code bases available in comparison to Java and other established languages. This Kotlin book will show you how to leverage software designs and concepts that have made Java the most dominant enterprise programming language. You'll understand how Kotlin is a modern approach to object-oriented programming (OOP). This book will take you through the vast array of features that Kotlin provides over other languages. These features include seamless interoperability with Java, efficient syntax, built-in functional programming constructs, and support for creating your own DSL. Finally, you will gain an understanding of implementing practical design patterns and best practices to help you master the Kotlin language. By the end of the book, you'll have obtained an advanced understanding of Kotlin in order to be able to build production-grade applications. What you will learn Model data using interfaces, classes, and data classes Grapple with practical interoperability challenges and solutions with Java Build parallel apps using concurrency solutions such as coroutines Explore functional, reactive, and imperative programming to build flexible apps Discover how to build your own domain-specific language Embrace functional programming using the standard library and Arrow Delve into the use of Kotlin for frontend JavaScript development Build server-side services using Kotlin and Ktor Who this book is forIf you're a Kotlin developer looking to further their skills or a professional Java developer looking for better or professional resources in order to make a switch to Kotlin, this book is for you. Familiarity with Kotlin programming will assist with understanding key concepts covered in the book.
(source: Nielsen Book Data)

It's time to stop treating loss of connectivity as an error state in your web apps. Whether your users are boarding a flight, landing in a country with no local data plan, hiking, or commuting in the metro, offline and poor connectivity are inevitable states in your apps--states you need to plan for. As you develop for an increasingly mobile world, you need to stop treating connectivity loss as an error state in web apps and start thinking offline-first. In this excerpt from Building Progressive Web Apps, author Tal Ater shows you how to plan and implement an effective offline-first strategy. By exploring code examples for a fictitious hotel web page, you'll learn how to work through several common caching problems. This ebook also includes examples of real-world offline-first approaches at Twitter and The Washington Post . Learn some of the more common design patterns used for caching Mix and match patterns to create new methods for caching and serving content Weigh several options when choosing a caching strategy for your web app Learn methods for implementing the caching strategy you choose Explore different approaches for caching and serving a dynamic web app Understand how an offline-first approach dramatically improves the experience for connected users.

• Table of Contents Introducing Kotlin Kotlin Basics Classes and Object-Oriented Programming Functions and Lambdas Advanced Kotlin Kotlin Standard Library Coding the Dictionary App with Kotlin.
• (source: Nielsen Book Data)

Get started with Kotlin programming for building real world applications Key Features Start programming with Kotlin Explore Kotlin language syntax, standard libraries and Java Interoperability Builds an example application with what you learn Book DescriptionKotlin is a general purpose, object-oriented language that primarily targets the JVM and Android. Intended as a better alternative to Java, its main goals are high interoperability with Java and increased developer productivity. Kotlin is still a new language and this book will help you to learn the core Kotlin features and get you ready for developing applications with Kotlin. This book covers Kotlin features in detail and explains them with practical code examples.You will learn how to set up the environment and take your frst steps with Kotlin and its syntax. We will cover the basics of the language, including functions, variables, and basic data types. With the basics covered, the next chapters show how functions are first-class citizens in Kotlin and deal with the object-oriented side of Kotlin. You will move on to more advanced features of Kotlin. You will explore Kotlin's Standard Library and learn how to work with the Collections API. The book finishes by putting Kotlin in to practice, showing how to build a desktop app. By the end of this book, you will be confident enough to use Kotlin for your next project. What you will learn Programming in Kotlin language syntax, basic types, control ?ow, classes, and OOP Writing functions and functional programming in Kotlin Defning and importing from packages in Kotlin Running Kotlin on JVMs and Android runtimes Working with the Kotlin Standard Library and advanced features of Kotlin programming Setting up a Kotlin development environment with JetBrains tools Building real-world applications with Kotlin Who this book is forThis book is intended for anybody who wants to learn the most important Kotlin features. No experience of Kotlin is expected.
(source: Nielsen Book Data)

Use Spring Boot to build lightning-fast apps About This Book * Get up to date with the defining characteristics of Spring Boot 2.0 in Spring Framework 5 * Learn to perform Reactive programming with SpringBoot * Learn about developer tools, AMQP messaging, WebSockets, security, MongoDB data access, REST, and more Who This Book Is For This book is designed for both novices and experienced Spring developers. It will teach you how to override Spring Boot's opinions and frees you from the need to define complicated configurations. What You Will Learn * Create powerful, production-grade applications and services with minimal fuss * Support multiple environments with one artifact, and add production-grade support with features * Find out how to tweak your apps through different properties * Use custom metrics to track the number of messages published and consumed * Enhance the security model of your apps * Make use of reactive programming in Spring Boot * Build anything from lightweight unit tests to fully running embedded web container integration tests In Detail Spring Boot provides a variety of features that address today's business needs along with today's scalable requirements. In this book, you will learn how to leverage powerful databases and Spring Boot's state-of-the-art WebFlux framework. This practical guide will help you get up and running with all the latest features of Spring Boot, especially the new Reactor-based toolkit. The book starts off by helping you build a simple app, then shows you how to bundle and deploy it to the cloud. From here, we take you through reactive programming, showing you how to interact with controllers and templates and handle data access. Once you're done, you can start writing unit tests, slice tests, embedded container tests, and even autoconfiguration tests. We go into detail about developer tools, AMQP messaging, WebSockets, security, and deployment. You will learn how to secure your application using both routes and method-based rules. By the end of the book, you'll have built a social media platform from which to apply the lessons you have learned to any problem. If you want a good understanding of building scalable applications using the core functionality of Spring Boot, this is the book for you. Style and approach This book takes a tutorial-based approach to teach you all you need to know to get up and running with the latest version of Spring Boot. Filled with examples, you will gain hands-on experience of every area that Spring tackles.
(source: Nielsen Book Data)

DESCRIPTION Although Spring Framework simplifies enterprise Java development, it can require a lot from developers in terms of framework configuration. Spring Boot radically streamlines the process of creating Spring applications by employing automatic configuration, along with a programming model built around established conventions for build-time and runtime dependencies. It also provides a component that gives insight into the internals of a running application and a handy CLI that can be used to write command-line scripts in Groovy. Developers who have used Spring Boot say that they can't imagine ever going back to hand-configuring their applications. Spring Boot in Action is a developer-focused guide to writing applications using Spring Boot. It shows readers how to bypass the tedious configuration steps so that they can concentrate on their application's behavior. Using interesting, relevant examples, Spring expert Craig Walls shows both how to use the default settings effectively and how to override and customize Spring Boot for each unique environment. Along the way, it offers insights from Craig's years of Spring development experience. KEY SELLING POINTS Practical hands-on guide Quickly develop Spring applications Author insights based on years of Spring Development Covers newest features of Spring Boot AUDIENCE Written for readers familiar with the Spring Framework. ABOUT THE TECHNOLOGY Spring Boot brings a convention-over-configuration programming model to the Spring Framework. With Spring Boot, Spring developers can focus on producing application functionality with little effort spent on configuring Spring itself.
(source: Nielsen Book Data)

• Foreword xi Preface xiii
• Chapter 1: What Could Possibly Go Wrong? 1 App Projects Are Not Small and Easy 1 Apps Are Not Easy to Program 5 Poor Skill Set Fit 8 If You Get a Good Developer, You Still Have to Worry 10 The Idea Is Not More Important Than the Execution 12 Unwillingness to Delegate: Micromanaging 15 Bikeshedding 16 Poorly Defined Requirements 16 Out-of-Date Requirements Documentation 18 Constantly Changing Requirements 20 Leaving the Worst for Last 20 Cost Overruns 24 That Last 10% 26 The Whack-a-Mole Problem 27 Poor Communication 29 Abdication of the Management Process 31 Wrapping Up 31
• Chapter 2: The App Development Life Cycle 33 The Design Phase 34 The Development Phase 39 The Testing Phase 45 Repeating the Cycle as Needed 49 Wrapping Up 52
• Chapter 3: Prototyping and Wireframing Your App 53 Focus on the Core Experience 54 Wireframe the App 58 Build an Interactive Prototype 76 Prototyping Tips and Tricks 91 Wrapping Up 95
• Chapter 4: Determining Your App's Components 97 Dealing with Devices 97 Native, Web, and Hybrid Apps 104 Dealing with Third-Party Frameworks 111 Dealing with Analytics 119 Dealing with Video and Audio 120 Dealing with Peripherals 121 Dealing with Accessibility 122 Dealing with Custom or Complex Animations 122 Dealing with Conditional Formatting 123 Dealing with Localization 124 Dealing with User Preferences 125 Dealing with Data Storage 125 Dealing with Servers 131 Dealing with Syncing 133 Dealing with Push Notifications 134 Dealing with Background Tasks 134 Wrapping Up 135
• Chapter 5: Finding the Right Tools 137 Selecting Tools for Your Project Size 138 Source Control 138 Bug Tracking 144 Project and Schedule Tracking 148 The Development Environment 154 Continuous Integration 157 Beta Testing Distribution 159 Crash Reporting 160 End-User Feedback 161 Wrapping Up 162
• Chapter 6: Skill Gap Analysis 163 Programming 163 Testing and Quality Assurance 168 Server Support and Troubleshooting 168 User Experience Design 169 Graphic Design 173 Sound Design and Music 176 Copywriting 178 Marketing 179 About Games 181 Wrapping Up 183
• Chapter 7: Finding a Developer 185 Template App Sites 185 App Developer Matchmaker Sites 189 Local Versus Remote Developers 191 Creative Agencies 194 App Development Companies 196 Independent Developers 199 Grow Your Own Developer (Maybe Even You) 203 Wrapping Up 204
• Chapter 8: Interviewing and Selecting a Developer 207 Nondisclosure Agreements 208 Setting Up an Interview 208 Previous Work 210 Gap Analysis 212 Contingency Plans 213 Estimating and Planning 214 Working Relationship 217 Wrapping Up 224
• Chapter 9: Managing to Milestones 227 Never Agree to "30% Down, and I'll Talk to You in Three Months" 227 Minimizing Risk with Frequent Milestones 228 How I Learned to Stop Grumbling and Love Milestones 229 Milestones Are Not Sprints 230 Organization, Sequencing, and Focus 232 Let Conway's Law Be Your Guide 235 Scheduling Software: Strongly Suggested 237 Remember That Estimates Are Only Estimates 239 Renovation Versus New Construction 243 Estimates and Entomology 245 Plan Reevaluation and Project Feedback Loops 246 Wrapping Up 246
• Chapter 10: Understanding What You're Getting 249 Living Within Your Means 250 The Ticking Clock 251 Justifying Effort for Your Project Size 253 Get the Code, Even if There's Nothing to See in the UI 253 Comments in Source Control 254 Comments in Code 256 Build and Run the App Yourself 258 Third-Party Libraries 260 Source Code Project Organization 261 Automated Test Coverage 262 Detecting Plagiarism 262 Compiler Warnings 264 Duplicated Code 264 Commented Out Code 265 Magic Numbers 265 Huge Combinatorial Complexity 266 Useless, Ambiguous, or Confusing Naming 266 The "UI Thread" or "Main Thread" 267 Wrapping Up 267
• Chapter 11: Pulling the Plug Early 269 So You Missed a Milestone 270 Stop the Presses! Figure Out Where You Are 270 Discussing Failure 271 Milestone Hit but Bugs Abound 272 If Your Developer Is Proactive 274 If Your Developer Isn't Honest 275 If It Might Have Been Your Fault 275 Evaluating the Recovery Plan 277 How Far Gone Are You? 282 Trying to Salvage a Project 283 Fair Compensation 284 Transitioning to a New Developer 284 Wrapping Up 285
• Chapter 12: Communicating Using Bugs 287 Vocabulary 287 Bug Trackers as Communication Tools 288 One Bug per Bug Report, Please 290 Anatomy of a Bug Report 291 Feature Request Versus Bug Fix 292 Placeholder Issues 294 Bug Trackers as Business Continuity 295 Bug Trackers Versus Code Comments 295 Writing Useful Bug Reports 296 Attaching Files to Bugs 298 Data-Specific Bugs 299 Reproduction: There's the Rub 299 Bug States 300 Reopening Bugs Versus Creating New Ones 301 Splitting Bugs 303 Two Bugs, One Cause 303 Saving for Posterity 304 Wrapping Up 304
• Chapter 13: Testing 305 Types of Testing 305 Failures of Imagination 306 Your Testing Schedule 308 Approaching Deadlines 311 Your Testing Team 311 Getting and Incorporating Feedback 319 Wrapping Up 327
• Chapter 14: Submission and Beyond 329 Getting Your Marketing Material Together 330 Reviewer Instructions 331 Last-Minute Plea for Sanity 333 Pushing the Button 334 Dealing with Rejection 335 Resubmission 340 Launch 340 Getting Feedback 340 The Next Release 342 The Red Queen's Race 343 Wrapping Up 343 Index 345.
• (source: Nielsen Book Data)

Build Great Apps: End-to-End Processes, Tools, and Management Tips for Doing It Right! Foreword by Kyle Richter, CEO, MartianCraft Today, successful apps are complex software projects. You can't just knock them off in a weekend--and, worse, many common programming habits don't work well in mobile. You need skills, processes, tools, management techniques, and best practices that are honed for mobile platforms and realities. In App Accomplished, top mobile developer Carl Brown provides all that--so you can run your entire project effectively and get the answers you need right now. Whether you're writing your own code or contracting out, you'll find hard-won guidance for your entire app development life cycle. Brown guides you step-by-step from planning and design through testing and updates. Through case studies drawn from his immense experience, he reveals why so many app projects fail--and how to avoid the mistakes that derailed them. When it comes to apps, a great idea isn't enough: You have to execute. This is the first book that shows you how. Understand mobile-specific issues that lead even experienced developers astray Find developers who can do a great job with your unique app at a fair price Define the requirements you need to create accurate schedules and budgets Work with developers to get the best possible results Manage and communicate effectively to avoid cost overruns Solve problems before they get out of control Develop wireframes and prototypes that clarify the user's core experience Choose app components, from servers to data storage Select tools for source control, testing, project tracking, and more Identify and fill crucial skills gaps Estimate the quality of the app you're building Efficiently test and debug your app Recover from App Store rejection Leverage user feedback to help plan your next release Determine when an existing project is too far off course to fix.
(source: Nielsen Book Data)