l_share的博客

Preface to Book This book isn't an introduction to object-oriented technology or design. Many books already do a good job of that. This book assumes you are reasonably proficient in at least one object-oriented programming language, and you should have some experience in object-oriented design as well. You definitely shouldn't have to rush to the nearest dictionary the moment we mention "types" and "polymorphism," or "interface" as opposed to "implementation" inheritance. On the other hand, this isn't an advanced technical treatise either. It’s a book of design patterns that describes simple and elegant solutions to specific problems in object-oriented software design. Design patterns capture solutions that have developed and evolved overtime. Hence they aren't the designs people tend to generate initially. They reflect untold redesign and recoding as developers have struggled for greater reuse and flexibility in their software. Design patterns capture these solutions in a succinct and easily applied form. The design patterns require neither unusual language features nor amazing programming tricks with which to astound your friends and managers. All can be implemented in standard object-oriented languages, though they might take a little more work than ad hoc solutions. But the extra effort invariably pays dividends in increased flexibility and reusability. Once you understand the design patterns and have had an "Aha!" (and not just a "Huh?") experience with them, you won't ever think about object-oriented design in the same way. You'll have insights that can make your own designs more flexible, modular, reusable, and understandable — which is why you're interested in object-oriented technology in the first place, right? A word of warning and encouragement: Don't worry if you don’t understand this book completely on the first reading. We didn’t understand it all on the first writing! Remember that this isn't a book to read once and put on a shelf. We hope you'll find yourself referring to it again and again for design insights and for inspiration. This book has had a long gestation. It has seen four countries, three of its authors' marriages, and the birth of two (unrelated) offspring. Many people have had a part in its development. Special thanks are due Bruce Anderson, Kent Beck, and André Wein and for their inspiration and advice. We also thank those who reviewed drafts of the manuscript: Roger Bielefeld, Grady Booch, Tom Cargill, Marshall Cline, Ralph Hyre, Brian Kernighan, Thomas Laliberty, Mark Lorenz, Arthur Riel, Doug Schmidt, Clovis Tondo, Steve Vinoski, and Rebecca Wirfs-Brock. We are also grateful to the team at Addison-Wesley for their help and patience: Kate Habib, Tiffany Moore, Lisa Raffaele, Pradeepa Siva, and John Wait. Special thanks to Carl Kessler, Danny Sabbah, and Mark Wegman at IBM Research for their unflagging support of this work. Last but certainly not least, we thank everyone on the Internet and points beyond who commented on versions of the patterns, offered encouraging words, and told us that what we were doing was worthwhile. These people include but are not limited to Jon Avotins, Steve Berczuk, Julian Berdych, Matthias Bohlen, John Brant, Allan Clarke, Paul Chisholm, Jens Coldewey, Dave Collins, Jim Coplien, Don Dwiggins, Gabriele Elia, Doug Felt, Brian Foote, Denis Fortin, Ward Harold, Hermann Hueni, Nayeem Islam, Bikramjit Kalra, Paul Keefer, Thomas Kofler, Doug Lea, Dan LaLiberte, James Long, Ann Louise Luu, Pundi Madhavan, Brian Marick, Robert Martin, Dave McComb, Carl McConnell, Christine Mingins, Hanspeter Mössenböck, Eric Newton, Marianne Ozkan, Roxsan Payette, Larry Podmolik, George Radin, Sita Ramakrishnan, Russ Ramirez, Alexander Ran, Dirk Riehle, Bryan Rosenburg, Aamod Sane, Duri Schmidt, Robert Seidl, Xin Shu, and Bill Walker. We don't consider this collection of design patterns complete and static; it's more a recording of our current thoughts on design. We welcome comments on it, whether criticisms of our examples, references and known uses we've missed, or design patterns we should have included. You can write us care of Addison-Wesley, or send electronic mail to [email protected]. You can also obtain softcopy for the code in the Sample Code sections by sending the message "send design pattern source" to [email protected]. And now there's a Web page at http://www.cs.uiuc.edu/users/patterns/DPBook/DPBook.html for late-breaking information and updates. Mountain View, California E.G. Montreal, Quebec R.H. Urbana, Illinois R.J. Hawthorne, New York J.V. August 1994

