Computer programming / software engineering Books
No Starch Press,US Automate The Boring Stuff With Python 3rd Edition
Book SynopsisIf you''ve ever spent hours renaming files or updating hundreds of spreadsheet cells, you know how tedious tasks like these can be. But what if you could have your computer do them for you? In this fully revised edition of the best-selling classicAutomate the Boring Stuff with Python, you''ll learn how to use Python to write programs that do in minutes what would take you hours to do by hand - no prior programming experience required. You''ll learn the basics of coding in Python and explore the language''s rich library of modules for performing specific tasks, like scraping data from websites, searching for text across multiple files, and merging, watermarking, or encrypting PDFs. The third edition includes: Expanded coverage of developer techniques, like creating command line programs; Updated examples and new projects; Additional chapters about working with SQLite databases, speech-recognition technology, video and audio editing, and text-to-speech capabilities; Simplified explanations
£40.49
£18.75
Pearson Education (US) Pragmatic Programmer The
Book SynopsisDave Thomas and Andy Hunt are internationally recognized as leading voices in the software development community. They consult and speak around the world. Together, they founded the Pragmatic Bookshelf, publishing award-winning, leading-edge books for software developers. They were two of the authors of the Agile Manifesto. Dave currently teaches college, turns wood, and plays with new technology and paradigms. Andy writes science fiction, is an active musician, and loves to tinker with technology. But, most of all, they're both driven to keep learning.Trade Review"To participate in the next generation of professional product delivery you have to be pragmatic but disciplined. Otherwise, you are fated to be ungrounded dreamers whose products endanger people and whose ideas never become successfully integrated into the world. Andy and Dave described a pragmatic but disciplined approach which is a key step towards professionalism."–Ken Schwaber, co-creator of Scrum and founder of Scrum.org, agile manifesto signatory, and author of Software in 30 Days. "Picking adjectives is hard work. In The Pragmatic Programmer, Dave and Andy set the tone for their work–thoughtful, expert, aspirational, and full of care for themselves and those they touch through their programs. From its publication, this was the book to read if you wanted to work to improve."–Kent Beck, Gusto, author of Extreme Programming Explained: Embrace Change, Test-Driven Development: By Example, and The Smalltalk Best Practice Patterns "Some say that with The Pragmatic Programmer, Andy and Dave captured lightning in a bottle; that it’s unlikely anyone will soon write a book that can move an entire industry as it did. Sometimes, though, lightning does strike twice, and this book is proof. The updated content ensures that it will stay at the top of “best books in software development” lists for another 20 years, right where it belongs." —VM (Vicky) Brasseur, Director of Open Source Strategy, Juniper Networks "If you want your software to be easy to modernize and maintain, keep a copy of The Pragmatic Programmer close. It’s filled with practical advice, both technical and professional, that will serve you and your projects well for years to come." —Andrea Goulet, CEO, Corgibytes; Founder, LegacyCode.Rocks " The Pragmatic Programmer is the one book I can point to that completely dislodged the existing trajectory of my career in software and pointed me in the direction of success. Reading it opened my mind to the possibilities of being a craftsman, not just a cog in a big machine. One of the most significant books in my life." —Obie Fernandez, Author, The Rails Way "First-time readers can look forward to an enthralling induction into the modern world of software practice, a world that the first edition played a major role in shaping. Readers of the first edition will rediscover here the insights and practical wisdom that made the book so significant in the first place, expertly curated and updated, along with much that’s new." —David A. Black, Author, The Well-Grounded Rubyist "I have an old paper copy of the original Pragmatic Programmer on my bookshelf. It has been read and re-read and a long time ago it changed everything about how I approached my job as a programmer. In the new edition everything and nothing has changed: I now read it on my iPad and the code examples use modern programming languages—but the underlying concepts, ideas, and attitudes are timeless and universally applicable. Twenty years later, the book is as relevant as ever. It makes me happy to know that current and future developers will have the same opportunity to learn from Andy and Dave’s profound insights as I did back in the day." —Sandy Mamoli, Agile coach; Author of How Self-Selection Lets People Excel Table of ContentsForeword xiPreface to the Second Edition xvFrom the Preface to the First Edition xix Chapter 1: A Pragmatic Philosophy 1 Topic 1. It's Your Life 2 Topic 2. The Cat Ate My Source Code 3 Topic 3. Software Entropy 6 Topic 4. Stone Soup and Boiled Frogs 8 Topic 5. Good-Enough Software 11 Topic 6. Your Knowledge Portfolio 14 Topic 7. Communicate! 20 Chapter 2: A Pragmatic Approach 27 Topic 8. The Essence of Good Design 28 Topic 9. DRY–The Evils of Duplication 30 Topic 10. Orthogonality 39 Topic 11. Reversibility 47 Topic 12. Tracer Bullets 51 Topic 13. Prototypes and Post-it Notes 56 Topic 14. Domain Languages 60 Topic 15. Estimating 66 Chapter 3: The Basic Tools 73 Topic 16. The Power of Plain Text 74 Topic 17. Shell Games 78 Topic 18. Power Editing 81 Topic 19. Version Control 84 Topic 20. Debugging 88 Topic 21. Text Manipulation 97 Topic 22. Engineering Daybooks 100 Chapter 4: Pragmatic Paranoia 103 Topic 23. Design by Contract 104 Topic 24. Dead Programs Tell No Lies 112 Topic 25. Assertive Programming 115 Topic 26. How to Balance Resources 118 Topic 27. Don’t Outrun Your Headlights 125 Chapter 5: Bend, or Break 129 Topic 28. Decoupling 130 Topic 29. Juggling the Real World 137 Topic 30. Transforming Programming 147 Topic 31. Inheritance Tax 159 Topic 32. Configuration 167 Chapter 6: Concurrency 171 Topic 33. Breaking Temporal Coupling 172 Topic 34. Shared State Is Incorrect State 176 Topic 35. Actors and Processes 183 Topic 36. Blackboards 189 Chapter 7: While You Are Coding 195 Topic 37. Listen to Your Lizard Brain 196 Topic 38. Programming by Coincidence 201 Topic 39. Algorithm Speed 207 Topic 40. Refactoring 213 Topic 41. Test to Code 218 Topic 42. Property-Based Testing 228 Topic 43. Stay Safe Out There 235 Topic 44. Naming Things 242 Chapter 8: Before the Project 249 Topic 45. The Requirements Pit 250 Topic 46. Solving Impossible Puzzles 258 Topic 47. Working Together 262 Topic 48. The Essence of Agility 265 Chapter 9: Pragmatic Projects 269 Topic 49. Pragmatic Teams 270 Topic 50. Coconuts Don’t Cut It 276 Topic 51. Pragmatic Starter Kit 280 Topic 52. Delight Your Users 287 Topic 53. Pride and Prejudice 288 Postface 291 Bibliography 295Possible Answers to the Exercises 299Index 313
£35.99
Pearson Education Clean Code
Book SynopsisRobert C. Martin (Uncle Bob) has been a programmer and software development expert since 1970. He is founder of Uncle Bob Consulting, LLC, and cofounder with his son Micah Martin of The Clean Coders LLC. Martin has published dozens of articles in various trade journals and is a regular speaker at international conferences and trade shows. He is the author of many books, including Agile Software Development: Principles, Patterns, and Practices; UML for Java Programmers; Clean Code; The Clean Coder; Clean Architecture; Clean Agile; Clean Craftsmanship; and Functional Design. Martin served for three years as editor-in-chief of the C++ Report and as the first chairman of the Agile Alliance.
£43.19
No Starch Press,US Python Crash Course, 3rd Edition: A Hands-On,
Book SynopsisSince its initial debut in 2015, this critically acclaimed quick-start guide to programming has taught millions of people all over the world to write clean code, solve problems, and build custom applications in the popular language of Python. The highly anticipated third edition of Python Crash Course has been completely revised with updated code, practices, and projects-making it the ultimate launchpad for beginners to start their engines and code in Python 3!Trade Review"Learning python is a smart investment of your time because the language is efficient and powerful. This book will get you where you need to be to program like a pro." —Sandra Henry-Stocker, NetworkWorld"Eric Matthes's Python Crash Course, 3rd Edition takes a well-regarded text for getting started with Python and brings it up to date for 2023. The book not only covers Python's basics but lets you put them to use in a series of projects involving data analysis, web development, and gaming. Many books offer either Python basics or projects to learn from. This one delivers both." —Serdar Yegulalp, InfoWorld"Just looking at the fact that this is the 3rd Edition of Eric's book, you likely realize that there is something special about this . . . It's amazing that he gets all of [this] into 500+ pages and at the same time it's all understandable. . . . ★★★★★"—Greg Walters, Full Circle MagazineReviews for the 2nd Edition:"With a patient and experienced pedagogical style, and a combination of thorough language instruction and plenty of illustrative sample code, Python Crash Course is a terrific way to begin learning computer programming in general and the Python language in particular."—Michael J. Ross, web developer and former Slashdot contributor“It has been interesting to see, over the last few years, No Starch Press, which produces this book, growing and producing future classics that should be alongside the more traditional O’Reilly Press programming books. Python Crash Course is one of those books.”—Greg Laden, ScienceBlogs“All of these projects are well thought out and presented in such a way that learning the subject matter and implementing it is much more an enjoyable pastime rather than an onerous task that must be completed. Eric took the time to deal with some rather complex projects and lay them out in a consistent, logical and pleasant manner that draws the reader into the subject willingly, which unfortunately, many authors fail to do.”—Full Circle Magazine“The book is well presented with good explanations of the code snippets. It works with you, one small step at a time, building more complex code, explaining what's going on all the way.”—FlickThrough Reviews“Learning Python with Python Crash Course was an extremely positive experience! A great choice if you’re new to Python.”—Mikke Goes Coding"While Python Crash Course uses Python to teach you to code, it also teaches clean programming skills that apply to most other languages."—Great Lakes Geek"It does what it says on the tin, and it does it really well. If you want a crash course in Python, fear not!!! The Python Crash Course is an excellent book that provides a thorough introduction to Python that will have you writing programs and solving problems in no time!"—Technical YA, Best Books to Learn Python Language in 2021Table of ContentsPreface to the Third EditionAcknowledgmentsIntroductionPart I: BASICSChapter 1: Getting StartedChapter 2: Variables and Simple Data TypesChapter 3: Introducing ListsChapter 4: Working with ListsChapter 5: if StatementsChapter 6: DictionariesChapter 7: User Input and while LoopsChapter 8: FunctionsChapter 9: ClassesChapter 10: Files and ExceptionsChapter 11: Testing Your CodePart II: PROJECTSChapter 12: A Ship That Fires BulletsChapter 13: Aliens!Chapter 14: ScoringChapter 15: Generating DataChapter 16: Downloading DataChapter 17: Working with APIsChapter 18: Getting Started with DjangoChapter 19: User AccountsChapter 20: Styling and Deploying an AppAfterwordAppendix A: Installation and TroubleshootingAppendix B: Text Editors and IDEsAppendix C: Getting HelpAppendix D: Using Git for Version ControlAppendix E: Troubleshooting DeploymentsIndex
£38.39
Franklin, Beedle & Associates Inc CS For All: An Introduction to Computer Science
Book SynopsisA unique approach to “Intro CS.” In a nutshell, the authors of this book's objective is to provide an introduction to computer science as an intellectually rich and vibrant field rather than focusing exclusively on computer programming. While programming is certainly an important and pervasive element of their approach, they emphasize concepts and problem-solving over syntax and programming language features.This book is a companion to the course “CS for All” developed at Harvey Mudd College and subsequently adopted at a variety of colleges and universities. At Mudd, this course is taken by almost every first-year student - irrespective of the student’s ultimate major - as part of the college’s core curriculum. The offering is also taken by many students at the Claremont Colleges, including students majoring in the humanities, social sciences, and the arts. Thus, it serves as a first computing course for students regardless of their major.This book is intended to be used with the substantial resources that we have developed for the course. These resources include complete lecture slides, a rich collection of weekly assignments, some accompanying software, documentation, and papers that have been published about the course. The authors have deliberately kept this book relatively short and have endeavored to make it fun and readable.The content of this book is an accurate reflection of the content of the course rather than an intimidating encyclopedic tome that can’t possibly be covered in a single semester. The book has been written in the belief that a student can read all of it comfortably as the course proceeds.
£36.71
Pearson Education The XML Companion
Book Synopsis
£26.62
No Starch Press,US The Ghidra Book 2nd Edition
£53.99
Pearson Education (US) Code
Book SynopsisCharles Petzold is also the author of The Annotated Turing: A Guided Tour through Alan Turing's Historic Paper on Computability and the Turing Machine (Wiley, 2008). He wrote a bunch of other books too, but they're mostly about programming applications for Microsoft Windows, and they're all obsolete now. He lives in New York City with his wife, historian and novelist Deirdre Sinnott, and two cats named Honey and Heidi. His website is www.charlespetzold.com.Table of ContentsPreface to the Second Edition Chapter One: Best Friends Chapter Two: Codes and Combinations Chapter Three: Braille and Binary Codes Chapter Four: Anatomy of a Flashlight Chapter Five: Communicating Around Corners Chapter Six: Logic with Switches Chapter Seven: Telegraphs and Relays Chapter Eight: Relays and Gates Chapter Nine: Our Ten Digits Chapter Ten: Alternative 10s Chapter Eleven: Bit by Bit by Bit Chapter Twelve: Bytes and Hexadecimal Chapter Thirteen: From ASCII to Unicode Chapter Fourteen: Adding with Logic Gates Chapter Fifteen: Is This for Real? Chapter Sixteen: But What About Subtraction? Chapter Seventeen: Feedback and Flip-Flops Chapter Eighteen: Let's Build a Clock! Chapter Nineteen: An Assemblage of Memory Chapter Twenty: Automating Arithmetic Chapter Twenty-One: The Arithmetic Logic Unit Chapter Twenty-Two: Registers and Busses Chapter Twenty-Three: CPU Control Signals Chapter Twenty-Four: Loops, Jumps, and Calls Chapter Twenty-Five: Peripherals Chapter Twenty-Six: The Operating System Chapter Twenty-Seven: Coding Chapter Twenty-Eight: The World Brain
£24.64
Pearson Education (US) Clean Architecture
Book SynopsisRobert C. Martin (Uncle Bob) has been a programmer since 1970. He is founder of Uncle Bob Consulting, LLC, and cofounder with his son Micah Martin of The Clean Coders LLC. Martin has published dozens of articles in various trade journals and is a regular speaker at international conferences and trade shows. He has authored and edited many books, including: Designing Object Oriented C++ Applications Using the Booch Method, Patterns Languages of Program Design 3, More C++ Gems, Extreme Programming in Practice, Agile Software Development: Principles, Patterns, and Practices, UML for Java Programmers, Clean Code, and The Clean Coder. A leader in the industry of software development, Martin served for three years as editor-in-chief of the C++ Report, and he served as the first chairman of the Agile Alliance.Table of Contents Foreword xv Preface xix Acknowledgments xxiii About the Author xxv Part I: Introduction 1 Chapter 1: What Is Design and Architecture? 3 The Goal? 4 Case Study 5 Conclusion 12 Chapter 2: A Tale of Two Values 13 Behavior 14 Architecture 14 The Greater Value 15 Eisenhower’s Matrix 16 Fight for the Architecture 18 Part II: Starting with the Bricks: Programming Paradigms 19 Chapter 3: Paradigm Overview 21 Structured Programming 22 Object-Oriented Programming 22 Functional Programming 22 Food for Thought 23 Conclusion 24 Chapter 4: Structured Programming 25 Proof 27 A Harmful Proclamation 28 Functional Decomposition 29 No Formal Proofs 30 Science to the Rescue 30 Tests 31 Conclusion 31 Chapter 5: Object-Oriented Programming 33 Encapsulation? 34 Inheritance? 37 Polymorphism? 40 Conclusion 47 Chapter 6: Functional Programming 49 Squares of Integers 50 Immutability and Architecture 52 Segregation of Mutability 52 Event Sourcing 54 Conclusion 56 Part III: Design Principles 57 Chapter 7: SRP: The Single Responsibility Principle 61 Symptom 1: Accidental Duplication 63 Symptom 2: Merges 65 Solutions 66 Conclusion 67 Chapter 8: OCP: The Open-Closed Principle 69 A Thought Experiment 70 Directional Control 74 Information Hiding 74 Conclusion 75 Chapter 9: LSP: The Liskov Substitution Principle 77 Guiding the Use of Inheritance 78 The Square/Rectangle Problem 79 LSP and Architecture 80 Example LSP Violation 80 Conclusion 82 Chapter 10: ISP: The Interface Segregation Principle 83 ISP and Language 85 ISP and Architecture 86 Conclusion 86 Chapter 11: DIP: The Dependency Inversion Principle 87 Stable Abstractions 88 Factories 89 Concrete Components 91 Conclusion 91 Part IV: Component Principles 93 Chapter 12: Components 95 A Brief History of Components 96 Relocatability 99 Linkers 100 Conclusion 102 Chapter 13: Component Cohesion 103 The Reuse/Release Equivalence Principle 104 The Common Closure Principle 105 The Common Reuse Principle 107 The Tension Diagram for Component Cohesion 108 Conclusion 110 Chapter 14: Component Coupling 111 The Acyclic Dependencies Principle 112 Top-Down Design 118 The Stable Dependencies Principle 120 The Stable Abstractions Principle 126 Conclusion 132 Part V: Architecture 133 Chapter 15: What Is Architecture? 135 Development 137 Deployment 138 Operation 138 Maintenance 139 Keeping Options Open 140 Device Independence 142 Junk Mail 144 Physical Addressing 145 Conclusion 146 Chapter 16: Independence 147 Use Cases 148 Operation 149 Development 149 Deployment 150 Leaving Options Open 150 Decoupling Layers 151 Decoupling Use Cases 152 Decoupling Mode 153 Independent Develop-ability 153 Independent Deployability 154 Duplication 154 Decoupling Modes (Again) 155 Conclusion 158 Chapter 17: Boundaries: Drawing Lines 159 A Couple of Sad Stories 160 FitNesse 163 Which Lines Do You Draw, and When Do You Draw Them? 165 What About Input and Output? 169 Plugin Architecture 170 The Plugin Argument 172 Conclusion 173 Chapter 18: Boundary Anatomy 175 Boundary Crossing 176 The Dreaded Monolith 176 Deployment Components 178 Threads 179 Local Processes 179 Services 180 Conclusion 181 Chapter 19: Policy and Level 183 Level 184 Conclusion 187 Chapter 20: Business Rules 189 Entities 190 Use Cases 191 Request and Response Models 193 Conclusion 194 Chapter 21: Screaming Architecture 195 The Theme of an Architecture 196 The Purpose of an Architecture 197 But What About the Web? 197 Frameworks Are Tools, Not Ways of Life 198 Testable Architectures 198 Conclusion 199 Chapter 22: The Clean Architecture 201 The Dependency Rule 203 A Typical Scenario 207 Conclusion 209 Chapter 23: Presenters and Humble Objects 211 The Humble Object Pattern 212 Presenters and Views 212 Testing and Architecture 213 Database Gateways 214 Data Mappers 214 Service Listeners 215 Conclusion 215 Chapter 24: Partial Boundaries 217 Skip the Last Step 218 One-Dimensional Boundaries 219 Facades 220 Conclusion 220 Chapter 25: Layers and Boundaries 221 Hunt the Wumpus 222 Clean Architecture? 223 Crossing the Streams 226 Splitting the Streams 227 Conclusion 228 Chapter 26: The Main Component 231 The Ultimate Detail 232 Conclusion 237 Chapter 27: Services: Great and Small 239 Service Architecture? 240 Service Benefits? 240 The Kitty Problem 242 Objects to the Rescue 244 Component-Based Services 245 Cross-Cutting Concerns 246 Conclusion 247 Chapter 28: The Test Boundary 249 Tests as System Components 250 Design for Testability 251 The Testing API 252 Conclusion 253 Chapter 29: Clean Embedded Architecture 255 App-titude Test 258 The Target-Hardware Bottleneck 261 Conclusion 273 Part VI: Details 275 Chapter 30: The Database Is a Detail 277 Relational Databases 278 Why Are Database Systems So Prevalent? 279 What If There Were No Disk? 280 Details 281 But What about Performance? 281 Anecdote 281 Conclusion 283 Chapter 31: The Web Is a Detail 285 The Endless Pendulum 286 The Upshot 288 Conclusion 289 Chapter 32: Frameworks Are Details 291 Framework Authors 292 Asymmetric Marriage 292 The Risks 293 The Solution 294 I Now Pronounce You … 295 Conclusion 295 Chapter 33: Case Study: Video Sales 297 The Product 298 Use Case Analysis 298 Component Architecture 300 Dependency Management 302 Conclusion 302 Chapter 34: The Missing Chapter 303 Package by Layer 304 Package by Feature 306 Ports and Adapters 308 Package by Component 310 The Devil Is in the Implementation Details 315 Organization versus Encapsulation 316 Other Decoupling Modes 319 Conclusion: The Missing Advice 321 Part VII: Appendix 323 Appendix A Architecture Archaeology 325 Index 375
£28.49
The Pragmatic Programmers Practical Vim
Book SynopsisVim is a fast and efficient text editor that will make you a faster and more efficient developer. It's available on almost every OS, and if you master the techniques in this book, you'll never need another text editor. In more than 120 Vim tips, you'll quickly learn the editor's core functionality and tackle your trickiest editing and writing tasks. This beloved bestseller has been revised and updated to Vim 7.4 and includes two brand-new tips and five fully revised tips.A highly configurable, cross-platform text editor, Vim is a serious tool for programmers, web developers, and sysadmins who want to raise their game. No other text editor comes close to Vim for speed and efficiency; it runs on almost every system imaginable and supports most coding and markup languages.Learn how to edit text the "Vim way": complete a series of repetitive changes with The Dot Formula using one keystroke to strike the target, followed by one keystroke to execute the change. Automate complex tasks by recording your keystrokes as a macro. Discover the "very magic" switch that makes Vim's regular expression syntax more like Perl's. Build complex patterns by iterating on your search history. Search inside multiple files, then run Vim's substitute command on the result set for a project-wide search and replace. All without installing a single plugin! Two new tips explain how to run multiple ex commands as a batch and autocomplete sequences of words."Practical Vim, Second Edition" will show you new ways to work with Vim 7.4 more efficiently, whether you're a beginner or an intermediate Vim user. All this, without having to touch the mouse.What You Need: Vim version 7.4
£20.69
No Starch Press,US The Rust Programming Language: 2nd Edition
Book SynopsisWith over 50,000 copies sold, The Rust Programming Language is the quintessential guide to programming in Rust. Thoroughly updated to Rust's latest version, this edition is considered the language's official documentation. The Rust Programming Language, 2nd Edition is the official language guide for Rust 2021, and the best way to get started with Rust. The new edition includes a quick-reference section on organizing code with modules, and improved closure examples of captures, the move keyboard, and Fn traits. From web apps to operating systems, Rust is the safe, fast, reliable programming language used for an expansive variety of applications. Revised and updated by the original authors, the second edition of The Rust Programming Language shows readers how to take full advantage of Rust 2021 features, from installation to creating robust and scalable programs. It begins with the basics, like creating functions and binding variables, then moves on to more advanced concepts, like errorTrade Review"The Rust Programming Language has always been, and continues to be, the first place I point anyone looking to learn Rust. It's referred to simply as "The Book", and with good reason -- it's comprehensive and elaborate, yet friendly and thoughtful, and serves as a guide not only to the language itself, but to the principles and mental models that Rust encourages its users to adopt. The 2nd edition is a reflection of the ongoing love for the book in the community, and ensures that it will remain a solid introduction to the best Rust has to offer for years to come."—Jon Gjengset, author of Rust for Rustaceans "The Rust Programming Language, 2nd Edition has been improved, refined, and still remains *the book* to get started with learning Rust. Whether an experienced or a new Rustacean it's an invaluable resource on how Rust works." —Michael Gattozzi, Senior Software Engineer at Fastly "A great resource for mastering Rust's fundamentals. Rust is a language that rewards a deep understanding of its features, from ownership rules to pattern matching, and this book is an excellent tool to achieve that. . . . If you're thinking about seriously learning Rust, this book is for you."—Adam Vartanian, Engineering Manager at Cord"From a person who read the first edition front to back, the second edition of The Rust Programming Language met and exceeded my expectations! It's well-written and formatted to help introduce the reader to all the concepts of Rust. . . . Overall, this edition won't disappoint and is an excellent addition to a programmer's personal library." —Jared Wolff, Owner, Circuit Dojo LLC"Verdict: Recommended"—Paul Floyd, CVu MagazineTable of ContentsForewordPrefaceAcknowledgmentsIntroductionChapter 1: Getting StartedChapter 2: Programming a Guessing GameChapter 3: Common Programming ConceptsChapter 4: Understanding OwnershipChapter 5: Using Structs to Structure Related DataChapter 6: Enums and Pattern MatchingChapter 7: Managing Growing Projects with Packages, Crates, and ModulesChapter 8: Common CollectionsChapter 9: Error HandlingChapter 10: Generic Types, Traits, and LifetimesChapter 11: Writing Automated TestsChapter 12: An I/O Project: Building a Command Line ProgramChapter 13: Functional Language Features: Iterators and Closures Chapter 14: More About Cargo and Crates.ioChapter 15: Smart PointersChapter 16: Fearless ConcurrencyChapter 17: Object-Oriented Programming FeaturesChapter 18: Patterns and MatchingChapter 19: Advanced FeaturesChapter 20: Final Project: Building a Multithreaded Web ServerAppendix A: KeywordsAppendix B: Operators and SymbolsAppendix C: Derivable TraitsAppendix D: Useful Development Tools Appendix E: EditionsIndex
£38.39
No Starch Press,US Inside The Machine: An Illustrated Introduction
Book SynopsisThis is a softcover version of the original hardcover edition released December 28, 2006 (ISBN 9781593271046). Computers perform countless tasks ranging from the business critical to the recreational, but regardless of how differently they may look and behave, they're all amazingly similar in basic function. Once you understand how the microprocessor-or central processing unit (CPU)-works, you'll have a firm grasp of the fundamental concepts at the heart of all modern computing. Inside the Machine, from the co-founder of the highly respected Ars Technica website, explains how microprocessors operate-what they do and how they do it. Now in softcover, the book uses analogies, full-color diagrams, and clear language to convey the ideas that form the basis of modern computing. After discussing computers in the abstract, the book examines specific microprocessors from Intel, IBM, and Motorola, from the original models up through today's leading processors. It contains
£40.79
John Wiley & Sons Inc Arduino Projects For Dummies
Book SynopsisDiscover all the amazing things you can do with Arduino Arduino is a programmable circuit board that is being used by everyone from scientists, programmers, and hardware hackers to artists, designers, hobbyists, and engineers in order to add interactivity to objects and projects and experiment with programming and electronics.Table of ContentsIntroduction 1 Part I: Getting Started with Arduino Projects 7 Chapter 1: Exploring the World of Arduino 9 Chapter 2: Setting Up Your Workspace and Tools 19 Chapter 3: Understanding the Basics 41 Part II: Basic Arduino Projects 63 Chapter 4: The All-Seeing Eye 65 Chapter 5: Making a Light Pet 85 Chapter 6: Making a Scrolling Sign 107 Chapter 7: Building an Arduino Clock 127 Part III: The Interactive Home and Garden 153 Chapter 8: Building a Keypad Entry System 155 Chapter 9: Building an RFID Tag Reader 181 Chapter 10: Building an Automated Garden 201 Chapter 11: Building a Tweeting Pet Door 221 Chapter 12: Building a Home Sensing Station 243 Part IV: Advanced Arduino Projects 273 Chapter 13: Building a GPS Data Logger 275 Chapter 14: Building a Remote-Controlled Car 299 Chapter 15: Building an LED Cube 323 Part V: The Part of Tens 349 Chapter 16: Ten Great Arduino Resources 351 Chapter 17: Ten Troubleshooting Tips 359 Index 369
£18.90
Pearson Education Programming
Book SynopsisBjarne Stroustrup is the designer and original implementer of C++, as well as the author of The C++ Programming Language (4th Edition), A Tour of C++ (3rd edition), Programming: Principles and Practice Using C++ (3rd Edition), and many popular and academic publications. He is a professor of Computer Science at Columbia University in New York City. Dr. Stroustrup is a member of the US National Academy of Engineering, and an IEEE, ACM, and CHM fellow. He received the 2018 Charles Stark Draper Prize, the IEEE Computer Society's 2018 Computer Pioneer Award, and the 2017 IET Faraday Medal.
£53.99
No Starch Press,US Automate The Boring Stuff With Python, 2nd
Book SynopsisIn this second edition of Automate the Boring Stuff with Python, you'll learn the basics of programming in Python, the fastest growing programming language today, before moving on to create Python programs that effortlessly perform useful and impressive feats of automation. This updated edition is full of step-by-step instructions that walk through each programme. Practice projects at the end of each chapter challenge you to improve those programmes and use your newfound skills to automate similar tasks.Trade Review"With lessons on how to use Python to program Excel spreadsheets, crawl websites, parse PDFs and Word documents, send emails, and other productivity-boosting task automation, it's a stellar resource for office workers, academics, and administrators."—Mashable"I think many educational resources jump levels way too quickly. One of the best I ever used was Automate the Boring Stuff with Python - that book stayed at the right level the whole way!"—Oscar Baruffa, @OscarBaruffaPraise for the first edition of Automate the Boring Stuff with Python:"The best part of programming is the triumph of seeing the machine do something useful. Automate the Boring Stuff with Python frames all of programming as these small triumphs; it makes the boring fun.”—Hilary Mason, Founder of Fast Forward Labs and Data Scientist in Residence at Accel “Do you need Automate the Boring Stuff with Python? Yes, if you want to enhance your workflow by using automation, this is an excellent place to start. Highly recommended.” —Network World “Valuable to have on your shelf...an extremely useful book.” —Kids, Code, and Computer Science Magazine "Automate the Boring Stuff with Python is perfect for anyone who has menial tasks they don't want to spend hours doing." —GeekMom "Whether you prefer working through a book, or learning by watching, or both together, Automate the Boring Stuff will have you productive in Python in no time." —Serdar Yegulalp, InfoWorld"If you seriously want to know how much Python helps with automation, my favorite place is the Automate Boring Stuff with Python book, a simply awesome book." —Javin Paul, Hacker Noon"This is certainly a much more engaging way to learn Python . . . it gets you all excited by the prospect of making cool little programs that will save you time."—Andrew Lau, AndrewLauActuary.com"I've found both the book and Udemy course of Automate the Boring Stuff with Python by Al Sweigart to be really helpful."—Mark S, @Awful_Curious"Best Python book you can buy today."—Rodrigo Ribeiro, @mcapablancaTable of ContentsAcknowledgmentsIntroductionPart I: Python Programming BasicsChapter 1: Python BasicsChapter 2: Flow ControlChapter 3: FunctionsChapter 4: ListsChapter 5: Dictionaries and Structuring DataChapter 6: Manipulating StringsPart II: Automating TasksChapter 7: Pattern Matching with Regular ExpressionsChapter 8: Input ValidationChapter 9: Reading and Writing FilesChapter 10: Organizing FilesChapter 11: DebuggingChapter 12: Web ScrapingChapter 13: Working with Excel SpreadsheetsChapter 14: Working with Google SheetsChapter 15: Working with PDF and Word DocumentsChapter 16: Working with CSV Files and JSON DataChapter 17: Keeping Time, Scheduling Tasks, and Launching ProgramsChapter 18: Sending Email and Text MessagesChapter 19: Manipulating ImagesChapter 20: Controlling the Keyboard and Mouse with GUI AutomationAppendix A: Installing Third-Party ModulesAppendix B: Running ProgramsAppendix C: Answers to the Practice Questions
£34.19
Raspberry Pi Press The Official Raspberry Pi Handbook: Astounding
Book SynopsisThe Official Raspberry Pi Handbook is fully updated for Raspberry Pi in 2024. Packed with all the information beginners need to use their new Raspberry Pi computer. And the best projects from the year for long-term Raspberry Pi enthusiasts. Learn how to set up the Raspberry Pi, install an operating system, and start using Raspberry Pi OS. Follow step-by-step guides to code animations and games using both Scratch and Python languages. Create incredible computing projects with electronic components. The Official Raspberry Pi Handbook 2024 the biggest book of the year for the Raspberry Pi community and a must-buy for all Raspberry Pi owners.
£14.00
MIT Press Structure and Interpretation of Computer Programs
Book Synopsis
£60.06
McGraw-Hill Education Programming Arduino Getting Started with Sketches
Book SynopsisAn up-to-date Arduino programming guideâno prior programming experience required!This fully updated guide shows, step by step, how to quickly and easily program all Arduino models using its modified C language and the Arduino IDE. Electronics guru Simon Monk gets you up to speed quickly, teaching all concepts through simple language and clear instruction. Programming Arduino : Getting Started with Sketches, Third Edition features dozens of easy-to-follow examples and high-quality illustrations. All of the sample sketches featured in the book can be used as is or modified to suit your needs. You will also get all new coverage of using Arduino as a framework for programming other popular boards. Configure your Arduino and start writing sketches Understand the basics of C language and the Arduino IDE Add functions, arrays, and strings to your sketches Set up Arduinoâs digital and analog I/O Use Arduino-compatible boards in
£10.99
O'Reilly Media Head First Python
Book SynopsisWant to learn the Python language without slogging your way through how-to manuals? With Head First Python, you'll quickly grasp Python's fundamentals by working with built-in data structures and functions. You'll build your very own web app, which—once it's ready for prime time—runs in the cloud.
£39.74
No Starch Press,US Linux Basics for Hackers 2nd Edition
Book SynopsisIf you're getting started along the exciting path of hacking, cybersecurity, and pentesting, this book is an excellent first step. Using Kali Linux - an advanced penetration testing distribution of Linux - you'll quickly pick up the basics of using the Linux operating system, and acquire the tools and techniques you'll need to take control of a Linux environment. Later chapters focus on foundational hacking concepts like security, anonymity and scripting, along with practical tutorials and exercises that test your skills. This fully revised second edition covers the latest version of Kali, includes new options for setting up a Linux virtual machine, and discusses some differences between the bash and Z shells used on the newest versions of the distribution. It also addresses contemporary examples of real-world hacking, such as the cyberwar between Russia and Ukraine. You'll learn how to: Install Kali on a virtual machine and build your own hacking tools; Perform common tasks like manipulating text and controlling file and directory permissions; Cover your tracks by leveraging the rsyslog logging utility; Hide your internet activity using Tor, proxy servers, VPNs, and encrypted email; Write bash and Python scripts to scan open ports for potential targets. If you're ready to dive into hacking, cybersecurity, or pentesting, Linux Basics for Hackers, 2nd Edition is exactly what you need to get going.
£26.99
ITSTART Mobile Applications
a huge range and FREE tracked UK delivery on ALL orders.
£32.00
No Starch Press,US Practical Sql, 2nd Edition
Book SynopsisSecond edition of the best-selling Practical SQL. An approachable guide to programming in SQL (Structured Query Language) that will teach even beginning programmers how to build powerful databases and analyze data to find meaningful information.Trade Review"Even better than the previous edition!"—Jakub Romanowski, LearnSQL.com"This book is comprehensive, well organized, and contains almost everything a new developer needs to learn SQL using Postgres. Besides, the arrangement of the sections is logical, and the writing style is not complicated where information is supported by the required examples and images, in addition to evidence from the writer's practical experiences."—Hadi Fadlallah, SQLShack"[W]ell-written and informative . . . an extremely enjoyable book that will keep the reader engaged with interesting, thought-provoking exercises . . . I highly recommend Practical SQL, 2nd Edition to anyone wanting to learn PostgreSQL and how to tell stories with data."—Joshua Allen Holm, Opensource.comREVIEWS FOR THE FIRST EDITION:"This book is comprehensive, well organized, and contains almost everything a new developer needs to learn SQL using Postgres. Besides, the arrangement of the sections is logical, and the writing style is not complicated where information is supported by the required examples and images, in addition to evidence from the writer's practical experiences."—Hadi Fadlallah, SQLShack“One of the best-organized travelogues we've seen into the SQL realm.”—Newstips Bulletin"More fun and more engaging [than Learning SQL from O'Reilly]."—Giles McMullen-Klein, Python Programmer, YouTuber“Practical SQL will take you from an absolute databases beginner towards becoming a database and SQL master. This book is one of those books that you feel like [you're] reading a novel, not a technical book. It uses an easy to follow and [understandable] approach that makes it easy to read for people from all backgrounds.”—Sara A. Metwalli, Towards Data Science"I recommend reading Practical SQL by Anthony DeBarros for a more in-depth look on how to implement regression analysis and other analytical tools using SQL."—Michael Grogan, Towards Data Science"One of the most interesting books about SQL I've ever read. At first glance, it looks like a guide for complete rookies. But the author raises topics that will interest advanced users."—Jakub Romanowski, LearnSQL.comTable of ContentsIntroduction1. Setting up pgAdmin2. Creating Your First Database and Table3. Beginning Data Exploration with SELECT4. Understanding Data Types5. Importing and Exporting Data6. Basic Math and Stats7. Joining Tables in a Relational Database8. Table Design that Works for You9. Extracting Information by Grouping and Summarizing10. Inspecting and Modifying Data11. Statistical Functions in SQL12. Working with Dates and Times13. Advanced Query Techniques14. Mining Text to Find Meaningful Data15. Analyzing Spatial Data with PostGIS16. Working with JSON Data17. Saving Time with Views, Functions, and Triggers18. Using PostgreSQL from the Command Line19. Maintaining Your Database20. Identifying and Telling the Story Behind Your DataAppendix A. Additional Resources
£28.49
Manning Publications The Programmer's Brain: What every programmer
Book Synopsis"I am in awe of this book, it is a very good read and has tons of interesting lessons for any engineer." - Tim van Deurzen Your brain responds in a predictable way when it encounters new or difficult tasks. This unique book teaches you concrete techniques rooted in cognitive science that will improve the way you learn and think about code. In The Programmer's Brain: What every programmer needs to know about cognition you will learn: - Fast and effective ways to master new programming languages- Speed reading skills to quickly comprehend new code- Techniques to unravel the meaning of complex code- Ways to learn new syntax and keep it memorized- Writing code that is easy for others to read- Picking the right names for your variables- Making your codebase more understandable to newcomers- Onboarding new developers to your team Learn how to optimize your brain's natural cognitive processes to read code more easily, write code faster, and pick up new languages in much less time. This book will help you through the confusion you feel when faced with strange and complex code, and explain a codebase in ways that can make a new team member productive in days! about the technologyUnderstanding the cognitive functions that govern the way your brain thinks about coding will help you work smarter, not harder. You'll improve your productivity, reduce your need for constant rewrites, and say goodbye to spending late nights struggling with new languages. about the bookThe Programmer's Brain explores the way your brain works when it's thinking about code. In it, you'll master practical ways to apply these cognitive principles to your daily programming life. You'll improve your code comprehension by turning confusion into a learning tool, and pick up awesome techniques for reading code and quickly memorizing syntax. This practical guide includes tips for creating your own flashcards and study resources that can be applied to any new language you want to master. By the time you're done, you'll not only be better at teaching yourself—you'll be an expert at bringing new colleagues and junior programmers up to speed. about the readerFor programmers who have experience working in more than one language. about the authorDr. Felienne Hermans is an associate professor at Leiden University in the Netherlands. She has spent the last decade researching learning and teaching programming. Felienne is an award-winning educator, the creator of the Hedy programming language for novice programmers, and a host of Software Engineering Radio—one of the world's largest programming podcasts.Trade Review“A great book with deep insights into the bridge between programming and the human mind.” Mike Taylor, CGI “Helps you understand how your brain works and how you can use it more effectively to read, write, and collaborate on code.” Ben McNamara,DataGeek “Teaches you science-based habits to reduce your mental workload and hack your way to becoming a rockstar programmer!” Daniela Zapata Riesco,M1 Finance “If you've ever wondered what working smarter instead of harder is supposed to look like, you should read this book. I am already seeing improvements in my day-to-day work.” Zhijun Liu, Mediaocean
£37.99
Pearson Education Limited Pearson Edexcel 91 Computer Science Student Book
Book SynopsisThe Pearson Edexcel GCSE (9-1) Computer Science Student Book is aligned to the 2020 specification, bringing Computer Science to life with real-world examples, and providing support for the new practical on-screen assessment.
£32.20
Pearson Education (US) Software Architecture in Practice
Book SynopsisLen Bass, an award-winning author and lecturer, has more than 50 years of advanced software experience, including 25 years at Carnegie Mellon University's (CMU) Software Engineering Institute (SEI). He now teaches DevOps as an adjunct faculty member at CMU. Dr. Paul Clements, VP of Customer Success with BigLever Software, helps organizations gain value from Product Line Engineering (PLE). As senior member of technical staff at SEI, he led advanced projects in PLE and software architecture. Rick Kazman is Professor, University of Hawaii, and Visiting Researcher at SEI. His interests include software architecture, visualization, design, analysis, and economics. He co-created influential architecture analysis methods and tools, including SAAM, ATAM, CBAM, Dali, and Titan.Table of ContentsPreface xvAcknowledgments xvii Part I: Introduction 1Chapter 1: What Is Software Architecture? 1 1.1 What Software Architecture Is and What It Isn't 2 1.2 Architectural Structures and Views 5 1.3 What Makes a "Good" Architecture? 19 1.4 Summary 21 1.5 For Further Reading 21 1.6 Discussion Questions 22 Chapter 2: Why Is Software Architecture Important? 25 2.1 Inhibiting or Enabling a System's Quality Attributes 26 2.2 Reasoning about and Managing Change 27 2.3 Predicting System Qualities 28 2.4 Communication among Stakeholders 28 2.5 Early Design Decisions 31 2.6 Constraints on Implementation 31 2.7 Influences on Organizational Structure 32 2.8 Enabling Incremental Development 33 2.9 Cost and Schedule Estimates 33 2.10 Transferable, Reusable Model 34 2.11 Architecture Allows Incorporation of Independently Developed Elements 34 2.12 Restricting the Vocabulary of Design Alternatives 35 2.13 A Basis for Training 36 2.14 Summary 36 2.15 For Further Reading 37 2.16 Discussion Questions 37 Part II: Quality Attributes 39Chapter 3: Understanding Quality Attributes 39 3.1 Functionality 40 3.2 Quality Attribute Considerations 41 3.3 Specifying Quality Attribute Requirements: Quality Attribute Scenarios 42 3.4 Achieving Quality Attributes through Architectural Patterns and Tactics 45 3.5 Designing with Tactics 46 3.6 Analyzing Quality Attribute Design Decisions: Tactics-Based Questionnaires 48 3.7 Summary 49 3.8 For Further Reading 49 3.9 Discussion Questions 50 Chapter 4: Availability 51 4.1 Availability General Scenario 53 4.2 Tactics for Availability 55 4.3 Tactics-Based Questionnaire for Availability 62 4.4 Patterns for Availability 66 4.5 For Further Reading 68 4.6 Discussion Questions 69 Chapter 5: Deployability 71 5.1 Continuous Deployment 72 5.2 Deployability 75 5.3 Deployability General Scenario 76 5.4 Tactics for Deployability 78 5.5 Tactics-Based Questionnaire for Deployability 80 5.6 Patterns for Deployability 81 5.7 For Further Reading 87 5.8 Discussion Questions 87 Chapter 6: Energy Efficiency 89 6.1 Energy Efficiency General Scenario 90 6.2 Tactics for Energy Efficiency 92 6.3 Tactics-Based Questionnaire for Energy Efficiency 95 6.4 Patterns 97 6.5 For Further Reading 98 6.6 Discussion Questions 99 Chapter 7: Integrability 101 7.1 Evaluating the Integrability of an Architecture 102 7.2 General Scenario for Integrability 104 7.3 Integrability Tactics 105 7.4 Tactics-Based Questionnaire for Integrability 110 7.5 Patterns 112 7.6 For Further Reading 114 7.7 Discussion Questions 115 Chapter 8: Modifiability 117 8.1 Modifiability General Scenario 120 8.2 Tactics for Modifiability 121 8.3 Tactics-Based Questionnaire for Modifiability 125 8.4 Patterns 126 8.5 For Further Reading 130 8.6 Discussion Questions 131 Chapter 9: Performance 133 9.1 Performance General Scenario 134 9.2 Tactics for Performance 137 9.3 Tactics-Based Questionnaire for Performance 145 9.4 Patterns for Performance 146 9.5 For Further Reading 149 9.6 Discussion Questions 150 Chapter 10: Safety 151 10.1 Safety General Scenario 154 10.2 Tactics for Safety 156 10.3 Tactics-Based Questionnaire for Safety 160 10.4 Patterns for Safety 163 10.5 For Further Reading 165 10.6 Discussion Questions 166 Chapter 11: Security 169 11.1 Security General Scenario 170 11.2 Tactics for Security 172 11.3 Tactics-Based Questionnaire for Security 176 11.4 Patterns for Security 179 11.5 For Further Reading 180 11.6 Discussion Questions 180 Chapter 12: Testability 183 12.1 Testability General Scenario 186 12.2 Tactics for Testability 187 12.3 Tactics-Based Questionnaire for Testability 192 12.4 Patterns for Testability 192 12.5 For Further Reading 194 12.6 Discussion Questions 195 Chapter 13: Usability 197 13.1 Usability General Scenario 198 13.2 Tactics for Usability 200 13.3 Tactics-Based Questionnaire for Usability 202 13.4 Patterns for Usability 203 13.5 For Further Reading 205 13.6 Discussion Questions 205 Chapter 14: Working with Other Quality Attributes 207 14.1 Other Kinds of Quality Attributes 207 14.2 Using Standard Lists of Quality Attributes--Or Not 209 14.3 Dealing with "X-Ability": Bringing a New QA into the Fold 212 14.4 For Further Reading 215 14.5 Discussion Questions 215 Part III: Architectural Solutions 217Chapter 15: Software Interfaces 217 15.1 Interface Concepts 218 15.2 Designing an Interface 222 15.3 Documenting the Interface 228 15.4 Summary 230 15.5 For Further Reading 230 15.6 Discussion Questions 231 Chapter 16: Virtualization 233 16.1 Shared Resources 234 16.2 Virtual Machines 235 16.3 VM Images 238 16.4 Containers 239 16.5 Containers and VMs 241 16.6 Container Portability 242 16.7 Pods 242 16.8 Serverless Architecture 243 16.9 Summary 244 16.10 For Further Reading 245 16.11 Discussion Questions 245 Chapter 17: The Cloud and Distributed Computing 247 17.1 Cloud Basics 248 17.2 Failure in the Cloud 251 17.3 Using Multiple Instances to Improve Performance and Availability 253 17.4 Summary 261 17.5 For Further Reading 262 17.6 Discussion Questions 262 Chapter 18: Mobile Systems 263 18.1 Energy 264 18.2 Network Connectivity 266 18.3 Sensors and Actuators 267 18.4 Resources 268 18.5 Life Cycle 270 18.6 Summary 273 18.7 For Further Reading 274 18.8 Discussion Questions 275 Part IV: Scalable Architecture Practices 277Chapter 19: Architecturally Significant Requirements 277 19.1 Gathering ASRs from Requirements Documents 278 19.2 Gathering ASRs by Interviewing Stakeholders 279 19.3 Gathering ASRs by Understanding the Business Goals 282 19.4 Capturing ASRs in a Utility Tree 284 19.5 Change Happens 286 19.6 Summary 286 19.7 For Further Reading 287 19.8 Discussion Questions 287 Chapter 20: Designing an Architecture 289 20.1 Attribute-Driven Design 289 20.2 The Steps of ADD 292 20.3 More on ADD Step 4: Choose One or More Design Concepts 295 20.4 More on ADD Step 5: Producing Structures 298 20.5 More on ADD Step 6: Creating Preliminary Documentation during the Design 301 20.6 More on ADD Step 7: Perform Analysis of the Current Design and Review the Iteration Goal and Achievement of the Design Purpose 304 20.7 Summary 306 20.8 For Further Reading 306 20.9 Discussion Questions 307 Chapter 21: Evaluating an Architecture 309 21.1 Evaluation as a Risk Reduction Activity 309 21.2 What Are the Key Evaluation Activities? 310 21.3 Who Can Perform the Evaluation? 311 21.4 Contextual Factors 312 21.5 The Architecture Tradeoff Analysis Method 313 21.6 Lightweight Architecture Evaluation 324 21.7 Summary 326 21.8 For Further Reading 327 21.9 Discussion Questions 327 Chapter 22: Documenting an Architecture 329 22.1 Uses and Audiences for Architecture Documentation 330 22.2 Notations 331 22.3 Views 332 22.4 Combining Views 339 22.5 Documenting Behavior 340 22.6 Beyond Views 345 22.7 Documenting the Rationale 346 22.8 Architecture Stakeholders 347 22.9 Practical Considerations 350 22.10 Summary 353 22.11 For Further Reading 353 22.12 Discussion Questions 354 Chapter 23: Managing Architecture Debt 355 23.1 Determining Whether You Have an Architecture Debt Problem 356 23.2 Discovering Hotspots 358 23.3 Example 362 23.4 Automation 363 23.5 Summary 364 23.6 For Further Reading 364 23.7 Discussion Questions 365 Part V: Architecture and the Organization 367Chapter 24: The Role of Architects in Projects 367 24.1 The Architect and the Project Manager 367 24.2 Incremental Architecture and Stakeholders 369 24.3 Architecture and Agile Development 370 24.4 Architecture and Distributed Development 373 24.5 Summary 376 24.6 For Further Reading 376 24.7 Discussion Questions 377 Chapter 25: Architecture Competence 379 25.1 Competence of Individuals: Duties, Skills, and Knowledge of Architects 379 25.2 Competence of a Software Architecture Organization 386 25.3 Become a Better Architect 387 25.4 Summary 388 25.5 For Further Reading 388 25.6 Discussion Questions 389 Part VI: Conclusions 391Chapter 26: A Glimpse of the Future: Quantum Computing 391 26.1 Single Qubit 392 26.2 Quantum Teleportation 394 26.3 Quantum Computing and Encryption 394 26.4 Other Algorithms 395 26.5 Potential Applications 396 26.6 Final Thoughts 397 26.7 For Further Reading 398 References 399About the Authors 415Index 417
£46.79
Pearson Education (US) Patterns of Distributed Systems
Book SynopsisUnmesh Joshi is a Principal Consultant at Thoughtworks with 22 years of industry experience. He is a software architecture enthusiast, who believes that understanding principles of distributed systems is as essential today as understanding web architecture or object-oriented programming was in the last decade. For the last two years he has been publishing patterns of distributed systems on martinfowler.com. He has also conducted various training sessions around this topic. Twitter: @unmeshjoshiTable of ContentsForeword xviiPreface xixAcknowledgments xxiiiAbout the Author xxv Part I: Narratives 1 Chapter 1: The Promise and Perils of Distributed Systems 3The Limits of a Single Server 3Separate Business Logic and Data Layer 5Partitioning Data 6A Look at Failures 7Replication: Masking Failures 9Defining the Term "Distributed Systems" 10The Patterns Approach 10 Chapter 2: Overview of the Patterns 13Keeping Data Resilient on a Single Server 14Competing Updates 15Dealing with the Leader Failing 17Multiple Failures Need a Generation Clock 21Log Entries Cannot Be Committed until They Are Accepted by a Majority Quorum 26Followers Commit Based on a High-Water Mark 29Leaders Use a Series of Queues to Remain Responsive to Many Clients 34Followers Can Handle Read Requests to Reduce Load on the Leader 40A Large Amount of Data Can Be Partitioned over Multiple Nodes 42Partitions Can Be Replicated for Resilience 45A Minimum of Two Phases Are Needed to Maintain Consistency across Partitions 46In Distributed Systems, Ordering Cannot Depend on System Timestamps 49A Consistent Core Can Manage the Membership of a Data Cluster 58Gossip Dissemination for Decentralized Cluster Management 62 Part II: Patterns of Data Replication 69 Chapter 3: Write-Ahead Log 71Problem 71Solution 71Examples 76 Chapter 4: Segmented Log 77Problem 77Solution 77Examples 79 Chapter 5: Low-Water Mark 81Problem 81Solution 81Examples 83 Chapter 6: Leader and Followers 85Problem 85Solution 85Examples 92 Chapter 7: HeartBeat 93Problem 93Solution 93Examples 98 Chapter 8: Majority Quorum 99Problem 99Solution 100Examples 102 Chapter 9: Generation Clock 103Problem 103Solution 104Examples 107 Chapter 10: High-Water Mark 109Problem 109Solution 109Examples 115 Chapter 11: Paxos 117Problem 117Solution 117Examples 132 Chapter 12: Replicated Log 133Problem 133Solution 133Examples 158 Chapter 13: Singular Update Queue 159Problem 159Solution 159Examples 166 Chapter 14: Request Waiting List 167Problem 167Solution 167Examples 173 Chapter 15: Idempotent Receiver 175Problem 175Solution 175Examples 181 Chapter 16: Follower Reads 183Problem 183Solution 183Examples 191 Chapter 17: Versioned Value 193Problem 193Solution 193Examples 201 Chapter 18: Version Vector 203Problem 203Solution 203Examples 216 Part III: Patterns of Data Partitioning 217 Chapter 19: Fixed Partitions 219Problem 219Solution 220Examples 241 Chapter 20: Key-Range Partitions 243Problem 243Solution 244Examples 255 Chapter 21: Two-Phase Commit 257Problem 257Solution 257Examples 297 Part IV: Patterns of Distributed Time 299 Chapter 22: Lamport Clock 301Problem 301Solution 301Examples 307 Chapter 23: Hybrid Clock 309Problem 309Solution 309Examples 316 Chapter 24: Clock-Bound Wait 317Problem 317Solution 318Examples 332 Part V: Patterns of Cluster Management 335 Chapter 25: Consistent Core 337Problem 337Solution 337Examples 342 Chapter 26: Lease 345Problem 345Solution 345Examples 354 Chapter 27: State Watch 355Problem 355Solution 355Examples 362 Chapter 28: Gossip Dissemination 363Problem 363Solution 363Examples 373 Chapter 29: Emergent Leader 375Problem 375Solution 375Examples 392 Part VI: Patterns of Communication between Nodes 393 Chapter 30: Single-Socket Channel 395Problem 395Solution 395Examples 397 Chapter 31: Request Batch 399Problem 399Solution 399Examples 404 Chapter 32: Request Pipeline 405Problem 405Solution 405Examples 408 References 409Index 413
£34.19
John Wiley & Sons Inc Beginning Programming with Python For Dummies
Book SynopsisTable of ContentsIntroduction 1 Part 1: Getting Started with Python 7 Chapter 1: Talking to Your Computer 9 Chapter 2: Working with Google Colab 23 Chapter 3: Interacting with Python 41 Chapter 4: Writing Your First Application 57 Chapter 5: Performing Magic 79 Part 2: Talking the Talk 93 Chapter 6: Storing and Modifying Information 95 Chapter 7: Managing Information 107 Chapter 8: Making Decisions 127 Chapter 9: Performing Repetitive Tasks 143 Chapter 10: Dealing with Errors 157 Part 3: Performing Common Tasks 187 Chapter 11: Interacting with Packages 189 Chapter 12: Working with Strings 215 Chapter 13: Managing Lists 239 Chapter 14: Collecting All Sorts of Data 257 Chapter 15: Creating and Using Classes 279 Part 4: Performing Advanced Tasks 301 Chapter 16: Storing Data in Files 303 Chapter 17: Sending an Email 321 Part 5: The Part of Tens 337 Chapter 18: Ten Amazing Programming Resources 339 Chapter 19: Ten Ways to Make a Living with Python 349 Chapter 20: Ten Tools That Enhance Your Python Experience 357 Chapter 21: Ten (Plus) Libraries You Need to Know About 369 Index 379
£21.59
John Wiley & Sons Inc Systems Analysis and Design with EEPUB Access
Book Synopsis
£107.96
No Starch Press,US Learn Robotics With Raspberry Pi
Book SynopsisMatt Timmons-Brown takes you through the process of building your own robot with the Raspberry Pi microcomputer - with no experience necessary! Starting from the ground up, you'll add complexity to your robot with each chapter by adding and tweaking code and components, and also receive advice on which materials you can use to make your builds unique and personal. By the end of the book, you'll know how to apply the knowledge you've gained to build other robots. If you're ready to level up your robotics skills with Raspberry Pi, let Learn Robotics with Raspberry Pi be your guide!
£19.19
No Starch Press,US The Linux Programming Interface
Book SynopsisThe Linux Programming Interface (TLPI) is the definitive guide to the Linux and UNIX programming interface the interface employed by nearly every application that runs on a Linux or UNIX system. In this authoritative work, Linux programming expert Michael Kerrisk provides detailed descriptions of the system calls and library functions that you need in order to master the craft of system programming, and accompanies his explanations with clear, complete example programs. You'll find descriptions of over 500 system calls and library functions, and more than 200 example programs, 88 tables, and 115 diagrams. You'll learn how to: Read and write files efficiently Use signals, clocks, and timers Create processes and execute programs Write secure programs Write multithreaded programs using POSIX threads Build and use shared libraries Perform interprocess communication using pipes, message queues, shared memory, and semaphores Write network applications with the sockets API While The LTable of ContentsPraise for The Linux Programming Interface; Dedication; Preface;; Chapter 1: History and Standards; 1.1 A Brief History of UNIX and C; 1.2 A Brief History of Linux; 1.3 Standardization; 1.4 Summary; Chapter 2: Fundamental Concepts; 2.1 The Core Operating System: The Kernel; 2.2 The Shell; 2.3 Users and Groups; 2.4 Single Directory Hierarchy, Directories, Links, and Files; 2.5 File I/O Model; 2.6 Programs; 2.7 Processes; 2.8 Memory Mappings; 2.9 Static and Shared Libraries; 2.10 Interprocess Communication and Synchronization; 2.11 Signals; 2.12 Threads; 2.13 Process Groups and Shell Job Control; 2.14 Sessions, Controlling Terminals, and Controlling Processes; 2.15 Pseudoterminals; 2.16 Date and Time; 2.17 Client-Server Architecture; 2.18 Realtime; 2.19 The /proc File System; 2.20 Summary; Chapter 3: System Programming Concepts; 3.1 System Calls; 3.2 Library Functions; 3.3 The Standard C Library; The GNU C Library (glibc); 3.4 Handling Errors from System Calls and Library Functions; 3.5 Notes on the Example Programs in This Book; 3.6 Portability Issues; 3.7 Summary; 3.8 Exercise; Chapter 4: File I/O: The Universal I/O Model; 4.1 Overview; 4.2 Universality of I/O; 4.3 Opening a File: open(); 4.4 Reading from a File: read(); 4.5 Writing to a File: write(); 4.6 Closing a File: close(); 4.7 Changing the File Offset: lseek(); 4.8 Operations Outside the Universal I/O Model: ioctl(); 4.9 Summary; 4.10 Exercises; Chapter 5: File I/O: Further Details; 5.1 Atomicity and Race Conditions; 5.2 File Control Operations: fcntl(); 5.3 Open File Status Flags; 5.4 Relationship Between File Descriptors and Open Files; 5.5 Duplicating File Descriptors; 5.6 File I/O at a Specified Offset: pread() and pwrite(); 5.7 Scatter-Gather I/O: readv() and writev(); 5.8 Truncating a File: truncate() and ftruncate(); 5.9 Nonblocking I/O; 5.10 I/O on Large Files; 5.11 The /dev/fd Directory; 5.12 Creating Temporary Files; 5.13 Summary; 5.14 Exercises; Chapter 6: Processes; 6.1 Processes and Programs; 6.2 Process ID and Parent Process ID; 6.3 Memory Layout of a Process; 6.4 Virtual Memory Management; 6.5 The Stack and Stack Frames; 6.6 Command-Line Arguments (argc, argv); 6.7 Environment List; 6.8 Performing a Nonlocal Goto: setjmp() and long jmp(); 6.9 Summary; 6.10 Exercises; Chapter 7: Memory Allocation; 7.1 Allocating Memory on the Heap; 7.2 Allocating Memory on the Stack: alloca(); 7.3 Summary; 7.4 Exercises; Chapter 8: Users and Groups; 8.1 The Password File: /etc/passwd; 8.2 The Shadow Password File: /etc/shadow; 8.3 The Group File: /etc/group; 8.4 Retrieving User and Group Information; 8.5 Password Encryption and User Authentication; 8.6 Summary; 8.7 Exercises; Chapter 9: Process Credentials; 9.1 Real User ID and Real Group ID; 9.2 Effective User ID and Effective Group ID; 9.3 Set-User-ID and Set-Group-ID Programs; 9.4 Saved Set-User-ID and Saved Set-Group-ID; 9.5 File-System User ID and File-System Group ID; 9.6 Supplementary Group IDs; 9.7 Retrieving and Modifying Process Credentials; 9.8 Summary; 9.9 Exercises; Chapter 10: Time; 10.1 Calendar Time; 10.2 Time-Conversion Functions; 10.3 Timezones; 10.4 Locales; 10.5 Updating the System Clock; 10.6 The Software Clock (Jiffies); 10.7 Process Time; 10.8 Summary; 10.9 Exercise; Chapter 11: System Limits and Options; 11.1 System Limits; 11.2 Retrieving System Limits (and Options) at Run Time; 11.3 Retrieving File-Related Limits (and Options) at Run Time; 11.4 Indeterminate Limits; 11.5 System Options; 11.6 Summary; 11.7 Exercises; Chapter 12: System and Process Information; 12.1 The /proc File System; 12.2 System Identification: uname(); 12.3 Summary; 12.4 Exercises; Chapter 13: File I/O Buffering; 13.1 Kernel Buffering of File I/O: The Buffer Cache; 13.2 Buffering in the stdio Library; 13.3 Controlling Kernel Buffering of File I/O; 13.4 Summary of I/O Buffering; 13.5 Advising the Kernel About I/O Patterns; 13.6 Bypassing the Buffer Cache: Direct I/O; 13.7 Mixing Library Functions and System Calls for File I/O; 13.8 Summary; 13.9 Exercises; Chapter 14: File Systems; 14.1 Device Special Files (Devices); 14.2 Disks and Partitions; 14.3 File Systems; 14.4 I-nodes; 14.5 The Virtual File System (VFS); 14.6 Journaling File Systems; 14.7 Single Directory Hierarchy and Mount Points; 14.8 Mounting and Unmounting File Systems; 14.9 Advanced Mount Features; 14.10 A Virtual Memory File System: tmpfs; 14.11 Obtaining Information About a File System: statvfs(); 14.12 Summary; 14.13 Exercise; Chapter 15: File Attributes; 15.1 Retrieving File Information: stat(); 15.2 File Timestamps; 15.3 File Ownership; 15.4 File Permissions; 15.5 I-node Flags (ext2 Extended File Attributes); 15.6 Summary; 15.7 Exercises; Chapter 16: Extended Attributes;;;;;; 16.1 Overview; 16.2 Extended Attribute Implementation Details; 16.3 System Calls for Manipulating Extended Attributes; 16.4 Summary; 16.5 Exercise; Chapter 17: Access Control Lists; 17.1 Overview; 17.2 ACL Permission-Checking Algorithm; 17.3 Long and Short Text Forms for ACLs; 17.4 The ACL_MASK Entry and the ACL Group Class; 17.5 The getfacl and setfacl Commands; 17.6 Default ACLs and File Creation; 17.7 ACL Implementation Limits; 17.8 The ACL API; 17.9 Summary; 17.10 Exercise; Chapter 18: Directories and Links; 18.1 Directories and (Hard) Links; 18.2 Symbolic (Soft) Links; 18.3 Creating and Removing (Hard) Links: link() and unlink(); 18.4 Changing the Name of a File: rename(); 18.5 Working with Symbolic Links: symlink() and readlink(); 18.6 Creating and Removing Directories: mkdir() and rmdir(); 18.7 Removing a File or Directory: remove(); 18.8 Reading Directories: opendir() and readdir(); 18.9 File Tree Walking: nftw(); 18.10 The Current Working Directory of a Process; 18.11 Operating Relative to a Directory File Descriptor; 18.12 Changing the Root Directory of a Process: chroot(); 18.13 Resolving a Pathname: realpath(); 18.14 Parsing Pathname Strings: dirname() and basename(); 18.15 Summary; 18.16 Exercises; Chapter 19: Monitoring File Events; 19.1 Overview; 19.2 The inotify API; 19.3 inotify Events; 19.4 Reading inotify Events; 19.5 Queue Limits and /proc Files; 19.6 An Older System for Monitoring File Events: dnotify; 19.7 Summary; 19.8 Exercise; Chapter 20: Signals: Fundamental Concepts; 20.1 Concepts and Overview; 20.2 Signal Types and Default Actions; 20.3 Changing Signal Dispositions: signal(); 20.4 Introduction to Signal Handlers; 20.5 Sending Signals: kill(); 20.6 Checking for the Existence of a Process; 20.7 Other Ways of Sending Signals: raise() and killpg(); 20.8 Displaying Signal Descriptions; 20.9 Signal Sets; 20.10 The Signal Mask (Blocking Signal Delivery); 20.11 Pending Signals; 20.12 Signals Are Not Queued; 20.13 Changing Signal Dispositions: sigaction(); 20.14 Waiting for a Signal: pause(); 20.15 Summary; 20.16 Exercises; Chapter 21: Signals: Signal Handlers; 21.1 Designing Signal Handlers; 21.2 Other Methods of Terminating a Signal Handler; 21.3 Handling a Signal on an Alternate Stack: sigaltstack(); 21.4 The SA_SIGINFO Flag; 21.5 Interruption and Restarting of System Calls; 21.6 Summary; 21.7 Exercise; Chapter 22: Signals: Advanced Features; 22.1 Core Dump Files; 22.2 Special Cases for Delivery, Disposition, and Handling; 22.3 Interruptible and Uninterruptible Process Sleep States; 22.4 Hardware-Generated Signals; 22.5 Synchronous and Asynchronous Signal Generation; 22.6 Timing and Order of Signal Delivery; 22.7 Implementation and Portability of signal(); 22.8 Realtime Signals; 22.9 Waiting for a Signal Using a Mask: sigsuspend(); 22.10 Synchronously Waiting for a Signal; 22.11 Fetching Signals via a File Descriptor; 22.12 Interprocess Communication with Signals; 22.13 Earlier Signal APIs (System V and BSD); 22.14 Summary; 22.15 Exercises; Chapter 23: Timers and Sleeping; 23.1 Interval Timers; 23.2 Scheduling and Accuracy of Timers; 23.3 Setting Timeouts on Blocking Operations; 23.4 Suspending Execution for a Fixed Interval (Sleeping); 23.5 POSIX Clocks; 23.6 POSIX Interval Timers; 23.7 Timers That Notify via File Descriptors: The timerfd API; 23.8 Summary; 23.9 Exercises; Chapter 24: Process Creation; 24.1 Overview of fork(), exit(), wait(), and execve(); 24.2 Creating a New Process: fork(); 24.3 The vfork() System Call; 24.4 Race Conditions After fork(); 24.5 Avoiding Race Conditions by Synchronizing with Signals; 24.6 Summary; 24.7 Exercises; Chapter 25: Process Termination; 25.1 Terminating a Process: _exit() and exit(); 25.2 Details of Process Termination; 25.3 Exit Handlers; 25.4 Interactions Between fork(), stdio Buffers, and _exit(); 25.5 Summary; 25.6 Exercise; Chapter 26: Monitoring Child Processes; 26.1 Waiting on a Child Process; 26.2 Orphans and Zombies; 26.3 The SIGCHLD Signal; 26.4 Summary; 26.5 Exercises; Chapter 27: Program Execution; 27.1 Executing a New Program: execve(); 27.2 The exec() Library Functions; 27.3 Interpreter Scripts; 27.4 File Descriptors and exec(); 27.5 Signals and exec(); 27.6 Executing a Shell Command: system(); 27.7 Implementing system(); 27.8 Summary; 27.9 Exercises; Chapter 28: Process Creation and Program Execution in More Detail; 28.1 Process Accounting; 28.2 The clone() System Call; 28.3 Speed of Process Creation; 28.4 Effect of exec() and fork() on Process Attributes; 28.5 Summary; 28.6 Exercise; Chapter 29: Threads: Introduction; 29.1 Overview; 29.2 Background Details of the Pthreads API; 29.3 Thread Creation; 29.4 Thread Termination; 29.5 Thread IDs; 29.6 Joining with a Terminated Thread; 29.7 Detaching a Thread; 29.8 Thread Attributes; 29.9 Threads Versus Processes; 29.10 Summary; 29.11 Exercises; Chapter 30: Threads: Thread Synchronization; 30.1 Protecting Accesses to Shared Variables: Mutexes; 30.2 Signaling Changes of State: Condition Variables; 30.3 Summary; 30.4 Exercises; Chapter 31: Threads: Thread Safety and Per-Thread Storage; 31.1 Thread Safety (and Reentrancy Revisited); 31.2 One-Time Initialization; 31.3 Thread-Specific Data; 31.4 Thread-Local Storage; 31.5 Summary; 31.6 Exercises; Chapter 32: Threads: Thread Cancellation; 32.1 Canceling a Thread; 32.2 Cancellation State and Type; 32.3 Cancellation Points; 32.4 Testing for Thread Cancellation; 32.5 Cleanup Handlers; 32.6 Asynchronous Cancelability; 32.7 Summary; Chapter 33: Threads: Further Details; 33.1 Thread Stacks; 33.2 Threads and Signals; 33.3 Threads and Process Control; 33.4 Thread Implementation Models; 33.5 Linux Implementations of POSIX Threads; 33.6 Advanced Features of the Pthreads API; 33.7 Summary; 33.8 Exercises; Chapter 34: Process Groups, Sessions, and Job Control; 34.1 Overview; 34.2 Process Groups; 34.3 Sessions; 34.4 Controlling Terminals and Controlling Processes; 34.5 Foreground and Background Process Groups; 34.6 The SIGHUP Signal; 34.7 Job Control; 34.8 Summary; 34.9 Exercises; Chapter 35: Process Priorities and Scheduling; 35.1 Process Priorities (Nice Values); 35.2 Overview of Realtime Process Scheduling; 35.3 Realtime Process Scheduling API; 35.4 CPU Affinity; 35.5 Summary; 35.6 Exercises; Chapter 36: Process Resources; 36.1 Process Resource Usage; 36.2 Process Resource Limits; 36.3 Details of Specific Resource Limits; 36.4 Summary; 36.5 Exercises; Chapter 37: Daemons; 37.1 Overview; 37.2 Creating a Daemon; 37.3 Guidelines for Writing Daemons; 37.4 Using SIGHUP to Reinitialize a Daemon; 37.5 Logging Messages and Errors Using syslog; 37.6 Summary; 37.7 Exercise; Chapter 38: Writing Secure Privileged Programs; 38.1 Is a Set-User-ID or Set-Group-ID Program Required?; 38.2 Operate with Least Privilege; 38.3 Be Careful When Executing a Program; 38.4 Avoid Exposing Sensitive Information; 38.5 Confine the Process; 38.6 Beware of Signals and Race Conditions; 38.7 Pitfalls When Performing File Operations and File I/O; 38.8 Don't Trust Inputs or the Environment; 38.9 Beware of Buffer Overruns; 38.10 Beware of Denial-of-Service Attacks; 38.11 Check Return Statuses and Fail Safely; 38.12 Summary; 38.13 Exercises; Chapter 39: Capabilities; 39.1 Rationale for Capabilities; 39.2 The Linux Capabilities; 39.3 Process and File Capabilities; 39.4 The Modern Capabilities Implementation; 39.5 Transformation of Process Capabilities During exec(); 39.6 Effect on Process Capabilities of Changing User IDs; 39.7 Changing Process Capabilities Programmatically; 39.8 Creating Capabilities-Only Environments; 39.9 Discovering the Capabilities Required by a Program; 39.10 Older Kernels and Systems Without File Capabilities; 39.11 Summary; 39.12 Exercise; Chapter 40: Login Accounting; 40.1 Overview of the utmp and wtmp Files; 40.2 The utmpx API; 40.3 The utmpx Structure; 40.4 Retrieving Information from the utmp and wtmp Files; 40.5 Retrieving the Login Name: getlogin(); 40.6 Updating the utmp and wtmp Files for a Login Session; 40.7 The lastlog File; 40.8 Summary; 40.9 Exercises; Chapter 41: Fundamentals of Shared Libraries; 41.1 Object Libraries; 41.2 Static Libraries; 41.3 Overview of Shared Libraries; 41.4 Creating and Using Shared Libraries--A First Pass; 41.5 Useful Tools for Working with Shared Libraries; 41.6 Shared Library Versions and Naming Conventions; 41.7 Installing Shared Libraries; 41.8 Compatible Versus Incompatible Libraries; 41.9 Upgrading Shared Libraries; 41.10 Specifying Library Search Directories in an Object File; 41.11 Finding Shared Libraries at Run Time; 41.12 Run-Time Symbol Resolution; 41.13 Using a Static Library Instead of a Shared Library; 41.14 Summary; 41.15 Exercise; Chapter 42: Advanced Features of Shared Libraries; 42.1 Dynamically Loaded Libraries; 42.2 Controlling Symbol Visibility; 42.3 Linker Version Scripts; 42.4 Initialization and Finalization Functions; 42.5 Preloading Shared Libraries; 42.6 Monitoring the Dynamic Linker: LD_DEBUG; 42.7 Summary; 42.8 Exercises; Chapter 43: Interprocess Communication Overview; 43.1 A Taxonomy of IPC Facilities; 43.2 Communication Facilities; 43.3 Synchronization Facilities; 43.4 Comparing IPC Facilities; 43.5 Summary; 43.6 Exercises; Chapter 44: Pipes and FIFOs; 44.1 Overview; 44.2 Creating and Using Pipes; 44.3 Pipes as a Method of Process Synchronization; 44.4 Using Pipes to Connect Filters; 44.5 Talking to a Shell Command via a Pipe: popen(); 44.6 Pipes and stdio Buffering; 44.7 FIFOs; 44.8 A Client-Server Application Using FIFOs; 44.9 Nonblocking I/O; 44.10 Semantics of read() and write() on Pipes and FIFOs; 44.11 Summary; 44.12 Exercises; Chapter 45: Introduction to System V IPC; 45.1 API Overview; 45.2 IPC Keys; 45.3 Associated Data Structure and Object Permissions; 45.4 IPC Identifiers and Client-Server Applications; 45.5 Algorithm Employed by System V IPC get Calls; 45.6 The ipcs and ipcrm Commands; 45.7 Obtaining a List of All IPC Objects; 45.8 IPC Limits; 45.9 Summary; 45.10 Exercises; Chapter 46: System V Message Queues; 46.1 Creating or Opening a Message Queue; 46.2 Exchanging Messages; 46.3 Message Queue Control Operations; 46.4 Message Queue Associated Data Structure; 46.5 Message Queue Limits; 46.6 Displaying All Message Queues on the System; 46.7 Client-Server Programming with Message Queues; 46.8 A File-Server Application Using Message Queues; 46.9 Disadvantages of System V Message Queues; 46.10 Summary; 46.11 Exercises; Chapter 47: System V Semaphores; 47.1 Overview; 47.2 Creating or Opening a Semaphore Set; 47.3 Semaphore Control Operations; 47.4 Semaphore Associated Data Structure; 47.5 Semaphore Initialization; 47.6 Semaphore Operations; 47.7 Handling of Multiple Blocked Semaphore Operations; 47.8 Semaphore Undo Values; 47.9 Implementing a Binary Semaphores Protocol; 47.10 Semaphore Limits; 47.11 Disadvantages of System V Semaphores; 47.12 Summary; 47.13 Exercises; Chapter 48: System V Shared Memory; 48.1 Overview; 48.2 Creating or Opening a Shared Memory Segment; 48.3 Using Shared Memory; 48.4 Example: Transferring Data via Shared Memory; 48.5 Location of Shared Memory in Virtual Memory; 48.6 Storing Pointers in Shared Memory; 48.7 Shared Memory Control Operations; 48.8 Shared Memory Associated Data Structure; 48.9 Shared Memory Limits; 48.10 Summary; 48.11 Exercises; Chapter 49: Memory Mappings; 49.1 Overview; 49.2 Creating a Mapping: mmap(); 49.3 Unmapping a Mapped Region: munmap(); 49.4 File Mappings; 49.5 Synchronizing a Mapped Region: msync(); 49.6 Additional mmap() Flags; 49.7 Anonymous Mappings; 49.8 Remapping a Mapped Region: mremap(); 49.9 MAP_NORESERVE and Swap Space Overcommitting; 49.10 The MAP_FIXED Flag; 49.11 Nonlinear Mappings: remap_file_pages(); 49.12 Summary; 49.13 Exercises; Chapter 50: Virtual Memory Operations; 50.1 Changing Memory Protection: mprotect(); 50.2 Memory Locking: mlock() and mlockall(); 50.3 Determining Memory Residence: mincore(); 50.4 Advising Future Memory Usage Patterns: madvise(); 50.5 Summary; 50.6 Exercises; Chapter 51: Introduction to POSIX IPC; 51.1 API Overview; 51.2 Comparison of System V IPC and POSIX IPC; 51.3 Summary; Chapter 52: POSIX Message Queues; 52.1 Overview; 52.2 Opening, Closing, and Unlinking a Message Queue; 52.3 Relationship Between Descriptors and Message Queues; 52.4 Message Queue Attributes; 52.5 Exchanging Messages; 52.6 Message Notification; 52.7 Linux-Specific Features; 52.8 Message Queue Limits; 52.9 Comparison of POSIX and System V Message Queues; 52.10 Summary; 52.11 Exercises; Chapter 53: POSIX Semaphores; 53.1 Overview; 53.2 Named Semaphores; 53.3 Semaphore Operations; 53.4 Unnamed Semaphores; 53.5 Comparisons with Other Synchronization Techniques; 53.6 Semaphore Limits; 53.7 Summary; 53.8 Exercises; Chapter 54: POSIX Shared Memory; 54.1 Overview; 54.2 Creating Shared Memory Objects; 54.3 Using Shared Memory Objects; 54.4 Removing Shared Memory Objects; 54.5 Comparisons Between Shared Memory APIs; 54.6 Summary; 54.7 Exercise; Chapter 55: File Locking; 55.1 Overview; 55.2 File Locking with flock(); 55.3 Record Locking with fcntl(); 55.4 Mandatory Locking; 55.5 The /proc/locks File; 55.6 Running Just One Instance of a Program; 55.7 Older Locking Techniques; 55.8 Summary; 55.9 Exercises; Chapter 56: Sockets: Introduction; 56.1 Overview; 56.2 Creating a Socket: socket(); 56.3 Binding a Socket to an Address: bind(); 56.4 Generic Socket Address Structures: struct sockaddr; 56.5 Stream Sockets; 56.6 Datagram Sockets; 56.7 Summary; Chapter 57: Sockets: UNIX Domain; 57.1 UNIX Domain Socket Addresses: struct sockaddr_un; 57.2 Stream Sockets in the UNIX Domain; 57.3 Datagram Sockets in the UNIX Domain; 57.4 UNIX Domain Socket Permissions; 57.5 Creating a Connected Socket Pair: socketpair(); 57.6 The Linux Abstract Socket Namespace; 57.7 Summary; 57.8 Exercises; Chapter 58: Sockets: Fundamentals of TCP/IP Networks; 58.1 Internets; 58.2 Networking Protocols and Layers; 58.3 The Data-Link Layer; 58.4 The Network Layer: IP; 58.5 IP Addresses; 58.6 The Transport Layer; 58.7 Requests for Comments (RFCs); 58.8 Summary; Chapter 59: Sockets: Internet Domains; 59.1 Internet Domain Sockets; 59.2 Network Byte Order; 59.3 Data Representation; 59.4 Internet Socket Addresses; 59.5 Overview of Host and Service Conversion Functions; 59.6 The inet_pton() and inet_ntop() Functions; 59.7 Client-Server Example (Datagram Sockets); 59.8 Domain Name System (DNS); 59.9 The /etc/services File; 59.10 Protocol-Independent Host and Service Conversion; 59.11 Client-Server Example (Stream Sockets); 59.12 An Internet Domain Sockets Library; 59.13 Obsolete APIs for Host and Service Conversions; 59.14 UNIX Versus Internet Domain Sockets; 59.15 Further Information; 59.16 Summary; 59.17 Exercises; Chapter 60: Sockets: Server Design; 60.1 Iterative and Concurrent Servers; 60.2 An Iterative UDP echo Server; 60.3 A Concurrent TCP echo Server; 60.4 Other Concurrent Server Designs; 60.5 The inetd (Internet Superserver) Daemon; 60.6 Summary; 60.7 Exercises; Chapter 61: Sockets: Advanced Topics; 61.1 Partial Reads and Writes on Stream Sockets; 61.2 The shutdown() System Call; 61.3 Socket-Specific I/O System Calls: recv() and send(); 61.4 The sendfile() System Call; 61.5 Retrieving Socket Addresses; 61.6 A Closer Look at TCP; 61.7 Monitoring Sockets: netstat; 61.8 Using tcpdump to Monitor TCP Traffic; 61.9 Socket Options; 61.10 The SO_REUSEADDR Socket Option; 61.11 Inheritance of Flags and Options Across accept(); 61.12 TCP Versus UDP; 61.13 Advanced Features; 61.14 Summary; 61.15 Exercises; Chapter 62: Terminals; 62.1 Overview; 62.2 Retrieving and Modifying Terminal Attributes; 62.3 The stty Command; 62.4 Terminal Special Characters; 62.5 Terminal Flags; 62.6 Terminal I/O Modes; 62.7 Terminal Line Speed (Bit Rate); 62.8 Terminal Line Control; 62.9 Terminal Window Size; 62.10 Terminal Identification; 62.11 Summary; 62.12 Exercises; Chapter 63: Alternative I/O Models; 63.1 Overview; 63.2 I/O Multiplexing; 63.3 Signal-Driven I/O; 63.4 The epoll API; 63.5 Waiting on Signals and File Descriptors; 63.6 Summary; 63.7 Exercises; Chapter 64: Pseudoterminals; 64.1 Overview; 64.2 UNIX 98 Pseudoterminals; 64.3 Opening a Master: ptyMasterOpen(); 64.4 Connecting Processes with a Pseudoterminal: ptyFork(); 64.5 Pseudoterminal I/O; 64.6 Implementing script(1); 64.7 Terminal Attributes and Window Size; 64.8 BSD Pseudoterminals; 64.9 Summary; 64.10 Exercises; Tracing System Calls; Parsing Command-Line Options; Example program; GNU-specific behavior; GNU extensions; Casting the NULL Pointer; Kernel Configuration; Further Sources of Information; Manual pages; GNU info documents; The GNU C library (glibc) manual; Books; Source code of existing applications; The Linux Documentation Project; The GNU project; Newsgroups; Linux kernel mailing list; Web sites; The kernel source code; Solutions to Selected Exercises;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Bibliography; Updates; Colophon;
£71.24
No Starch Press,US Learn You A Haskell For Great Good
Book SynopsisIt's all in the name: Learn You a Haskell for Great Good! is a hilarious, illustrated guide to this complex functional language. Packed with the author's original artwork, pop culture references, and most importantly, useful example code, this book teaches functional fundamentals in a way you never thought possible. You'll start with the kid stuff: basic syntax, recursion, types and type classes. Then once you've got the basics down, the real black belt master-class begins: you'll learn to use applicative functors, monads, zippers, and all the other mythical Haskell constructs you've only read about in storybooks. As you work your way through the author's imaginative (and occasionally insane) examples, you'll learn to: Laugh in the face of side effects as you wield purely functional programming techniques Use the magic of Haskell's 'laziness' to play with infinite sets of data Organize your programs by creating your own types, type classes, and modules Use Haskell's elegant input/Trade Review"The thing that's most impressive about Learn You a Haskell for Great Good! is how well-written it is. This book is just fantastic."—Gregory Collins, Google Switzerland"Managed to walk me through all important Haskell concepts without ever making any of the material sound complicated. A good introduction to functional programming."—Marijn Haverbeke, author of Eloquent JavaScript"This is a fantastic book and I highly recommend it as the first book on Haskell—and possibly even the second."—Michael Fogus, author of The Joy of Clojure"A fantastic, fun, thorough introduction to Haskell, spiced up by Miran's great sense of humor and zany illustrations."—Brent Yorgey, The Math Less Traveled"Miran Lipovača has done a fantastic job of writing a book aimed at beginning Haskell programmers. I like his very straightforward writing style of introducing each topic with the minimum of complexity."—Bryan Bell, Math and More"This is a remarkable book and may be just what this beautiful language was missing."—Michael Kohl, Citizen428"This book is the best way I know to obtain the Haskell foundation you need for fluency."—Jeremy Bowers, Jerf.org"This is a terrific book. It makes what might otherwise seem impenetrable mathy-code and makes it fun and approachable."—Simon ReynoldsTable of ContentsIntroductionChapter 1: Starting OutChapter 2: Believe the TypeChapter 3: Syntax in FunctionsChapter 4: Hello Recursion!Chapter 5: Higher-Order FunctionsChapter 6: ModulesChapter 7: Making Our Own Types and Type ClassesChapter 8: Input and OutputChapter 9: More Input and More OutputChapter 10: Functionally Solving ProblemsChapter 11: Applicative FunctorsChapter 12: MonoidsChapter 13: A Fistful of MonadsChapter 14: For a Few Monads MoreChapter 15: ZippersColophonUpdates
£32.24
Manning Publications Learn PowerShell in a Month of Lunches: Covers
Book Synopsis"Not only for MacOS and Linux users, but also a great resource for Windows PS users." - Bruce Bergman Learn PowerShell in a Month of Lunches: Covers Windows, Linux, and macOS is a task-focused tutorial for administering Linux and macOS systems using Microsoft PowerShell. Adapted by PowerShell team members Travis Plunk and Tyler Leonhardt from the bestselling Learn Windows PowerShell in a Month of Lunches by community legends Don Jones and Jeffrey Hicks, it features Linux-based examples covering core language features and admin tasks. Designed for busy IT professionals, this innovative guide will take you from the basics to PowerShell proficiency through 25 tutorials you can do in your lunch break. about the technologyThe PowerShell scripting language and administrative shell was initially created for Windows, providing a high-quality command-line interface and awesome automation features. As part of Microsoft's ongoing strategy to support non-Windows platforms with its Azure cloud service and .NET Core framework, PowerShell now runs on Linux and macOS. Like Bash, PowerShell can execute and script nearly any aspect of Linux, so you can easily manage repetitive daily tasks, servers, Cloud resources, Continuous Integration pipelines, and more. Because PowerShell is a full-featured programming language, however, it provides capability well beyond traditional shell scripting languages, such as the ability to treat OS components as objects. about the bookLearn PowerShell in a Month of Lunches: Covers Windows, Linux, and macOS is a user-friendly tutorial to managing Linux and macOS systems with PowerShell. It's based on the bestselling Learn Windows PowerShell in a Month of Lunches, which has introduced PowerShell to nearly 100,000 readers. You'll learn how PowerShell shapes up to Bash or Python scripting as you write and run simple scripts that automate boring daily tasks. As you progress through the book, you'll use PowerShell to write Continuous Integration Pipelines and manage cloud-based servers. Just set aside one hour a day for a month, and you'll be automating tasks faster than you ever thought possible! what's inside- Why you should use PowerShell on Linux and macOS- Background jobs and automation techniques- Simple scripting to automate repetitive daily tasks- Common syntax and commands cheat sheet- Each lesson takes you an hour or less about the readerFor IT professionals comfortable administering Windows or Linux. No previous experience with PowerShell or Bash required. about the authorTravis Plunk has been a Software Engineer on various PowerShell teams since 2013, and at Microsoft since 1999. He was involved in open sourcing PowerShell and has worked on the project full time since shortly after the project was announced. James Petty is a Microsoft MVP, and the CEO and Executive Director for the DevOps Collective and PowerShell.org. Tyler Leonhardt has been a Software Engineer on the PowerShell team since 2017, and at Microsoft since 2016. He is a core maintainer of the PowerShell extension for Visual Studio Code. Learn Windows PowerShell in a Month of Lunches was written by PowerShell community legends Don Jones and Jeffrey Hicks, who have years of experience as successful PowerShell trainers.Trade Review“Notonly for MacOS and Linux users, but also a great resource for Windows PS users.” Bruce Bergman “Gives developers a lot of insight on how PowerShell works and how to accomplish everyday tasks.” Marcel van den Brink “This book enabled me to quickly get using PowerShell for real-lifetasks.” Rick Michaels “The book is great, especially if you have no previous experience with PowerShell, tasks automation, or DevOps.” Max Almonte “Approaches PowerShell from a building block like perspective.” FosterHaines “Unlike other PowerShell type books, this book expands beyond just Windows environments to accommodate those on Mac or Linux platforms who may want to explore this area as well.” James Matlock
£30.39
John Wiley & Sons Inc Effective Project Management
Book SynopsisThe popular guide to the project management body of knowledge, now fully updated Now in its eighth edition, this comprehensive guide to project management has long been considered the standard for both professionals and academics, with nearly 40,000 copies sold in the last three editions! Well-known expert Robert Wysocki has added four chapters of new content based on instructor feedback, enhancing the coverage of best-of-breed methods and tools for ensuring project management success. With enriched case studies, accompanying exercises and solutions on the companion website, and PowerPoint slides for all figures and tables, the book is ideal for instructors and students as well as active project managers. Serves as a comprehensive guide to project management for both educators and project management professionalsUpdated to cover the new PMBOK Sixth Edition Examines traditional, agile, and extreme project management techniques; the Enterprise Project Management Model; and Kanban and Scrumban methodologiesIncludes a companion website with exercises and solutions and well as PowerPoint slides for all the figures and tables usedWritten by well-known project management expert Robert Wysocki Effective Project Management, Eighth Editionremains the comprehensive resource for project management practitioners, instructors, and students. (PMBOK is a registered mark of the Project Management Institute, Inc.)Table of ContentsPreface xxxiii Introduction xxxvii Part I Understanding the Project Management Landscape 1 Chapter 1 What Is a Project? 3 Chapter 2 What Is Project Management? 23 Chapter 3 What Is Strategic Project Management? 63 Chapter 4 What Is a Collaborative Project Team? 91 Chapter 5 What Are Project Management Process Groups? 115 Part II Traditional Project Management 151 Chapter 6 How to Scope a TPM Project 153 Chapter 7 How to Plan a TPM Project 191 Chapter 8 How to Launch a TPM Project 263 Chapter 9 How to Execute a TPM Project 313 Chapter 10 How to Close a TPM Project 343 Part III Complex Project Management 353 Chapter 11 Complexity and Uncertainty in the Project Landscape 355 Chapter 12 Agile Complex Project Management Models 381 Chapter 13 Extreme Complex Project Management Models 393 Chapter 14 Hybrid Project Management Framework 405 Chapter 15 Comparing TPM and CPM Models 453 Appendix A Terms and Acronyms 537 Appendix B Case Study: Workforce and Business Development Center 543 Appendix C Case Study: Pizza Delivered Quickly ( PDQ ) 557 Appendix D Cited References 561 Appendix E What’s on the eiipbs.com Website? 565
£41.60
John Wiley & Sons Inc Python for Data Science For Dummies
Book SynopsisTable of ContentsIntroduction 1 Part 1: Getting Started with Data Science and Python 7 Chapter 1: Discovering the Match between Data Science and Python 9 Chapter 2: Introducing Python’s Capabilities and Wonders 21 Chapter 3: Setting Up Python for Data Science 33 Chapter 4: Working with Google Colab 49 Part 2: Getting Your Hands Dirty with Data 71 Chapter 5: Working with Jupyter Notebook 73 Chapter 6: Working with Real Data 83 Chapter 7: Processing Your Data 105 Chapter 8: Reshaping Data 131 Chapter 9: Putting What You Know into Action 143 Part 3: Visualizing Information 157 Chapter 10: Getting a Crash Course in Matplotlib 159 Chapter 11: Visualizing the Data 177 Part 4: Wrangling Data 199 Chapter 12: Stretching Python’s Capabilities 201 Chapter 13: Exploring Data Analysis 223 Chapter 14: Reducing Dimensionality 251 Chapter 15: Clustering 273 Chapter 16: Detecting Outliers in Data 291 Part 5: Learning from Data 305 Chapter 17: Exploring Four Simple and Effective Algorithms 307 Chapter 18: Performing Cross-Validation, Selection, and Optimization 327 Chapter 19: Increasing Complexity with Linear and Nonlinear Tricks 351 Chapter 20: Understanding the Power of the Many 391 Part 6: The Part of Tens 413 Chapter 21: Ten Essential Data Resources 415 Chapter 22: Ten Data Challenges You Should Take 421 Index 431
£22.94
No Starch Press,US Computer Architecture
Book Synopsis
£42.74
Penguin Random House Group Effective C 2nd Edition
Book Synopsis
£44.19
John Wiley & Sons Inc Beginning Programming AllinOne 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 Book 1: Getting Started with Programming 5 Chapter 1: Getting Started Programming a Computer 7 How Computer Programming Works 8 Identifying the problem 8 Defining the steps 9 The History of Computer Programming 10 Talking to a processor in machine language 11 Using assembly language as a shortcut to machine language 12 Hiding the details of a computer with a high-level language 15 Combining the best of both worlds with the C programming language 15 Weighing the pros and cons of programming languages 16 Figuring Out Programming 18 Desire beats technical training every time 19 Picking a computer and an operating system 19 Writing programs with an editor 21 Converting source code with an assembler or compiler 23 Translating source code with an interpreter 25 Combining a compiler with an interpreter to create p-code 25 Taking the time to understand 26 Chapter 2: Different Methods for Writing Programs 29 Spaghetti Programming 31 Structured Programming 34 The three parts of structured programming 34 Top-down programming 36 Event-Driven Programming 38 Designing a user interface 41 Writing event handlers 42 Writing your program 44 Object-Oriented Programming 44 Isolating data 46 Simplifying modifications 47 Using Protocol-Oriented Programming 49 Design Patterns 50 Chapter 3: Types of Programming Languages 53 Your First Language 54 BASICally disrespected 55 Visual programming with Scratch 56 Programming robots with LEGO Mindstorms 57 Learning object-oriented programming with Alice 57 Programming a killer robot 58 Curly-Bracket Languages 60 Learning programming with C 60 Adding object-oriented programming with C++ 62 Gaining true portability with Java 63 Programming more safely with C# 64 Choosing a curly-bracket language 66 Artificial Intelligence Languages 67 Scripting Languages 71 Automating a program 72 Customizing a program 73 Transferring data among multiple programs 74 Creating stand-alone programs 74 Database Programming Languages 75 Comparing Programming Languages 76 Chapter 4: Programming Tools 77 Choosing a Compiler 78 Defining your needs for a compiler 79 Evaluating the technical features of a compiler 80 Finding an Interpreter 84 Compiling to a Virtual Machine 86 Writing a Program with an Editor 88 Stand-alone editors 88 Integrated development environments 90 Fixing a Program with a Debugger 91 Stepping line-by-line 92 Watching variables 95 Saving Time with Third-Party Components 96 Optimizing a Program with a Profiler 97 Managing Source Code 97 Creating a Help File 99 Installing a Program 99 Dissecting Programs with a Disassembler 99 Book 2: Programming Basics 101 Chapter 1: How Programs Work 103 Using Keywords as Building Blocks 105 Organizing a Program 108 Dividing a Program into Subprograms 109 Dividing a Program into Objects 113 Creating a User Interface 115 Chapter 2: Variables, Data Types, and Constants 119 Declaring Variables 120 Variable naming conventions 121 Creating variables in a command 122 Declaring the data type of a variable 124 Using Different Data Types 126 Storing Data in a Variable 130 Retrieving Data from a Variable 132 Using Constant Values 133 Defining the Scope of a Variable 135 Handling global variables with care 136 Restricting scope to a module 137 Isolating variables in a subprogram 138 Passing data among subprograms 139 Chapter 3: Manipulating Data 141 Storing Data with the Assignment Operator 142 Using Math to Manipulate Numbers 143 Organizing equations with operator precedence 144 Using built-in math functions 146 Manipulating Strings 147 Finding Strings with Regular Expressions 148 Pattern-matching with the single character (.) wildcard 149 Pattern-matching for specific characters 149 Pattern-matching with the multiple-character (*) and plus (+) wildcards 150 Pattern-matching with ranges 151 Using Comparison Operators 153 Using Boolean Operators 156 Using the Not operator 156 Using the And operator 157 Using the Or operator 158 Using the Xor operator 159 Converting Data Types 160 Chapter 4: Making Decisions by Branching 163 Picking One Choice with the IF-THEN Statement 164 Picking Two Choices with the IF-THEN-ELSE Statement 166 Picking Three or More Choices with the IF-THEN-ELSEIF Statement 168 Checking a condition for each set of commands 168 Offering three or more choices 170 Playing with Multiple Boolean Operators 171 Making Multiple Choices with the SELECT CASE Statement 174 Matching multiple values in a SELECT CASE statement 177 Checking a range of values 178 Comparing values 179 Chapter 5: Repeating Commands by Looping 181 Looping a Fixed Number of Times with the FOR-NEXT Loop 182 Using a FOR-NEXT loop variable 183 Counting by a different range 185 Counting by different increments 186 Counting backward 187 Counting over arrays and other items 188 Looping Zero or More Times with the WHILE Loop 189 Looping at Least Once with the DO Loop 192 Playing with Nested Loops 193 Prematurely Exiting from a Loop 195 Checking Your Loops 195 Chapter 6: Breaking a Large Program into Subprograms 197 Creating and Using Subprograms 199 Creating a subprogram 200 “Calling” a subprogram 201 Passing Parameters 203 Passing parameters by reference 206 Storing values in a subprogram name 210 Repeating a Subprogram with Recursion 212 Chapter 7: Breaking a Large Program into Objects 215 How Object-Oriented Programming Works 216 Encapsulation Isolates Data and Subprograms 219 Shielding data inside an object 221 Grouping methods inside of an object 221 Protecting code from other programmers 222 Sharing Code with Inheritance 223 Polymorphism: Modifying Code without Changing Its Name 226 Design Patterns 228 Object-Oriented Languages 230 Hybrid languages 231 Pure languages 231 Disadvantages of object-oriented programming 232 Real-Life Programming Examples 233 Defining an object with a class 233 Creating an object from a class 236 Running methods stored in an object 236 Inheriting an object 238 Using method overloading to rewrite an inherited subprogram 239 Chapter 8: Reading and Saving Files 243 Storing Data in Text Files 243 Creating a text file 246 Reading a text file 247 Storing Fixed-Size Data in Random-Access Files 250 Writing data 251 Reading data 252 Storing Varying-Size Data in Untyped Files 253 Writing data 254 Reading data 255 Using Database Files 257 Looking at the structure of a database 257 Connecting to a database 259 Chapter 9: Documenting Your Program 263 Adding Comments to Source Code 264 Identifying the two types of comments 265 Describing code and algorithms 268 Documentation 270 Debugging 271 Writing Software Documentation 272 Documentation types 272 Documentation tools 274 Help files 275 Chapter 10: Principles of User Interface Design 277 The Evolution of User Interfaces 278 Command-line interface 278 Menus 278 Graphical user interface 280 Elements of a User Interface 281 Displaying commands to a user interface 281 Giving data to the user interface 284 Showing information back to the user 288 Organizing a user interface 290 Designing a User Interface 291 Know the user 291 Hide/disable unusable options 292 Tolerate mistakes 293 Be consistent 294 Give the user freedom to customize the user interface 295 Make navigation easy 295 Chapter 11: Debugging and Testing 297 Common Types of Programming Errors 297 Debugging with Comments and Print Statements 300 Breakpoints, Stepping, and Watching 302 Stepping through code 304 Watching variables 305 Testing Code 306 Unit tests 307 Integration tests 308 User interface testing 309 Book 3: Data Structures 311 Chapter 1: Structures and Arrays 313 Using Structures 314 Storing data 315 Retrieving data 315 Using an Array 316 Defining the size 317 Storing data 320 Retrieving data 321 Working with Resizable Arrays 321 BASIC 322 C# 323 Swift 323 Working with Multidimensional Arrays 323 Creating a multidimensional array 324 Storing and retrieving data 325 Using Structures with Arrays 325 Drawbacks of Arrays 327 Data types 328 Searching and sorting 328 Adding and deleting 329 Identifying the location of data in an array 330 Chapter 2: Sets and Linked Lists 333 Using Sets 334 Adding and deleting data in a set 335 Checking for membership 336 Avoiding duplicate data 337 Manipulating two sets 337 Using Linked Lists 342 Creating a linked list 343 Modifying a linked list 344 Creating a double linked list 345 Drawbacks of Sets and Linked Lists 346 Problems with pointers 347 Problems with accessing data 347 Chapter 3: Collections and Dictionaries 351 Using a Collection 352 Adding data to a collection 352 Deleting data from a collection 354 Identifying data with keys 355 Searching and retrieving data 356 Using Dictionaries 358 Adding data to a dictionary 358 Searching and retrieving data from a dictionary 359 Understanding Hash Tables 360 Converting keys with a hash function 360 Hash function collisions 362 Chapter 4: Stacks, Queues, and Deques 367 Using Stacks 368 Adding data to a stack 369 Removing data from a stack 370 Counting and searching a stack 371 Using Queues 372 Adding data to a queue 373 Removing data from a queue 374 Counting and searching a queue 375 Using Deques 376 Chapter 5: Graphs and Trees 381 Understanding Graphs 383 Types of graphs 384 Uses for graphs 385 Creating Trees 386 Ordered trees 387 Binary trees 388 B-trees 389 Taking Action on Trees 390 Traversing a tree to search for data 390 Adding new data 392 Deleting data 393 Pruning and grafting sub-trees 394 Book 4: Algorithms 397 Chapter 1: Sorting Algorithms 399 Using Bubble Sort 400 Using Selection Sort 402 Using Insertion Sort 403 Using Shell Sort 405 Using Heap Sort 406 Using Merge Sort 410 Using Quick Sort 411 Comparing Sorting Algorithms 412 Chapter 2: Searching Algorithms 415 Sequential Search 416 Backward or forward searching 417 Block searching 418 Binary searching 419 Interpolation searching 420 Using Indexes 422 Creating an index 422 Clustered and unclustered indexes 423 Problems with indexes 424 Adversarial Search 424 Depth versus time 426 Alpha-beta pruning 426 Looking up a library of good moves 427 Chapter 3: String Searching 429 Sequential Text Search 430 The Boyer-Moore algorithm 431 The Rabin–Karp algorithm 431 The Shift Or algorithm 433 The finite automaton algorithm 435 Searching with Regular Expressions 436 Searching for single character patterns 436 Searching for multiple character patterns 437 Searching for alternate patterns 438 Searching Phonetically 438 Chapter 4: Data Compression Algorithms 441 Lossless Data Compression Algorithms 442 Run-length encoding 442 The Burrows–Wheeler transform algorithm 442 Dictionary encoding 445 Lossy Data Compression 449 Chapter 5: Encryption Algorithms 451 How Encryption Works 451 The Basics of Encryption 453 Stream ciphers 456 Block ciphers 457 Symmetric/Asymmetric Encryption Algorithms 459 Cracking Encryption 463 Brute-force attacks 463 Dictionary attacks 464 Plaintext and ciphertext attacks 466 Book 5: Web Programming 469 Chapter 1: HyperText Markup Language 471 The Structure of an HTML Document 472 Creating a title 472 Creating the body text 472 Aligning text 474 Emphasizing text 475 Adding color 476 Changing the font size 477 Adding comments 478 Adding Graphics 478 Defining the Background 479 Creating Hyperlinks 480 Defining an anchor point 480 Linking to an anchor point 480 Making Tables 481 Defining a table 481 Defining a table heading 482 Creating table rows and data 483 Displaying a table caption, header, and footer 484 Chapter 2: CSS 487 The Structure of a Stylesheet 488 Creating Style Classes 489 Separating Styles in Files 491 Cascading Stylesheets 493 Chapter 3: JavaScript 495 The Structure of a JavaScript Program 496 Creating Comments 497 Declaring Variables 498 Using Operators 498 Increment and decrement operators 500 Assignment operators 501 Branching Statements 501 Looping Statements 503 Creating Functions 504 Using Arrays 505 Designing User Interfaces 505 Creating dialog boxes 505 Creating windows 507 Chapter 4: PHP 509 Examining the Structure of a PHP Program 510 Creating Comments 510 Declaring Variables 511 Using Operators 512 Increment and decrement operators 513 Assignment operators 515 Branching Statements 515 Looping Statements 517 Creating Functions 518 Using Arrays 519 Creating Objects 520 Chapter 5: Ruby 523 The Structure of a Ruby Program 524 Creating Comments 524 Declaring Variables 525 Using Operators 526 Branching Statements 528 Looping Statements 530 Creating Functions 531 Using Data Structures 532 Creating Objects 534 Book 6: Programming Language Syntax 537 Chapter 1: C and C++ 539 Looking at the Structure of a C/C++ Program 540 Creating Comments 541 Declaring Variables 542 Declaring string data types 542 Declaring integer data types 543 Declaring floating-point data types 544 Declaring Boolean values 545 Using Operators 545 Increment and decrement operators 546 Assignment operators 548 Branching Statements 548 Looping Statements 550 Creating Functions 551 Data Structures 553 Creating a structure 553 Creating enumerations 554 Creating an array 554 Using Objects 555 Chapter 2: Java and C# 557 Looking at the Structure of a Java/C# Program 558 Creating Comments 559 Declaring Variables 559 Declaring string data types 560 Declaring integer data types 560 Declaring floating-point data types 561 Declaring Boolean variables 562 Using Operators 562 Increment and decrement operators 564 Assignment operators 564 Branching Statements 565 Looping Statements 568 Creating Functions 569 Data Structures 571 Creating a C# structure 571 Creating an array 572 Creating a Java linked list 573 Creating C# data structures 574 Using Objects 574 Chapter 3: Perl and Python 577 Reviewing the Structure of a Perl or Python Program 578 Creating Comments 579 Defining Variables 580 Using Operators 580 Increment and decrement operators 582 Assignment operators 583 Branching Statements 584 Looping Statements 586 Creating Functions 588 Making Data Structures 588 Perl data structures 589 Python data structures 590 Using Objects 592 Chapter 4: Kotlin 595 Looking at the Structure of a Kotlin Program 596 Creating Comments 596 Declaring Variables 597 Declaring string data types 597 Declaring integer data types 598 Declaring floating-point data types 599 Declaring Boolean values 599 Declaring Constants 600 Using Operators 600 Branching Statements 601 Looping Statements 605 Creating Functions 606 Creating Data Structures 608 Creating a list 609 Creating an array 610 Creating a set 610 Creating Objects 611 Chapter 5: Swift and SwiftUI 613 Considering the Structure of a Swift Program 614 Understanding SwiftUI 614 Creating a SwiftUI user interface 616 Understanding SwiftUI state variables 616 Creating Comments 618 Declaring Variables 618 Declaring string data types 619 Declaring integer data types 620 Declaring decimal data types 620 Declaring Boolean values 621 Declaring Constants 621 Using Operators 622 Branching Statements 623 Looping Statements 627 Creating Functions 628 Data Structures 630 Creating an array 630 Creating a dictionary 632 Creating a set 633 Creating Objects 634 Chapter 6: Flutter and Dart 637 Working with Flutter 638 Understanding the structure of a Flutter program 638 Working with widgets in Flutter 639 Aligning widgets in rows and columns 642 Understanding the Dart Language 645 Creating comments 645 Declaring variables 646 Using operators 646 Using branching statements 649 Using looping statements 650 Creating functions 652 Creating data structures 653 Using objects 656 Book 7: Applications 657 Chapter 1: Database Management 659 Understanding the Basics of Databases 659 Free-form databases 660 Flat-file databases 661 Relational databases 663 Manipulating Data 667 Writing database commands 669 The SQL language 670 Data integrity 671 Data mining 672 Database Programming 672 Chapter 2: Bioinformatics 675 The Basics of Bioinformatics 676 Representing molecules 676 Manipulating molecules in a computer 677 Database Searches 679 Bioinformatics Programming 681 Chapter 3: Computer Security 685 Stopping Malware 686 Viruses 687 Worms 687 Trojan horses 688 Spyware 689 Distributed denial-of-service attacks 690 Stopping Hackers 691 Intrusion detection systems 692 Rootkit detectors 693 Forensics 694 Secure Computing 695 Patching as an afterthought 695 Security in coding 696 Security by design 697 Chapter 4: Artificial Intelligence 699 Problem Solving 700 Game-playing 701 Natural language processing 702 Speech recognition 704 Image recognition 705 Machine Learning 706 Bayesian probability 707 Neural networks 707 Applications of Artificial Intelligence 710 Chapter 5: Mobile and Wearable Computing 711 Understanding the Different Generations of Computing 712 Giving Data to the User 714 Getting Data from the User 716 Tracking Motion and Location 717 Tracking Real-Time Health Data 718 Looking to the Future of Augmented Reality and Wearable Computers 718 Chapter 6: Game Engines 721 Understanding Game Engines 722 Picking a Game Engine 723 Programming a Game Engine 724 Exploring the Future Uses of Game Engines 726 Filmmaking 726 Architecture and engineering simulations 727 Marketing and advertising 728 Chapter 7: The Future of Computer Programming 731 Picking a Programming Language 732 Picking an Operating System 733 Doing Cross-Platform Programming 735 The portability of C 735 Cross-platform languages 736 Virtual machines 737 Software as a service 738 Data science 739 Website programming 740 Macro programming 740 Robotics programming 741 Blockchain programming 742 Defining Your Future in Programming 743 Teaching yourself other languages 743 Combining other interests besides programming 744 Getting experience and knowledge 744 Index 747
£24.64
No Starch Press,US Practical Forensic Imaging
Book SynopsisForensic image acquisition is an important part of postmortem incident response and evidence collection. Digital forensic investigators acquire, preserve, and manage digital evidence to support civil and criminal cases; examine organizational policy violations; resolve disputes; and analyze cyber attacks. Practical Forensic Imaging takes a detailed look at how to secure and manage digital evidence using Linux-based command line tools. This essential guide walks you through the entire forensic acquisition process and covers a wide range of practical scenarios and situations related to the imaging of storage media. You ll learn how to: Perform forensic imaging of magnetic hard disks, SSDs and flash drives, optical discs, magnetic tapes, and legacy technologies Protect attached evidence media from accidental modification Manage large forensic image files, storage capacity, image format conversion, compression, splitting, duplication, secure transfer and storage, and secure disposal PTrade Review“Despite the huge impact of this subject matter, there have been precious few books on the topic to date. Luckily, Practical Forensic Imaging steps in now to fill the gap. An excellent addition to any bookshelf.”—Forensic Focus“I am a big fan of this book, and found it to contain the right amount of technical content coupled with important concepts and concerns surrounding forensic imaging. I’d encourage anyone in DFIR who is imaging regularly or looking to increase their Linux skills to check out a copy of the book.”—505 Forensics“Cybercrime and digital forensics expert Bruce Nikkel describes the use of open source command line technology to obtain and manage forensic data. Target readers are the expanding number of forensic practitioners including forensic and electronic discovery technicians in legal, auditing, and consulting firms; incident response teams; law enforcement forensic specialists; and forensic investigators.”—The Lawyer's PC“It's commonly said that you should assume the bad guys have already breached your networks. The ability to carry out forensic examinations is one of the key skills you'll need in response to that risk, and this book is a solid introduction to acquiring those skills.”—Network Security Newsletter"I loved Bruce Nikkel's book Practical Forensic Imaging from @nostarch - but his new book Practical Linux Forensics is [fire]. Beginner to intermediate, and a good desktop reference."—DFIRScience, @DFIRScienceTable of ContentsIntroductionChapter 0: Digital Forensics OverviewChapter 1: Storage Media Overview<Chapter 2: Linux as a Forensic Acquisition PlatformChapter 3: Forensic Image FormatsChapter 4: Planning and PreparationChapter 5: Attaching Subject Media to an Acquisition HostChapter 6: Forensic Image AcquisitionChapter 7: Forensic Image ManagementChapter 8: Special Image Access TopicsChapter 9: Extracting Subsets of Forensic Images
£35.99
Manning Publications Kotlin in Action
Book SynopsisKotlin is a new programming language targeting the Java platform. Itoffers on expressiveness and safety without compromising simplicity,seamless interoperability with existing Java code, and great toolingsupport. Because Kotlin generates regular Java bytecode and workstogether with existing Java libraries and frameworks, it can be usedalmost everywhere where Java is used today - for server-sidedevelopment, Android apps, and much more. Kotlin in Action takes experienced Java developers from the languagebasics all the way through building applications to run on the JVM andAndroid devices. Written by core developers of Kotlin, this examplerichbook begins by teaching the basic syntax of the Kotlin language.Then readers learn how to use features that let them build reusableabstractions, higher-level functions, libraries, and even entire domainspecific languages. Finally, the book focuses on details of applyingKotlin in real-world projects, such as build system integration, Androidsupport and concurrent programming. KEY FEATURES • Hands on examples• Tutorial for a new programming language• Teaches how to build Android applications• Written by core developers of Kotlin AUDIENCEThis book is for experienced Java developers. ABOUT THE TECHNOLOGYKotlin is a new programming language targeting the Java platform. It offersexpressiveness and safety without compromising simplicity, seamlessinteroperability with existing Java code, and great tooling support.
£34.19
No Starch Press,US Bare Metal C: Embedded Programming for the Real
Book SynopsisBare Metal C will teach you how to program embedded devices with the C programming language. For embedded system programmers who want precise and complete control over the system they are using, this book pulls back the curtain on what the compiler is doing for you so that you can see all the details of what's happening with your program. As you progress through the book you'll learn how to integrate serial input/output and interrupts into your programs, what the C compiler and linker do behind the scenes, how to write more efficient programmes, and much more.
£35.99
Penguin Random House Group Evasive Malware
Book Synopsis
£50.24
Penguin Random House Group Serious Cryptography 2nd Edition
Book Synopsis
£42.74
Pearson Education Limited Intro to Python for Computer Science and Data
Book SynopsisPaul J. Deitel, CEO and Chief Technical Officer of Deitel & Associates, Inc., is an MIT graduate with 38 years of computing and corporate training experience and is an Oracle Java Champion and a Microsoft C# MVP (2012-2014). He is a best-selling programming-language textbook/professional book/video/e-learning author. Paul is one of the world's most experienced programming-languages trainers. Through Deitel & Associates, Inc., he has delivered hundreds of programming courses worldwide to clients, including Cisco, IBM, Siemens, Sun Microsystems (now Oracle), Dell, Fidelity, NASA at the Kennedy Space Center, the National Severe Storm Laboratory, White Sands Missile Range, Rogue Wave Software, Boeing, SunGard Higher Education, Nortel Networks, Puma, iRobot, Invensys and many more. He and his co-author, Dr. Harvey M. Deitel, are the world's best-selling programming-language textbook/professional book/video authors. Dr. Harv
£63.86
Penguin Random House Group Windows Security Internals
Book Synopsis
£42.74
No Starch Press,US Practical Julia: A Hands-On Introduction for
Book SynopsisApplied Julia provides a comprehensive, hands-on language introduction that's packed with examples leveraging real scientific libraries used by researchers in various fields. Solve problems of genuine interest, such as modeling the course of a pandemic, and learn to use Julia as a tool for research. The Julia programming language can be used to write all types of applications, but its features are especially powerful for numerical analysis and computational science. Applied Julia shows readers how to take advantage of Julia's particular strengths, as well as how to write effective and efficient programs. The book takes Julia novices from their very first steps to writing real-world applications for use in fields such as biology, physics, math, statistics, and machine learning. Not only will readers develop the Julia knowledge needed for solving computational problems, but they'll also learn how to explore and visualise data, solve equations, write simulations, and create libraries. AdTrade Review"A great starting point for the reader’s journey into Julia - with the first part covering the fundamentals of the language and second part diving into a variety of different scientific disciplines." —Viral Shah, co-creator of the Julia programming language and CEO of JuliaHub"This is a nice deep dive that covers a lot of ground, from the basics on how to define arrays and use the type system all the way to biochemical modeling and scientific machine learning. Lee gives a very nice in-depth treatment, showing not only the most standard ways to do things, but also some different library options along with a good explanation of the pros and cons to the choices. I think this is a great book for any Julia user's shelf."—Christopher Rackauckas, Applied Mathematics Instructor, Massachusetts Institute of Technology"Practical Julia is clear, concise, and complete, exactly what you want in an introductory book. It’s also really interesting; the author has an engaging voice and a knack for good examples. Along with a general introduction to Julia, he provides real-world illustrations of applying Julia to specific problems in biology, physics, statistics, machine learning, and other areas. Highly recommended."—David Chappell, Principal of Chappell & AssociatesTable of ContentsIntroductionPART I: LEARNING JULIAChapter 1: Getting StartedChapter 2: Language BasicsChapter 3: Modules and PackagesChapter 4: The Plotting SystemChapter 5: CollectionsChapter 6: Functions, Metaprogramming, and ErrorsChapter 7: Diagrams and AnimationsChapter 8: The Type SystemPART II: APPLICATIONSChapter 9: PhysicsChapter 10: StatisticsChapter 11: BiologyChapter 12: MathematicsChapter 13: Scientific Machine LearningChapter 14: Signal and Image ProcessingChapter 15: Parallel ProcessingIndex
£42.74
No Starch Press Building a Debugger
Book Synopsis
£40.49
No Starch Press,US The Big Book Of Small Python Projects: 81 Easy
Book SynopsisThe 100+ short, complete Python programmes in this book are designed to help beginning-to-intermediate Python programmers broaden their skills by providing a diverse set of coding examples they can study, emulate, and draw inspiration from. The programmes range from classic card and board games and mazes, to maths and probability demos, and mad libs. The author includes the complete code for each programme, as well as commentary and suggestions for how to modify and experiment with code.Trade Review"I've always been impressed by the variety of simple, but interesting and fun, projects Al can come up with and this collection takes that to the next level. . . . Even experienced coders are likely to be pulled into browsing through the wide variety that Al has put into this book." —Naomi Ceder, Fellow of the Python Software Foundation"Al Sweigart presents fun programs, inspiring learners to tweak them. That's how I learned to program: tinkering with examples from books and magazines. It works!" –Luciano Ramalho, Technical Principal at ThoughtWorks and author of Fluent Python"Whether you're new to Python or want to exercise your coding brain, I recommend The Big Book of Small Python Projects to spark your thinking. Both the 'big' and the 'small' in the title are accurate. There are a lot of projects in this book, but most code takes up only a page or two. That makes it a fun reference book to get you into the flow or kick off a session in your terminal."—Adam DuVander, Founder, EveryDeveloper"This book is excellent for beginners to Python and a great reference book for programmers who are well versed in programming. I'm happy to give this book 5 out of 5 stars!"—Greg Walters, Full Circle Magazine"This book is packed with fun and easy programs, I can confirm." —BC Gain, @bcamerongain
£30.39
