%{search_type} search results

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)

If you are a developer who has some object-oriented programming experience, Learning Apex Programming is the perfect book for you. This book is most appropriate for developers who wish to gain an understanding of the Force.com platform and how to use Apex to create business applications.
(source: Nielsen Book Data)

• Foreword xix Acknowledgments xxi Merb pastie xxiii Introduction xxvii About the author xxxi
• Chapter 1: Fundamentals 1 1.1 Generating a new application 1 1.2 The layout of a Merb application 2 1.3 Interactive Merb 9 1.4 Merb configuration 12 1.5 Understanding the Merb stack 20 1.6 An overview of Merb internals 27 1.7 Conclusion 35
• Chapter 2: Routing 37 2.1 How Merb routing works 38 2.2 Router configuration 43 2.3 Checking routes 45 2.4 Match rules 50 2.5 Registering routes 54 2.6 Other route settings 57 2.7 Resource routes 60 2.8 Conclusion 64
• Chapter 3: Controllers 65 3.1 From request to controller 65 3.2 The controller classes 68 3.3 Custom controller classes 75 3.4 Filters 79 3.5 Redirects 84 3.6 Exceptions 87 3.7 Rendering templates 89 3.8 run_later 97 3.9 Sending and streaming 97 3.10 Conclusion 99
• Chapter 4: Views 101 4.1 ERB 101 4.2 Haml 105 4.3 Merb view templates 109 4.4 Partials 111 4.5 Conclusion 112
• Chapter 5: Models 113 5.1 Configuration 113 5.2 Model classes 115 5.3 Properties 118 5.4 Associations 132 5.5 CRUD basics 140 5.6 Hooks 154 5.7 Plugins 155 5.8 Conclusion 165
• Chapter 6: Helpers 167 6.1 Truncate helper 167 6.2 Numeric helpers 168 6.3 Date and time helpers 171 6.4 Cycle helper 176 6.5 Tag helpers 177 6.6 Form helpers 179 6.7 Conclusion 192
• Chapter 7: Slices 193 7.1 Slice development 193 7.2 Slice usage 201 7.3 Conclusion 203
• Chapter 8: Sessions 205 8.1 How sessions work 205 8.2 Configuration 206 8.3 Storing sessions 207 8.4 Request access 219 8.5 Controller access 220 8.6 Conclusion 220
• Chapter 9: Authentication 221 9.1 Auth core 221 9.2 Auth more 237 9.3 Auth password slices 245 9.4 Conclusion 251
• Chapter 10: Mailers 253 10.1 Configuration 253 10.2 Using mailers directly 255 10.3 Mail controllers 257 10.4 Testing 261 10.5 Generation 261 10.6 Conclusion 262
• Chapter 11: Parts 263 11.1 Parts controllers 263 11.2 Invoking actions 266 11.3 Generation 267 11.4 Conclusion 267
• Chapter 12: Caching 269 12.1 Configuration 269 12.2 Caching basics 271 12.3 Caching helpers 274 12.4 Conclusion 278
• Chapter 13: Testing 279 13.1 Rake tasks 279 13.2 Spec files 282 13.3 Model specs 283 13.4 Request specs 285 13.5 Request helper 289 13.6 Request matchers 290 13.7 RSpec extensions 292 13.8 Miscellaneous extensions 294 13.9 Conclusion 295
• Afterword 297 Index 299.
• (source: Nielsen Book Data)

"Foy is a gifted writer and his descriptions of the philosophies that( impacted the design and implementation of Merb are definitely useful to( everyone affected by the changes in Rails 3." -Obie Fernandez, Series Editor The Expert Guide to Building Merb Applications Thousands of Ruby and Rails developers are discovering the extraordinary scalability, agility, flexibility, and performance offered by the new Merb MVC framework. The Merb Way is the first comprehensive guide to using, extending, and deploying Merb. Like the bestseller The Rails Way (Addison-Wesley, 2008), this book can either be read cover-to-cover as a tutorial or used for modular coverage that makes it an ideal task reference. Foy Savas systematically covers everything developers need to know to build production-quality Merb applications, offering detailed code examples for jumpstarting virtually any project. Savas is not only involved in the Merb project as an open source contributor: He uses Merb every day as a professional developer. Drawing on his extensive practical expertise, he delves deeply into the Merb framework's architecture and source code, revealing its elegance and offering powerful best practices for using it. To maximize this book's practical value, he also covers the tools most widely used alongside Merb, including the DataMapper ORM, the RSpec tester (and associated behavior-driven development techniques), and several leading Merb plugins. The Merb Way will help you Master Merb innovations that will be incorporated into Rails 3 Understand the fundamentals of Merb development, one step at a time Use Merb's sophisticated application router to guide incoming requests Explore the Merb stack, master its configuration options, and dive into its internals Use Merb controllers to integrate application code, handle responses, and manage sessions, filters, and exceptions Build templates with both ERB (Erubis) and HAML Use the DataMapper ORM to represent object properties and behaviors Learn best practices for RESTful development with Merb Leverage Helpers to simplify many common development tasks Refactor code, encapsulate it in gems, and share it across multiple applications Customize the responses your application sends to each user Gain a deep, practical understanding of Merb plugins and extensibility Authenticate users with Merb's modular authentication plugin Configure, generate, describe, and test Merb mailers Use the merb-parts gem to create component-like regions on Web pages Cache content to relieve stress on Web servers Make the most of Behavior Driven Development and testing with RSpec.
(source: Nielsen Book Data)