Preface JavaScript (and its frameworks such as jQuery) and HTML (along with its style sheet language CSS) have become a ubiquitous presence in software development. Due to their monopoly position in web browsers, and the fact web browsers have spread from PCs to phones, tablets and TVs; this pervasiveness will continue to grow and grow. Despite their success, many software engineers are apprehensive about JavaScript and HTML. This apprehensiveness is not completely unfounded; both JavaScript and HTML were rushed in their early years, and driven by commercial rather than engineering interests. As a result, many dubious features crept into these languages. Due to backwards compatibility concerns, most of these features still remain. In addition, many software engineers have used these languages without ever learning them. JavaScript and HTML have low barriers to entry, and this, along with their similarity to other languages, led many software engineers to conclude that there really was nothing much to learn. If you have not used JavaScript and HTML for a number of years you may be surprised at what they now offer. Browser based web applications are now capable of matching or exceeding the sophistication and scale of traditional desktop applications. In order to create complex web applications however, it is essential to learn these languages. This book takes the point of view that once you have a strong grasp of the fundamentals, the details will take care of themselves. It will not present you with long lists of APIs, or intricate details of every attribute, these can be found in reference manuals. It will focus on the details of each language that are fundamental to understanding how they work. I hope this book helps you discover the elegance and beauty of JavaScript and HTML, and makes you think differently about what can be achieved with these languages. October, 2013

Focus and Topics This book is not about building complex models and simulations, nor is it about spending time running benchmarks over and over. It’s not about mathematical concepts such as Little’s Law, Markov chains, or Poisson arrival rates. What this book is about is practical capacity planning and management that can take place in the real world. It’s about using real tools, and being able to adapt to changing usage on a website that will (hopefully) grow over time. When you have a flat tire on the highway, you could spend a lot of time trying to figure out the cause, or you can get on with the obvious task of installing the spare and getting back on the road. This is the approach I’m presenting to capacity planning: adaptive, not theoretical. Keep in mind a good deal of the information in this book will seem a lot like common sense—this is a good thing. Quite often the simplest approaches to problem solving are the best ones, and capacity planning is no exception. This book will cover the process of capacity planning for growing websites, including measurement, procurement, and deployment. I’ll discuss some of the more popular and proven measurement tools and techniques. Most of these tools run in both LAMP and Windows-based environments. As such, I’ll try to keep the discussion as platform-agnostic as possible. Of course, it’s beyond the scope of this book to cover the details of every database, web server, caching server, and storage solution. Instead, I’ll use examples of each to illustrate the process and concepts, but this book is not meant to be an implementation guide. The intention is to be as generic as possible when it comes to explaining resource management—it’s the process itself we want to emphasize. For example, a database is used to store data and provide responses to queries. Most of the more popular databases allow for replicating data to other servers, which enhances redundancy, performance, and architectural decisions. It also assists the technical implementation of replication with Postgres, Oracle, or MySQL (a topic for other books). This book covers what replication means in terms of planning capacity and deployment. Essentially, this book is about measuring, planning, and managing growth for a web application, regardless of the underlying technologies you choose.

Preface Thanks for your interest in Scalability Rules! This book is meant to serve as a primer, a refresher, and a lightweight reference manual to help engineers, architects, and managers develop and maintain scalable Internet products. It is laid out in a series of rules, each of them bundled thematically by different topics. Most of the rules are technically focused, while a smaller number of them address some critical mindset or process concern—each of which is absolutely critical to building scalable products. The rules vary in their depth and focus. Some rules are high level, such as defining a model that can be applied to nearly any scalability problem, while others are specific and may explain a technique, such as how to modify headers to maximize the “cache-ability” of content. Why Write Another Book on Scale? There simply aren’t many good books on scalability on the market yet, and Scalability Rules is unique in its approach in this sparse market. It is the first book to address the topic of scalability in a rules-oriented fashion. It is the first book meant to be as much of a reference as it is an overview of the topic. It includes a chapter summarizing the 50 rules and gives a prioritization of the rules for those looking to apply the book to their existing platforms. One of our most-commented-on blog posts is on the need for scalability to become a discipline.We and the community of technologists that tackle scalability problems believe that scalability architects are needed in today’s technology organizations. In Scalability Rules the early days of computer systems almost everyone involved was a programmer, and then came specialization with system operators, DBAs, architects, and so on.We now have many different disciplines and specialties that make up our technology teams. One of the missing disciplines is the scalability architect. Unlike a DBA, whose job is to get things done and not necessarily teach someone else unless they are mentoring a junior DBA, one of the primary responsibilities of the scalability architect would be to educate technology people.The scalability architects should be evangelists and teachers rather than the gatekeepers of secret knowledge. As part of that teaching we’ve made a step forward by putting together these 50 rules that we believe will help guide any organization in scaling its systems.

