Swift Programming Using Agile Tools and Techniques
This short step by step guide walks you through unit testing, mocking and continuous integration and how to get these key ingredients running in your Swift projects. This book also looks at how to write your Swift apps using test driven development (TDD).
Agile practices have made major inroads in more » iOS development, however it’s very unusual to see something as basic as unit testing on a Swift application. Done correctly, Agile development results in a significant increase in development efficiency and a reduction in the number of defects.
Apple has released unit testing and code coverage frameworks for Swift development in XCode. Up until now getting unit testing up and running in Swift was not for the faint-hearted. Thankfully now, there is no excuse other than a lack of information on where to get started.
iOS developers are faced with their own set of problems such as tightly coupled code, fragmentation, immature testing tools all of which can be solved using existing Agile tools and techniques. After using this book, you'll learn how to make your Swift apps agile and sound.
What You Will Learn:
* How to write unit tests in Swift
* How to write an application using Test Driven Development
* Mocking frameworks
* How to set up and configure a Continuous Integration Server
* How to measure code coverage
* GUI Testing
Who This Book Is For:
Swift developers and would be mobile app testers will benefit from the guidance in this book. « less
Source code is one of the biggest assets of a software company. However if not maintained well, it can become a big liability. As source code becomes larger. more complex and accessed via the cloud, maintaining code quality becomes even more challenging. The author provides straightforward tools and advice on how to manage code quality in this new environment.
Roslyn exposes a set of APIs which allow developers to parse their C# and VB.NET code and drastically lower the barrier to entry for Meta programming in .NET. Roslyn has a dedicated set of APIs for creating custom refactoring for integrating with Visual Studio.
What You Will Learn
* Understand the Roslyn Syntax API
* Use Data Visualization techniques to assist code analysis process visually
* Code health monitoring matrices (from the standard of Code Query Language)
* Code mining techniques to identify design patterns used in source code
* Code forensics techniques to identify probable author of a given source code
* Techniques to identify duplicate/near duplicate code
Who This Book is For
.NET Software Developers and Architects « less
Building Quality into Software
To build high-quality software, you need to write testable code. That's harder than it seems: it requires insights drawn from arenas ranging from software craftsmanship to unit testing, refactoring to test-driven development. Most programming books either discuss testing only briefly, or drill down on more » just one or two techniques, with little guidance on how to systematically verify code. Most testing books, on the other hand, focus on a specific testing process, without showing how to write software that can be easily and systematically tested. In Developer Testing, leading software engineering consultant Alexander Tarnowski strikes an optimal balance, integrating insights from multiple disciplines to help frustrated practitioners get better results.
Drawing on his extensive experience as a mentor and trainer, he offers insights that help you accelerate through the typical software assurance learning curve, so you can progress far more rapidly.
Tarnowski organizes his insights into "chunks" to help you quickly absorb key concepts, and focuses on technology-agnostic approaches you can keep using with any new language, platform, or toolset. Along the way, he answers many questions development teams often ask about testing, including:
* What makes code testable? What makes it hard to test?
* When have I done enough testing on a piece of code?
* How many unit tests do I need to write?
* Exactly what should my test verify?
* How do I transform monolithic legacy code into manageable pieces I can test?
* What's the best way to structure my tests?
The first guide to cover testing mindset, techniques, and applications from the developer's perspective, Developer Testing will help developers get what they really want: better code. « less
Functional Reactive Programming teaches the concepts and applications of FRP. It offers a careful walk-through of core FRP operations and introduces the concepts and techniques you'll need to use FRP in any language.
Purchase of the print book includes a free eBook in PDF, Kindle, and ePub more » formats from Manning Publications.
About the Technology
Today's software is shifting to more asynchronous, event-based solutions. For decades, the Observer pattern has been the go-to event infrastructure, but it is known to be bug-prone. Functional reactive programming (FRP) replaces Observer, radically improving the quality of event-based code.
About the Book
* Think differently about data and events
* Eliminate Observer one listener at a time
* Explore Sodium, RxJS, and Kefir.js FRP systems
About the Reader
About the Authors
Stephen Blackheath and Anthony Jones are experienced software developers and the creators of the Sodium FRP library for multiple languages. Foreword by Heinrich Apfelmus. Illustrated by Duncan Hill.
Table of Contents
1. Stop listening!
2. Core FRP
3. Some everyday widget stuff
4. Writing a real application
5. New concepts
6. FRP on the web
8. Operational primitives
9. Continuous time
10. Battle of the paradigms
11. Programming in the real world
12. Helpers and patterns
14. Adding FRP to existing projects
15. Future directions « less
Take Python beyond scripting to build robust, reusable, and efficient applications
* Get to grips with Python techniques that address commonly encountered problems in general application development.
* Develop, package, and deploy efficient applications in a fun way.
* All-practical coverage of the major areas of application development, including best practices, exception more » handling, testing, refactoring, design patterns, performance, and GUI application development.
Python is one of the most widely used dynamic programming languages, supported by a rich set of libraries and frameworks that enable rapid development. But fast paced development often comes with its own baggage that could bring down the quality, performance, and extensibility of an application. This book will show you ways to handle such problems and write better Python applications.
From the basics of simple command-line applications, develop your skills all the way to designing efficient and advanced Python apps. Guided by a light-hearted fantasy learning theme, overcome the real-world problems of complex Python development with practical solutions. Beginning with a focus on robustness, packaging, and releasing application code, you'll move on to focus on improving application lifetime by making code extensible, reusable, and readable. Get to grips with Python refactoring, design patterns and best practices. Techniques to identify the bottlenecks and improve performance are covered in a series of chapters devoted to performance, before closing with a look at developing Python GUIs.
WHAT YOU WILL LEARN
* Build a robust application by handling exceptions.
* Modularize, package, and release the source distribution.
* Document the code and implement coding standards.
* Create automated tests to catch bugs in the early development stage.
* Identify and re-factor badly written code to improve application life.
* Detect recurring problems in the code and apply design patterns.
* Improve code efficiency by identifying performance bottlenecks and fixing them.
* Develop simple GUI applications using Python.
ABOUT THE AUTHOR
Ninad Sathaye has spent several years of his professional career designing and developing performance-critical engineering applications written in a variety of languages, including Python and C++. He has worked as a software architect in the semiconductor industry, and more recently in the domain of Internet of Things. He holds a master's degree in mechanical engineering.
TABLE OF CONTENTS
1. Developing Simple Applications
2. Dealing with Exceptions
3. Modularize, Package, Deploy!
4. Documentation and Best Practices
5. Unit Testing and Refactoring
6. Design Patterns
7. Performance – Identifying Bottlenecks
8. Improving Performance – Part One
9. Improving Performance – Part Two, NumPy and Parallelization
10. Simple GUI Applications « less
As a developer, you may inherit projects built on existing codebases with design patterns, usage assumptions, infrastructure, and tooling from another time and another team. Fortunately, there are ways to breathe new life into legacy projects so you can maintain, improve, and scale them without more » fighting their limitations.
About the Book
Re-Engineering Legacy Software is an experience-driven guide to revitalizing inherited projects. It covers refactoring, quality metrics, toolchain and workflow, continuous integration, infrastructure automation, and organizational culture. You'll learn techniques for introducing dependency injection for code modularity, quantitatively measuring quality, and automating infrastructure. You'll also develop practical processes for deciding whether to rewrite or refactor, organizing teams, and convincing management that quality matters. Core topics include deciphering and modularizing awkward code structures, integrating and automating tests, replacing outdated build systems, and using tools like Vagrant and Ansible for infrastructure automation.
* Refactoring legacy codebases
* Continuous inspection and integration
* Automating legacy infrastructure
* New tests for old code
* Modularizing monolithic projects
About the Reader
This book is written for developers and team leads comfortable with an OO language like Java or C#.
About the Author
Chris Birchall is a senior developer at the Guardian in London, working on the back-end services that power the website.
Table of Contents
1. PART 1 GETTING STARTED
2. Understanding the challenges of legacy projects
3. Finding your starting point
4. PART 2 REFACTORING TO IMPROVE THE CODEBASE
5. Preparing to refactor
8. The Big Rewrite
9. PART 3 BEYOND REFACTORING—IMPROVING PROJECT WORKFLOWAND INFRASTRUCTURE
10. Automating the development environment
11. Extending automation to test, staging, and production environments
12. Modernizing the development, building, and deployment of legacy software
13. Stop writing legacy code! « less
A practical guide to get you up and running with unit testing using Mockito
ABOUT THIS BOOK
* Explore Mockito features and learn stubbing, mocking and spying dependencies using the Mockito framework
* Mock external dependencies for legacy and greenfield projects and create an automated JUnit safety net for building reliable, maintainable and testable software
* A focused more » guide filled with examples and supporting illustrations on testing your software using Mockito
WHO THIS BOOK IS FOR
This book is ideal for developers who have some experience in Java application development as well as some basic knowledge of test doubles and JUnit testing. This book also introduces you to the fundamentals of JUnit testing, test doubles, refactoring legacy code, and writing JUnit tests for GWT and web services.
WHAT YOU WILL LEARN
* Explore test doubles and work with dummy, spy, fake, stub, and mock objects
* Uncover the Mockito architecture and build a custom mocking framework
* Mock, stub, and spy external code dependencies using Mockito
* Practice Behavior-driven Development (BDD) with Mockito
* Make legacy code testable by mocking and spying dependencies
* Mock GWT and web service dependencies using Mockito
* Discover argument captors, inline stubbing, and resetting mock objects
Whether you are new to JUnit testing and mocking or a seasoned Mockito expert, this book will provide you with the skills you need to successfully build and maintain meaningful JUnit test cases and effectively mock external dependencies. At the beginning, this book deals with dummy and fake objects and then moves on to exploring stubs followed by an example on spying. Then, it will show you how to make legacy code testable, mock external dependencies using Mockito, and write testable code for greenfield projects. You will also gain an insight on the concepts of Service-oriented Architecture (SOA) as well as understand how to unit test RESTful web services with Mockito. By sequentially working through the steps in each chapter, you will quickly learn the features of Mockito.
Mockito Essentials will ensure your success with these concepts, tools, and frameworks. « less
Learn how to apply Test-Driven Development and the Mockito framework in real life projects, using realistic, hands-on examples
* Start writing clean, high quality code to apply Design Patterns and principles
* Add new features to your project by applying Test-first development- JUnit 4.0 and Mockito framework
* Make legacy code testable and clean up technical debts
The usual life cycle of code involves more » adding code, breaking an existing functionality, fixing that and breaking a new area! This fragility can be fixed using automated tests and Test Driven Development.
TDD’s test first approach expedites the development process and unit tests act as safety nets for code refactoring and help in maintaining and extending the code. This makes TDD highly beneficial for new projects.
This practical, hands-on guide provides you with a number of clear, step-by-step exercises that will help you to take advantage of the real power that is behind Test Driven Development and the Mockito framework. By using this book, you will gain the knowledge that you need to use the Mockito framework in your project.
This book explains the concept of Test Driven Development (TDD), including mocking and refactoring, as well as breaking down the mystery and confusion that surrounds the test first approach of TDD. It will take you through a number of clear, practical examples that will help you to take advantage of TDD with the Mockito framework, quickly and painlessly.
You will learn how to write unit tests, refactor code and remove code smells. We will also take a look at mock objects and learn to use Mockito framework to stub, mock, verify and spy objects for testability. You will also learn to write clean, maintainable, and extensible code using design principles and patterns.
If you want to take advantage of using Test Driven Development and learn about mocking frameworks, then this is the book for you. You will learn everything you need to know to apply Test Driven Development in a real life project, as well as how to refactor legacy code and write quality code using design patterns.
What you will learn from this book
* Create your first unit test and discover the power of unit testing
* Familiarize yourself with Test-first Development and the refactoring process
* Add new features to your project applying Test Driven Development
* Create readable, maintainable, and extensible software using design principles and patterns
* Start stubbing, mocking, spying, and verifying objects using Mockito APIs
* Apply inside-out and outside-in TDD styles
* Expedite the development process using Eclipse and keyboard shortcuts
* Apply JUnit 4.0 and advanced Mockito features – argument captor, callbacks, and answers
This book is a hands-on guide, full of practical examples to illustrate the concepts of Test Driven Development.
Who this book is written for
If you are a developer who wants to develop software following Test Driven Development using Mockito and leveraging various Mockito features, this book is ideal for you. You don’t need prior knowledge of TDD, Mockito, or JUnit.
It is ideal for developers, who have some experience in Java application development as well as a basic knowledge of unit testing, but it covers the basic fundamentals of TDD and JUnit testing to get you acquainted with these concepts before delving into them. « less
With refactoring, programmers can transform even the most chaotic software into well-designed systems that are far easier to evolve and maintain. What's more, they can do it one step at a time, through a series of simple, proven steps. Now, there's an authoritative and extensively updated version of more » Martin Fowler's classic refactoring book that utilizes Ruby examples and idioms throughout - not code adapted from Java or any other environment. « less
What can you do when database performance doesn't meet expectations? Before you turn to expensive hardware upgrades to solve the problem, reach for this book. Refactoring SQL Applications provides a set of tested options for making code modifications to dramatically improve the way your database applications more » function. Backed by real-world examples, you'll find quick fixes for simple problems, in-depth answers for more complex situations, and complete solutions for applications with extensive problems. « less