This IBM Redbook provides detailed information on how to effectively use WebSphere Studio Application Developer for the development of applications based on the Enterprise JavaBeans (EJB) architecture, and deployment of such applications to a WebSphere Application Server. Throughout the book, we provide examples based on a simple banking application with an underlying relational database. In Part 1, we introduce EJBs as a part of Java 2 Enterprise Edition (J2EE) and cover the basic concepts and the architecture. In particular we point out the new functions introduced with the EJB 2.0 specification that provide, for example, enhanced functionality for container-managed persistence entity beans and message-driven beans. We also provide best practice guidelines for successful implementations of EJBs. In Part 2, we introduce the sample banking application and then implement entity beans, session beans, and message-driven beans using WebSphere Studio Application Developer. We also implement finder methods, different mapping strategies, and simple clients that use the EJBs. At the end, we describe how to deploy EJB applications to a WebSphere Application Server.

With Windows CE 3.0, CE finally comes of age as a development platform -- and as a development opportunity. Now's the time to master CE development -- but many CE programming books focus almost entirely on building attractive user interfaces, and leave you hanging when it comes to the rest. Not this one! Windows CE: Application Programming offers comprehensive, code-rich coverage of CE networking, communications, database access, desktop interoperability, COM/ActiveX, mail store and messaging, power management -- everything you need to know to build world-class Windows CE apps! Nick Grattan and Marshall Brain deliver extensive code examples throughout -- as well as great tips for leveraging your existing Visual C++ expertise. Master CE file access and directories; processes and threads; and using ActiveSync to synchronizing PDAs and desktops. Build networked CE applications; learn expert techniques for managing limited memory; access databases; build components with COM and ActiveX; and more -- including today's most effective CE user interface development solutions.
(source: Nielsen Book Data)

Ansible is a great tool for handling deployment as well as configuration management, providing a lot more functionality than shell scripts. It doesn't require that one learn a new set of abstractions to hide the differences between operating systems. That makes its surface area smaller; there's less you need to know before you get started. Why is it important? We're all slowly turning into system engineers. Using a single tool for both configuration management and deployment makes life simpler for the folks responsible for operations. Project goals include a consistent, secure, highly reliable tool that's minimal in nature and has a low learning curve. What you'll learn--and how you can apply it Covers the basic concepts of Ansible at a high level, including how it communicates with remote servers and how it differs from other configuration-management tools. You'll learn how to use the Ansible command-line tool to perform simple tasks on a single host This lesson is for you because ... You're a developer deploying your code to production You're a systems administrator looking for a better way to automate You need a quick introduction to leveraging an idempotent resource model for immutable infrastructure Prerequisites Be familiar with at least one Linux distribution (e.g., Ubuntu, RHEL/CentOS, SUSE) Be familiar with basic Linux system administration tasks, e.g., know how to: Connect to a remote machine using SSH Interact with the bash command-line shell (pipes and redirection) Install packages Use the sudo command Check and set file permissions Start and stop services Set environment variables Write scripts (any language) Learn some YAML and Jinja2 Materials or downloads needed in advance Have a Linux server with which to practice This Lesson is taken from Ansible: Up and Running by Lorin Hochstein.

This IBM® Redbooks® publication introduces the IBM System z® Personal Development Tool (zPDT), which runs on an underlying Linux system based on an Intel processor. zPDT provides a System z system on a PC capable of running current System z operating systems, including emulation of selected System z I/O devices and control units. It is intended as a development, demonstration, and learning platform; it is not designed as a production system. This book, discussing more advanced topics, is the last of three volumes. The first volume introduces zPDT and provides reference material for zPDT commands and device managers. The second volume describes the installation of zPDT (including the underlying Linux, and a particular z/OS® distribution) and basic usage patterns. The third volume discusses more advanced topics that may not interest all zPDT users. The IBM order numbers for the three volumes are SG24-7721, SG24-7722, and SG24-7723. The systems discussed in these volumes are complex, with elements of Linux (for the underlying PC machine), z/Architecture® (for the core zPDT elements), System z I/O functions (for emulated I/O devices), and z/OS (providing the System z application interface), and possibly with other System z operating systems. We assume the reader is familiar with the general concepts and terminology of System z hardware and software elements and with basic PC Linux characteristics.