Book Organization and Structure We’ve divided the book into four parts. Part I, Staffing a Scalable Organization, focuses on organization, management, and leadership. Far too often, managers and leaders are promoted based on their talents within their area of expertise. Engineering leaders and managers, for example, are very often promoted based on their technical acumen and often aren’t given the time or resources to develop business, management, and leadership acumen. Although they might perform well in the architectural and technical aspects of scale, their expertise in organizational scale needs are often shallow or nonexistent. Our intent is to arm these managers and leaders with a foundation from which they can grow and prosper as managers and leaders. Part II, Building Processes for Scale, focuses on the processes that help hypergrowth companies scale their technical platforms. We cover topics ranging from technical issue resolution to crisis management. We also discuss processes meant for governing architectural decisions and principles to help companies scale their platforms. Part III, Architecting Scalable Solutions, focuses on the technical and architectural aspects of scale. We introduce proprietary models developed within our consulting and advisory practice of AKF Partners. These models help organizations think through their scalability needs and alternatives. Part IV, Solving Other Issues and Challenges, discusses emerging technologies such as grid computing and cloud computing. We also address some unique problems within hyper-growth companies such as the immense growth and cost of data as well as what to consider when planning data centers and how to evolve your monitoring strategies to be closer to your customers. The lessons in this book have not been designed in the laboratory nor are they based on unapplied theory. Rather, these lessons have been designed and implemented by engineers, technology leaders, and organizations through years of struggling to keep their dreams, businesses, and systems a float. The authors have had the great fortune to be a small part of many of these teams in many different roles—sometimes as active participants, other times as observers. We have seen how putting these lessons into practice has yielded success and the unwillingness or inability to do so has led to failure. This book will teach these lessons and hopefully put you and your team on the road to success. We believe the lessons herein are valuable for everyone from engineering staffs to product staffs including every level from the individual contributor to the CEO.

How This Book Is Organized After two quick introductory chapters, I jump into the main part of this book: the 14 performance rules.Each rule is described, one per chapter, in priority order.Not every rule applies to every site, and not every site should apply a rule the same way, but each is worth considering.The final chapter of this book shows how to analyze web pages from a performance perspective, including some case studies. Chapter A, The Importance of Frontend Performance explains that at least 80 percent of the time it takes to display a web page happens after the HTML document has been downloaded, and describes the importance of the techniques in this book. Chapter B, HTTP Overview provides a short description of HTTP, highlighting the parts that are relevant to performance. Chapter 1, Rule 1: Make Fewer HTTP Requests describes why extra HTTP requests have the biggest impact on performance, and discusses ways to reduce these HTTP requests including image maps, CSS sprites, inline images using data: URLs, and combining scripts and stylesheets. Chapter 2, Rule 2: Use a Content Delivery Network highlights the advantages of using a content delivery network. Chapter 3, Rule 3: Add an Expires Header digs into how a simple HTTP header dramatically improves your web pages by using the browser’s cache. Chapter 4, Rule 4: Gzip Components explains how compression works and how to enable it for your web servers, and discusses some of the compatibility issues that exist today. Chapter 5, Rule 5: Put Stylesheets at the Top reveals how stylesheets affect the rendering of your page. Chapter 6, Rule 6: Put Scripts at the Bottom shows how scripts affect rendering and downloading in the browser. Chapter 7, Rule 7: Avoid CSS Expressions discusses the use of CSS expressions and the importance of quantifying their impact. Chapter 8, Rule 8: Make JavaScript and CSS External talks about the tradeoffs of inlining your JavaScript and CSS versus putting them in external files. Chapter 9, Rule 9: Reduce DNS Lookups highlights the often-overlooked impact of resolving domain names. Chapter 10, Rule 10: Minify JavaScript quantifies the benefits of removing whitespace from your JavaScript. Chapter 11, Rule 11: Avoid Redirects warns against using redirects, and provides alternatives that you can use instead. Chapter 12, Rule 12: Remove Duplicate Scripts reveals what happens if a script is included twice in a page. Chapter 13, Rule 13: Configure ETags describes how ETags work and why the default implementation is bad for anyone with more than one web server. Chapter 14, Rule 14: Make Ajax Cacheable emphasizes the importance of keeping these performance rules in mind when using Ajax. Chapter 15, Deconstructing 10 Top Sites gives examples of how to identify performance improvements in real-world web sites.

