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

    But recently, the industry has turned to dynamic languages for increased productivity and speed to market.Groovy is one of a new breed of dynamic languages that run on the Java platform. You can use these new languages on the JVM and intermix them with your existing Java code. You can leverage your Java investments while benefiting from advanced features including true Closures, Meta Programming, the ability to create internal DSLs, and a higher level of abstraction.If you're an experienced Java developer, Programming Groovy will help you learn the necessary fundamentals of programming in Groovy. You'll see how to use Groovy to do advanced programming including using Meta Programming, Builders, Unit Testing with Mock objects, processing XML, working with Databases and creating your own Domain-Specific Languages (DSLs).

    This is official Amazon Web Services (AWS) documentation for Amazon Compute Cloud (Amazon EC2).This guide explains the infrastructure provided by the Amazon EC2 web service, and steps you through how to configure and manage your virtual servers using the AWS Management Console (an easy-to-use graphical interface), the Amazon EC2 API, or web tools and utilities.Amazon EC2 provides resizable computing capacity—literally, server instances in Amazon's data centers—that you use to build and host your software systems.

    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

    Now, for the first time, leading agile methodologist Scott Ambler and renowned consultantPramodkumar Sadalage introduce powerful refactoring techniquesspecifically designed for database systems. Ambler and Sadalagedemonstrate how small changes to table structures, data, storedprocedures, and triggers can significantly enhance virtually anydatabase design - without changing semantic

    Previously undocumented, these 23 patterns allow designers to create more flexible, elegant, and ultimately reusable designs without having to rediscover the design solutions themselves.The authors begin by describing what patterns are and how they can help you design object-oriented software. They then go on to systematically name, explain, evaluate, and catalog recurring designs in object-oriented systems. With Design Patterns as your guide, you will learn how these important patterns fit into the software development process, and how you can leverage them to solve your own design problems most efficiently. Each pattern describes the circumstances in which it is applicable, when it can be applied in view of other design constraints, and the consequences and trade-offs of using the pattern within a larger design. All patterns are compiled from real systems and are based on real-world examples. Each pattern also includes code that demonstrates how it may be implemented in object-oriented programming languages like C++ or Smalltalk.

    Every integrated software development environment in the world--open-source, standards-based, and proprietary--now supports UML and, more importantly, the model-driven approach to software development. This makes learning the newest UML standard, UML 2.0, critical for all software developers--and there isn't a better choice than this clear, step-by-step guide to learning the language."--Richard Mark Soley, Chairman and CEO, OMGIf you're like most software developers, you're building systems that are increasingly complex. Whether you're creating a desktop application or an enterprise system, complexity is the big hairy monster you must manage.The Unified Modeling Language (UML) helps you manage this complexity. Whether you're looking to use UML as a blueprint language, a sketch tool, or as a programming language, this book will give you the need-to-know information on how to apply UML to your project. While there are plenty of books available that describe UML, Learning UML 2.0 will show you how to use it. Topics covered include:Capturing your system's requirements in your model to help you ensure that your designs meet your users' needsModeling the parts of your system and their relationshipsModeling how the parts of your system work together to meet your system's requirementsModeling how your system moves into the real world, capturing how your system will be deployedEngaging and accessible, this book shows you how to use UML to craft and communicate your project's design. Russ Miles and Kim Hamilton have written a pragmatic introduction to UML based on hard-earned practice, not theory. Regardless of the software process or methodology you use, this book is the one source you need to get up and running with UML 2.0.Russ Miles is a software engineer for General Dynamics UK, where he works with Java and Distributed Systems, although his passion at the moment is Aspect Orientation and, in particular, AspectJ. Kim Hamilton is a senior software engineer at Northrop Grumman, where she's designed and implemented a variety of systems including web applications and distributed systems, with frequent detours into algorithms development.

    And how to move all of this data becomes nearly as important as the data itself. If you� re an application architect, developer, or production engineer new to Apache Kafka, this practical guide shows you how to use this open source streaming platform to handle real-time data feeds.Engineers from Confluent and LinkedIn who are responsible for developing Kafka explain how to deploy production Kafka clusters, write reliable event-driven microservices, and build scalable stream-processing applications with this platform. Through detailed examples, you� ll learn Kafka� s design principles, reliability guarantees, key APIs, and architecture details, including the replication protocol, the controller, and the storage layer.Understand publish-subscribe messaging and how it fits in the big data ecosystem.Explore Kafka producers and consumers for writing and reading messagesUnderstand Kafka patterns and use-case requirements to ensure reliable data deliveryGet best practices for building data pipelines and applications with KafkaManage Kafka in production, and learn to perform monitoring, tuning, and maintenance tasksLearn the most critical metrics among Kafka� s operational measurementsExplore how Kafka� s stream delivery capabilities make it a perfect source for stream processing systems

    He explains why invisible and unmanaged queues are the underlying root cause of poor product development performance. He shows why these queues form and how they undermine the speed, quality, and efficiency in product development.

    Find out how the Swedish police combined XP, Scrum, and Kanban in a 60-person project. From start to finish, you'll see how to deliver a successful product using Lean principles. We start with an organization in desperate need of a new way of doing things and finish with a group of sixty, all working in sync to develop a scalable, complex system. You'll walk through the project step by step, from customer engagement, to the daily "cocktail party," version control, bug tracking, and release. In this honest look at what works--and what doesn't--you'll find out how to: Make quality everyone's business, not just the testers. Keep everyone moving in the same direction without micromanagement. Use simple and powerful metrics to aid in planning and process improvement. Balance between low-level feature focus and high-level system focus. You'll be ready to jump into the trenches and streamline your own development process.ContentsForewordPrefacePART I: HOW WE WORK1. About the Project1.1 Timeline 51.2 How We Sliced the Elephant 61.3 How We Involved the Customer 72. Structuring the Teams3. Attending the Daily Cocktail Party3.1 First Tier: Feature Team Daily Stand-up3.2 Second Tier: Sync Meetings per Specialty3.3 Third Tier: Project Sync Meeting4. The Project Board4.1 Our Cadences4.2 How We Handle Urgent Issues and Impediments5. Scaling the Kanban Boards6. Tracking the High-Level Goal7. Defining Ready and Done7.1 Ready for Development7.2 Ready for System Test7.3 How This Improved Collaboration 8. Handling Tech Stories8.1 Example 1: System Test Bottleneck8.2 Example 2: Day Before the Release8.3 Example 3: The 7-Meter Class9. Handling Bugs9.1 Continuous System Test9.2 Fix the Bugs Immediately9.3 Why We Limit the Number of Bugs in the Bug Tracker9.4 Visualizing Bugs9.5 Preventing Recurring Bugs10. Continuously Improving the Process10.1 Team Retrospectives10.2 Process Improvement Workshops10.3 Managing the Rate of Change11. Managing Work in Progress11.1 Using WIP Limits11.2 Why WIP Limits Apply Only to Features12. Capturing and Using Process Metrics12.1 Velocity (Features per Week)12.2 Why We Don’t Use Story Points12.3 Cycle Time (Weeks per Feature)12.4 Cumulative Flow12.5 Process Cycle Efficiency13. Planning the Sprint and Release13.1 Backlog Grooming13.2 Selecting the Top Ten Features13.3 Why We Moved Backlog Grooming Out of the Sprint Planning Meeting13.4 Planning the Release14. How We Do Version Control14.1 No Junk on the Trunk14.2 Team Branches14.3 System Test Branch15. Why We Use Only Physical Kanban Boards16. What We Learned16.1 Know Your Goal16.2 Experiment16.3 Embrace Failure16.4 Solve Real Problems16.5 Have Dedicated Change Agents16.6 Involve PeoplePART II: A CLOSER LOOK AT THE TECHNIQUES 17. Agile and Lean in a Nutshell17.1 Agile in a Nutshell17.2 Lean in a Nutshell17.3 Scrum in a Nutshell17.4 XP in a Nutshell17.5 Kanban in a Nutshell18. Reducing the Test Automation Backlog18.1 What to Do About It18.2 How to Improve Test Coverage a Little Bit Each Iteration18.3 Step 1: List Your Test Cases18.4 Step 2: Classify Each Test18.5 Step 3: Sort the List in Priority Order18.6 Step 4: Automate a Few Tests Each Iteration18.7 Does This Solve the Problem?19. Sizing the Backlog with Planning Poker19.1 Estimating Without Planning Poker19.2 Estimating with Planning Poker19.3 Special Cards20. Cause-Effect Diagrams20.1 Solve Problems, Not Symptoms20.2 The Lean Problem-Solving Approach: A3 Thinking20.3 How to Use Cause-Effect Diagrams20.4 Example 1: Long Release Cycle20.5 Example 2: Defects Released to Production20.6 Example 3: Lack of Pair Programming20.7 Example 4: Lots of Problems20.8 Practical Issues: How to Create and Maintain the Diagrams20.9 Pitfalls20.10 Why Use Cause-Effect Diagrams?21. Final WordsA1. Glossary: How We Avoid Buzzword BingoIndex

    What has been missing from the agile literature is a solid, practical book on the specifics of developing large projects in an agile way. Dean Leffingwell's book Scaling Software Agility fills this gap admirably. It offers a practical guide to large project issues such as architecture, requirements development, multi-level release planning, and team organization. Leffingwell's book is a necessary guide for large projects and large organizations making the transition to agile development." -Jim Highsmith, director, Agile Practice, Cutter Consortium, author of Agile Project Management "There's tension between building software fast and delivering software that lasts, between being ultra-responsive to changes in the market and maintaining a degree of stability. In his latest work, Scaling Software Agility, Dean Leffingwell shows how to achieve a pragmatic balance among these forces. Leffingwell's observations of the problem, his advice on the solution, and his description of the resulting best practices come from experience: he's been there, done that, and has seen what's worked." -Grady Booch, IBM Fellow Agile development practices, while still controversial in some circles, offer undeniable benefits: faster time to market, better responsiveness to changing customer requirements, and higher quality. However, agile practices have been defined and recommended primarily to small teams. In Scaling Software Agility, Dean Leffingwell describes how agile methods can be applied to enterprise-class development. Part I provides an overview of the most common and effective agile methods. Part II describes seven best practices of agility that natively scale to the enterprise level. Part III describes an additional set of seven organizational capabilities that companies can master to achieve the full benefits of software agility on an enterprise scale. This book is invaluable to software developers, testers and QA personnel, managers and team leads, as well as to executives of software organizations whose objective is to increase the quality and productivity of the software development process but who are faced with all the challenges of developing software on an enterprise scale. Foreword Preface Acknowledgments About the Author Part I: Overview of Software Agility Chapter 1: Introduction to Agile Methods Chapter 2: Why the Waterfall Model Doesn't Work Chapter 3: The Essence of XP Chapter 4: The Essence of Scrum Chapter 5: The Essence of RUP Chapter 6: Lean Software, DSDM, and FDD Chapter 7: The Essence of Agile Chapter 8: The Challenge of Scaling Agile Part II: Seven Agile Team Practices That Scale Chapter 9: The Define/Build/Test Component Team Chapter 10: Two Levels of Planning and Tracking Chapter 11: Mastering the Iteration Chapter 12: Smaller, More Frequent Releases Chapter 13: Concurrent Testing Chapter 14: Continuous Integration Chapter 15: Regular Reflection and Adaptation Part III: Creating the Agile Enterprise Chapter 16: Intentional Architecture Chapter 17: Lean Requirements at Scale: Vision, Roadmap, and Just-in-Time Elaboration Chapter 18: Systems of Systems and the Agile Release Train Chapter 19: Managing Highly Distributed Development Chapter 20: Impact on Customers and Operations Chapter 21: Changing the Organization Chapter 22: Measuring Business Performance Conclusion: Agility Works at Scale Bibliography Index

    In this book, you'll learn how to become an entrepreneur, driving your career in the direction of your choosing. You'll learn how to build your software development career step by step, following the same path that you would follow if you were building, marketing, and selling a product. After all, your skills themselves are a product. The choices you make about which technologies to focus on and which business domains to master have at least as much impact on your success as your technical knowledge itself--don't let those choices be accidental. We'll walk through all aspects of the decision-making process, so you can ensure that you're investing your time and energy in the right areas. You'll develop a structured plan for keeping your mind engaged and your skills fresh. You'll learn how to assess your skills in terms of where they fit on the value chain, driving you away from commodity skills and toward those that are in high demand. Through a mix of high-level, thought-provoking essays and tactical "Act on It" sections, you will come away with concrete plans you can put into action immediately. You'll also get a chance to read the perspectives of several highly successful members of our industry from a variety of career paths. As with any product or service, if nobody knows what you're selling, nobody will buy. We'll walk through the often-neglected world of marketing, and you'll create a plan to market yourself both inside your company and to the industry in general. Above all, you'll see how you can set the direction of your career, leading to a more fulfilling and remarkable professional life.

    Now this classic book has been fully updated and revised with leading-edge practices--and hundreds of new code samples--illustrating the art and science of software construction. Capturing the body of knowledge available from research, academia, and everyday commercial practice, McConnell synthesizes the most effective techniques and must-know principles into clear, pragmatic guidance. No matter what your experience level, development environment, or project size, this book will inform and stimulate your thinking--and help you build the highest quality code. Discover the timeless techniques and strategies that help you: Design for minimum complexity and maximum creativity Reap the benefits of collaborative development Apply defensive programming techniques to reduce and flush out errors Exploit opportunities to refactor--or evolve--code, and do it safely Use construction practices that are right-weight for your project Debug problems quickly and effectively Resolve critical construction issues early and correctly Build quality into the beginning, middle, and end of your project

    The Web is awash in Ruby code that is now virtually impossible to change or extend. This text helps you solve that problem by using powerful real-world object-oriented design techniques, which it thoroughly explains using simple and practical Ruby examples. Sandi Metz has distilled a lifetime of conversations and presentations about object-oriented design into a set of Ruby-focused practices for crafting manageable, extensible, and pleasing code. She shows you how to build new applications that can survive success and repair existing applications that have become impossible to change. Each technique is illustrated with extended examples, all downloadable from the companion Web site, poodr.info. The first title to focus squarely on object-oriented Ruby application design, Practical Object-Oriented Design in Ruby will guide you to superior outcomes, whatever your previous Ruby experience. Novice Ruby programmers will find specific rules to live by; intermediate Ruby programmers will find valuable principles they can flexibly interpret and apply; and advanced Ruby programmers will find a common language they can use to lead development and guide their colleagues. This guide will help you Understand how object-oriented programming can help you craft Ruby code that is easier to maintain and upgrade Decide what belongs in a single Ruby class Avoid entangling objects that should be kept separate Define flexible interfaces among objects Reduce programming overhead costs with duck typing Successfully apply inheritance Build objects via composition Design cost-effective tests Solve common problems associated with poorly designed Ruby code

    I'm going to share that mindset with you — along with hundreds of actionable techniques and proven habits — so you can shortcut those years.Introducing The Effective Engineer — the only book designed specifically for today's software engineers, based on extensive interviews with engineering leaders at top tech companies, and packed with hundreds of techniques to accelerate your career.For two years, I embarked on a quest seeking an answer to one question:How do the most effective engineers make their efforts, their teams, and their careers more successful?I interviewed and collected stories from engineering VPs, directors, managers, and other leaders at today's top software companies: established, household names like Google, Facebook, Twitter, and LinkedIn; rapidly growing mid-sized companies like Dropbox, Square, Box, Airbnb, and Etsy; and startups like Reddit, Stripe, Instagram, and Lyft.These leaders shared stories about the most valuable insights they've learned and the most common and costly mistakes that they've seen engineers — sometimes themselves — make.This is just a small sampling of the hard questions I posed to them:- What engineering qualities correlate with future success?- What have you done that has paid off the highest returns?- What separates the most effective engineers you've worked with from everyone else?- What's the most valuable lesson your team has learned in the past year?- What advice do you give to new engineers on your team? Everyone's story is different, but many of the lessons share common themes.You'll get to hear stories like:- How did Instagram's team of 5 engineers build and support a service that grew to over 40 million users by the time the company was acquired?- How and why did Quora deploy code to production 40 to 50 times per day?- How did the team behind Google Docs become the fastest acquisition to rewrite its software to run on Google's infrastructure?- How does Etsy use continuous experimentation to design features that are guaranteed to increase revenue at launch?- How did Facebook's small infrastructure team effectively operate thousands of database servers?- How did Dropbox go from barely hiring any new engineers to nearly tripling its team size year-over-year? What's more, I've distilled their stories into actionable habits and lessons that you can follow step-by-step to make your career and your team more successful.The skills used by effective engineers are all learnable.And I'll teach them to you. With The Effective Engineer, I'll teach you a unifying framework called leverage — the value produced per unit of time invested — that you can use to identify the activities that produce disproportionate results.Here's a sneak peek at some of the lessons you'll learn. You'll learn how to:- Prioritize the right projects and tasks to increase your impact.- Earn more leeway from your peers and managers on your projects.- Spend less time maintaining and fixing software and more time building and shipping new features.- Produce more accurate software estimates.- Validate your ideas cheaply to reduce wasted work.- Navigate organizational and people-related bottlenecks.- Find the appropriate level of code reviews, testing, abstraction, and technical debt to balance speed and quality.- Shorten your debugging workflow to increase your iteration speed.