The 15 project-based lessons in this book show users step-by-step the key techniques for working in Photoshop and how to correct, enhance, and distort digital images, create image composites, and prepare images for print and the web. In addition to learning the key elements of the Photoshop interface, this completely revised CC (2017 release) edition covers features like new and improved search capabilities, Content-Aware Crop, Select and Mask, Face-Aware Liquify, designing with multiple artboards, and much more! The online companion files include all the necessary assets for readers to complete the projects featured in each chapter as well as ebook updates when Adobe releases new features for Creative Cloud customers. All buyers of the book get full access to the Web Edition: a Web-based version of the complete ebook enhanced with video and interactive multiple-choice quizzes. As always with the Classroom in a Book, Instructor Notes are available for teachers to download.

    Guided by Sysinternals creator Mark Russinovich and Windows expert Aaron Margosis, you’ll drill into the features and functions of dozens of free file, disk, process, security, and Windows management tools. And you’ll learn how to apply the book’s best practices to help resolve your own technical issues the way the experts do.Diagnose. Troubleshoot. Optimize.Analyze CPU spikes, memory leaks, and other system problems Get a comprehensive view of file, disk, registry, process/thread, and network activity Diagnose and troubleshoot issues with Active Directory® Easily scan, disable, and remove autostart applications and components Monitor application debug output Generate trigger-based memory dumps for application troubleshooting Audit and analyze file digital signatures, permissions, and other security information Execute Sysinternals management tools on one or more remote computers Master Process Explorer, Process Monitor, and Autoruns

    Work at your own pace through a series of lessons and practical exercises, and then assess your skills with practice tests on CD—featuring multiple, customizable testing options.Maximize your performance on the exam by learning how to:Create database objectsWork with dataModify dataTroubleshoot and optimize queriesYou also get an exam discount voucher—making this book an exceptional value and a great career investment.

    This one's a keeper." --Robert C. Martin "If you want to be an expert in the state of the art in TDD, you need to understand the ideas in this book."--Michael Feathers Test-Driven Development (TDD) is now an established technique for delivering better software faster. TDD is based on a simple idea: Write tests for your code before you write the code itself. However, this simple idea takes skill and judgment to do well. Now there's a practical guide to TDD that takes you beyond the basic concepts. Drawing on a decade of experience building real-world systems, two TDD pioneers show how to let tests guide your development and "grow" software that is coherent, reliable, and maintainable. Steve Freeman and Nat Pryce describe the processes they use, the design principles they strive to achieve, and some of the tools that help them get the job done. Through an extended worked example, you'll learn how TDD works at multiple levels, using tests to drive the features and the object-oriented structure of the code, and using Mock Objects to discover and then describe relationships between objects. Along the way, the book systematically addresses challenges that development teams encounter with TDD--from integrating TDD into your processes to testing your most difficult features. Coverage includes - Implementing TDD effectively: getting started, and maintaining your momentum throughout the project - Creating cleaner, more expressive, more sustainable code - Using tests to stay relentlessly focused on sustaining quality - Understanding how TDD, Mock Objects, and Object-Oriented Design come together in the context of a real software development project - Using Mock Objects to guide object-oriented designs - Succeeding where TDD is difficult: managing complex test data, and testing persistence and concurrency

     Test-Driven JavaScript Development is a complete, best-practice guide to agile JavaScript testing and quality assurance with the test-driven development (TDD) methodology. Leading agile JavaScript developer Christian Johansen covers all aspects of applying state-of-the-art automated testing in JavaScript environments, walking readers through the entire development lifecycle, from project launch to application deployment, and beyond.Using real-life examples driven by unit tests, Johansen shows how to use TDD to gain greater confidence in your code base, so you can fearlessly refactor and build more robust, maintainable, and reliable JavaScript code at lower cost. Throughout, he addresses crucial issues ranging from code design to performance optimization, offering realistic solutions for developers, QA specialists, and testers.Coverage includes - Understanding automated testing and TDD - Building effective automated testing workflows - Testing code for both browsers and servers (using Node.js) - Using TDD to build cleaner APIs, better modularized code, and more robust software - Writing testable code - Using test stubs and mocks to test units in isolation - Continuously improving code through refactoring - Walking through the construction and automated testing of fully functional softwareThe accompanying Web site, tddjs.com, contains all of the book's code listings and additional resources.

    A focus is placed on the principles and practices of decomposing a complex problem space as well as the implementation patterns and best practices for shaping a maintainable solution space.

    In 1999, "Refactoring" revolutionized design by introducing an effective process for improving code. With the highly anticipated " Refactoring to Patterns ," Joshua Kerievsky has changed our approach to design by forever uniting patterns with the evolutionary process of refactoring.This book introduces the theory and practice of pattern-directed refactorings: sequences of low-level refactorings that allow designers to safely move designs to, towards, or away from pattern implementations. Using code from real-world projects, Kerievsky documents the thinking and steps underlying over two dozen pattern-based design transformations. Along the way he offers insights into pattern differences and how to implement patterns in the simplest possible ways.Coverage includes: A catalog of twenty-seven pattern-directed refactorings, featuring real-world code examples Descriptions of twelve design smells that indicate the need for this book s refactorings General information and new insights about patterns and refactoringDetailed implementation mechanics: how low-level refactorings are combined to implement high-level patterns Multiple ways to implement the same pattern and when to use each Practical ways to get started even if you have little experience with patterns or refactoring"Refactoring to Patterns" reflects three years of refinement and the insights of more than sixty software engineering thought leaders in the global patterns, refactoring, and agile development communities. Whether you re focused on legacy or greenfield development, this book will make you a better software designer by helping you learn how to make important design changes safely and effectively. "

    Jon has done a wonderful job of updating the material. I am very impressed at how fresh the new examples seem." - Steve McConnell, author, Code CompleteWhen programmers list their favorite books, Jon Bentley's collection of programming pearls is commonly included among the classics. Just as natural pearls grow from grains of sand that irritate oysters, programming pearls have grown from real problems that have irritated real programmers. With origins beyond solid engineering, in the realm of insight and creativity, Bentley's pearls offer unique and clever solutions to those nagging problems. Illustrated by programs designed as much for fun as for instruction, the book is filled with lucid and witty descriptions of practical programming techniques and fundamental design principles. It is not at all surprising that Programming Pearls has been so highly valued by programmers at every level of experience. In this revision, the first in 14 years, Bentley has substantially updated his essays to reflect current programming methods and environments. In addition, there are three new essays on (1) testing, debugging, and timing; (2) set representations; and (3) string problems. All the original programs have been rewritten, and an equal amount of new code has been generated. Implementations of all the programs, in C or C++, are now available on the Web.What remains the same in this new edition is Bentley's focus on the hard core of programming problems and his delivery of workable solutions to those problems. Whether you are new to Bentley's classic or are revisiting his work for some fresh insight, this book is sure to make your own list of favorites.

    With this practical guide, Alex Banks and Eve Porcello deliver a clear learning path for frontend web developers, backend engineers, and project and product managers looking to get started with GraphQL.You'll explore graph theory, the graph data structure, and GraphQL types before learning hands-on how to build a schema for a photo-sharing application. This book also introduces you to Apollo Client, a popular framework you can use to connect GraphQL to your user interface.Explore graph theory and review popular graph examples in use todayLearn how GraphQL applies database querying methods to the internetCreate a schema for a PhotoShare application that serves as a roadmap and a contract between the frontend and backend teamsUse JavaScript to build a fully functioning GraphQL service and Apollo to implement a clientLearn how to prepare GraphQL APIs and clients for production

    To grow professionally, you also need soft skills and effective learning techniques. Honing those skills is what this book is all about. Authors Dave Hoover and Adewale Oshineye have cataloged dozens of behavior patterns to help you perfect essential aspects of your craft. Compiled from years of research, many interviews, and feedback from O'Reilly's online forum, these patterns address difficult situations that programmers, administrators, and DBAs face every day. And it's not just about financial success. Apprenticeship Patterns also approaches software development as a means to personal fulfillment. Discover how this book can help you make the best of both your life and your career. Solutions to some common obstacles that this book explores in-depth include:Burned out at work? "Nurture Your Passion" by finding a pet project to rediscover the joy of problem solving.Feeling overwhelmed by new information? Re-explore familiar territory by building something you've built before, then use "Retreat into Competence" to move forward again.Stuck in your learning? Seek a team of experienced and talented developers with whom you can "Be the Worst" for a while. "Brilliant stuff! Reading this book was like being in a time machine that pulled me back to those key learning moments in my career as a professional software developer and, instead of having to learn best practices the hard way, I had a guru sitting on my shoulder guiding me every step towards master craftsmanship. I'll certainly be recommending this book to clients. I wish I had this book 14 years ago!" -Russ Miles, CEO, OpenCredo

    Each idiom comes with a detailed description, example code showing the "wrong" way to do it, and code for the idiomatic, "Pythonic" alternative. *This version of the book is for Python 2.7.3+. There is also a Python 3.3+ version available.* "Writing Idiomatic Python" contains the most common and important Python idioms in a format that maximizes identification and understanding. Each idiom is presented as a recommendation to write some commonly used piece of code. It is followed by an explanation of why the idiom is important. It also contains two code samples: the "Harmful" way to write it and the "Idiomatic" way. * The "Harmful" way helps you identify the idiom in your own code. * The "Idiomatic" way shows you how to easily translate that code into idiomatic Python. This book is perfect for you: * If you're coming to Python from another programming language * If you're learning Python as a first programming language * If you're looking to increase the readability, maintainability, and correctness of your Python code What is "Idiomatic" Python? Every programming language has its own idioms. Programming language idioms are nothing more than the generally accepted way of writing a certain piece of code. Consistently writing idiomatic code has a number of important benefits: * Others can read and understand your code easily * Others can maintain and enhance your code with minimal effort * Your code will contain fewer bugs * Your code will teach others to write correct code without any effort on your part

    The authors' enthusiasm for their subject is compelling as they present abstract concepts in a humorous and easy-to-grasp fashion. Together, these books will open new doors of thought to anyone who wants to find out what computing is really about. The Little Schemer introduces computing as an extension of arithmetic and algebra; things that everyone studies in grade school and high school. It introduces programs as recursive functions and briefly discusses the limits of what computers can do. The authors use the programming language Scheme, and interesting foods to illustrate these abstract ideas. The Seasoned Schemer informs the reader about additional dimensions of computing: functions as values, change of state, and exceptional cases. The Little LISPer has been a popular introduction to LISP for many years. It had appeared in French and Japanese. The Little Schemer and The Seasoned Schemer are worthy successors and will prove equally popular as textbooks for Scheme courses as well as companion texts for any complete introductory course in Computer Science.

    Lambda enables users to develop code that executes in response to events - API calls, file uploads, schedules, etc - and upload it without worrying about managing traditional server metrics such as disk space, memory, or CPU usage. With its "per execution" cost model, Lambda can enable organizations to save hundreds or thousands of dollars on computing costs. With in-depth walkthroughs, large screenshots, and complete code samples, the reader is guided through the step-by-step process of creating new functions, responding to infrastructure events, developing API backends, executing code at specified intervals, and much more. Introduction to AWS Computing Evolution of the Computing Workload Lambda Background The Internals The Basics Functions Languages Resource Allocation Getting Set Up Hello World Uploading the Function Working with Events AWS Events Custom Events The Context Object Properties Methods Roles and Permissions Policies Trust Relationships Console Popups Cross Account Access Dependencies and Resources Node Modules OS Dependencies OS Resources OS Commands Logging Searching Logs Testing Your Function Lambda Console Tests Third-Party Testing Libraries Simulating Context Hello S3 Object The Bucket The Role The Code The Event The Trigger Testing When Lambda Isn’t the Answer Host Access Fine-Tuned Configuration Security Long-Running Tasks Where Lambda Excels AWS Event-Driven Tasks Scheduled Events (Cron) Offloading Heavy Processing API Endpoints Infrequently Used Services Real-World Use Cases S3 Image Processing Shutting Down Untagged Instances Triggering CodeDeploy with New S3 Uploads Processing Inbound Email Enforcing Security Policies Detecting Expiring Certificates Utilizing the AWS API Execution Environment The Code Pipeline Cold vs. Hot Execution What is Saved in Memory Scaling and Container Reuse From Development to Deployment Application Design Development Patterns Testing Deployment Monitoring Versioning and Aliasing Costs Short Executions Long-Running Processes High-Memory Applications Free Tier Calculating Pricing CloudFormation Reusable Template with Minimum Permissions Cross Account Access CloudWatch Alerts AWS API Gateway API Gateway Event Creating the Lambda Function Creating a New API, Resource, and Method Initial Configuration Mapping Templates Adding a Query String Using HTTP Request Information Within Lambda Deploying the API Additional Use Cases Lambda Competitors Iron.io StackHut WebTask.io Existing Cloud Providers The Future of Lambda More Resources Conclusion

    Database in Depth: The Relational Model for Practitioners goes beyond the hype and gets to the heart of how relational databases actually work.Ideal for experienced database developers and designers, this concise guide gives you a clear view of the technology--a view that's not influenced by any vendor or product. Featuring an extensive set of exercises, it will help you:understand why and how the relational model is still directly relevant to modern database technology (and will remain so for the foreseeable future)see why and how the SQL standard is seriously deficientuse the best current theoretical knowledge in the design of their databases and database applicationsmake informed decisions in their daily database professional activitiesDatabase in Depth will appeal not only to database developers and designers, but also to a diverse field of professionals and academics, including database administrators (DBAs), information modelers, database consultants, and more. Virtually everyone who deals with relational databases should have at least a passing understanding of the fundamentals of working with relational models.Author C.J. Date has been involved with the relational model from its earliest days. An exceptionally clear-thinking writer, Date lays out principle and theory in a manner that is easily understood. Few others can speak as authoritatively the topic of relational databases as Date can.

    Collected from the series of blog posts starting at: https://bartoszmilewski.com/2014/10/2...Hardcover available at: http://www.blurb.com/b/9008339-catego...