What This Book Is About This book is primarily about web application design: the design of software and hardware systems for web applications. We’ll be looking at application architecture, development practices, technologies, Unicode, and general infrastructural work. Perhaps as importantly, this book is about the development of web applications: the practice of building the hardware and implementing the software systems that we design. While the theory of application design is all well and good (and an essential part of the whole process), we need to recognize that the implementation plays a very important part in the construction of large applications and needs to be borne in mind during the design process. If we’re designing things that we can’t build, then we can’t know if we’re designing the right thing. This book is not about programming. At least, not really. Rather than talking about snippets of code, function names, and so forth, we’ll be looking at generalized techniques and approaches for building web applications. While the book does contain some snippets of example code, they are just that: examples. Most of the code examples in this book can be used only in the context of a larger application or infrastructure. A lot of what we’ll be looking at relates to designing application architectures and building application infrastructures. In the field of web applications, infrastructures tend to mean a combination of hardware platform, software platform, and maintenance and development practices. We’ll consider how all of these fit together to build a seamless infrastructure for large-scale applications. The largest chapter in this book (Chapter 9) deals solely with scaling applications: architectural approaches to design for scalability as well as technologies and techniques that can be used to help scale existing systems. While we can hardly cover the whole field in a single chapter (we could barely cover the basics in an entire book), we’ve picked a couple of the most useful approaches for applications with common requirements. It should be noted, however, that this is hardly an exhaustive guide to scaling, and there’s plenty more to learn. For an introduction to the wider world of scalable infrastructures, you might want to pick up a copy of Performance by Design: Computer Capacity Planning by Example (Prentice Hall). Toward the end of the book (Chapters 10 and 11), we look at techniques for keeping web applications running with event monitoring and long-term statistical tracking for capacity planning. Monitoring and alerting are core skills for anyone looking to create an application and then manage it for any length of time. For applications with custom components, or even just many components, the task of designing and building the probes and monitors often falls to the application designers, since they should best know what needs to be tracked and what constitutes an alertable state. For every component of our system, we need to design some way to check that it’s both working and working correctly. In the last chapter, we’ll look at techniques for sharing data and allowing other applications to integrate with our own via data feeds and read/write APIs. While we’ll be looking at the design of component APIs throughout the book as we deal with different components in our application, the final chapter deals with ways to present those interfaces to the outside world in a safe and accessible manner. We’ll also look at the various standards that have evolved for data export and interaction and look at approaches for presenting them from our application.

Why You Should Read This Book This book will teach you how to create interactive websites from the simplest order form through to complex, secure e-commerce sites or interactive Web 2.0 sites.What’s more, you’ll learn how to do it using open source technologies. This book is aimed at readers who already know at least the basics of HTML and have done some programming in a modern programming language before but have not necessarily programmed for the Internet or used a relational database. If you are a beginning programmer, you should still find this book useful, but digesting it might take a little longer.We’ve tried not to leave out any basic concepts, but we do cover them at speed.The typical readers of this book want to master PHP and MySQL for the purpose of building a large or commercial website.You might already be working in another web development language; if so, this book should get you up to speed quickly. We wrote the first edition of this book because we were tired of finding PHP books that were basically function references.These books are useful, but they don’t help when your boss or client has said,“Go build me a shopping cart.” In this book, we have done our best to make every example useful.You can use many of the code samples directly in your website, and you can use many others with only minor modifications. What You Will Learn from This Book Reading this book will enable you to build real-world, dynamic websites. If you’ve built websites using plain HTML, you realize the limitations of this approach. Static content from a pure HTML website is just that—static. It stays the same unless you physically update it.Your users can’t interact with the site in any meaningful fashion. Using a language such as PHP and a database such as MySQL allows you to make your sites dynamic: to have them be customizable and contain real-time information. We have deliberately focused this book on real-world applications, even in the introductory chapters.We begin by looking at a simple online ordering system and work our way through the various parts of PHP and MySQL. We then discuss aspects of electronic commerce and security as they relate to building a real-world website and show you how to implement these aspects in PHP and MySQL. In the final part of this book, we describe how to approach real-world projects and take you through the design, planning, and building of the following projects: User authentication and personalization Shopping carts Web-based email Mailing list managers Web forums PDF document generation Web services with XML and SOAP Web 2.0 application with Ajax You should be able to use any of these projects as is, or you can modify them to suit your needs.We chose them because we believe they represent some the most common web-based applications built by programmers. If your needs are different, this book should help you along the way to achieving your goals.

