Computer programming / software engineering Books
Pearson Education (US) Implementing DomainDriven Design
Book SynopsisVaughn Vernon is a champion of simplifying software architecture and development, with an emphasis on reactive methods. He has a unique ability to teach and lead with Domain-Driven Design using lightweight tools to unveil unimagined value. He helps organizations achieve competitive advantages using enduring tools such as architectures, patterns, and approaches, and through partnerships between business stakeholders and software developers.Trade Review"With Implementing Domain-Driven Design, Vaughn has made an important contribution not only to the literature of the Domain-Driven Design community, but also to the literature of the broader enterprise application architecture field. In key chapters on Architecture and Repositories, for example, Vaughn shows how DDD fits with the expanding array of architecture styles and persistence technologies for enterprise applications-including SOA and REST, NoSQL and data grids-that has emerged in the decade since Eric Evans' seminal book was first published. And, fittingly, Vaughn illuminates the blocking and tackling of DDD-the implementation of entities, value objects, aggregates, services, events, factories, and repositories-with plentiful examples and valuable insights drawn from decades of practical experience. In a word, I would describe this book as thorough. For software developers of all experience levels looking to improve their results, and design and implement domain-driven enterprise applications consistently with the best current state of professional practice, Implementing Domain-Driven Design will impart a treasure trove of knowledge hard won within the DDD and enterprise application architecture communities over the last couple decades." -Randy Stafford, Architect At-Large, Oracle Coherence Product Development "Domain-Driven Design is a powerful set of thinking tools that can have a profound impact on how effective a team can be at building software-intensive systems. The thing is that many developers got lost at times when applying these thinking tools and really needed more concrete guidance. In this book, Vaughn provides the missing links between theory and practice. In addition to shedding light on many of the misunderstood elements of DDD, Vaughn also connects new concepts like Command/Query Responsibility Segregation and Event Sourcing that many advanced DDD practitioners have used with great success. This book is a must-read for anybody looking to put DDD into practice." -Udi Dahan, Founder of NServiceBus "For years, developers struggling to practice Domain-Driven Design have been wishing for more practical help in actually implementing DDD. Vaughn did an excellent job in closing the gap between theory and practice with a complete implementation reference. He paints a vivid picture of what it is like to do DDD in a contemporary project, and provides plenty of practical advice on how to approach and solve typical challenges occurring in a project life cycle." - Alberto Brandolini, DDD Instructor, Certified by Eric Evans and Domain Language, Inc. "Implementing Domain-Driven Design does a remarkable thing: it takes a sophisticated and substantial topic area in DDD and presents it clearly, with nuance, fun and finesse. This book is written in an engaging and friendly style, like a trusted advisor giving you expert counsel on how to accomplish what is most important. By the time you finish the book you will be able to begin applying all the important concepts of DDD, and then some. As I read, I found myself highlighting many sections ... I will be referring back to it, and recommending it, often." - Paul Rayner, Principal Consultant & Owner, Virtual Genius, LLC., DDD Instructor, Certified by Eric Evans and Domain Language, Inc., DDD Denver Founder and Co-leader "One important part of the DDD classes I teach is discussing how to put all the ideas and pieces together into a full blown working implementation. With this book, the DDD community now has a comprehensive reference that addresses this in detail. Implementing Domain-Driven Design deals with all aspects of building a system using DDD, from getting the small details right to keeping track of the big picture. This is a great reference and an excellent companion to Eric Evans seminal DDD book." - Patrik Fredriksson, DDD Instructor, Certified by Eric Evans and Domain Language, Inc. "If you care about software craftsmanship-and you should-then Domain-Driven Design is a crucial skill set to master and Implementing Domain-Driven Design is the fast path to success. IDDD offers a highly readable yet rigorous discussion of DDD's strategic and tactical patterns that enables developers to move immediately from understanding to action. Tomorrow's business software will benefit from the clear guidance provided by this book." -Dave Muirhead, Principal Consultant, Blue River Systems Group "There's theory and practice around DDD that every developer needs to know, and this is the missing piece of the puzzle that puts it all together. Highly recommended!" -Rickard Oberg, Java Champion and Developer at Neo Technology "In IDDD, Vaughn takes a top-down approach to DDD, bringing strategic patterns such as bounded context and context maps to the fore, with the building block patterns of entities, values and services tackled later. His book uses a case study throughout, and to get the most out of it you'll need to spend time grokking that case study. But if you do you'll be able to see the value of applying DDD to a complex domain; the frequent sidenotes, diagrams, tables, and code all help illustrate the main points. So if you want to build a solid DDD system employing the architectural styles most commonly in use today, Vaughn's book comes recommended." -Dan Haywood, author of Domain-Driven Design with Naked Objects "This book employs a top-down approach to understanding DDD in a way that fluently connects strategic patterns to lower level tactical constraints. Theory is coupled with guided approaches to implementation within modern architectural styles. Throughout the book, Vaughn highlights the importance and value of focusing on the business domain all while balancing technical considerations. As a result, the role of DDD, as well as what it does and perhaps more importantly doesn't imply, become ostensibly clear. Many a time, my team and I would be at odds with the friction encountered in applying DDD. With Implementing Domain-Driven Design as our luminous guide we were able to overcome those challenges and translate our efforts into immediate business value." -Lev Gorodinski, Principal Architect, DrillSpot.comTable of Contents Chapter 1: Getting Started with DDD Chapter 2: Domains, Subdomains, and Bounded Contexts Chapter 3: Context Maps Chapter 4: Architecture Chapter 5: Entities Chapter 6: Value Objects Chapter 7: Services Chapter 8: Domain Events Chapter 9: Modules Chapter 10: Aggregates Chapter 11: Factories Chapter 12: Repositories Chapter 13: Integrating Bounded Contexts Chapter 14: Application Appendix A: Aggregates and Event Sourcing: A+ES
£43.19
No Starch Press,US The Nature of Code
Book Synopsis
£28.49
McGraw-Hill Education ISE Software Engineering A Practitioners Approach
Book SynopsisFor almost four decades, Software Engineering: A Practitioner''s Approach (SEPA) has been the world''s leading textbook in software engineering. The ninth edition represents a major restructuring and update of previous editions, solidifying the book''s position as the most comprehensive guide to this important subject.Table of Contents1) Software and Software EngineeringPart One - The Software Process2) Process Models3) Agility and Process4) Recommended Process Model5) Human Aspects of Software EngineeringPart Two - Modeling6) Principles That Guide Practice7) Understanding Requirements8) Requirements Modeling - A Recommended Approach9) Design Concepts10) Architectural Design - A Recommended Approach11) Component-Level Design12) User Experience Design13) Design for Mobility14) Pattern-Based DesignPart Three - Quality and Security15) Quality Concepts16) Reviews - A Recommended Approach17) Software Quality Assurance18) Software Security Engineering19) Software Testing - Component Level20) Software Testing - Integration Level21) Software Testing - Specialized Testing for Mobility22) Software Configuration Management23) Software Metrics and AnalyticsPart Four - Managing Software Projects24) Project Management Concepts25) Creating a Viable Software Plan26) Risk Management27) A Strategy for Software SupportPart Five - Advanced Topics 28) Software Process Improvement29) Emerging Trends in Software Engineering30) Concluding CommentsAppendix I - An Introduction to UML Appendix II - Data Science for Software Engineers
£56.99
Pearson Education Art of Computer Programming The Volumes 14B Boxed
Book SynopsisDonald E. Knuth is known throughout the world for his pioneering work on algorithms and programming techniques, for his invention of the TEX and METAFONT systems for computer typesetting, and for his prolific and influential writing (26 books, 161 papers). Professor Emeritus of The Art of Computer Programming at Stanford University, he currently devotes full time to the completion of his seminal multivolume series on classical computer science, begun in 1962 when he was a graduate student at California Institute of Technology. Professor Knuth is the recipient of numerous awards and honors, including the ACM Turing Award, the Medal of Science presented by President Carter, the AMS Steele Prize for expository writing, and, in November, 1996, the prestigious Kyoto Prize for advanced technology. He lives on the Stanford campus with his wife, Jill.
£205.69
John Wiley & Sons Inc GitHub For Dummies
Book SynopsisGet more out of your coding with GitHub For today's coders, GitHub is a must. The world's largest software development platform, GitHub helps developers store, track, and collaborate on software projects. In this easy-to-follow Dummies guide, you'll find insight into creating repositories, establishing projects, collaborating, incorporating open-source resources, and establishing yourself as a valued member of the GitHub community. With a working knowledge of GitHub, you'll be a better, more employable programmer. The simple instructions and interactive examples in this book will get you there quickly. Get the instructions you need for using GitHub to collaborate on software projectsBecome more attractive to employers with knowledge and experience in the largest development platformSet up GitHub Desktop, create a repository, and launch your first projectUse GitHub Skills courses to learn new tricks, for beginners to prosYou've learned how to write a little codenow learn how to share itTable of ContentsIntroduction 1 Part 1: Getting Started with GitHub.com 5 Chapter 1: Understanding the Git in GitHub 7 Chapter 2: Setting Up Your Collaborative Coding Environment 25 Part 2: Starting Your First Solo Project 35 Chapter 3: Introducing GitHub Repositories 37 Chapter 4: Setting Up a GitHub Website Repo 57 Chapter 5: Creating a Website with GitHub Pages 73 Part 3: Contributing to Your First Project 91 Chapter 6: Forking GitHub Repositories 93 Chapter 7: Writing and Committing Code 109 Chapter 8: Working with Pull Requests 129 Part 4: Managing and Contributing to Large Projects 149 Chapter 9: Exploring and Contributing to OSS 151 Chapter 10: Starting Your Own OSS 165 Chapter 11: Inner-Source Your Code on GitHub 185 Part 5: Making GitHub Work for You 203 Chapter 12: Collaborating Outside of GitHub 205 Chapter 13: GitHub Workflow Integrations 219 Chapter 14: Personalizing GitHub 233 Part 6: The GitHub Ecosystem 247 Chapter 15: Exploring the GitHub Marketplace 249 Chapter 16: GitHub and You 259 Chapter 17: Attending Events 267 Part 7: The Part of Tens 277 Chapter 18: Ten Ways to Level Up on GitHub 279 Chapter 19: Ten Ways to Improve Your Development Workflow 291 Chapter 20: Ten Tips for Being an Effective Community Member 299 Index 307
£19.54
Penguin Random House Group Black Hat Bash
Book Synopsis
£42.74
No Starch Press,US Practical Malware Analysis: The Hands-On Guide to
Book SynopsisMalware analysis is big business, and attacks can cost a company dearly. When malware breaches your defenses, you need to act quickly to cure current infections and prevent future ones from occurring. For those who want to stay ahead of the latest malware, Practical Malware Analysis will teach you the tools and techniques used by professional analysts. With this book as your guide, you'll be able to safely analyze, debug, and disassemble any malicious software that comes your way. You'll learn how to: Set up a safe virtual environment to analyze malware Quickly extract network signatures and host-based indicators Use key analysis tools like IDA Pro, OllyDbg, and WinDbg Overcome malware tricks like obfuscation, anti-disassembly, anti-debugging, and anti-virtual machine techniques Use your newfound knowledge of Windows internals for malware analysis Develop a methodology for unpacking malware and get practical experience with five of the most popular packers Analyze special casesTrade Review"A hands-on introduction to malware analysis. I'd recommend it to anyone who wants to dissect Windows malware."—Ilfak Guilfanov, Creator of IDA Pro"The book every malware analyst should keep handy."—Richard Bejtlich, CSO of Mandiant & Founder of TaoSecurity"This book does exactly what it promises on the cover; it's crammed with detail and has an intensely practical approach, but it's well organised enough that you can keep it around as handy reference."—Mary Branscombe, ZDNet"If you're starting out in malware analysis, or if you are are coming to analysis from another discipline, I'd recommend having a nose."—Paul Baccas, Naked Security from Sophos"An excellent crash course in malware analysis."—Dino Dai Zovi, Independent Security Consultant"The most comprehensive guide to analysis of malware, offering detailed coverage of all the essential skills required to understand the specific challenges presented by modern malware."—Chris Eagle, Senior Lecturer of Computer Science at the Naval Postgraduate School"A great introduction to malware analysis. All chapters contain detailed technical explanations and hands-on lab exercises to get you immediate exposure to real malware."—Sebastian Porst, Google Software Engineer"Brings reverse engineering to readers of all skill levels. Technically rich and accessible, the labs will lead you to a deeper understanding of the art and science of reverse engineering. I strongly recommend this book for beginners and experts alike. I strongly believe this will become the defacto text for learning malware analysis in the future."—Danny Quist, PhD, Founder of Offensive Computing“An awesome book. . . written by knowledgeable authors who possess the rare gift of being able to communicate their knowledge through the written word.”—Richard Austin, IEEE Cipher"If you only read one malware book or are looking to break into the world of malware analysis, this is the book to get."—Patrick Engebretson, IA Professor at Dakota State University and Author of The Basics of Hacking and Pen Testing"An excellent addition to the course materials for an advanced graduate level course on Software Security or Intrusion Detection Systems. The labs are especially useful to students in teaching the methods to reverse engineer, analyze and understand malicious software."—Sal Stolfo, Professor, Columbia University"The explanation of the tools is clear, the presentation of the process is lucid, and the actual detective work fascinating. All presented clearly and hitting just the right level so that developers with no previous experience in this particular area can participate fully. Highly recommended."—Dr. Dobb's"This book is like having your very own personal malware analysis teacher without the expensive training costs."—Dustin Schultz, TheXploit"I highly recommend this book to anyone looking to get their feet wet in malware analysis or just looking for a good desktop reference on the subject."—Pete Arzamendi, 403 Labs“I do not see how anyone who has hands-on responsibility for security of Windows systems can rationalize not being familiar with these tools.”—Stephen Northcutt, SANS Institute"Practical Malware Analysis is another book that should be within reaching distance in anyone’s DFIR shop. I went ahead and purchased PMA hoping the book would improve my knowledge and skills when faced with malware. What I ended up with was knowledge, a process and tools I can use to analyze any program I encounter. PMA gets a five star review (5 out of 5)."—Journey Into Incident Response“Highly recommend it to those looking to enter the malware analysis field.”—Linux Ninja"If you are a beginner to this hacking field, then this book will be an excellent choice for you."—Hackerzzz"I cannot recommend it enough."—Tony Robinson, Security BoulevardTable of ContentsPraise for Practical Malware Analysis; Warning; About the Authors; About the Technical Reviewer; About the Contributing Authors; Foreword; Acknowledgments; Individual Thanks; Introduction; What Is Malware Analysis?; Prerequisites; Practical, Hands-On Learning; What's in the Book?; Chapter 0: Malware Analysis Primer; 1.1 The Goals of Malware Analysis; 1.2 Malware Analysis Techniques; 1.3 Types of Malware; 1.4 General Rules for Malware Analysis; Basic Analysis; Chapter 1: Basic Static Techniques; 2.1 Antivirus Scanning: A Useful First Step; 2.2 Hashing: A Fingerprint for Malware; 2.3 Finding Strings; 2.4 Packed and Obfuscated Malware; 2.5 Portable Executable File Format; 2.6 Linked Libraries and Functions; 2.7 Static Analysis in Practice; 2.8 The PE File Headers and Sections; 2.9 Conclusion; 2.10 Labs; Chapter 2: Malware Analysis in Virtual Machines; 3.1 The Structure of a Virtual Machine; 3.2 Creating Your Malware Analysis Machine; 3.3 Using Your Malware Analysis Machine; 3.4 The Risks of Using VMware for Malware Analysis; 3.5 Record/Replay: Running Your Computer in Reverse; 3.6 Conclusion; Chapter 3: Basic Dynamic Analysis; 4.1 Sandboxes: The Quick-and-Dirty Approach; 4.2 Running Malware; 4.3 Monitoring with Process Monitor; 4.4 Viewing Processes with Process Explorer; 4.5 Comparing Registry Snapshots with Regshot; 4.6 Faking a Network; 4.7 Packet Sniffing with Wireshark; 4.8 Using INetSim; 4.9 Basic Dynamic Tools in Practice; 4.10 Conclusion; 4.11 Labs; Advanced Static Analysis; Chapter 4: A Crash Course in x86 Disassembly; 5.1 Levels of Abstraction; 5.2 Reverse-Engineering; 5.3 The x86 Architecture; 5.4 Conclusion; Chapter 5: IDA Pro; 6.1 Loading an Executable; 6.2 The IDA Pro Interface; 6.3 Using Cross-References; 6.4 Analyzing Functions; 6.5 Using Graphing Options; 6.6 Enhancing Disassembly; 6.7 Extending IDA with Plug-ins; 6.8 Conclusion; 6.9 Labs; Chapter 6: Recognizing C Code Constructs in Assembly; 7.1 Global vs. Local Variables; 7.2 Disassembling Arithmetic Operations; 7.3 Recognizing if Statements; 7.4 Recognizing Loops; 7.5 Understanding Function Call Conventions; 7.6 Analyzing switch Statements; 7.7 Disassembling Arrays; 7.8 Identifying Structs; 7.9 Analyzing Linked List Traversal; 7.10 Conclusion; 7.11 Labs; Chapter 7: Analyzing Malicious Windows Programs; 8.1 The Windows API; 8.2 The Windows Registry; 8.3 Networking APIs; 8.4 Following Running Malware; 8.5 Kernel vs. User Mode; 8.6 The Native API; 8.7 Conclusion; 8.8 Labs; Advanced Dynamic Analysis; Chapter 8: Debugging; 9.1 Source-Level vs. Assembly-Level Debuggers; 9.2 Kernel vs. User-Mode Debugging; 9.3 Using a Debugger; 9.4 Exceptions; 9.5 Modifying Execution with a Debugger; 9.6 Modifying Program Execution in Practice; 9.7 Conclusion; Chapter 9: OllyDbg; 10.1 Loading Malware; 10.2 The OllyDbg Interface; 10.3 Memory Map; 10.4 Viewing Threads and Stacks; 10.5 Executing Code; 10.6 Breakpoints; 10.7 Loading DLLs; 10.8 Tracing; 10.9 Exception Handling; 10.10 Patching; 10.11 Analyzing Shellcode; 10.12 Assistance Features; 10.13 Plug-ins; 10.14 Scriptable Debugging; 10.15 Conclusion; 10.16 Labs; Chapter 10: Kernel Debugging with WinDbg; 11.1 Drivers and Kernel Code; 11.2 Setting Up Kernel Debugging; 11.3 Using WinDbg; 11.4 Microsoft Symbols; 11.5 Kernel Debugging in Practice; 11.6 Rootkits; 11.7 Loading Drivers; 11.8 Kernel Issues for Windows Vista, Windows 7, and x64 Versions; 11.9 Conclusion; 11.10 Labs; Malware Functionality; Chapter 11: Malware Behavior; 12.1 Downloaders and Launchers; 12.2 Backdoors; 12.3 Credential Stealers; 12.4 Persistence Mechanisms; 12.5 Privilege Escalation; 12.6 Covering Its Tracks--User-Mode Rootkits; 12.7 Conclusion; 12.8 Labs; Chapter 12: Covert Malware Launching; 13.1 Launchers; 13.2 Process Injection; 13.3 Process Replacement; 13.4 Hook Injection; 13.5 Detours; 13.6 APC Injection; 13.7 Conclusion; 13.8 Labs; Chapter 13: Data Encoding; 14.1 The Goal of Analyzing Encoding Algorithms; 14.2 Simple Ciphers; 14.3 Common Cryptographic Algorithms; 14.4 Custom Encoding; 14.5 Decoding; 14.6 Conclusion; 14.7 Labs; Chapter 14: Malware-Focused Network Signatures; 15.1 Network Countermeasures; 15.2 Safely Investigate an Attacker Online; 15.3 Content-Based Network Countermeasures; 15.4 Combining Dynamic and Static Analysis Techniques; 15.5 Understanding the Attacker's Perspective; 15.6 Conclusion; 15.7 Labs; Anti-Reverse-Engineering; Chapter 15: Anti-Disassembly; 16.1 Understanding Anti-Disasseeeeeembly; 16.2 Defeating Disassembly Algorithms; 16.3 Anti-Disassembly Techniques; 16.4 Obscuring Flow Control; 16.5 Thwarting Stack-Frame Analysis; 16.6 Conclusion; 16.7 Labs; Chapter 16: Anti-Debugging; 17.1 Windows Debugger Detection; 17.2 Identifying Debugger Behavior; 17.3 Interfering with Debugger Functionality; 17.4 Debugger Vulnerabilities; 17.5 Conclusion; 17.6 Labs; Chapter 17: Anti-Virtual Machine Techniques; 18.1 VMware Artifacts; 18.2 Vulnerable Instructions; 18.3 Tweaking Settings; 18.4 Escaping the Virtual Machine; 18.5 Conclusion; 18.6 Labs; Chapter 18: Packers and Unpacking; 19.1 Packer Anatomy; 19.2 Identifying Packed Programs; 19.3 Unpacking Options; 19.4 Automated Unpacking; 19.5 Manual Unpacking; 19.6 Tips and Tricks for Common Packers; 19.7 Analyzing Without Fully Unpacking; 19.8 Packed DLLs; 19.9 Conclusion; 19.10 Labs; Special Topics; Chapter 19: Shellcode Analysis; 20.1 Loading Shellcode for Analysis; 20.2 Position-Independent Code; 20.3 Identifying Execution Location; 20.4 Manual Symbol Resolution; 20.5 A Full Hello World Example; 20.6 Shellcode Encodings; 20.7 NOP Sleds; 20.8 Finding Shellcode; 20.9 Conclusion; 20.10 Labs; Chapter 20: C++ Analysis; 21.1 Object-Oriented Programming; 21.2 Virtual vs. Nonvirtual Functions; 21.3 Creating and Destroying Objects; 21.4 Conclusion; 21.5 Labs; Chapter 21: 64-Bit Malware; 22.1 Why 64-Bit Malware?; 22.2 Differences in x64 Architecture; 22.3 Windows 32-Bit on Windows 64-Bit; 22.4 64-Bit Hints at Malware Functionality; 22.5 Conclusion; 22.6 Labs; Important Windows Functions; Tools for Malware Analysis; Solutions to Labs; Lab 1-1 Solutions; Lab 1-2 Solutions; Lab 1-3 Solutions; Lab 1-4 Solutions; Lab 3-1 Solutions; Lab 3-2 Solutions; Lab 3-3 Solutions; Lab 3-4 Solutions; Lab 5-1 Solutions; Lab 6-1 Solutions; Lab 6-2 Solutions; Lab 6-3 Solutions; Lab 6-4 Solutions; Lab 7-1 Solutions; Lab 7-2 Solutions; Lab 7-3 Solutions; Lab 9-1 Solutions; Lab 9-2 Solutions; Lab 9-3 Solutions; Lab 10-1 Solutions; Lab 10-2 Solutions; Lab 10-3 Solutions; Lab 11-1 Solutions; Lab 11-2 Solutions; Lab 11-3 Solutions; Lab 12-1 Solutions; Lab 12-2 Solutions; Lab 12-3 Solutions; Lab 12-4 Solutions; Lab 13-1 Solutions; Lab 13-2 Solutions; Lab 13-3 Solutions; Lab 14-1 Solutions; Lab 14-2 Solutions; Lab 14-3 Solutions; Lab 15-1 Solutions; Lab 15-2 Solutions; Lab 15-3 Solutions; Lab 16-1 Solutions; Lab 16-2 Solutions; Lab 16-3 Solutions; Lab 17-1 Solutions; Lab 17-2 Solutions; Lab 17-3 Solutions; Lab 18-1 Solutions; Lab 18-2 Solutions; Lab 18-3 Solutions; Lab 18-4 Solutions; Lab 18-5 Solutions; Lab 19-1 Solutions; Lab 19-2 Solutions; Lab 19-3 Solutions; Lab 20-1 Solutions; Lab 20-2 Solutions; Lab 20-3 Solutions; Lab 21-1 Solutions; Lab 21-2 Solutions;
£42.74
No Starch Press,US Hacking: The Art Of Exploitation, 2nd Edition
Book SynopsisHacking is the art of creative problem solving, whether that means finding an unconventional solution to a difficult problem or exploiting holes in sloppy programming. Many people call themselves hackers, but few have the strong technical foundation needed to really push the envelope. Rather than merely showing how to run existing exploits, author Jon Erickson explains how arcane hacking techniques actually work. To share the art and science of hacking in a way that is accessible to everyone, Hacking: The Art of Exploitation, 2nd Edition introduces the fundamentals of C programming from a hacker's perspective. The included LiveCD provides a complete Linux programming and debugging environment all without modifying your current operating system. Use it to follow along with the book's examples as you fill gaps in your knowledge and explore hacking techniques on your own. Get your hands dirty debugging code, overflowing buffers, hijacking network communications, bypassing protections, exTrade Review"A book this good is a rare find, and certainly worth the read for any individual interested in security. Rating: 9/10"—Slashdot"We can surely say that this book is one of the essential hacking books of all time."—Hackerzzz"This book does a great job of covering C programming, assembly programming, vulnerability discovery, and exploitation all in one. If you are going to read only one book, start here."—Dino Dai Zovi"Anyone can read this book to get a good understanding of how network hacking was started . . . if you want to know early 20’s hacking theories, this book is for you!"—Mic Johnson, Latest Hacking News, "Five Best Hacking Books That Are Still Relevant in 2021""Like all good books, Hacking: The Art of Exploitation, 2nd Edition encourages you to get your hands dirty. Each chapter focuses on a series of examples with finely worded guidance from Erickson. It's not a beast of a read either; it is highly accessible with an emphasis on allowing practice of the examples rather than drowning the reader in hacking theory."—The Register"With especially clear coverage of heap and stack overflows, this book not only explains what's involved in hacking, but walks readers through common tools and techniques."—InformIT"A security professional's paradise, burrowing down to the code level of dozens of different loopholes and explaining the underlying logic behind the attacks."—GeekDad on Wired.com"This is a good book. It does a great job of first establishing the mindset of a hacker and then walking the reader step by step through the various techniques of finding interesting ways to solve problems. This in itself is what the author claims is the defining characteristic of a hacker, and I agree."—;login: The USENIX Magazine"This book will take any programmer well beyond the usual programming techniques covered in conventional programming books."—Electronic Design"Those whose jobs are to protect computer systems and applications must understand these flaws and techniques in order to fix, prevent and protect against them. This does not only apply to computing, but to any other field where a 'bad guy' can take advantage of a system for their own selfish reasons. Once knowledge has been released, it becomes very difficult to put it back in its box. This book is just knowledge wrapped in a different package. We recommend you strongly consider this title if you would like to enter this field or add to your repertoire."—Gizmos for Geeks"Jon Erickson has completed the second edition of his seminal work, Hacking: The Art of Exploitation, adding a significant amount of text to the original work. In doing so, he has created a work that will quickly become a "go-to" guide for anyone wanting to learn hacking, or who wants to understand the hacking mindset."—Blogcritics.org"Personally, this is a book I am extremely glad to own. I see it as a powerful tool in the arsenal of both sysadmins and developers alike in guarding their applications and systems from these attacks, as well as understanding what to look for, how they can happen, and the mindset of those trying them out."—Cory Foy, software developer"This fantastic little book - actually not so little anymore at 488 pages - is a real gem for the serious code geek, or those in search of their inner code geek."—The IT Security Guy"I now recommend this book for the Exploitation chapter alone. This chapter covers buffer and function overflows and the format string vulnerability. Buy the book and discover why strings should be formatted like this:printf("%s", text);and never like this:printf(text);"—Linux Pro Magazine"Probably the most detailed, thorough, and lucid coverage of 'the fundamental techniques of serious hacking.'"—Major Keary, Linux and Open Source SIG"The most important book on a real hacker's library. . . . I like to think that this book resembles the Holy Grail of Hacking."—Sudo Realm"Hacking: The Art of Exploitation will cover everything you need to know, however this book is extremely technical and seriously in depth, definitely not for script kiddies. Starts simple and ramps up very fast. I give five stars and a (black) hat off."—quotebotTable of ContentsHACKING: THE ART OF EXPLOITATION, 2ND EDITION.ACKNOWLEDGMENTSPREFACEChapter 0x100: INTRODUCTIONChapter 0x200: PROGRAMMINGChapter 0x300: EXPLOITATIONChapter 0x400: NETWORKINGChapter 0x500: SHELLCODEChapter 0x600: COUNTERMEASURESChapter 0x700: CRYPTOLOGYChapter 0x800: CONCLUSIONCOLOPHON
£38.39
Pearson Education (US) Continuous Architecture in Practice
Book Synopsis Murat Erder has more than twenty-five years' experience in the software industry working for software vendors, management consultancies and large international banks. During his career Murat has had a variety of roles, from developer, to software architect, to management consultant. Murat's corporate IT roles cover the areas of data, integration, architecture and working as a CTO. He is co-author of the book Continuous Architecture: Sustainable Architecture in an Agile and Cloud-Centric World (2015) and has presented on this topic at a range of conferences, including SEI Saturn, O'Reilly Software Architecture and GOTOLondon. Pierre Pureur is an experienced software architect, with extensive innovation and application development background, vast exposure to the financial services industry, broad consulting experience and comprehensive technology infrastructure knowledge. His past roles include serving as Chief EnTrade Review" Continuous Architecture in Practice captures the key concerns of software architects today, including security, scalability and resilience, and provides valuable insights into managing emerging technologies such as machine/deep learning and blockchain. A recommended read!" --Jan Bosch, Professor of Software Engineering and Director of the Software Center at Chalmers University of Technology, Sweden " Continuous Architecture in Practice is a great introduction to modern-day software architecture, explaining the importance of shifting architectural thinking 'left' in order to form a set of firm foundations for delivery and continuous architecture evolution. I really liked the coverage of quality attributes, with a real-world case study providing a way to highlight the real-world complexities of the trade-offs associated with different solutions. The set of references to other material is impressive too, making this book incredibly useful for readers new to the domain of software architecture." --Simon Brown, author of Software Architecture for Developers "In our ever-changing world of increasing system complexity, the responsibilities and skills required to be a software architect must continually evolve. Successfully adapting to constant requirements, technology, and business changes requires an architect to be multi-skilled, capable in engineering and technology, business and management. The role of architect has never been more challenging. "This is why Continuous Architecture in Practice is an important book for all architects to absorb. The principles-based approach espoused in this book can be used to guide architects in charting a successful path in a broad range of project contexts. The essential activities for software architects present an excellent overview of the core professional skills an agile architect must possess, regardless of the problem domain and technologies in use. "Most notably, the book devotes chapters to the key run-time quality attributes that drive modern systems. Security, performance, scalability, and resilience are the lifeblood of Internet-facing systems. Each chapter provides a contemporary overview of the characteristics of these quality attributes and explains tactics an architect can adopt to design and evolve systems that are built for long term survival. An additional chapter on data architectures recognizes an important system component that is rarely covered in architecture books. Data lies at the heart of most systems and creating resilient and scalable data architectures exploiting modern data technologies is a skill all architects should have. "Written in an approachable, concise, and informative style, with concepts illustrated using an ongoing case study, this is an excellent book that will help architects address the many challenges of engineering systems in the 2020s and beyond. It is a deep source of knowledge suitable for practicing and aspiring architects, and an advanced college course in software architecture. It will repay the time investment many times over." --Professor Ian Gorton, Northeastern University "Focus on software architecture can get lost when talking about agile software practices. However, the importance of architecture in software systems has always been and continues to be relevant. The authors address this important topic with their second book on Continuous Architecture. This time they provide advice on aspects that will make or break your system, from data to security, scalability and resilience. A much recommended book that offers practical guidance for anyone developing systems in today's rapidly evolving technology landscape." --Ivar Jacobson "This book continues the journey where its predecessor left off. Software today is never-ending, and true to its name, this book looks at continuing trends and applies Continuous Architecture principles using practical examples. The authors avoid the trap of picking popular tools whose relevance quickly expire, choosing instead to look at those trends that should influence and shape architecture decisions. This book will be essential reading for any person wanting to design and architect software systems that continue to keep up with the times." --Patrick Kua, CTO Coach and Mentor "In the two-decade-old conflict between 'big upfront design' and 'emergent architecture,' software architects have often had a hard time finding a meaningful compromise. In Continuous Architecture in Practice, Erder, Pureur, and Woods provide them with a proven path. This book is a big leap forward: I liked the more systematic use of architectural tactics--a design artifact that has not been exploited as much as it should. And that they brought the concept of architectural technical debt to a more prominent position in the process of making technical and managerial decisions." --Philippe Kruchten, software architect "It's high time that Agile architecture evolved from oxymoron to what it really needs to be, a lean, enabling practice that accelerates development and delivery of the next generation of resilient and scalable enterprise class systems. Continuous Architecture in Practice is another quantum step toward that goal and provides practical guidance toward creating designs that are responsive to changing requirements and technologies." --Dean Leffingwell, creator of SAFeTable of ContentsForeword by Vaughn Vernon, Series Editor xvForeword by Kurt Bittner xixIntroduction xxiAcknowledgments xxvAbout the Authors xxvii Chapter 1: Why Software Architecture Is More Important than Ever 1 What Do We Mean by Architecture? 1 Software Industry Today 3 Current Challenges with Software Architecture 5 Software Architecture in an (Increasingly) Agile World 8 Introducing Continuous Architecture 11 Applying Continuous Architecture 17 Introduction to the Case Study 19 Summary 22 Chapter 2: Architecture in Practice: Essential Activities 23 Essential Activities Overview 24 Architectural Decisions 26 Quality Attributes 32 Technical Debt 36 Feedback Loops: Evolving an Architecture 42 Common Themes in Today's Software Architecture Practice 48 Summary 54 Chapter 3: Data Architecture 55 Data as an Architectural Concern 56 Key Technology Trends 60 Additional Architectural Considerations 76 Summary 84 Further Reading 85 Chapter 4: Security as an Architectural Concern 87 Security in an Architectural Context 88 Architecting for Security 92 Architectural Tactics for Mitigation 101 Maintaining Security 115 Summary 119 Further Reading 119 Chapter 5: Scalability as an Architectural Concern 123 Scalability in the Architectural Context 124 Architecting for Scalability: Architecture Tactics 134 Summary 155 Further Reading 156 Chapter 6: Performance as an Architectural Concern 159 Performance in the Architectural Context 159 Architecting for Performance 163 Summary 183 Further Reading 184 Chapter 7: Resilience as an Architectural Concern 187 Resilience in an Architectural Context 188 Architecting for Resilience 195 Architectural Tactics for Resilience 200 Maintaining Resilience 216 Summary 222 Further Reading 223 Chapter 8: Software Architecture and Emerging Technologies 225 Using Architecture to Deal with Technical Risk Introduced by New Technologies 226 Introduction to Artificial Intelligence, Machine Learning, and Deep Learning 227 Using Machine Learning for TFX 230 Using a Shared Ledger for TFX 246 Summary 257 Further Reading 258 Chapter 9: Conclusion 259 What Changed and What Remained the Same? 259 Updating Architecture Practice 261 Data 263 Key Quality Attributes 264 The Architect in the Modern Era 267 Putting Continuous Architecture in Practice 268 Appendix A: Case Study 269Appendix B: Comparison of Technical Implementations of Shared Ledgers 299 Glossary 301Index 311
£29.69
No Starch Press,US Clojure For The Brave And True
Book SynopsisFor weeks, months nay! from the very moment you were born, you ve felt it calling to you. At long last you ll be united with the programming language you ve been longing for: Clojure! As a Lisp-style functional programming language, Clojure lets you write robust and elegant code, and because it runs on the Java Virtual Machine, you can take advantage of the vast Java ecosystem. Clojure for the Brave and True offers a 'dessert-first' approach: you ll start playing with real programs immediately, as you steadily acclimate to the abstract but powerful features of Lisp and functional programming. Inside you ll find an offbeat, practical guide to Clojure, filled with quirky sample programs that catch cheese thieves and track glittery vampires. Learn how to: Wield Clojure s core functions Use Emacs for Clojure development Write macros to modify Clojure itself Use Clojure s tools to simplify concurrency and parallel programming Clojure for the Brave and True assumes no prior experience wTable of ContentsIntroductionPart I: Environment SetupChapter 1: Building, Running, and the REPLChapter 2: How to Use Emacs, an Excellent Clojure EditorPart II: Language FundamentalsChapter 3: Do Things: A Clojure Language Crash CourseChapter 4: Core Functions in DepthChapter 5: Functional ProgrammingChapter 6: Organizing Your Project: a Librarian's TaleChapter 7: Clojure Alchemy: Reading, Evaluation, and MacrosChapter 8: Writing MacrosPart III: Advanced TopicsChapter 9: Concurrent and Parallel ProgrammingChapter 10: Clojure Metaphysics: Atoms, Refs, Vars, and Cuddle ZombiesChapter 11: Master Concurrent Processes with core.asyncChapter 12: Interacting with JavaChapter 13: Create and Extend Abstractions with Multimethods, Protocols, and RecordsAppendix A: Building and Developing with LeiningenAppendix B: Boot, the Fancy Clojure Build Framework
£34.19
MIT Press Physically Based Rendering fourth edition
Book Synopsis
£102.60
John Wiley & Sons Inc SQL For Dummies
Book SynopsisTable of ContentsIntroduction 1 About This Book 1 Foolish Assumptions 2 Icons Used in This Book 2 Beyond the Book 3 Where to Go from Here 3 Part 1: Getting Started with SQL 5 Chapter 1: Relational Database Fundamentals 7 Keeping Track of Things 8 What Is a Database? 9 Database Size and Complexity 10 What Is a Database Management System? 10 Flat Files 12 Database Models 13 Database Design Considerations 20 Chapter 2: SQL Fundamentals 23 What SQL Is and Isn’t 23 A (Very) Little History 25 SQL Statements 26 Reserved Words 28 Data Types 28 Null Values 49 Constraints 50 Using SQL in a Client/Server System 50 Using SQL on the Internet or an Intranet 52 Chapter 3: The Components of SQL 55 Data Definition Language 56 Data Manipulation Language 68 Data Control Language 76 Part 2: Using SQL to Build Databases 83 Chapter 4: Building and Maintaining a Simple Database Structure 85 Using a RAD Tool to Build a Simple Database 86 Building POWER with SQL’s DDL 98 Portability Considerations 107 Chapter 5: Building a Multi-table Relational Database 109 Designing a Database 110 Working with Indexes 119 Maintaining Data Integrity 122 Normalizing the Database 134 Part 3: Storing and Retrieving Data 141 Chapter 6: Manipulating Database Data 143 Retrieving Data 144 Creating Views 145 Updating Views 149 Adding New Data 150 Chapter 7: Handling Temporal Data 163 Understanding Times and Periods 164 Working with Application-Time Period Tables 165 Working with System-Versioned Tables 171 Tracking Even More Time Data with Bitemporal Tables 175 Formatting and Parsing Dates and Times 176 Chapter 8: Specifying Values 179 Values 179 Value Expressions 186 Functions 189 Chapter 9: Using Advanced SQL Value Expressions 209 CASE Conditional Expressions 210 CAST Data-Type Conversions 217 Row Value Expressions 221 Chapter 10: Zeroing In on the Data You Want 223 Modifying Clauses 224 FROM Clauses 225 WHERE Clauses 226 Logical Connectives 243 GROUP BY Clauses 245 HAVING Clauses 247 ORDER BY Clauses 248 Limited FETCH 250 Peering through a Window to Create a Result Set 251 Chapter 11: Using Relational Operators 259 UNION 259 INTERSECT 262 EXCEPT 264 Join Operators 265 ON versus WHERE 282 Chapter 12: Delving Deep with Nested Queries 283 What Subqueries Do 285 Chapter 13: Recursive Queries 303 What Is Recursion? 303 What Is a Recursive Query? 306 Where Might You Use a Recursive Query? 306 Where Else Might You Use a Recursive Query? 311 Part 4: Controlling Operations 313 Chapter 14: Providing Database Security 315 The SQL Data Control Language 316 User Access Levels 316 Granting Privileges to Users 318 Granting Privileges across Levels 325 Granting the Power to Grant Privileges 327 Taking Privileges Away 328 Using GRANT and REVOKE Together to Save Time and Effort 329 Chapter 15: Protecting Data 331 Threats to Data Integrity 332 Reducing Vulnerability to Data Corruption 336 Constraints Within Transactions 345 Avoiding SQL Injection Attacks 350 Chapter 16: Using SQL within Applications 351 SQL in an Application 352 Hooking SQL into Procedural Languages 354 Part 5: Taking SQL to the Real World 365 Chapter 17: Accessing Data with ODBC and JDBC 367 ODBC 368 ODBC in a Client/Server Environment 370 ODBC and the Internet 370 ODBC and an Intranet 373 JDBC 373 Chapter 18: Operating on XML Data with SQL 377 How XML Relates to SQL 377 The XML Data Type 378 Mapping SQL to XML and XML to SQL 380 SQL Functions That Operate on XML Data 385 Predicates 390 Transforming XML Data into SQL Tables 392 Mapping Non-Predefined Data Types to XML 393 The Marriage of SQL and XML 398 Chapter 19: SQL and JSON 399 Using JSON with SQL 400 The SQL/JSON Data Model 401 SQL/JSON Functions 403 SQL/JSON Path Language 411 There’s More 412 Part 6: Advanced Topics 413 Chapter 20: Stepping through a Dataset with Cursors 415 Declaring a Cursor 416 Opening a Cursor 421 Fetching Data from a Single Row 422 Closing a Cursor 425 Chapter 21: Adding Procedural Capabilities with Persistent Stored Modules 427 Compound Statements 428 Flow of Control Statements 435 Stored Procedures 440 Stored Functions 442 Privileges 442 Stored Modules 443 Chapter 22: Handling Errors 445 SQLSTATE 445 WHENEVER Clause 447 Diagnostics Areas 448 Handling Exceptions 455 Chapter 23: Triggers 457 Examining Some Applications of Triggers 457 Creating a Trigger 458 Firing a Succession of Triggers 460 Referencing Old Values and New Values 461 Firing Multiple Triggers on a Single Table 462 Part 7: The Parts of Tens 463 Chapter 24: Ten Common Mistakes 465 Assuming That Your Clients Know What They Need 465 Ignoring Project Scope 466 Considering Only Technical Factors 466 Not Asking for Client Feedback 466 Always Using Your Favorite Development Environment 467 Using Your Favorite System Architecture Exclusively 467 Designing Database Tables in Isolation 467 Neglecting Design Reviews 468 Skipping Beta Testing 468 Not Documenting Your Process 468 Chapter 25: Ten Retrieval Tips 469 Verify the Database Structure 470 Try Queries on a Test Database 470 Double-Check Queries That Include Joins 470 Triple-Check Queries with Subselects 470 Summarize Data with GROUP BY 471 Watch GROUP BY Clause Restrictions 471 Use Parentheses with AND, OR, and NOT 471 Control Retrieval Privileges 472 Back Up Your Databases Regularly 472 Handle Error Conditions Gracefully 472 Appendix: ISO/IEC SQL: 2016 Reserved Words 473 Index 479
£22.09
McGraw-Hill Education Hacking Electronics Learning Electronics with
Book SynopsisPublisher's Note: Products purchased from Third Party sellers are not guaranteed by the publisher for quality, authenticity, or access to any online entitlements included with the product.Up-to-date hacks that will breathe life into your Arduino and Raspberry Pi creations!This intuitive DIY guide shows how to wire, disassemble, tweak, and re-purpose household devices and integrate them with your Raspberry Pi and Arduino inventions. Packed with full-color illustrations, photos, and diagrams, Hacking Electronics: Learning Electronics with Arduino and Raspberry Pi, Second Edition, features fun, easy-to-follow projects. Youâll discover how to build an Internet-controlled hacked electric toy, ultrasonic rangefinder, remote-controlled robotic rover, audio amp, slot car brakes and headlightsâeven a smart card reader!â Get up and running on both Arduino and Raspberry P
£21.84
Little, Brown Book Group The Selftaught Programmer
Book Synopsis''One of the best software design books of all time'' - BookAuthorityCory Althoff is a self-taught programmer. After a year of self-study, he learned to program well enough to land a job as a software engineer II at eBay. But once he got there, he realised he was severely under-prepared. He was overwhelmed by the amount of things he needed to know but hadn''t learned. His journey learning to program, and his experience in first software engineering job were the inspiration for this book. This book is not just about learning to program, although you will learn to code. If you want to program professionally, it is not enough to learn to code; that is why, in addition to helping you learn to program, Althoff also cover the rest of the things you need to know to program professionally that classes and books don''t teach you. The Self-taught Programmer is a roadmap, a guide to take you from writing your first Python program to passing your first technTrade ReviewI always keep a few copies of The Self-taught Programmer around to give to anyone that comes to me for career advice -- Robin Abrams, board member, HCL Technologies, FactSet Research, Lattice Semiconductor and Sierra WirelessWant to learn to program professionally? Follow Cory's advice -- David Phillips, co-founder, Hackbright AcademyI am incredibly impressed with this book -- JoAnn Buchanan, senior research associate, Allen Institute for Brain ScienceLearning to program is increasingly important in finance. Althoff's book taught me the skills I need to stay competitive -- Derek Schaefer, senior finance manager, Charles SchwabThe Self-taught Programmer was a pleasure to read - something I never thought I would say about a technical book -- Melinda Sacks, former writer, editor, San Jose Mercury NewsOne of the best software design books of all time * BookAuthority *
£15.29
APress The C Programmers Study Guide MCSD
Book Synopsis Prepare for Microsoft Certification Exam 70-483: Programming in C#. The What, Why, and How of each concept is presented along with quick summaries, code challenges, and exam questions to review and practice key concepts. You will learn how to use: Lambda expressions to write LINQ query expressions Asynchronous programming with the Async and Await keywords to maximize performance of slow applications Regular expressions to validate user input Reflection to create and handle types at runtime and much more The source code in the book will be available in the form of iCanCSharp notebooks and scripts that allow you to try out examples and extend them in interesting ways. What You Will Learn Understand the necessary knowledge and skill set to prepare for Microsoft Exam 70-483 Study Table of ContentsChapter 1:Fundamentals of C#.- Chapter 2: Types in C#.- Chapter 3: Getting Started with Object Oriented Programming.- Chapter 4: Advanced C#.- Chapter 5: Implementing Delegates and Events.- Chapter 6: Taking a Deep Dive into LINQ.- Chapter 7: Managing the Object Life Cycle.- Chapter 8: Multi-Threaded, Async, and Parallel Programming.- Chapter 9: Exception Handling and Validating Application Input - Chapter 10: File I/O Operations.- Chapter 11: Serialization ad Deserialization.- Chapter 12: Consuming Data.- Chapter 13: Working with Cryptography.- Chapter 14: Assembly and Reflection.- Chapter 15: Debugging and Diagnostics.- Chapter 16: MCQs.
£41.24
BCS, the Chartered Institute for IT Super User Networks for Software Projects: Best
Book SynopsisTo successfully compete in the modern world, organisations are accelerating their digital transformations. It is essential for them to utilise best practice methods when implementing new systems and adopting new technologies. The Super User Model is a proven methodology for delivering digital transformation projects, including large scale transitions.This book is designed to help project, learning and change professionals who are responsible for this delivery by introducing the Super User Model and how to use it. It provides the tools, techniques, and theory needed to plan out where and how Super Users can add value at each phase of a project - across software design, change management, testing, and training - and to manage Super User Networks beyond the transition into business as usual for sustained benefits.If your organisation is investing in new technology, you cannot afford not to use Super Users in taking the latest step in your digital transformation journey.
£33.24
No Starch Press,US The Missing Readme: A Guide for the New Software
Book SynopsisFor new software engineers, knowing how to programme is only half the battle, and many of the skills and processes key to success are not taught in any school or bootcamp. The Missing README fills in that gap with workplace lessons, best practices, and engineering fundamentals that the authors have taught rookie developers at top companies for more than a decade. This is the book your tech lead wishes every new engineer would read before they start. By the end, you'll know what it takes to transition into the workplace - from CS classes or bootcamps to professional software engineering.Trade Review“This is an impressively thorough overview of the many skills a new software engineer will need to learn, beyond coding, to be successful in the job. A great book for new college grads and those just entering the profession who want to see what the next phase of their career curriculum will be.”—Camille Fournier, former Vice President of Technology at Goldman Sachs and author of The Manager's Path: A Guide for Tech Leaders Navigating Growth and Change"The Missing README is exactly the book I wish I had when I started my career. Fun to read, full of sage advice and priceless stories. It is like having coffee with a senior mentor, except you don't even need to come up with the right questions. Very useful for engineers early in their career, and senior engineers who wonder what they missed."—Gwen Shapira, Engineering Leader at Confluent"The Missing README is an excellent practical introduction to the day-to-day realities of software engineering in the 21st century. It covers the wide range of essential skills, techniques and heuristics that you'll need to be an effective part of any team that builds, deploys and operates production systems."—Adewale Oshineye, Developer Advocate at Google and co-author of Apprenticeship Patterns"This book puts together all the things you don’t learn on your own starting out. The information is well organized and a pleasure to read. I will be giving a copy to all my interns and new college grads."—Thomas Hanley, Senior Engineering Manager"An accessible, handy guide to practical aspects of being a Software Engineer . . . The clear, Readme-style writing makes this book an excellent reference for any level Software Engineer from Intern to CTO."—Tim Burns, Data Architect"The Missing README provides practical and actionable insights for both new and seasoned developers. The authors cover, in detail, how to expertly navigate widespread obstacles software developers will encounter at any organization they join. This book is the README we all need."—George D., Advanced Reviewer“The Missing README is like having a mentor on hand to give how-to tips and general encouragement. The book acknowledges that it will not describe every workplace or every situation, but the lessons offered should prove useful to both junior engineers and those already on their career path. For undergraduate students it could serve as a textbook for the things you don’t learn in Software Engineering Class . . . I plan to incorporate the chapter on 'Learning to Learn' as part of my lesson plans because I am always happy for my students to hear advice from another source."—Mary Moore, Professor of Computer Information Systems at West Virginia University, Advanced ReviewerTable of ContentsPreface Chapter 1: The Journey Ahead Chapter 2: Getting to Conscious Competence Chapter 3: Working with Code Chapter 4: Writing Operable Code Chapter 5: Managing Dependencies Chapter 6: Testing Chapter 7: Code Reviews Chapter 8: Delivering Software Chapter 9: Going On-Call Chapter 10: Technical Design Process Chapter 11: Creating Evolvable Architectures Chapter 12: Agile Planning Chapter 13: Working with Managers Chapter 14: Navigating Your Career
£20.39
No Starch Press,US The Art of ARM Assembly Volume 1
Book SynopsisThis book is the latest in Randall Hyde's iconic series on assembly language programming. A comprehensive masterclass on 64-bit ARM, it guides you through the instruction set for the increasingly popular 64-bit ARM CPU, teaching you to translate high-level language operations into assembly language, write powerful programs unique to ARM, and handle the development of large software projects easily. This book's 'quick-start' chapter lets you hit the ground running, showing you how to begin writing simple programs right away. After learning basic 64-bit ARM architecture and syntax for the GNU assembler, Hyde goes in-depth on the fundamentals of machine organization, computer data representation and operations, and memory access. After building a strong foundational knowledge for mastering GAS, control structures, and arithmetic functions, in later chapters you'll be ready to dive into advanced ARM programming - and that's when the real fun begins. Full of illuminating illustrations, portable source code, and hands-on exercises that test your skills,The Art of ARM Assemblyis an essential reference guide from the world's foremost expert on the subject.
£60.74
No Starch Press,US Computer Science From Scratch
£33.74
No Starch Press,US Kill It With Fire: Managing Aging Computer
Book SynopsisThe Legacy Apocalypse is upon us and business, community, and political leaders at all levels need this timely and thoughtful book from a superstar in the field. Aging computer systems present complex technical challenges for organisations both large and small, and Kill It with Fire provides sound strategies for spearheading modernisation efforts. Kill It with Fire examines ageing computer systems, the evolution of technology over time, and how organisations can modernise, maintain, and future-proof their current systems.Trade Review"A valuable addition to the literature on the topic, particularly for managers and senior contributors . . . Kill it With Fire is a useful and highly readable guide to solving these problems by leveraging the organization—the system around the system."—Laura Nolan, USENIX"Modernizing legacy systems is an increasingly common task for software developers. Kill It with Fire guides you through the ins and outs of these endeavors in an engaging way, diving into both the technical and social aspects that are crucial to making you successful when undertaking modernization projects." –Damian Schenkelman, Principal Engineer, Auth0"Kill It With Fire is incredibly well timed. For those alarmed by the provocative title, rest assured the only thing Bellotti advocates torching is the notion of torching itself. And while the book is written for technical leadership, her wisdom is something many nontechnical government leaders need to hear right now, lest they fall prey to the gaggle of advisers saying things like 'we just need to get them off the mainframe.' . . . Bellotti’s book could not have come at a better time, and while there are other factors in this equation, she outlines some of the most important." —Jennifer Pahlka, OneZero"When it comes to the right processes and thought patterns for successfully dealing with legacy systems, Bellotti's remarks are worth their weight in gold."—Peter Schmitz, Heise Media"A most excellent book for both engineers and managers alike."—Michael Simons, @rotnroll666"I am RIDICULOUSLY EXCITED to read this book!"—Katie Sylor-Miller, @ksylorTable of ContentsIntroductionChapter 1: Time Is a Flat CircleChapter 2: Cannibal CodeChapter 3: Evaluating Your ArchitectureChapter 4: Why Is It Hard?Chapter 5: Building and Protecting MomentumChapter 6: Coming in MidstreamChapter 7: Design and DestinyChapter 8: Breaking ChangesChapter 9: How to FinishChapter 10: Future-ProofingConclusion
£15.19
Pearson Education (US) Enterprise Integration Patterns
Book SynopsisGregor Hohpe leads the enterprise integration practice at ThoughtWorks, Inc., a specialized provider of application development and integration services. Drawing from his extensive experience designing and implementing integration solutions for enterprise clients, Gregor has published a number of papers and articles presenting a no-hype view on enterprise integration, Web services, and Service-Oriented Architectures. He is a frequent speaker at technical conferences around the world. Bobby Woolf is coauthor of The Design Patterns Smalltalk Companion (Addison-Wesley, 1998), and author of articles in IBM DeveloperWorks, Java Developer's Journal, and elsewhere. He has been a tutorial presenter at OOPSLA, JavaEdge, and Smalltalk Solutions, among other conferences. 0321200683AB09122003Table of Contents 1. Solving Integration Problems Using Patterns 2. Integration Styles 3. Messaging Systems 4. Messaging Channels 5. Message Construction 6. Interlude: Simple Messaging 7. Message Routing 8. Message Transformation 9. Interlude: Composed Messaging 10. Messaging Endpoints 11. System Management 12. Interlude: System Management Example 13. Integration Patterns in Practice 14. Concluding Remarks
£46.79
No Starch Press,US Black Hat Python, 2nd Edition: Python Programming
Book SynopsisWhen it comes to creating powerful and effective hacking tools, Python is the language of choice for most security analysts. But just how does the magic happen? In Black Hat Python, the latest from Justin Seitz (author of the best-selling Gray Hat Python), you ll explore the darker side of Python s capabilities writing network sniffers, manipulating packets, infecting virtual machines, creating stealthy trojans, and more. You ll learn how to: Create a trojan command-and-control using GitHub Detect sandboxing and automate comèmon malware tasks, like keylogging and screenshotting Escalate Windows privileges with creative process control Use offensive memory forensics tricks to retrieve password hashes and inject shellcode into a virtual machine Extend the popular Burp Suite web-hacking tool Abuse Windows COM automation to perform a man-in-the-browser attack Exfiltrate data from a network most sneakily Insider techniques and creative challenges throughout show you how to extend thTrade Review“Black Hat Python is a fun read written by experts with years of experience who are willing to share the secrets they have learned along the way. While It might not immediately turn you into a super stunt hacker like me, it will certainly get you started down the correct path.” (from the foreword)—Charlie Miller, Security Researcher"This book breaks down how to create powerful tools using Python like network sniffers or keyloggers. This book even goes over how to escalate privileges in Windows."—Davin Jackson, Alpha Cyber Security, Books to Start Your Penetration Testing Journey"An essential resource for anyone involved in offensive security or looking to improve their Python programming skills. Its comprehensive coverage, practical examples, and step-by-step instructions make it an invaluable tool for anyone looking to become a skilled hacker or penetration tester." —InfoSecNoobs.comPraise for the first edition of Black Hat Python"Another incredible Python book. With a minor tweak or two many of these programs will have at least a ten year shelf life, and that is rare for a security book."—Stephen Northcutt, founding president of the SANS Technology Institute"A great book using Python for offensive security purposes."—Andrew Case, Volatility core developer and coauthor of The Art of Memory Forensics"If you truly have a hacker’s mindset, a spark is all you need to make it your own and do something even more amazing. Justin Seitz offers plenty of sparks."—Ethical Hacker "Whether you're interested in becoming a serious hacker/penetration tester or just want to know how they work, this book is one you need to read. Intense, technically sound, and eye-opening."—Sandra Henry-Stocker, IT World "Definitely a recommended read for the technical security professional with some basic previous exposure to Python."—Richard Austin, IEEE Cipher"A well-written book that will put you on track to being able to write powerful and potentially scary tools. It’s up to you to use them for good."—Steve Mansfield-Devine, editor of Elsevier's Network Security Newsletter"A well implemented read with lots of good ideas for fun offensive Python projects. So enjoy, and don't forget it's all about the code!"—Dan Borges, LockBoxx"A useful eye-opener."—MagPi Magazine"If you work as a computer security professional and want to code in Python, this is definitely a book that belongs on your bookshelf."—Craig Mullins, Data and Technology TodayTable of ContentsPrefaceChapter 1: Setting up Your Python EnvironmentChapter 2: Basic Networking ToolsChapter 3: Writing a SnifferChapter 4: Owning the Network with ScapyChapter 5: Web HackeryChapter 6: Extending Burp ProxyChapter 7: GitHub Command and ControlChapter 8: Common Trojaning Tasks on WindowsChapter 9: Fun with Internet ExplorerChapter 10: Windows Privilege EscalationChapter 11: Automating Offensive ForensicsIndex
£32.24
No Starch Press,US JavaScript Crash Course
Book Synopsis
£35.99
Pearson Education (US) Code That Fits in Your Head
Book SynopsisMark Seemann, a former economist, found a second career as a programmer and has worked as a web and enterprise developer since the late 1990s. He is a Certified Rockstar Developer and has written a Jolt Award-winning book about Dependency Injection, given more than a hundred international conference talks, and authored video courses for both Pluralsight and Clean Coders. Mark has regularly published his blog ( blog.ploeh.dk) since 2006.Trade Review"We progress in software by standing on the shoulders of those who came before us. Mark's vast experience ranges from philosophical and organisational considerations right down to the precise details of writing code. In this book, you're offered an opportunity to build on that experience. Use it." --Adam Ralph, speaker, tutor, and software simplifier, Particular Software "I've been reading Mark's blogs for years and he always manages to entertain while at the same time offering deep technical insights. Code That Fits in Your Head follows in that vein, offering a wealth of information to any software developer looking to take their skills to the next level." --Adam Tornhill, founder of CodeScene, author of Software Design X-Rays and Your Code as a Crime Scene "My favorite thing about this book is how it uses a single code base as a working example. Rather than having to download separate code samples, you get a single Git repository with the entire application. Its history is handcrafted to show the evolution of the code alongside the concepts being explained in the book. As you read about a particular principle or technique, you'll find a direct reference to the commit that demonstrates it in practice. Of course, you're also free to navigate the history at your own leisure, stopping at any stage to inspect, debug, or even experiment with the code. I've never seen this level of interactivity in a book before, and it brings me special joy because it takes advantage of Git's unique design in a new constructive way." --Enrico Campidoglio, independent consultant, speaker and Pluralsight author "Mark Seemann not only has decades of experience architecting and building large software systems, but is also one of the foremost thinkers on how to scale and manage the complex relationship between such systems and the teams that build them." --Mike Hadlow, freelance software consultant and blogger "Mark writes, 'Successful software endures'--this book will help you to write that kind of software." --Bryan Hogan, software architect, podcaster, blogger "Mark has an extraordinary ability to help others think deeply about the industry and profession of software development. With every interview on .NET Rocks! I have come away knowing I would have to go back and listen to my own show to really take in everything we discussed." --Richard Campbell, co-host, .NET Rocks!Table of ContentsSeries Editor Foreword xixPreface xxiiiAbout the Author xxix Part I: Acceleration 1Chapter 1: Art or Science? 3 1.1 Building a House 4 1.2 Growing a Garden 7 1.3 Towards Engineering 8 1.4 Conclusion 14 Chapter 2: Checklists 15 2.1 An Aid to Memory 15 2.2 Checklist for a New Code Base 17 2.3 Adding Checks to Existing Code Bases 29 2.4 Conclusion 32 Chapter 3: Tackling Complexity 33 3.1 Purpose 34 3.2 Why Programming Is Difficult 38 3.3 Towards Software Engineering 44 3.4 Conclusion 46 Chapter 4: Vertical Slice 49 4.1 Start with Working Software 50 4.2 Walking Skeleton 53 4.3 Outside-in 60 4.4 Complete the Slice 77 4.5 Conclusion 85 Chapter 5: Encapsulation 87 5.1 Save the Data 87 5.2 Validation 92 5.3 Protection of Invariants 105 5.4 Conclusion 108 Chapter 6: Triangulation 111 6.1 Short-Term versus Long-Term Memory 111 6.2 Capacity 114 6.3 Conclusion 127 Chapter 7: Decomposition 129 7.1 Code Rot 129 7.2 Code That Fits in Your Brain 136 7.3 Conclusion 153 Chapter 8: API Design 155 8.1 Principles of API Design 156 8.2 API Design Example 168 8.3 Conclusion 176 Chapter 9: Teamwork 177 9.1 Git 178 9.2 Collective Code Ownership 187 9.3 Conclusion 199 Part II: Sustainability 201Chapter 10: Augmenting Code 203 10.1 Feature Flags 204 10.2 The Strangler Pattern 209 10.3 Versioning 218 10.4 Conclusion 220 Chapter 11: Editing Unit Tests 223 11.1 Refactoring Unit Tests 223 11.2 See Tests Fail 233 11.3 Conclusion 234 Chapter 12: Troubleshooting 235 12.1 Understanding 235 12.2 Defects 240 12.3 Bisection 250 12.4 Conclusion 255 Chapter 13: Separation of Concerns 257 13.1 Composition 258 13.2 Cross-Cutting Concerns 267 13.3 Conclusion 274 Chapter 14: Rhythm 275 14.1 Personal Rhythm 276 14.2 Team Rhythm 282 14.3 Conclusion 285 Chapter 15: The Usual Suspects 287 15.1 Performance 288 15.2 Security 292 15.3 Other Techniques 300 15.4 Conclusion 308 Chapter 16: Tour 309 16.1 Navigation 309 16.2 Architecture 318 16.3 Usage 323 16.4 Conclusion 326 Appendix A: List of Practices 329 A.1 The 50/72 Rule 329 A.2 The 80/24 Rule 330 A.3 Arrange Act Assert 330 A.4 Bisection 330 A.5 Checklist for A New Code Base 331 A.6 Command Query Separation 331 A.7 Count the Variables 331 A.8 Cyclomatic Complexity 331 A.9 Decorators for Cross-Cutting Concerns 332 A.10 Devil's Advocate 332 A.11 Feature Flag 332 A.12 Functional Core, Imperative Shell 333 A.13 Hierarchy of Communication 333 A.14 Justify Exceptions from the Rule 333 A.15 Parse, Don't Validate 334 A.16 Postel's Law 334 A.17 Red Green Refactor 334 A.18 Regularly Update Dependencies 335 A.19 Reproduce Defects as Tests 335 A.20 Review Code 335 A.21 Semantic Versioning 335 A.22 Separate Refactoring of Test and Production Code 335 A.23 Slice 336 A.24 Strangler 336 A.25 Threat-Model 337 A.26 Transformation Priority Premise 337 A.27 X-driven Development 337 A.28 X Out Names 338 Bibliography 339Index 349
£26.99
No Starch Press,US Machine Learning Q and AI
Book Synopsis
£35.99
Pearson Education (US) Creating Agile Organizations
Book Synopsis Cesario Ramos works worldwide as a senior management consultant on large-scale Agile adoptions in the financial and high-tech industries. His international experience, a strong background in technology, and passion for people make him an influential partner in organization design and in leading the adoption of Agile. Cesario has a MSc in mathematics and computing science from the University of Eindhoven and is also a Certified LeSS Trainer and Professional Scrum Trainer from Scrum.org. Outside of his consulting work, Cesario has served as a Java/C# developer, lead software architect, CTO, and as a product manager. He is also the author of Create Agile Organizations, A Scrum Book, and EMERGENT -- Lean & Agile Adoption for an Innovative Workplace. Ilia Pavlichenko leads Agile transformations in companies around the world. He is an organization design consultant with a rigorous focus on coaching senior management. IliTable of Contents Foreword by Craig Larman xix Foreword by Dave West xxi Preface xxiii Introduction xxvii Acknowledgments xxxv About the Authors xxxvii Part I: Foundational Concepts 1 Chapter 1: Organizing for Adaptability 3 Hello, VUCA World! 3 What Is an Agile Organization Design? 4 Typical Problems When Adopting Agility 6 Avoid Copy–Paste Scaling: A Typical Scaling Approach 10 Overview of an Agile Organization Design 11 Summary 16 References 17 Chapter 2: Systems Thinking 19 Basics of Systems Thinking 19 Applying Systems Thinking 31 Summary 48 References 49 Chapter 3: Optimize for Adaptiveness 51 What It Means to Be Adaptable 53 Flow Efficiency 54 Behavior of Queues 54 Queueing System Structures 61 Algorithm for Dealing with Queues 62 Choose an Operational Strategy 63 Summary 67 References 68 Chapter 4: Agile Organizational Design 69 Why Organizational Redesign? 70 Business Strategy Drives Organizational Design 71 Overview of a Design Process 72 Agile Organization Design Guidelines 73 Agile vs. Traditional Human Resources Management 101 Summary 104 References 105 Chapter 5: An Agile Adoption Approach 107 Principles of an Agile Adoption 107 Overview of an Adoption Approach 109 Overarching Adoption Guidelines 111 Applying Systems Thinking in Organizational Coaching 120 Summary 130 References 131 Chapter 6: Coaching for Change 133 Guideline 1: Influence People 134 Guideline 2: Co-Create the Change 136 Guideline 3: Voluntary Participation 139 Guideline 4: Acknowledge the Loss 144 Guideline 5: Deliver the Message Continually 147 Guideline 6: Help People to Cross the Edge 149 Guideline 7: Axes of Change 153 Guideline 8: Find the Right Balance of Radical/Incremental Change 159 Summary 161 References 162 Part II: Applying the Concepts 165 Chapter 7: Group Facilitation 167 Principles of Facilitation 167 Workshop Design 172 Facilitating Scrum Events 178 Summary 195 References 196 Chapter 8: Preparing the Product Group 197 Areas of Concern for Successful Preparation 197 Area 1: Involve the Managers 198 Area 2: Understand the Current Reality 204 Area 3: Create a Vision of the Future 221 Area 4: Identify the Product Group 233 Organizational Design to Eliminate Dependencies 242 Summary 249 References 250 Chapter 9: Launching the Product Group 251 Menu of Available Choices 252 Initial Product Backlog Refinement 253 Define the Definition of Done 257 Feature Team Adoption Map 260 Self-Designing Team Workshop 265 Team Lift-Off 270 Identify and Launch Communities 282 Identify Coordination Mechanisms 284 Create Useful Checklists 286 Summary 288 References 289 Chapter 10: Coaching Teams 291 The Building Blocks of the Agile Organization 291 Observations of an Agile Team 292 Building on the Team Lift-Off: Coaching Multifunctional Learning 296 Dealing with Recurrent Complex Problems in Teams: Systems Team Coaching 315 Improving Team Dynamics: Trust 329 Facilitate Feedback Loops for Learning: Learning New Practices 332 Summary 335 References 335 Chapter 11: Guiding the Product Ownership 337 What Makes a Team Product Owner? 337 The Product Owner in a Senior Position 341 Product Ownership Measures 345 Customer Understanding 347 The Product Owner Process 349 Stakeholder Alignment 351 Product Owner Leadership 354 Summary 356 References 357 Appendix Case Studies and Workshop Examples 359 Index 413
£27.54
Manning Publications Data-Oriented Programming
Book SynopsisData-Oriented Programming teaches you to design and implement software using the data-oriented programming paradigm. In it, you'll learn author Yehonathan Sharvit's unique approach to DOP that he has developed over a decade of experience.Every chapter contains a new light bulb moment that will change the way you think about programming. As you read, you'll build a library management system using the DOP paradigm. You'll design data models for business entities, manipulate immutable data collections, and write unit tests for data-oriented systems. About the TechnologyData-oriented programming is an exciting new paradigm that eliminates the usual complexity caused by combining data and code into objects and classes. In DOP, you maintain application data in persistent generic data structures separated from the program's code. You use general-purpose functions to manipulate the data without mutating it. This approach rids your applications of state-related bugs and makes your code much easier to understand and maintain.Trade Review"Insightful. Nicely illustrates the limits of OOP in managing the complexity of developing software. Explains how focusing on the data can simplify solving certain problems." Gregor Rayman "This is a great guide to using Data-Oriented Programming to improve any new or existing OOP codebase." William E. Wheeler "An interesting read—a different approach that's worth examining and considering. It'll open your mind." Anne Epstein "Read this through if you want to learn a different point of view and want to experience many 'aha!' moments." Christian Kreutzer-Beck "Follows a very novel approach to introduce DOP concepts. Must read it if you want to rescue yourself from OOP." Kelum Prabath Senanayake
£43.69
No Starch Press,US Object-oriented Python: Master OOP by Building
Book SynopsisObject-Oriented Python is an intuitive and thorough guide to mastering object-oriented programming from the ground up. You'll cover the basics of building classes and creating objects, and put theory into practice using the pygame package with clear examples that help visualize the object-oriented style. You'll explore the key concepts of object-oriented programming - encapsulation, polymorphism, and inheritance - and learn not just how to code with objects, but the absolute best practices for doing so. Finally, you'll bring it all together by building a complex video game, complete with full animations and sounds. The book covers two fully functional Python code packages that will speed up development of graphical user interface (GUI) programs in Python.Trade Review"If only I could have learned programming with this book! Any sufficiently advanced Python code will work with classes and Irv Kalb has provided a useful, fun introduction to Object-Oriented Programming (OOP). The projects start simple and build upon each other, always with a specific outcome in mind. For example, the first example is a basic card game written in procedural Python. A dozen chapters later, you'll be including card graphics and keeping track of the state of the deck with OOP concepts like encapsulation, polymorphism, and inheritance—all without reading a dry textbook. Object-Oriented Python is a fun way for new coders to level up their skills."— Adam DuVander, EveryDeveloper"The projects for the most part are real world appropriate, and easily understandable for multiple levels of expertise of the readers . . . Anyone who is interested in learning Python Object Oriented Programming would benefit by having this book in their library. Kudos to both Mr. Kalb and No Starch Press for this book!"—Full Circle Magazine
£32.24
No Starch Press,US The Book Of Kubernetes: A Complete Guide to
Book SynopsisContainers ensure that software runs reliably no matter where it's deployed, and Kubernetes lets you manage all of your containers from a single control plane. In this comprehensive tour of the open-source platform, each chapter includes a set of example scripts with just enough automation to start your container exploration with ease. Beginning with an overview of modern architecture and the benefits of orchestration, you'll quickly learn how to create containers; how to deploy, administer and debug Kubernetes clusters all the way down to the OS.Table of ContentsPart I: Making and Using ContainersChapter 1: Why Containers MatterChapter 2: Process IsolationChapter 3: Resource LimitingChapter 4: Network NamespacesChapter 5: Container Images and Runtime LayersPart II: Containers in KubernetesChapter 6: Why Kubernetes MattersChapter 7: Deploying Containers to KubernetesChapter 8: Ovelay NetworksChapter 9: Service and Ingress NetworksChapter 10: When Things Go WrongChapter 11: Control Plane and Worker NodesChapter 12: Container RuntimeChapter 13: Health ProbesChapter 14: Limits and QuotasChapter 15: Persistent StorageChapter 16: Configuration and SecretsChapter 17: Custom ResourcesPart III: Performant KubernetesChapter 18: Affinity and Anti-AffinityChapter 19: Tuning Pods per NodeChapter 20: Application Resiliency
£42.74
McGraw-Hill Education Java A Beginners Guide Tenth Edition
Book SynopsisA hands-on introduction to Java programmingâfully revised for the latest version, Java SE 21Thoroughly updated for Java Platform Standard Edition 21, this practical resource uses a proven, step-by-step approach to teach the fundamentals of Java. You will discover how to get started programming in Java from the very first chapter. Written by Java guru Herbert Schildt and updated by Dr. Danny Coward, the book starts with the basics, such as how to create, compile, and run a Java program. From there, you will learn essential Java keywords, syntax, and commands.Java: A Beginner's Guide, Tenth Edition covers the basics and touches on advanced features, including multithreaded programming, generics, Lambda expressions, and Swing. Enumeration, modules, and interface methods are also clearly explained. This proven guide delivers the appropriate mix of theory and practical coding necessary to get readers up and running developing their own Java applications from t
£26.99
Oxford University Press Inc Arduino for Musicians A Complete Guide to Arduino
Book SynopsisThe Arduino platform provides a virtually limitless range of creative opportunities to musicians who are interested to explore new technologies. In Arduino for Musicians, Brent Edstrom provides a comprehensive guide to the underlying technologies enabling the creation of custom instruments that respond to light, touch, breath, and other forms of control.Trade Review"I heartily recommend this book as a way to get started with Arduino or electronics even for non-musicians. But if you ever wanted to make your own Moog synth or Theremin (and who hasn't) then you will love this book."--Dr. Simon Monk, author and maker "A comprehensive and easy to use guide for everything you may need to know about how to use the Arduino for musical applications. The book is well-organized, allowing both technical novices and experienced music technologists to find the information and guidance they may be looking for."--Gil Weinberg, Professor and Director, Georgia Tech Center for Music Technology "Edstrom has developed a very useful resource for musicians interested in using microcomputer controllers and software tools in Arduino for Musicians. This publication, organized in three sections, serves not only as an introduction for those just learning the world of the Arduino, but also for those learning to use the open-source electronics platform to apply creative applications of the core concepts for the more advanced projects. The intermediate and advanced sections are written in a casual narrative style with well-organized sequencing. The book is a welcome addition as a resource or required text for undergraduate or graduate students enrolled in music technology or related courses in multimedia performance."--G. David Peters, Professor and Head of Graduate Studies, Music and Arts Technology, Indiana University - IUPUITable of ContentsTable of Contents Forward Chapter 1 Getting Started Chapter 2 Introduction To Programming Chapter 3 Introduction To Electronics Chapter 4 Interfacing With Arduino Chapter 5 Music Instrument Digital Interface (MIDI) I/O Chapter 6 Real-Time Input: Musical Expression Chapter 7 Music-Making Shields Chapter 8 Programming Part II Chapter 9 Audio Output and Sound Synthesis Chapter 10 Audio Input Chapter 11 Finalizing Projects Chapter 12 Standalone Arduino Chapter 13 MIDI Hand Drum Project Chapter 14 Stella Synthesizer Project Chapter 15 Step Sequencer Project Chapter 16 Emöte MIDI Controller Notes Bibliography Appendix A: MIDI Control Changes Appendix B: MMC Commands Appendix C: Introduction to Bit Twiddling Index
£44.99
No Starch Press,US Game Hacking
Book SynopsisYou don t need to be a wizard to transform a game you like into a game you love. Imagine if you could give your favorite PC game a more informative heads-up display or instantly collect all that loot from your latest epic battle. Bring your knowledge of Windows-based development and memory management, and Game Hacking will teach you what you need to become a true game hacker. Learn the basics, like reverse engineering, assembly code analysis, programmatic memory manipulation, and code injection, and hone your new skills with hands-on example code and practice binaries. Level up as you learn how to: Scan and modify memory with Cheat Engine Explore program structure and execution flow with OllyDbg Log processes and pinpoint useful data files with Process Monitor Manipulate control flow through NOPing, hooking, and more Locate and dissect common game memory structures You ll even discover the secrets behind common game bots, including: Extrasensory perception hacks, such as wallhacTable of ContentsIntroductionPART 1: TOOLS OF THE TRADEChapter 1: Scanning Memory Using Cheat EngineChapter 2: Debugging Games with OllyDbgChapter 3: Reconnaissance with Process Monitor and Process ExplorerPART 2: GAME DISSECTIONChapter 4: From Code to Memory: A General PrimerChapter 5: Advanced Memory ForensicsChapter 6: Reading from and Writing to Game MemoryPART 3: PROCESS PUPPETEERINGChapter 7: Code InjectionChapter 8: Manipulating Control Flow in a GamePART 4: CREATING BOTSChapter 9: Using Extrasensory Perception to Ward Off Fog of WarChapter 10: Responsive HacksChapter 11: Putting It All Together: Writing Autonomous Bots1Chapter 12: Staying Hidden
£34.39
Manning Publications Spring Microservices in Action
Book SynopsisBy dividing large applications into separate self-contained units, Microservices are a great step toward reducing complexity and increasing flexibility. Spring Microservices in Action, Second Edition teaches you how to build microservice-based applications using Java and the Spring platform. This second edition is fully updated for the latest version of Spring, with expanded coverage of API routing with Spring Cloud Gateway, logging with the ELK stack, metrics with Prometheus and Grafana, security with the Hashicorp Vault, and modern deployment practices with Kubernetes and Istio. about the technologyMicroservices break up your code into independent interconnected services that require careful forethought and design. Fortunately, Spring Boot, Spring Cloud, and Spring Cloud Gateway simplify the tedious plumbing and infrastructure setup required for microservice applications. Spring Boot removes the boilerplate code involved with writing a REST-based service. Spring Cloud provides a suite of tools for the discovery, routing, and deployment of microservices to the enterprise and the cloud. Spring Cloud Gateway provides a clear and effective routing to APIs, with a single entry point into a system. Together, they make it a snap to spin up Spring applications as microservices and wire them together into a reliable, scalable system. about the bookFully updated and upgraded for the latest version of Spring, Spring Microservices in Action, Second Edition is an expanded revision of a Manning bestseller. In it, you’ll learn how to build microservice-based applications using Java and the Spring platform and how to efficiently monitor and log your microservices operations. Throughout the book, carefully selected real-life examples expose microservice-based patterns for configuring, routing, scaling, and deploying your services. You'll see how Spring's intuitive tooling can help augment and refactor existing applications with microservices and how Spring Cloud Gateway makes it easy to handle multiple APIs with a single tool. You’ll also pick up best practices for using Spring with modern deployment platforms based on Kubernetes and Istio. what's inside Core microservice design principles Microservices best practices Using docker containers to run microservices Managing configuration with Spring Cloud Config and Hashicorp Vault for sensitive information Client-side resiliency with Hystrix, and Ribbon Managing application metrics with Prometheus and Grafana Intelligent routing using Spring Cloud Gateway Distributed tracing with Spring Cloud Sleuth, Zipkin and ELK Stack Deploying Spring Cloud applications with Kubernetes and Istio about the readerThis book is written for developers with Java and Spring experience. about the authors John Carnell is a senior cloud engineer with twenty years of experience in Java. Illary Huaylupo Sánchez is a software engineer with an MBA in IT management and over twelve years of experience in Java.
£35.99
No Starch Press,US Machine Learning For Kids: A Playful Introduction
Book SynopsisMachine Learning for Kids introduces young readers to the concept of Artificial Intelligence (AI) and the related applications of Machine Learning. Readers learn how to create intelligent games like a rock-paper-scissors game that can learn hand motions and use them to compete against another player; a post sorting game that will recognise the postal code on an envelope and use it to send a letter to the right place. Each project demonstrates a different way that AI is used in the real-world, and readers will be introduced to the biggest issues and challenges that the adoption of AI brings to society.Trade Review"Machine Learning for Kids is another leading-edge resource for data scientists, this time for very young data scientists."—Daniel Gutierrez, insideBIGDATA“What delights me about this book is that it’s wonderfully pragmatic, for it guides you in building AI systems that are very much relevant to contemporary computer science.” (from the foreword)—Grady Booch, IBM Fellow and Chief Scientist for Software Engineering, IBM Research"The book is a guided hands-on and practical introduction to how artificial intelligence impacts our lives. It includes step-by-step instructions for making a variety of machine learning-powered projects in Scratch, and explains how they each relate to real-world AI applications."—Alphonse Devasia Blog"Machine Learning and children in one sentence is only possible when cool folks like Dale Lane make it their passion to ‘make tech understandable.'"—Coding and More, YouTuberTable of ContentsIntroductionChapter 1. What is Artificial Intelligence?Chapter 2. Introducing Machine Learning for KidsChapter 3. Sorting Animal PicturesChapter 4. Playing Rock, Paper, Scissors Against Your ComputerChapter 5. Recognizing Movie PostersChapter 6. Mail SortingChapter 7. Insulting a ComputerChapter 8. Recognizing Language in NewspapersChapter 9. Finding an Object in a PictureChapter 10. Smart AssistantsChapter 11. ChatbotsChapter 12. Avoiding the MonsterChapter 13. Tic Tac ToeChapter 14. Confusing the ComputerChapter 15. Biasing the ComputerChapter 16. AfterwordAppendix: Scratch
£24.74
No Starch Press,US Engineering Secure Devices
Book Synopsis
£42.74
John Wiley & Sons HTML CSS Essentials For Dummies
Book SynopsisThe easy way to brush up on your HTML & CSS programming skills HTML & CSS Essentials For Dummies is your quick and handy reference to all the core concepts of HTML & CSSthe must-know markup and style languages that make the internet go. This no-nonsense book gets right to the point, eliminating review material, wordy explanations, and fluff. Understand all the fundamentals of HTML and CSS, quickly. Perfect for a brush-up on the basics or as an everyday desk reference on the job, this is the reliable little book you can always turn to for answers. Get simple explanations of the basic concepts of coding with HTML & CSSReview what you've already learned or pick up essential new skillsCreate attractive and functional front ends for websites of all kindsKeep this concise reference book handy for jogging your memory as you work This book is clear and direct, focusing on the key topics you need to know about defining a website's user interface. Great for supplementing classroom learning, revi
£11.69
No Starch Press,US Writing a C Compiler
Book Synopsis
£50.24
No Starch Press,US Androids: The Team that Built the Android
Book SynopsisIn 2004, Android was two people who wanted to build camera software but couldn't get investors interested. Today, Android is a large team at Google, delivering an operating system (including camera software) to over 3 billion devices worldwide. This is the inside story, told by the people who made it happen. This is a first-hand chronological account of how the start-up began, how the team came together, and how they all built an operating system from the kernel level to its applications and everything in between.Trade Review"Well-written [with] humorous and clever narration . . . highly recommended . . . a must-read book for every developer." —Joseph Henry, Tech Times"I highly recommend reading it in order to understand [the] ecosystem of the mobile technology before iPhone and later Android appeared." —@Farenain"A great read on operating systems, teams and life inside Google." —Tom Karlo, @tkarlo, Product Manager at Meta Reality Labs
£17.99
No Starch Press,US Learn To Code By Solving Problems: A Python
Book SynopsisLearn to Program by Solving Problems is a practical introduction to programming using Python, one of the world's most popular programming languages. The book emphasises problem-solving strategies that teach readers not only the mechanics of coding, but how to think like savvy programmers. Teaches readers how to use Python to solve short, situational problems (for example, how to predict when a gambler will run out of money while playing slot machines; how to create a programme to track cell phone data usage; how to set up a system of identifying the popularity of berths in a parking lot).Trade Review"The book is an exceptionally well-written technical Python book for beginners that uses active learning techniques. If you’re a beginner to intermediate-level coder, this book will significantly improve your Python skills. It’s easy to read, and solving the problems is fun and satisfying."—Christian Mayer, Finxter"Best resource I’ve encountered for learning to code . . . If you are serious about learning Python, there is absolutely no better resource to get started. One chapter, one practice problem at a time, you will be amazed with the progress you make if you stick with it." —Jun Tsuru, Amazon ReviewerTable of ContentsAcknowledgementsIntroductionChapter 1: Getting StartedChapter 2: Making DecisionsChapter 3: Repeating Code: Definite LoopsChapter 4: Repeating Code: Indefinite LoopsChapter 5: Organizing Values Using ListsChapter 6: Designing Programs with FunctionsChapter 7: Reading and Writing FilesChapter 8: Organizing Values Using Sets and DictionariesChapter 9: Designing Algorithms with Complete SearchChapter 10: Big O and Program EfficiencyAfterword
£25.49
No Starch Press,US Computer Graphics From Scratch: A Programmer's
Book SynopsisBehind the beautiful imagery of the latest animated movie and the realistic environments of popular videogames lie some mysterious algorithms. Computer Graphics from Scratch aims to demystify these algorithms and show readers that computer graphics can be surprisingly simple. This broad introductory book gives readers an overview of the computer graphics field. Every algorithm is built up without the use of external libraries or APIs and is presented with language agnostic pseudocode, allowing anyone with a basic understanding of programming and secondary school maths to follow along.Trade Review"If you've ever wanted to peek behind the curtain and understand how [computer graphics] work, here you've got it in a step-by-step process. . . . A nice resource to have to learn about the basics of computer graphics. . . . If you want to jump in and learn about computer graphics or get an understanding of how ray tracing works, this is a good choice." —Game From Scratch"There's enough information in his book for a university course. In fact, the book is based on the course Gambetta taught before he became a senior engineer at Google." —Joy Schwabach, Arkansas Democrat Gazette's On Computers"One of the best textbooks I have ever seen! . . . I am in awe of the simplicity of the math and science involved. It feels a lot like I am wielding magical powers that I've always thought were beyond my reach. [Gabriel Gambetta has] absolutely managed to demystify the process. I guess it's a sort of 'the power was within you the whole time' kind of moment." —/u/Grakkam, Reddit"I love it. I love fundamental and foundational books like this. It's not tied to language or platform so doesn't get dated. I learned SO MUCH going through this book. . . . I definitely recommend this book if learning computer graphics fundamentals is something you're curious about."—Dylan Bennett, Curator of PiGameDev"Computer Graphics from Scratch is a great jumping-off point for those who want to learn more about raytracing and rasterization."—Julia Roth, Geek Girl Authority"An ideal textbook on DIY computer graphic creation, Computer Graphics from Scratch: A Programmer's Introduction to 3D Rendering is especially and unreservedly recommended for personal, professional, community, school, college, and university library Computer Programming collections and supplemental studies curriculums."—James A. Cox, Midwest Book Review"If you want to understand how shaders are programmed, something important not just to game developers or animators but to anyone who needs to understand what's happening with the graphics library that they are using that isn't working right, this book is for you. The math is just algebra with linear algebra included, and Gambetta builds up his renderers from scratch in a manner that appears logical and easy to follow." —Rik Farrow, USENIXTable of ContentsIntroduction1. Introductory ConceptsPart I: Raytracing2. Basic Raytracing3. Light4. Shadows and Reflections5. Extending the RaytracerPart II: Rasterization6. Lines7. Filled Triangles8. Shaded Triangles9. Perspective Projection10. Describing and Rendering a Scene11. Clipping12. Removing Hidden Surfaces13. Shading14. Textures15. Extending the RasterizerAppendix A: Linear Algebra
£35.99
Pearson Education Art of Computer Programming Volume 4 Fascicle 7
Book SynopsisDonald E. Knuth is known throughout the world for his pioneering work on algorithms and programming techniques, for his invention of the TEX and METAFONT systems for computer typesetting, and for his prolific and influential writing (26 books, 161 papers). Professor Emeritus of The Art of Computer Programming at Stanford University, he currently devotes full time to the completion of his seminal multivolume series on classical computer science, begun in 1962 when he was a graduate student at California Institute of Technology. Professor Knuth is the recipient of numerous awards and honors, including the ACM Turing Award, the Medal of Science presented by President Carter, the AMS Steele Prize for expository writing, and, in November, 1996, the prestigious Kyoto Prize for advanced technology. He lives on the Stanford campus with his wife, Jill.
£26.59
£30.59
O'Reilly Media Flutter and Dart Cookbook
Book SynopsisTogether, the Flutter open source UI software development kit and the Dart programming language for client development provide a unified solution to building applications capable of targeting multiple platforms. Recipes in this cookbook show you how this potent combination provides an efficient approach to application development.
£39.74
O'Reilly Media TestDriven Development with Python
£64.05
John Wiley & Sons Inc Adventures in Arduino
Book SynopsisArduino programming for the absolute beginner, with project-based learning Adventures in Arduino is the beginner's guide to Arduino programming, designed specifically for 11-to 15-year olds who want to learn about Arduino, but don't know where to begin.Table of ContentsIntroduction 1 What Is an Arduino? 1 What You Will Learn 1 Parts You Will Need 2 Tools You Will Need 11 Software You Will Need 15 Other Useful Materials 15 What I Assume You Already Know 16 How This Book Is Organised 16 Conventions 18 The Companion Website 20 Reaching Out 20 Adventure 1 Setting Up Your Arduino 21 What You Need 22 Downloading and Installing the Arduino Software on Your Computer 22 Installing Arduino Software on a Mac 24 Installing Arduino Software on a Windows PC 25 Installing Arduino Software on a Linux Machine 27 Exploring the Arduino IDE 27 Using Blink to Test That Everything Is Set Up Correctly 29 Uploading Blink 30 Troubleshooting Common Problems 33 Building an LED Circuit 38 What You Need 38 Understanding Circuit Schematics 38 Using a Breadboard 41 Building Your First Circuit 43 Further Adventures with Arduino 45 Adventure 2 Reading from Sensors 47 What You Need 47 Adding More LEDs 48 Printing Messages to the Computer 54 Reading Data from a Potentiometer 58 Making Decisions in Code 62 Building a Status Message Sign 64 What You Need 64 Understanding the Circuit 65 Prototyping on a Breadboard 66 Writing the Code 67 Creating your Sign 71 Cutting Holes for the Potentiometer and LEDs 72 Adding the Status Messages and Decorating the Sign 72 Soldering the Circuit 73 Inserting the Electronics 76 Further Adventures with Arduino 77 Adventure 3 Working with Servos 79 What You Need 79 Understanding Different Types of Motors 81 Controlling a Servo with Arduino 82 Repeating the Same Thing Over and Over 85 Digital Input with a Push Button 87 Building a Combination Safe 91 What You Need 92 Understanding the Circuit 94 Prototyping on a Breadboard 95 Writing the Code 95 Making the Safe 102 Soldering the Wires 104 Inserting the Electronics 107 Further Adventures with Arduino 107 Adventure 4 Using Shift Registers 109 What You Need 110 Organising Your Code 111 Using Functions 111 Using for Loops 115 Getting More Outputs with Shift Registers 117 How a Shift Register Works 118 Clock 118 Data 119 Latch 119 Making the Connections for a Shift Register 119 Adding LEDs 122 Writing the Code 123 Adding More Shift Registers 127 Building Your Name in Lights 129 What You Need 130 Understanding the Circuit 131 Prototyping on a Breadboard 131 Writing the Code 132 Making the Lights 136 Soldering the Wires 137 Inserting the Electronics 138 Further Adventures with Shift Registers 139 Adventure 5 Playing Sounds 141 What You Need 141 Making a List 142 Making Your Intentions Known 144 Looping Through an Array 146 Putting It Into Practice 146 Making Noise 150 Wiring the Circuit 151 Writing the Code 151 Building an Augmented Wind Chime 155 What You Need 157 Understanding the Circuit 158 Prototyping on a Breadboard 158 Writing the Code 160 Making the Wind Chime 160 Making the Base 162 Making the Chimes 162 Attaching the Chimes 164 Connecting the Electronics 164 Further Adventures with Sound 165 Adventure 6 Adding Libraries 167 What You Need 167 Analogue Out168 Fading an LED 171 Mixing Light 174 Wiring the Circuit 175 Writing the Code 176 Capacitive Sensing 181 Adding a Library 181 Wiring the Circuit 183 Writing the Code 184 Building a Crystal Ball 187 What You Need 187 Understanding the Circuit 188 Prototyping on a Breadboard 189 Writing the Code 190 Making the Crystal Ball 193 Making a Papier Mache Ball 193 Soldering the Electronics 195 Connecting the Electronics 196 Further Adventures with Libraries 197 Adventure 7 Working with the Arduino Leonardo 199 What You Need 199 Introducing the Arduino Leonardo 200 Connecting Your Leonardo for the First Time 201 Acting Like a Keyboard 203 Sensing Light 206 Building the Circuit 208 Writing the Code 210 Building a Game Controller 211 What You Need 212 Building the Circuit 212 Writing the Code 214 Making the Controller Cover 220 Putting It All Together 220 Further Adventures with the Leonardo 221 Adventure 8 Working with the Lilypad Arduino USB 223 What You Need 224 Introducing the Lilypad Arduino USB 224 Blinking from a Lilypad Arduino 226 Prototyping Soft Circuits 228 Getting Clever with Arrays 230 Passing Data Between Functions 236 Building a POV Hoodie 239 What You Need 240 Understanding The Circuit 241 Prototyping with Alligator Clips 241 Charging the Battery 242 Writing the Code 243 Making the POV Hoodie 246 Making Sewable LEDs 246 Sewing the Electronics 247 Further Adventures with the Lilypad 249 In the Next Adventure 250 Adventure 9 The Big Adventure: Building a Marble Maze Game 251 What You Need 252 Part One: Scoring Points 253 Sensing Vibrations with Piezos 253 Setting a Points Threshold 254 Adding Sound Effects 258 Keeping Score 259 Part Two: Designing Your Maze Game 261 Drawing the Maze 261 Designing the Game Code 262 Prototyping the Circuit 263 Part Three: Writing the Code 265 Starting the Game 265 Ending the Game 266 Starting a New Game 269 Keeping Track of the High Score 270 Adding Sounds 272 Part Four: Building the Maze Game 280 Making the Maze 280 Assembling the Piezos 282 Assembling the LEDs and Button 283 Completing the Finishing Touches 284 Further Adventures: Continuing Your Adventures with Arduino 285 Appendix A Where to Go From Here 287 More Boards, Shields, Sensors and Actuators 287 Shields 287 Sensors and Actuators 288 On the Web 288 The Arduino Site 288 Manufacturers 289 Blogs 289 Videos 289 Books 289 Getting Started with Arduino and General Projects 290 General Electronics 290 Soft Circuits and Wearables 290 Other Specialised Topics 290 Appendix B Where to Get Tools and Components 291 Starter Kits 291 Brick]and]Mortar Stores 292 In the UK 292 In the US 292 Online Stores 292 Online Stores Shipping from the EU 292 Online Stores Shipping from the US or Canada 293 Glossary 295 Index 301
£13.49
John Wiley & Sons Inc Big Java
Book SynopsisBig Java: Early Objects, 7e focuses on the essentials of effective learning and is suitable for a two-semester introduction to programming sequence. The text requires no prior programming experience and only a modest amount of high school algebra. Objects and classes from the standard library are used where appropriate in early sections with coverage on object oriented design starting in Chapter 8. This gradual approach allows students to use objects throughout their study of the core algorithmic topics, without teaching bad habits that must be un-learned later. The second half covers algorithms and data structures at a level suitable for beginning students.Table of ContentsPreface iii Special Features xxiv 1 Introduction 1 1.1 Computer Programs 2 1.2 The Anatomy of a Computer 3 1.3 The Java Programming Language 5 1.4 Becoming Familiar with Your Programming Environment 7 1.5 Analyzing Your First Program 11 1.6 Errors 13 1.7 PROBLEM SOLVING Algorithm Design 15 The Algorithm Concept 15 An Algorithm for Solving an Investment Problem 16 Pseudocode 17 From Algorithms to Programs 18 2 Using Objects 23 2.1 Objects and Classes 24 Using Objects 24 Classes 25 2.2 Variables 26 Variable Declarations 26 Types 28 Names 29 Comments 30 Assignment 30 2.3 Calling Methods 33 The Public Interface of a Class 33 Method Arguments 34 Return Values 35 Method Declarations 36 2.4 Constructing Objects 38 2.5 Accessor and Mutator Methods 40 2.6 The API Documentation 41 Browsing the API Documentation 41 Packages 43 2.7 Implementing a Test Program 44 2.8 Object References 46 2.9 Graphical Applications 49 Frame Windows 50 Drawing on a Component 51 Displaying a Component in a Frame 53 2.10 Ellipses, Lines, Text, and Color 54 Ellipses and Circles 54 Lines 55 Drawing Text 56 Colors 56 3 Implementing Classes 61 3.1 Instance Variables and Encapsulation 62 Instance Variables 62 The Methods of the Counter Class 64 Encapsulation 64 3.2 Specifying the Public Interface of a Class 66 Specifying Methods 66 Specifying Constructors 67 Using the Public Interface 69 Commenting the Public Interface 69 3.3 Providing the Class Implementation 72 Providing Instance Variables 72 Providing Constructors 73 Providing Methods 75 3.4 Unit Testing 81 3.5 PROBLEM SOLVING Tracing Objects 84 3.6 Local Variables 86 3.7 The this Reference 88 3.8 Shape Classes 90 4 Fundamental Data Types 99 4.1 Numbers 100 Number Types 100 Constants 102 4.2 Arithmetic 107 Arithmetic Operators 107 Increment and Decrement 107 Integer Division and Remainder 108 Powers and Roots 109 Converting Floating-Point Numbers to Integers 110 4.3 Input and Output 114 Reading Input 114 Formatted Output 115 4.4 PROBLEM SOLVING First Do it By Hand 121 4.5 Strings 122 The String Type 122 Concatenation 123 String Input 124 Escape Sequences 124 Strings and Characters 124 Substrings 125 5 Decisions 131 5.1 The if Statement 132 5.2 Comparing Values 137 Relational Operators 138 Comparing Floating-Point Numbers 139 Comparing Strings 140 Comparing Objects 141 Testing for null 141 5.3 Multiple Alternatives 146 5.4 Nested Branches 149 5.5 PROBLEM SOLVING Flowcharts 156 5.6 PROBLEM SOLVING Selecting Test Cases 159 5.7 Boolean Variables and Operators 161 Operators 165 5.8 APPLICATION Input Validation 166 6 Loops 171 6.1 The while Loop 172 6.2 PROBLEM SOLVING Hand-Tracing 179 6.3 The for Loop 183 Header 189 6.4 The do Loop 190 6.5 APPLICATION Processing Sentinel Values 192 6.6 PROBLEM SOLVING Storyboards 197 6.7 Common Loop Algorithms 199 Sum and Average Value 199 Counting Matches 200 Finding the First Match 200 Prompting Until a Match is Found 201 Maximum and Minimum 201 Comparing Adjacent Values 202 6.8 Nested Loops 206 6.9 APPLICATION Random Numbers and Simulations 209 Generating Random Numbers 210 The Monte Carlo Method 211 6.10 Using a Debugger 213 7 Arrays and Array Lists 221 7.1 Arrays 222 Declaring and Using Arrays 222 Array References 225 Using Arrays with Methods 226 Partially Filled Arrays 226 Arguments 229 7.2 The Enhanced for Loop 230 7.3 Common Array Algorithms 232 Filling 232 Sum and Average Value 232 Maximum and Minimum 232 Element Separators 232 Linear Search 233 Removing an Element 234 Inserting an Element 234 Swapping Elements 236 Copying Arrays 237 Reading Input 238 7.4 PROBLEM SOLVING Adapting Algorithms 240 7.5 PROBLEM SOLVING Discovering Algorithms by Manipulating Physical Objects 245 7.6 Two-Dimensional Arrays 248 Declaring Two-Dimensional Arrays 248 Accessing Elements 249 Locating Neighboring Elements 250 Accessing Rows and Columns 251 Two-Dimensional Array Parameters 252 7.7 Array Lists 255 Declaring and Using Array Lists 255 Using the Enhanced for Loop with Array Lists 258 Copying Array Lists 259 Wrappers and Auto-boxing 259 Using Array Algorithms with Array Lists 260 Storing Input Values in an Array List 261 Removing Matches 261 Choosing Between Array Lists and Arrays 262 7.8 Regression Testing 264 8 Designing Classes 271 8.1 Discovering Classes 272 8.2 Designing Good Methods 273 Providing a Cohesive Public Interface 273 Minimizing Dependencies 274 Separating Accessors and Mutators 275 Minimizing Side Effects 276 8.3 PROBLEM SOLVING Patterns for Object Data 282 Keeping a Total 282 Counting Events 283 Collecting Values 283 Managing Properties of an Object 284 Modeling Objects with Distinct States 284 Describing the Position of an Object 285 8.4 Static Variables and Methods 286 8.5 PROBLEM SOLVING Solve a Simpler Problem First 291 8.6 Packages 295 Organizing Related Classes into Packages 295 Importing Packages 296 Package Names 297 Packages and Source Files 297 8.7 Unit Test Frameworks 300 9 Inheritance 305 9.1 Inheritance Hierarchies 306 9.2 Implementing Subclasses 310 9.3 Overriding Methods 314 9.4 Polymorphism 319 9.5 Object: The Cosmic Superclass 330 Overriding the toString Method 330 The equals Method 332 The instanceof Operator 333 10 Interfaces 339 10.1 Using Interfaces for Algorithm Reuse 340 Discovering an Interface Type 340 Declaring an Interface Type 341 Implementing an Interface Type 343 Comparing Interfaces and Inheritance 345 10.2 Working with Interface Variables 348 Converting from Classes to Interfaces 348 Invoking Methods on Interface Variables 349 Casting from Interfaces to Classes 349 10.3 The Comparable Interface 350 Interface 352 10.4 Using Interfaces for Callbacks 355 10.5 Inner Classes 360 10.6 Mock Objects 361 10.7 Event Handling 363 Listening to Events 363 Using Inner Classes for Listeners 365 10.8 Building Applications with Buttons 368 10.9 Processing Timer Events 371 10.10 Mouse Events 374 11 Input/Output and Exception Handling 383 11.1 Reading and Writing Text Files 384 11.2 Text Input and Output 389 Reading Words 389 Reading Characters 390 Classifying Characters 390 Reading Lines 390 Scanning a String 392 Converting Strings to Numbers 392 Avoiding Errors When Reading Numbers 392 Mixing Number, Word, and Line Input 393 Formatting Output 394 11.3 Command Line Arguments 396 11.4 Exception Handling 403 Throwing Exceptions 403 Catching Exceptions 405 Checked Exceptions 407 Closing Resources 409 Designing Your Own Exception Types 410 11.5 APPLICATION Handling Input Errors 412 12 Object-Oriented Design 419 12.1 Classes and Their Responsibilities 420 Discovering Classes 420 The CRC Card Method 421 12.2 Relationships Between Classes 423 Dependency 423 Aggregation 424 Inheritance 425 12.3 APPLICATION Printing an Invoice 428 Requirements 429 CRC Cards 429 UML Diagrams 432 Method Documentation 432 Implementation 434 13 Recursion 443 13.1 Triangle Numbers 444 13.2 Recursive Helper Methods 452 13.3 The Efficiency of Recursion 453 13.4 Permutations 459 13.5 Mutual Recursion 463 13.6 Backtracking 469 14 Sorting and Searching 477 14.1 Selection Sort 478 14.2 Profiling the Selection Sort Algorithm 481 14.3 Analyzing the Performance of the Selection Sort Algorithm 484 14.4 Merge Sort 488 14.5 Analyzing the Merge Sort Algorithm 491 14.6 Searching 495 Linear Search 495 Binary Search 497 14.7 PROBLEM SOLVING Estimating the Running Time of an Algorithm 500 Linear Time 500 Quadratic Time 501 The Triangle Pattern 502 Logarithmic Time 503 14.8 Sorting and Searching in the Java Library 504 Sorting 504 Binary Search 505 Comparing Objects 505 15 The Java Collections Framework 511 15.1 An Overview of the Collections Framework 512 15.2 Linked Lists 514 The Structure of Linked Lists 515 The LinkedList Class of the Java Collections Framework 516 List Iterators 516 15.3 Sets 520 Choosing a Set Implementation 520 Working with Sets 522 15.4 Maps 525 15.5 Stacks, Queues, and Priority Queues 531 Stacks 531 Queues 532 Priority Queues 533 15.6 Stack and Queue Applications 534 Balancing Parentheses 534 Evaluating Reverse Polish Expressions 535 Evaluating Algebraic Expressions 537 Backtracking 540 Customers 543 16 Basic Data Structures 545 16.1 Implementing Linked Lists 546 The Node Class 546 Adding and Removing the First Element 547 The Iterator Class 548 Advancing an Iterator 549 Removing an Element 550 Adding an Element 552 Setting an Element to a Different Value 553 Efficiency of Linked List Operations 553 16.2 Implementing Array Lists 560 Getting and Setting Elements 560 Removing or Adding Elements 562 Growing the Internal Array 563 16.3 Implementing Stacks and Queues 564 Stacks as Linked Lists 565 Stacks as Arrays 566 Queues as Linked Lists 567 Queues as Circular Arrays 568 16.4 Implementing a Hash Table 570 Hash Codes 570 Hash Tables 570 Finding an Element 572 Adding and Removing Elements 572 Iterating over a Hash Table 573 17 Tree Structures 581 17.1 Basic Tree Concepts 582 17.2 Binary Trees 585 Binary Tree Examples 586 Balanced Trees 588 A Binary Tree Implementation 589 17.3 Binary Search Trees 590 The Binary Search Property 591 Insertion 592 Removal 594 Efficiency of the Operations 595 17.4 Tree Traversal 599 Inorder Traversal 599 Preorder and Postorder Traversals 601 The Visitor Pattern 602 Depth-First and Breadth-First Search 603 Tree Iterators 604 17.5 Red-Black Trees 605 Basic Properties of Red-Black Trees 605 Insertion 607 Removal 608 17.6 Heaps 612 17.7 The Heapsort Algorithm 622 18 Generic Classes 629 18.1 Generic Classes and Type Parameters 630 18.2 Implementing Generic Types 631 18.3 Generic Methods 634 18.4 Constraining Type Parameters 636 18.5 Type Erasure 639 19 Stream Processing 645 19.1 The Stream Concept 646 19.2 Producing Streams 648 19.3 Collecting Results 649 19.4 Transforming Streams 652 19.5 Lambda Expressions 654 19.6 The Optional Type 659 19.7 Other Terminal Operations 661 19.8 Primitive-Type Streams 663 Creating Primitive-Type Streams 663 Mapping a Primitive-Type Stream 663 Processing Primitive-Type Streams 664 19.9 Grouping Results 665 19.10 Common Algorithms Revisited 667 Filling 667 Sum, Average, Maximum, and Minimum 668 Counting Matches 668 Element Separators 668 Linear Search 669 Comparing Adjacent Values 669 20 Graphical User Interfaces 675 20.1 Layout Management 676 Using Layout Managers 676 Achieving Complex Layouts 677 Using Inheritance to Customize Frames 678 20.2 Processing Text Input 680 Text Fields 680 Text Areas 682 20.3 Choices 685 Radio Buttons 685 Check Boxes 687 Combo Boxes 687 20.4 Menus 695 20.5 Exploring the Swing Documentation 702 21 Advanced Input/Output* (Etext Only) 21.1 Readers, Writers, and Input/Output Streams 21.2 Binary Input and Output 21.3 Random Access 21.4 Object Input and Output Streams 21.5 File and Directory Operations Paths Creating and Deleting Files and Directories Useful File Operations Visiting Directories 22 Multithreading* (Etext Only) 22.1 Running Threads 22.2 Terminating Threads 22.3 Race Conditions 22.4 Synchronizing Object Access 22.5 Avoiding Deadlocks 22.6 APPLICATION Algorithm Animation 23 Internet Networking* (Etext Only) 23.1 The Internet Protocol 23.2 Application Level Protocols 23.3 A Client Program 23.4 A Server Program 23.5 URL Connections 24 Relational Databases* (Etext Only) 24.1 Organizing Database Information Database Tables Linking Tables Implementing Multi-Valued Relationships 24.2 Queries Simple Queries Selecting Columns Selecting Subsets Calculations Joins Updating and Deleting Data 24.3 Installing a Database 24.4 Database Programming in Java Connecting to the Database Executing SQL Statements Analyzing Query Results Result Set Metadata 24.5 APPLICATION Entering an Invoice 25 XML* (Etext Only) 25.1 XML Tags and Documents Advantages of XML Differences Between XML and HTML The Structure of an XML Document 25.2 Parsing XML Documents 25.3 Creating XML Documents 25.4 Validating XML Documents Document Type Definitions Specifying a DTD in an XML Document Parsing and Validation Appendix A The Basic Latin and Latin-1 Subsets of Unicode A-1 Appendix B JAVA Operator Summary A-5 Appendix C JAVA Reserved Word Summary A-7 Appendix D The Java Library A-9 Appendix E JAVA Language Coding Guidelines A-38 Appendix F Tool Summary (Etext Only) Appendix G Number Systems (Etext Only) Appendix H UML Summary (Etext Only) Appendix I JAVA Syntax Summary (Etext Only) Appendix J Html Summary (Etext Only) Glossary G-1 Index I-1 Credits C-1 Quick Reference C-3
£48.44
John Wiley & Sons Inc C 10.0 AllInOne for Dummies
Book SynopsisTable of ContentsIntroduction 1 About This Book 1 Foolish Assumptions 2 Icons Used in This Book 3 Beyond the Book 3 Where to Go from Here 4 Book 1: The Basics of C# Programming 5 Chapter 1: Creating Your First C# Console Application 7 Getting a Handle on Computer Languages, C#, and NET 8 What’s a program? 8 What’s C#? 9 What’s NET? 9 What is Visual Studio 2022? 10 Creating Your First Console Application 11 Creating the source program 11 Taking it out for a test drive 17 Making Your Console App Do Something 17 Reviewing Your Console Application 18 The program framework 19 Comments 19 The meat of the program 19 Replacing All that Ceremonial Code: Top-Level Statements 20 Introducing the Toolbox Trick 21 Saving code in the Toolbox 22 Reusing code from the Toolbox 22 Interacting with C# Online 23 Working with Jupyter Notebook: The Short Version 23 Chapter 2: Living with Variability — Declaring Value-Type Variables 25 Declaring a Variable 26 What’s an int? 27 Rules for declaring variables 28 Variations on a theme: Different types of int 28 Representing Fractions 30 Handling Floating-Point Variables 31 Declaring a floating-point variable 31 Examining some limitations of floating-point variables 32 Using the Decimal Type: Is It an Integer or a Float? 34 Declaring a decimal 35 Comparing decimals, integers, and floating-point types 35 Examining the bool Type: Is It Logical? 36 Checking Out Character Types 36 The char variable type 36 Special chars 37 The string type 37 What’s a Value Type? 39 Comparing string and char 40 Calculating Leap Years: DateTime 41 Declaring Numeric Constants 43 Changing Types: The Cast 44 Letting the C# Compiler Infer Data Types 46 Chapter 3: Pulling Strings 49 The Union Is Indivisible, and So Are Strings 50 Performing Common Operations on a String 51 Comparing Strings 52 Equality for all strings: The Compare() method 52 Would you like your compares with or without case? 56 What If I Want to Switch Case? 56 Distinguishing between all-uppercase and all-lowercase strings 56 Converting a string to upper- or lowercase 57 Looping through a String 58 Searching Strings 59 Can I find it? 59 Is my string empty? 60 Using advanced pattern matching 60 Getting Input from Users in Console Applications 61 Trimming excess white space 62 Parsing numeric input 62 Handling a series of numbers 64 Joining an array of strings into one string 66 Controlling Output Manually 67 Using the Trim() and Pad() methods 67 Using the Concatenate() method 69 Go Ahead and Split() that concatenate program 71 Formatting Your Strings Precisely 72 Using the String.Format() method 72 Using the interpolation method 77 StringBuilder: Manipulating Strings More Efficiently 77 Chapter 4: Smooth Operators 81 Performing Arithmetic 81 Simple operators 82 Operating orders 82 The assignment operator 84 The increment operator 84 Performing Logical Comparisons — Is That Logical? 85 Comparing floating-point numbers: Is your float bigger than mine? 86 Compounding the confusion with compound logical operations 87 Matching Expression Types at TrackDownAMate.com 89 Calculating the type of an operation 89 Assigning types 91 Changing how an operator works: Operator overloading 92 Chapter 5: Getting into the Program Flow 95 Branching Out with if and switch 96 Introducing the if statement 97 Examining the else statement 100 Avoiding even the else 101 Nesting if statements 102 Running the switchboard 104 Here We Go Loop-the-Loop 110 Looping for a while 111 Doing the do while loop 114 Breaking up is easy to do 115 Looping until you get it right 116 Focusing on scope rules 120 Looping a Specified Number of Times with for 120 A for loop example 121 Why do you need another loop? 122 Nesting loops 123 Chapter 6: Lining Up Your Ducks with Collections 125 The C# Array 126 The argument for the array 126 The fixed-value array 127 The variable-length array 129 Initializing an array 132 Processing Arrays by Using foreach 133 Working with foreach loops in a standard way 133 Relying on GetEnumerator support 134 Sorting Arrays of Data 136 Using var for Arrays 139 Loosening Up with C# Collections 140 Understanding Collection Syntax 141 Figuring out 142 Going generic 142 Using Lists 143 Instantiating an empty list 143 Creating a list of type int 144 Converting between lists and arrays 144 Searching lists 144 Performing other list tasks 145 Using Dictionaries 145 Creating a dictionary 145 Searching a dictionary 146 Iterating a dictionary 146 Array and Collection Initializers 147 Initializing arrays 148 Initializing collections 148 Using Sets 149 Performing special set tasks 149 Creating a set 150 Adding items to a set 150 Performing a union 151 Performing an intersection 152 Performing a difference 153 Chapter 7: Stepping through Collections 155 Iterating through a Directory of Files 156 Using the LoopThroughFiles program 156 Getting started 157 Obtaining the initial input 157 Creating a list of files 159 Formatting the output lines 160 Displaying the hexadecimal output 161 Running from inside Visual Studio 163 Iterating foreach Collections: Iterators 164 Accessing a collection: The general problem 164 Letting C# access data foreach container 167 Accessing Collections the Array Way: Indexers 169 Indexer format 169 An indexer program example 170 Looping Around the Iterator Block 173 Creating the required iterator block framework 174 Iterating days of the month: A first example 176 What a collection is, really 177 Iterator syntax gives up so easily 178 Iterator blocks of all shapes and sizes 180 Chapter 8: Buying Generic 187 Writing a New Prescription: Generics 188 Generics are type-safe 188 Generics are efficient 189 Classy Generics: Writing Your Own 190 Shipping packages at OOPs 190 Queuing at OOPs: PriorityQueue 191 Unwrapping the package 194 Touring Main() 196 Writing generic code the easy way 197 Saving PriorityQueue for last 198 Using a (nongeneric) Simple Factory class 201 Understanding Variance in Generics 205 Contravariance 206 Covariance 208 Chapter 9: Some Exceptional Exceptions 209 Using an Exceptional Error-Reporting Mechanism 210 About try blocks 211 About catch blocks 211 About finally blocks 212 What happens when an exception is thrown 213 Throwing Exceptions Yourself 215 Can I Get an Exceptional Example? 216 Working with Custom Exceptions 220 Planning Your Exception-Handling Strategy 221 Some questions to guide your planning 221 Guidelines for code that handles errors well 222 How to find out which methods throw which exceptions 223 Grabbing Your Last Chance to Catch an Exception 225 Throwing Expressions 226 Chapter 10: Creating Lists of Items with Enumerations 229 Seeing Enumerations in the Real World 230 Working with Enumerations 231 Using the enum keyword 231 Creating enumerations with initializers 233 Specifying an enumeration data type 234 Creating Enumerated Flags 235 Defining Enumerated Switches 237 Working with Enumeration Methods 238 Book 2: Object-Oriented C# Programming 241 Chapter 1: Showing Some Class 243 A Quick Overview of Object-Oriented Programming 244 Considering OOP basics 244 Extending classes to meet other needs 244 Keeping objects safe 245 Working with objects 246 Defining a Class and an Object 246 Defining a class 247 What’s the object? 249 Accessing the Members of an Object 250 Working with Object-Based Code 250 Using the traditional approach 250 Using the C# 9.0 approach 252 Discriminating between Objects 253 Can You Give Me References? 254 Classes That Contain Classes Are the Happiest Classes in the World 256 Generating Static in Class Members 257 Defining const and readonly Data Members 259 Chapter 2: We Have Our Methods 261 Defining and Using a Method 262 Method Examples for Your Files 263 Understanding the problem 264 Working with standard coding methods 265 Applying a refactoring approach 268 Working with local functions 271 Having Arguments with Methods 273 Passing an argument to a method 273 Passing multiple arguments to methods 274 Matching argument definitions with usage 276 Overloading a method doesn’t mean giving it too much to do 276 Implementing default arguments 278 Using the Call-by-Reference Feature 280 Defining a Method with No Return Value 281 Returning Multiple Values Using Tuples 282 Using a tuple 283 Relying on the Create() method 284 Creating tuples with more than two items 284 Chapter 3: Let Me Say This about this 287 Passing an Object to a Method 288 Comparing Static and Instance Methods 290 Employing static properties and methods effectively 291 Employing instance properties and methods effectively 293 Expanding a method’s full name 295 Accessing the Current Object 296 What is the this keyword? 298 When is the this keyword explicit? 299 Using Local Functions 300 Creating a basic local function 300 Using attributes with local functions 301 Chapter 4: Holding a Class Responsible 303 Restricting Access to Class Members 303 A public example of public BankAccount 304 Jumping ahead — other levels of security 306 Why You Should Worry about Access Control 307 Accessor methods 308 Working with init-only setters 309 Access control to the rescue — an example 311 Defining Class Properties 313 Static properties 315 Properties with side effects 315 Accessors with access levels 316 Using Target Typing for Your Convenience 316 Dealing with Covariant Return Types 319 Getting Your Objects Off to a Good Start — Constructors 320 The C#-Provided Constructor 321 Replacing the Default Constructor 322 Constructing something 324 Initializing an object directly with an initializer 326 Seeing that construction stuff with initializers 326 Initializing an object without a constructor 327 Using Expression-Bodied Members 329 Creating expression-bodied methods 329 Defining expression-bodied properties 329 Defining expression-bodied constructors and destructors 330 Defining expression-bodied property accessors 330 Defining expression-bodied event accessors 331 Chapter 5: Inheritance: Is That All I Get? 333 Why You Need Inheritance 334 Inheriting from a BankAccount Class (a More Complex Example) 335 Working with the basic update 336 Tracking the BankAccount and SavingsAccount classes features 339 IS_A versus HAS_A — I’m So Confused_A 342 The IS_A relationship 342 Gaining access to BankAccount by using containment 343 The HAS_A relationship 345 When to IS_A and When to HAS_A 346 Other Features That Support Inheritance 346 Substitutable classes 346 Invalid casts at runtime 347 Avoiding invalid conversions with the is operator 348 Avoiding invalid conversions with the as operator 349 Chapter 6: Poly-what-ism? 353 Overloading an Inherited Method 354 It’s a simple case of method overloading 354 Different class, different method 355 Peek-a-boo — hiding a base class method 355 Polymorphism 361 Using the declared type every time (Is that so wrong?) 362 Using is to access a hidden method polymorphically 364 Declaring a method virtual and overriding it 365 Getting the most benefit from polymorphism 368 C# During Its Abstract Period 368 Class factoring 369 The abstract class: Left with nothing but a concept 373 How do you use an abstract class? 374 Creating an abstract object — not! 377 Sealing a Class 377 Chapter 7: Interfacing with the Interface 379 Introducing CAN_BE_USED_AS 379 Knowing What an Interface Is 381 How to implement an interface 382 Using the newer C# 8.0 additions 383 How to name your interface 386 Why C# includes interfaces 386 Mixing inheritance and interface implementation 387 And he-e-e-re’s the payoff 387 Using an Interface 388 As a method return type 389 As the base type of an array or collection 389 As a more general type of object reference 390 Using the C# Predefined Interface Types 390 Looking at a Program That CAN_BE_USED_AS an Example 391 Creating your own interface at home in your spare time 391 Implementing the incomparable I Comparable interface 392 Creating a list of students 394 Testing everything using Main() 395 Unifying Class Hierarchies 396 Hiding Behind an Interface 399 Inheriting an Interface 401 Using Interfaces to Manage Change in Object-Oriented Programs 402 Making flexible dependencies through interfaces 403 Abstract or concrete: When to use an abstract class and when to use an interface 404 Doing HAS_A with interfaces 405 Chapter 8: Delegating Those Important Events 407 E.T., Phone Home — The Callback Problem 408 Defining a Delegate 408 Pass Me the Code, Please — Examples 411 Delegating the task 411 First, a simple example 412 Considering the Action, Func, and Predicate delegate types 413 A More Real-World Example 415 Putting the app together 416 Setting the properties and adding event handlers 418 Looking at the workhorse code 419 Shh! Keep It Quiet — Anonymous Methods 421 Defining the basic anonymous method 421 Using static anonymous methods 422 Working with lambda discard parameters 424 Stuff Happens — C# Events 424 The Observer design pattern 425 What’s an event? Publish/Subscribe 425 How a publisher advertises its events 426 How subscribers subscribe to an event 427 How to publish an event 427 How to pass extra information to an event handler 428 A recommended way to raise your events 429 How observers “handle” an event 430 Chapter 9: Can I Use Your Namespace in the Library? 433 Dividing a Single Program into Multiple Source Files 434 Working with Global using Statements 435 Dividing a Single Program into Multiple Assemblies 437 Executable or library? 437 Assemblies 437 Executables 438 Class libraries 439 Putting Your Classes into Class Libraries 439 Creating the projects for a class library 439 Creating a stand-alone class library 440 Adding a second project to an existing solution 442 Creating the code for the library 445 Using a test application to test a library 446 Going Beyond Public and Private: More Access Keywords 448 Internal: For CIA eyes only 448 Protected: Sharing with subclasses 451 Putting Classes into Namespaces 453 Declaring a namespace 454 Using file-scoped namespaces 456 Relating namespaces to the access keyword story 456 Using fully qualified names 458 Working with partial classes 459 Working with Partial Methods 463 Defining what partial methods do 463 Creating a partial method 464 Chapter 10: Improving Productivity with Named and Optional Parameters 465 Exploring Optional Parameters 466 Working with optional value parameters 466 Avoiding optional reference types 468 Looking at Named Parameters 470 Using Alternative Methods to Return Values 470 Output (out) parameters 471 Working with out variables 471 Returning values by reference 472 Dealing with null Parameters 473 Chapter 11: Interacting with Structures 475 Comparing Structures to Classes 476 Considering struct limits 476 Understanding the value type difference 477 Determining when to use struct versus class 477 Creating Structures 478 Defining a basic struct 478 Including common struct elements 479 Using supplemental struct elements 482 Working with Read-only Structures 485 Working with Reference Structures 487 Using Structures as Records 489 Managing a single record 489 Adding structures to arrays 489 Overriding methods 490 Using the New Record Type 491 Comparing records to structures and classes 491 Working with a record 492 Using the positional syntax for property definition 493 Understanding value equality 494 Creating safe changes: Nondestructive mutation 494 Using the field keyword 495 Book 3: Designing For C# 497 Chapter 1: Writing Secure Code 499 Designing Secure Software 500 Determining what to protect 500 Documenting the components of the program 501 Decomposing components into functions 502 Identifying potential threats in functions 502 Building Secure Windows Applications 503 Authentication using Windows logon 503 Encrypting information 507 Deployment security 507 Using System.Security 508 Chapter 2: Accessing Data 509 Getting to Know System.Data 510 How the Data Classes Fit into the Framework 512 Getting to Your Data 512 Using the System.Data Namespace 513 Setting up a sample database schema 513 Creating the data access project 514 Connecting to a data source 514 Working with the visual tools 519 Writing data code 521 Chapter 3: Fishing the File Stream 525 Going Where the Fish Are: The File Stream 525 Streams 526 Readers and writers 527 StreamWriting for Old Walter 528 Using the stream: An example 529 Using some better fishing gear: The using statement 534 Pulling Them Out of the Stream: Using StreamReader 537 More Readers and Writers 539 Exploring More Streams than Lewis and Clark 541 Chapter 4: Accessing the Internet 543 Getting to Know System.Net 544 How Net Classes Fit into the Framework 545 Understanding the System.Net subordinate namespaces 545 Working with the System.Net classes 548 Using the System.Net Namespace 549 Checking the network status 549 Downloading a file from the Internet 551 Emailing a status report 553 Logging network activity 556 Chapter 5: Creating Images 559 Getting to Know System.Drawing 560 Graphics 561 Pens 562 Brushes 563 Text 563 How the Drawing Classes Fit into the Framework 564 Using the System.Drawing Namespace 565 Getting started 565 Setting up the project 567 Handling the score 567 Creating an event connection 569 Drawing the board 570 Printing the score 572 Starting a new game 574 Chapter 6: Programming Dynamically! 575 Shifting C# Toward Dynamic Typing 576 Employing Dynamic Programming Techniques 578 Putting Dynamic to Use 580 Classic examples 580 Making static operations dynamic 581 Understanding what’s happening under the covers 581 Running with the Dynamic Language Runtime 582 Using Static Anonymous Functions 585 Book 4: A Tour of Visual Studio 587 Chapter 1: Getting Started with Visual Studio 589 Versioning the Versions 590 An overview of Visual Studio 2022 updates 590 Community edition 592 Professional edition 594 Enterprise edition 594 MSDN 595 Installing Visual Studio 596 Breaking Down the Projects 597 Exploring the Create a New Project dialog box 600 Understanding solutions and projects 601 Chapter 2: Using the Interface 603 Designing in the Designer 604 Universal Windows Platform (UWP) application 604 Windows Presentation Foundation (WPF) 607 Windows Forms 609 Data View 609 Paneling the Studio 610 Solution Explorer 610 Properties 613 The Toolbox 614 Server Explorer 615 Class View 617 Coding in the Code Editor 618 Exercising the Code Editor 618 Exploring the auxiliary windows 619 Using the Tools of the Trade 621 The Tools menu 622 Building 623 Using the Debugger as an Aid to Learning 623 Stepping through code 623 Going to a particular code location 624 Watching application data 625 Viewing application internals 626 Chapter 3: Customizing Visual Studio 627 Setting Options 628 Environment 629 Language 630 Neat stuff 631 Creating Your Own Templates 632 Developing a project template 632 Developing an item template 635 Book 5: Windows Development with Wpf 639 Chapter 1: Introducing WPF 641 Understanding What WPF Can Do 642 Introducing XAML 643 Diving In! Creating Your First WPF Application 644 Declaring an application-scoped resource 647 Making the application do something 648 Whatever XAML Can Do, C# Can Do Better! 650 Chapter 2: Understanding the Basics of WPF 653 Using WPF to Lay Out Your Application 654 Arranging Elements with Layout Panels 655 The Stack panel 656 The Wrap panel 660 The Dock panel 661 Canvas 662 The Grid 662 Putting it all together with a simple data entry form 669 Exploring Common XAML Controls 672 Display-only controls 672 Basic input controls 674 List-based controls 677 Chapter 3: Data Binding in WPF 681 Getting to Know Dependency Properties 682 Exploring the Binding Modes 683 Investigating the Binding Object 683 Defining a binding with XAML 684 Defining a binding with C# 686 Editing, Validating, Converting, and Visualizing Your Data 687 Validating data 693 Converting your data 697 Finding Out More about WPF Data Binding 705 Chapter 4: Practical WPF 707 Commanding Attention 708 Traditional event handling 708 ICommand 709 Routed commands 710 Using Built-In Commands 711 Using Custom Commands 713 Defining the interface 713 Creating the window binding 714 Ensuring that the command can execute 714 Performing the task 715 Using Routed Commands 717 Defining the Command class 717 Making the namespace accessible 718 Adding the command bindings 718 Developing a user interface 718 Developing the custom command code-behind 719 Chapter 5: Programming for Windows 10 and Above 721 What is the Universal Windows Platform (UWP)? 722 Devices Supported by the UWP 725 Creating Your Own UWP App 726 Configuring Developer Mode 726 Defining the project 732 Creating an interface 734 Adding some background code 738 Choosing a test device 739 Working with NET Core Applications 740 Book 6: Web Development with Asp.Net 743 Chapter 1: Creating a Basic ASP.NET Core App 745 Understanding the ASP.NET Core Templates 746 Starting with nothing using ASP.NET Core Empty 746 Creating a basic app using the ASP.NET Core Web App 748 Fumbling around with HTTPS-enabled sites 749 Building in business logic using ASP.NET Core App (Model-View-Controller) 751 Developing a programming interface using ASP.NET Core Web API 752 An overview of those other weird templates 753 Developing a Basic Web App 754 Creating the project 754 Considering the development process 756 Adding web content 757 Making some basic changes to the first page 759 Chapter 2: Employing the Razor Markup Language 761 Avoiding Nicks from Razor 762 Comparing Razor to its predecessors 762 Considering the actual file layout 763 Understanding the syntax rules for C# 766 Working with some Razor basics 767 Creating Variables 770 Keeping Things Logical 771 Starting simply by using if 771 Sleeping at the switch 771 Implementing Loops 772 Creating an array 772 Performing tasks a specific number of times using for 773 Processing an unknown number of times using for each and while 773 Chapter 3: Generating and Consuming Data 775 Understanding Why These Projects Are Important 776 Serialized Data Isn’t for Breakfast 777 Developing a Data Generator and API 778 Creating the WeatherForecast project 778 Making the data believable 781 Looking at the API configuration 783 Checking the API for functionality 784 Creating a Consumer Website 786 Creating the RetrieveWeatherForecast project 786 Developing a user interface 787 Getting and deserializing the data 789 Seeing the application in action 793 Index 795
£31.19
John Wiley & Sons Inc Coding AllinOne For Dummies
Book SynopsisTable of ContentsIntroduction 1 Book 1: Getting Started with Coding 5 Chapter 1: What Is Coding? 7 Chapter 2: Programming for the Web 19 Chapter 3: Becoming a Programmer 33 Book 2: Basic Web Coding 43 Chapter 1: Exploring Basic HTML 45 Chapter 2: Getting More Out of HTML 63 Chapter 3: Getting Stylish with CSS 79 Chapter 4: Next Steps with CSS 101 Chapter 5: Responsive Layouts with Flexbox 123 Chapter 6: Styling with Bootstrap 143 Book 3: Advanced Web Coding 159 Chapter 1: What Is JavaScript? 161 Chapter 2: Writing Your First JavaScript Program 173 Chapter 3: Working with Variables 193 Chapter 4: Understanding Arrays 211 Chapter 5: Working with Operators, Expressions, and Statements 225 Chapter 6: Getting into the Flow with Loops and Branches 241 Chapter 7: Getting Functional 255 Chapter 8: Making and Using Objects 275 Chapter 9: Controlling the Browser with the Window Object 291 Chapter 10: Manipulating Documents with the DOM 307 Chapter 11: Using Events in JavaScript 327 Chapter 12: Integrating Input and Output 339 Chapter 13: Understanding Callbacks and Closures 355 Chapter 14: Embracing AJAX and JSON 367 Book 4: Creating Mobile Apps 383 Chapter 1: What Is Flutter? 385 Chapter 2: Setting Up Your Computer for Mobile App Development. 401 Chapter 3: “Hello” from Flutter 433 Chapter 4: Hello Again 469 Chapter 5: Making Things Happen 495 Chapter 6: Laying Things Out 527 Chapter 7: Interacting with the User 567 Chapter 8: Navigation, Lists, and Other Goodies 605 Chapter 9: Moving Right Along 653 Book 5: Getting Started with Python 675 Chapter 1: Wrapping Your Head around Python 677 Chapter 2: Installing a Python Distribution 689 Chapter 3: Working with Real Data 707 Book 6: Data Analysis with Python 729 Chapter 1: Conditioning Your Data 731 Chapter 2: Shaping Data 759 Chapter 3: Getting a Crash Course in MatPlotLib 779 Chapter 4: Visualizing the Data 795 Book 7: Career Building with Coding 813 Chapter 1: Exploring Coding Career Paths 815 Chapter 2: Exploring Undergraduate and Graduate Degrees 829 Chapter 3: Training on the Job 843 Chapter 4: Coding Career Myths 853 Index 861
£23.19
