If you want to leverage OpenGL 2.1's major improvements, you really need the Fourth Edition. It's a comprehensive tutorial, systematic API reference, and massive code library, all in one. You'll start with the fundamental techniques every graphics programmer needs: transformations, lighting, texture mapping, and so forth. Then, building on those basics, you'll move towards newer capabilities, from advanced buffers to vertex shaders. Of course, OpenGL's cross-platform availability remains one of its most compelling features. This book's extensive multiplatform coverage has been thoroughly rewritten, and now addresses everything from Windows Vista to OpenGL ES for handhelds. This is stuff you absolutely want the latest edition for. A small but telling point: This book's recently been invited into Addison-Wesley's OpenGL Series, making it an "official" OpenGL book -- and making a powerful statement about its credibility. Bill Camarda, from the August 2007 href="http://www.barnesandnoble.com/newslet... Only

    As expected, .NET 4 brings a wealth of new APIs to the base class libraries and several new syntactical constructs to C#. For example, it is now possible to create C# methods that support optional and named arguments. As well, you are able to resolve types completely at runtime using the new dynamic keyword. As far as APIs are concerned, this edition of Pro C# 2010 and the .NET 4 Platform will cover a number of new details, including:• the Dynamic Language Runtime (DLR)• the Task Parallel Library (TPL, including PLINQ)• the ADO.NET Entity Framework (as well as LINQ to EF)• expanded coverage of the Windows Presentation Foundation (WPF) API• improved support for COM interopIf you're checking out this book for the first time, understand that it targets experienced software professionals and students of computer science—so please don't expect three chapters devoted to "variable scope" here! The mission of this text is to provide you with a rock-solid foundation in the C# programming language (including a full discussion of OOP) and the critical aspects of the .NET 4 platform.Once you digest the information presented in the book you hold in your hands, you'll be in a perfect position to apply this knowledge to your specific programming assignments, and you'll be well-equipped to explore the .NET universe on your own terms.Andrew TroelsenMicrosoft MVP, Visual Developer—Visual C#; Microsoft Certified Trainer (MCT)

    Everyone and their dog wants an API, so you should probably learn how to build them.Tasked with building an API for your company but don't have a clue where to start? Taken over an existing API and hate it? Built your own API and still hate it? This book is for you.

    This text is split into distinct sections, each concentrating on a core angle of the language. The book also contains sections for Web and application development, the two most popular uses for Python. It is designed to teach a programmer how to use Python by explaining the mechanics of Python. The appendixes offer a quick guide to the main features of the Python language, as well as additional guides to non-essential systems such as the IDLE development environment and general guidelines for migrating from another language.

    Over the past five years, authors Dustin Boswell and Trevor Foucher have analyzed hundreds of examples of "bad code" (much of it their own) to determine why they’re bad and how they could be improved. Their conclusion? You need to write code that minimizes the time it would take someone else to understand it—even if that someone else is you.This book focuses on basic principles and practical techniques you can apply every time you write code. Using easy-to-digest code examples from different languages, each chapter dives into a different aspect of coding, and demonstrates how you can make your code easy to understand.Simplify naming, commenting, and formatting with tips that apply to every line of codeRefine your program’s loops, logic, and variables to reduce complexity and confusionAttack problems at the function level, such as reorganizing blocks of code to do one task at a timeWrite effective test code that is thorough and concise—as well as readable"Being aware of how the code you create affects those who look at it later is an important part of developing software. The authors did a great job in taking you through the different aspects of this challenge, explaining the details with instructive examples." —Michael Hunger, passionate Software Developer

    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...

    This book demonstrates how the notation and process complement one another, using UML models to illustrate the new process in action. It describes the constructs such as use cases, actors, and more.

    Concurrency and parallelism are the keys, and Seven Concurrency Models in Seven Weeks equips you for this new world. See how emerging technologies such as actors and functional programming address issues with traditional threads and locks development. Learn how to exploit the parallelism in your computer's GPU and leverage clusters of machines with MapReduce and Stream Processing. And do it all with the confidence that comes from using tools that help you write crystal clear, high-quality code. This book will show you how to exploit different parallel architectures to improve your code's performance, scalability, and resilience. Learn about the perils of traditional threads and locks programming and how to overcome them through careful design and by working with the standard library. See how actors enable software running on geographically distributed computers to collaborate, handle failure, and create systems that stay up 24/7/365. Understand why shared mutable state is the enemy of robust concurrent code, and see how functional programming together with technologies such as Software Transactional Memory (STM) and automatic parallelism help you tame it. You'll learn about the untapped potential within every GPU and how GPGPU software can unleash it. You'll see how to use MapReduce to harness massive clusters to solve previously intractible problems, and how, in concert with Stream Processing, big data can be tamed. With an understanding of the strengths and weaknesses of each of the different models and hardware architectures, you'll be empowered to tackle any problem with confidence.What You Need: The example code can be compiled and executed on *nix, OS X, or Windows. Instructions on how to download the supporting build systems are given in each chapter.

    Russ Olsen has done a great job of selecting classic patterns and augmenting these with newer patterns that have special relevance for Ruby. He clearly explains each idea, making a wealth of experience available to Ruby developers for their own daily work."--Steve Metsker, Managing Consultant with Dominion Digital, Inc."This book provides a great demonstration of the key 'Gang of Four' design patterns without resorting to overly technical explanations. Written in a precise, yet almost informal style, this book covers enough ground that even those without prior exposure to design patterns will soon feel confident applying them using Ruby. Olsen has done a great job to make a book about a classically 'dry' subject into such an engaging and even occasionally humorous read."--Peter Cooper"This book renewed my interest in understanding patterns after a decade of good intentions. Russ picked the most useful patterns for Ruby and introduced them in a straightforward and logical manner, going beyond the GoF's patterns. This book has improved my use of Ruby, and encouraged me to blow off the dust covering the GoF book."--Mike Stok" Design Patterns in Ruby is a great way for programmers from statically typed objectoriented languages to learn how design patterns appear in a more dynamic, flexible language like Ruby."--Rob Sanheim, Ruby Ninja, RelevanceMost design pattern books are based on C++ and Java. But Ruby is different--and the language's unique qualities make design patterns easier to implement and use. In this book, Russ Olsen demonstrates how to combine Ruby's power and elegance with patterns, and write more sophisticated, effective software with far fewer lines of code.After reviewing the history, concepts, and goals of design patterns, Olsen offers a quick tour of the Ruby language--enough to allow any experienced software developer to immediately utilize patterns with Ruby. The book especially calls attention to Ruby features that simplify the use of patterns, including dynamic typing, code closures, and "mixins" for easier code reuse.Fourteen of the classic "Gang of Four" patterns are considered from the Ruby point of view, explaining what problems each pattern solves, discussing whether traditional implementations make sense in the Ruby environment, and introducing Ruby-specific improvements. You'll discover opportunities to implement patterns in just one or two lines of code, instead of the endlessly repeated boilerplate that conventional languages often require. Design Patterns in Ruby also identifies innovative new patterns that have emerged from the Ruby community. These include ways to create custom objects with metaprogramming, as well as the ambitious Rails-based "Convention Over Configuration" pattern, designed to help integrate entire applications and frameworks.Engaging, practical, and accessible, Design Patterns in Ruby will help you build better software while making your Ruby programming experience more rewarding.

    Learn You a Haskell for Great Good! introduces programmers familiar with imperative languages (such as C++, Java, or Python) to the unique aspects of functional programming. Packed with jokes, pop culture references, and the author's own hilarious artwork, Learn You a Haskell for Great Good! eases the learning curve of this complex language, and is a perfect starting point for any programmer looking to expand his or her horizons. The well-known web tutorial on which this book is based is widely regarded as the best way for beginners to learn Haskell, and receives over 30,000 unique visitors monthly.

    Did you design your system to survivef a sudden rush of visitors from Digg or Slashdot? Or an influx of real world customers from 100 different countries? Are you ready for a world filled with flakey networks, tangled databases, and impatient users?If you're a developer and don't want to be on call for 3AM for the rest of your life, this book will help.In Release It!, Michael T. Nygard shows you how to design and architect your application for the harsh realities it will face. You'll learn how to design your application for maximum uptime, performance, and return on investment.Mike explains that many problems with systems today start with the design.

    This book presents all the important test design techniques in a single place and in a consistent and easy-to-digest format. An immediately useful handbook for test engineers, developers, quality assurance professionals and requirements and systems analysts, it enables you to: choose the best test case design; find software defects in less time and with fewer resources; and develop optimal strategies that help reduce the likelihood of costly errors. It also assists you in estimating the effort, time and cost of good testing. included, helping you to fully understand the practical applications of these techniques. From well-established techniques such as equivalence classes, boundary value analysis, decision tables and state-transition diagrams, to new techniques like use case testing, pairwise testing and exploratory testing, the book is a usful resource for testing professionals seeking to improve their skills and a handy reference for college-level courses in software test design.

    Together, they ruled big business. They transformed popular culture. And they provoked a national controversy. More than anything, they lived a unique and rollicking American Dream, escaping the broken homes of their youth to produce the most notoriously successful game franchises in history—Doom and Quake— until the games they made tore them apart. This is a story of friendship and betrayal, commerce and artistry—a powerful and compassionate account of what it's like to be young, driven, and wildly creative.

    It is designed to be used in conjunction with code provided on an online repository. The book complements and explains the raw code in a way that is accessible to anyone who regularly practices the art of programming. The book can also be used in advanced programming courses in computer science and software engineering programs.The book contains 33 different styles for writing the term frequency task. The styles are grouped into nine categories: historical, basic, function composition, objects and object interactions, reflection and metaprogramming, adversity, data-centric, concurrency, and interactivity. The author verbalizes the constraints in each style and explains the example programs. Each chapter first presents the constraints of the style, next shows an example program, and then gives a detailed explanation of the code. Most chapters also have sections focusing on the use of the style in systems design as well as sections describing the historical context in which the programming style emerged.

    It describes 11 interpreters and 2 compilers, including very recent techniques of interpretation and compilation. The book is in two parts. The first starts from a simple evaluation function and enriches it with multiple name spaces, continuations and side-effects with commented variants, while at the same time the language used to define these features is reduced to a simple lambda-calculus. Denotational semantics is then naturally introduced. The second part focuses more on implementation techniques and discusses precompilation for fast interpretation: threaded code or bytecode; compilation towards C. Some extensions are also described such as dynamic evaluation, reflection, macros and objects. This will become the new standard reference for people wanting to know more about the Lisp family of languages: how they work, how they are implemented, what their variants are and why such variants exist. The full code is supplied (and also available over the Net). A large bibliography is given as well as a considerable number of exercises. Thus it may also be used by students to accompany second courses on Lisp or Scheme.