Preface to the Second Edition In this, the second edition of Game Engine Architecture, my goal was threefold. First, I wanted to update the book to include information on some new and exciting topics, including that latest variant of the C++ programming language, C++11, and the architecture of the eighth generation of gaming consoles—the Xbox One and the PlayStation 4. Second, I wanted to fill in some gaps in the content of the original book. Most notably, I decided to include a brand new chapter on audio technology. This decision was based in part on requests from you, my loyal and always helpful readers. It was also based in part on the fact that, to my knowledge, no book currently exists that covers the fundamentals of the physics, mathematics and technology that go into the creation of a AAA game audio engine. Audio plays a crucially important role in any great game, and it is my sincere hope that the audio chapter in this book will help at least a little to open up the field of game audio technology to a wider audience. Third, I wanted to repair the various errata that were brought to my attention by my readers. Thank you! I hope you’ll find that the mistakes you found have all been fixed—and replaced by a whole new batch of mistakes that you can tell me about for the third edition! Of course, as I've said before, the field of game engine programming is almost unimaginably broad and deep. There’s no way to cover every topic in one book. As such, the primary purpose of this book remains to serve as an awareness-building tool and a jumping-off point for further learning. I hope you find this edition helpful on your journey through the fascinating and multifaceted landscape of game engine architecture.

Preface to the Second Edition In this, the second edition of Game Engine Architecture, my goal was threefold. First, I wanted to update the book to include information on some new and exciting topics, including that latest variant of the C++ programming language, C++11, and the architecture of the eighth generation of gaming consoles—the Xbox One and the PlayStation 4. Second, I wanted to fill in some gaps in the content of the original book. Most notably, I decided to include a brand new chapter on audio technology. This decision was based in part on requests from you, my loyal and always helpful readers. It was also based in part on the fact that, to my knowledge, no book currently exists that covers the fundamentals of the physics, mathematics and technology that go into the creation of a AAA game audio engine. Audio plays a crucially important role in any great game, and it is my sincere hope that the audio chapter in this book will help at least a little to open up the field of game audio technology to a wider audience. Third, I wanted to repair the various errata that were brought to my attention by my readers. Thank you! I hope you’ll find that the mistakes you found have all been fixed—and replaced by a whole new batch of mistakes that you can tell me about for the third edition! Of course, as I've said before, the field of game engine programming is almost unimaginably broad and deep. There’s no way to cover every topic in one book. As such, the primary purpose of this book remains to serve as an awareness-building tool and a jumping-off point for further learning. I hope you find this edition helpful on your journey through the fascinating and multifaceted landscape of game engine architecture.

Review PART I: GAME PROGRAMMING FUNDAMENTALS. 1. What is Game Programming Really Like?. 2. What's in a Game?. 3. Coding Tidbits and Style That Will Save You. 4. Building Your Game. PART II: GET YOUR GAME RUNNING. 5. Game Initialization and Shutdown. 6. Controlling the Main Loop. 7. Loading and Caching Game Data. 8. Programming Input Devices. 9. User Interface Programming. PART III: CORE GAME TECHNIQUES. 10. Game Event Management. 11. Scripting with Lua. 12. Game Audio. 13. 3D Basics. 14. 3D Scenes. 15. Collision and Simple Physics. 16. Network Programming Primer. PART IV: ADVANCED TOPICS AND BRINGING IT ALL TOGETHER. 17. An Introduction to Game AI. 18. Introduction to Multiprogramming. 19. A Game of Teapot Wars!. 20. A Simple Game Editor in C#. 21. Debugging Your Game. 22. Driving to the Finish. About the Author Mike McShaffry, aka "Mr. Mike," began programming games as soon as he could tap a keyboard. After graduating from the University of Houston, he worked for Warren Spector and Richard Garriott, aka "Lord British," at Origin Systems on Martian Dreams, Ultima VII: The Black Gate, Ultima VIII: Pagan, Ultima IX: Ascension, and Ultima Online. Seven years later he formed his first company, Tornado Alley. Mike later accepted a position at Glass Eye Entertainment, working for his friend Monty Kerr, where he produced Microsoft Casino. Ten months later, Monty asked Mike and his newly assembled team to start their own company, called Compulsive Development, which would work exclusively with Microsoft on casual casino and card games. Mike served as the Head of Studio, and together with the rest of the Compulsive folks, produced three more casual titles for Microsoft until August 2002. Compulsive was acquired by Glass Eye Entertainment to continue work on Glass Eye's growing online casual games business. Mike was later recruited to start an Austin studio for Maryland-based Breakaway Games. Mike is currently self-employed, helping teams build a positive, creative and energetic environment so they can do what they do best--make great games. David "Rez" Graham is a self-taught programmer who has been writing games in his basement since 1996. In 2005, he landed a programming job at Super-Ego Games where he worked on mini-games and AI for Barbie Diaries: High School Mystery for the PC. He also worked on a comedy adventure game called RatRace for the PlayStation 3. In 2008, Rez went to work for Planet Moon and worked on Brain Quest for the Game Boy DS and Drawn to Life: The Next Chapter for the Wii. Rez went to PlayFirst in 2010 where he worked on Diner Dash: Grillin' Green for the iPad and was the lead engineer for Wedding Dash for the iPhone 4. Rez currently works at Electronic Arts as an AI programmer for the Sims division. He has shipped two titles there, which include The Sims Medieval and the Pirates & Nobles Adventure Pack. He is currently the lead AI programmer for an upcoming Sims title.

Ian Millington crosses the boundary between academic and professional game AI with his book Artificial Intelligence for Games. Most books either lack academic rigor or are rigorous with algorithms that won’t work under the CPU constraints imposed by modern games. This book walks a line between the two and does it well. It explains algorithms rigorously while also discussing appropriate implementation details such as scheduling AI over time and using the right data structures. I will be using this book for my Game AI course. —Jessica D. Bayliss, Ph.D. Rochester Institute of Technology This is the first serious attempt to create a comprehensive reference for all game AI practices, terminology, and know-how. Works like this are badly needed by the maturing video games industry. Systematic yet accessible, it is a must-have for any student or professional. —Marcin Chady, Ph.D. Radical Entertainment This book promises to be the closest I’ve seen to what is needed in the field. I would highly recommend it for people in the industry. —John Laird University of Michigan Ian Millington’s book is a comprehensive reference to the most widely used techniques in game AI today. Any game developer working on AI will learn something from this book, and game producers should make sure their AI programmers have a copy. —Dr. Ian Lane Davis Mad Doc Software

A 2010 CHOICE Outstanding Academic Title This course resource provides an excellent, comprehensive look at every major system and issue related to modern game development … a must-have textbook for computer science, software engineering, or game programming majors, amateur hobbyists, game 'modders,' and game developers. —A. Chen, CHOICE, January 2010 … it looks like most of the critical areas and concepts are touched on. … it looks like you’ll have some reasonably deep understanding of the elements that go into making a game engine. Quite an impressive work, and I know of nothing else in this area that is so detailed. —Eric Haines, www.realtimerendering.com/blog/, July 2009 Jason Gregory draws upon his many years of experience and expertise to create a complete and comprehensive textbook on the theory and practice of game engine software development. Informed and informative, replete with examples for every aspect of the game development process, and fully accessible to aspiring game engine developers as well as a very useful reference for even experienced technicians in the field, Game Engine Architecture is an invaluable, thoroughly 'user friendly', and highly recommended core addition to personal, professional, and academic Computer Science reference and resource collections in general, as well as gaming engine design instructional reading lists in particular. —The Midwest Book Review, September 2009 The book contains a huge amount of data on specifics to consider when developing a game engine. —Gamasutra.com, November 2009 Game Engine Architecture by Jason Gregory has been named a finalist for the Game Developer's 2009 Front Line Award. —PR Newswire, December 2009 Jason Gregory has worked as a professional software engineer since 1994. He got his start in game programming in 1999 at Midway Home Entertainment in San Diego, where he wrote tools and engine code, including the Playstation 2/Xbox animation system for Freaky Flyers, Hydro Thunder 2 and Crank the Weasel. In 2003, Jason moved to Electronic Arts Los Angeles, where he worked on engine and game play technology for Medal of Honor: Pacific Assault and served as a lead engineer during the Medal of Honor: Airborne project. Jason is currently a lead programmer at Naughty Dog Inc., where he most recently completed work on The Last of Us. He also developed engine and gameplay technology for Naughty Dog's Uncharted: Drake's Fortune, Uncharted 2: Among Thieves and Uncharted 3: Drake's Deception, and taught courses in game technology at the University of Southern California.