Programming and scripting languages: general Books
Pearson Education (US) Learn Python the Hard Way
Book SynopsisZed A. Shaw is the author of the popular books, Learn Python the Hard Way, Learn Ruby the Hard Way, and Learn C the Hard Way. He is also the creator of several open source software projects and has been programming and writing for nearly 30 years. Most of his free time is devoted to the study of painting and art history.Table of ContentsPreface xix Module 1: Getting Started in Python 1 Exercise 0: Gearing Up 2General Instructions 2Minimalist Start 3Complete Instructions 3Testing Your Setup 3Learning the Command Line 4Next Steps 5 Exercise 1: A Good First Program 6What You Should See 7Study Drills 8Common Student Questions 9The Blue Plus 9 Exercise 2: Comments and Pound Characters 10What You Should See 10Study Drills 10Common Student Questions 11 Exercise 3: Numbers and Math 12What You Should See 13Study Drills 13Common Student Questions 13 Exercise 4: Variables and Names 16What You Should See 17Study Drills 17Common Student Questions 17 Exercise 5: More Variables and Printing 20What You Should See 20Study Drills 21Common Student Questions 21 Exercise 6: Strings and Text 22What You Should See 23Study Drills 23Break It 23Common Student Questions 24 Exercise 7: Combining Strings 26What You Should See 26Study Drills 26Break It 27Common Student Questions 27 Exercise 8: Formatting Strings Manually 28What You Should See 28Study Drills 29Common Student Questions 29 Exercise 9: Multi-Line Strings 30What You Should See 30Study Drills 31Common Student Questions 31 Exercise 10: Escape Codes in Strings 32What You Should See 33Escape Sequences 33Study Drills 34Common Student Questions 34 Exercise 11: Asking People Questions 36What You Should See 36Study Drills 37Common Student Questions 37 Exercise 12: An Easier Way to Prompt 38What You Should See 38Study Drills 38Common Student Questions 39 Exercise 13: Parameters, Unpacking, Variables 40Code Description 41Hold Up! Features Have Another Name 42What You Should See 42Study Drills 43Common Student Questions 43 Exercise 14: Prompting and Passing 46What You Should See 47Study Drills 47Common Student Questions 47 Exercise 15: Reading Files 50What You Should See 51Study Drills 51Common Student Questions 52 Exercise 16: Reading and Writing Files 54What You Should See 55Study Drills 55Common Student Questions 56 Exercise 17: More Files 58What You Should See 59Study Drills 59Common Student Questions 59 Module 2: The Basics of Programming 61 Exercise 18: Names, Variables, Code, Functions 62Exercise Code 63What You Should See 65Study Drills 65Common Student Questions 66 Exercise 19: Functions and Variables 68What You Should See 69Study Drills 70Common Student Questions 70 Exercise 20: Functions and Files 72What You Should See 73Study Drills 73Common Student Questions 74 Exercise 21: Functions Can Return Something 76What You Should See 77Study Drills 77Common Student Questions 78 Exercise 22: Strings, Bytes, and Character Encodings 80Initial Research 80Switches, Conventions, and Encodings 82Dissecting the Output 84Dissecting the Code 84Encodings Deep Dive 86Breaking It 87 Exercise 23: Introductory Lists 88Accessing Elements of a List 88Practicing Lists 89The Code 89The Challenge 90Final Challenge 91 Exercise 24: Introductory Dictionaries 92Key/Value Structures 92Combining Lists with Data Objects 93The Code 94What You Should See 95The Challenge 95Final Challenge 96 Exercise 25: Dictionaries and Functions 98Step 1: Function Names Are Variables 98Step 2: Dictionaries with Variables 98Step 3: Dictionaries with Functions 99Step 4: Deciphering the Last Line 99Study Drill 100 Exercise 26: Dictionaries and Modules 102Step 1: Review of import 102Step 2: Find the __dict__ 102Step 3: Change the __dict__ 103Study Drill: Find the "Dunders" 104 Exercise 27: The Five Simple Rules to the Game of Code 106Rule 1: Everything Is a Sequence of Instructions 106Rule 2: Jumps Make the Sequence Non-Linear 108Rule 3: Tests Control Jumps 110Rule 4: Storage Controls Tests 111Rule 5: Input/Output Controls Storage 112Putting It All Together 113 Exercise 28: Memorizing Logic 116The Truth Terms 116The Truth Tables 117Common Student Questions 119 Exercise 29: Boolean Practice 120What You Should See 122Study Drills 122Common Student Questions 122 Exercise 30: What If 124What You Should See 124dis() It 125Study Drill 125Common Student Questions 125 Exercise 31: Else and If 126What You Should See 127dis() It 127Study Drills 128Common Student Questions 128 Exercise 32: Making Decisions 130What You Should See 131dis() It 131Study Drills 132Common Student Questions 132 Exercise 33: Loops and Lists 134What You Should See 135dis() It 136Study Drills 137Common Student Questions 137 Exercise 34: While Loops 138What You Should See 139dis() It 139Study Drills 140Common Student Questions 140 Exercise 35: Branches and Functions 142What You Should See 143Study Drills 144Common Student Questions 144 Exercise 36: Designing and Debugging 146From Idea to Working Code 146Rules for If-Statements 149Rules for Loops 149Tips for Debugging 149Homework 150 Exercise 37: Symbol Review 152Keywords 152Data Types 153String Escape Sequences 154Old-Style String Formats 154Operators 155Reading Code 156Study Drills 157Common Student Questions 157 Module 3: Applying What You Know 159 Exercise 38: Beyond Jupyter for Windows 160Why Learn PowerShell? 161What Is PowerShell? 161Crash Landing 171 Exercise 39: Beyond Jupyter for macOS/Linux 172Why Learn Bash or ZSH? 173What Is Bash? 173Crash Landing 184 Exercise 40: Advanced Developer Tools 186Managing conda Environments 186Adding conda-forge 187Using pip 188Using a .condarc 188General Editing Tips 189Going Further 189 Exercise 41: A Project Skeleton 190Activate an Environment 190Just Use cookiecutter 190Building Your Project 191Installing Your Project 191Testing the Install 192Remove test-project 192Common Errors 193Study Drills 193 Exercise 42: Doing Things to Lists 194What You Should See 195What Lists Can Do 196When to Use Lists 197Study Drills 197Common Student Questions 198 Exercise 43: Doing Things to Dictionaries 200A Dictionary Example 201What You Should See 203What Dictionaries Can Do 203Study Drills 204Common Student Questions 204 Exercise 44: From Dictionaries to Objects 206Step 1: Passing a Dict to a Function 206Step 2: talk inside the Dict 207Step 3: Closures 208Step 4: A Person Constructor 209Study Drills 211 Exercise 45: Basic Object-Oriented Programming 212Python's People 212Using dir() and __dict__ 213About the Dot (.) 214Terminology 215A Word on self 216Study Drills 217Common Student Questions 217 Exercise 46: Inheritance and Advanced OOP 218How This Looks in Code 219About class Name(object) 221Study Drills 221Common Student Questions 222 Exercise 47: Basic Object-Oriented Analysis and Design 224The Analysis of a Simple Game Engine 225Top Down versus Bottom Up 229The Code for "Gothons from Planet Percal #25" 230What You Should See 236Study Drills 237Common Student Questions 237 Exercise 48: Inheritance versus Composition 238What Is Inheritance? 238The Reason for super() 243Composition 243When to Use Inheritance or Composition 245Study Drill 245Common Student Questions 246 Exercise 49: You Make a Game 248Evaluating Your Game 248Function Style 249Class Style 249Code Style 250Good Comments 250Evaluate Your Game 250 Exercise 50: Automated Testing 252What Is the Purpose of Testing? 252How to Test Efficiently 252Install PyTest 253Simple PyTest Demo 254Running pytest 255Exceptions and try/except 255Getting Coverage Reports 256Study Drills 256Common Student Questions 257 Module 4: Python and Data Science 259 Exercise 51: What Is Data Munging? 260Why Data Munging? 261The Problem 261The Setup 262How to Code 262Process Example 263Solution Strategies 265Awesome ETL Tools 266Study Drills 266 Exercise 52: Scraping Data from the Web 268Introducing with 268The Problem 269The Setup 269The Clue 270Awesome Scraping Tools 270Study Drills 271 Exercise 53: Getting Data from APIs 272Introducing JSON 272The Problem 273The Setup 274The Clue 274Awesome API Tools 275Study Drills 275 Exercise 54: Data Conversion with pandas 276Introducing Pandoc 276The Problem 276The Setup 277The Clue 277Study Drills 278 Exercise 55: How to Read Documentation (Featuring pandas) 280Why Programmer Documentation Sucks 280How to Actively Read Programmer Docs 281Step #1: Find the Docs 281Step #2: Determine Your Strategy 282Step #3: Code First, Docs Second 283Step #4: Break or Change the Code 283Step #5: Take Notes 284Step #6: Use It on Your Own 284Step #7: Write About What You Learned 284Step #8: What’s the Gestalt? 285Reading My pandas Curriculum 286 Exercise 56: Using Only pandas 288Make a Project 288The Problem 288The Setup 289Study Drill 289 Exercise 57: The SQL Crash Course 290What Is SQL? 290The Setup 291Fixing and Loading 292Create, Read, Update, Delete 293SELECT 293Date and Time 294INSERT 295UPDATE 296DELETE and Transactions 297Math, Aggregates, and GROUP BY 298Python Access 299 Exercise 58: SQL Normalization 300What Is Normalization? 300First Normal Form 301Second Normal Form (2NF) 303Querying 2NF Data 306Querying with Joins 308Study Drills 308 Exercise 59: SQL Relationships 310One-to-Many (1:M) 310Many-to-Many (M:M) 311One-to-One (1:1) 312Attributed Relations 313Querying M:M Tables 313Your Last Study Drill 314 Exercise 60: Advice from an Even Older Programmer 316 Index 318
£28.79
O'Reilly Effective Go Recipes
Book SynopsisThere's an art to using Go effectively. Squeeze out the full use of advanced networking and multi-core power for which Go was designed. Save precious coding hours with recipes that help you manage objects, collect garbage, and safely use memory. Tackle Unicode, concurrency, and serialization with ease.
£40.84
Pearson Education (US) Code That Fits in Your Head
Book SynopsisMark Seemann, a former economist, found a second career as a programmer and has worked as a web and enterprise developer since the late 1990s. He is a Certified Rockstar Developer and has written a Jolt Award-winning book about Dependency Injection, given more than a hundred international conference talks, and authored video courses for both Pluralsight and Clean Coders. Mark has regularly published his blog ( blog.ploeh.dk) since 2006.Trade Review"We progress in software by standing on the shoulders of those who came before us. Mark's vast experience ranges from philosophical and organisational considerations right down to the precise details of writing code. In this book, you're offered an opportunity to build on that experience. Use it." --Adam Ralph, speaker, tutor, and software simplifier, Particular Software "I've been reading Mark's blogs for years and he always manages to entertain while at the same time offering deep technical insights. Code That Fits in Your Head follows in that vein, offering a wealth of information to any software developer looking to take their skills to the next level." --Adam Tornhill, founder of CodeScene, author of Software Design X-Rays and Your Code as a Crime Scene "My favorite thing about this book is how it uses a single code base as a working example. Rather than having to download separate code samples, you get a single Git repository with the entire application. Its history is handcrafted to show the evolution of the code alongside the concepts being explained in the book. As you read about a particular principle or technique, you'll find a direct reference to the commit that demonstrates it in practice. Of course, you're also free to navigate the history at your own leisure, stopping at any stage to inspect, debug, or even experiment with the code. I've never seen this level of interactivity in a book before, and it brings me special joy because it takes advantage of Git's unique design in a new constructive way." --Enrico Campidoglio, independent consultant, speaker and Pluralsight author "Mark Seemann not only has decades of experience architecting and building large software systems, but is also one of the foremost thinkers on how to scale and manage the complex relationship between such systems and the teams that build them." --Mike Hadlow, freelance software consultant and blogger "Mark writes, 'Successful software endures'--this book will help you to write that kind of software." --Bryan Hogan, software architect, podcaster, blogger "Mark has an extraordinary ability to help others think deeply about the industry and profession of software development. With every interview on .NET Rocks! I have come away knowing I would have to go back and listen to my own show to really take in everything we discussed." --Richard Campbell, co-host, .NET Rocks!Table of ContentsSeries Editor Foreword xixPreface xxiiiAbout the Author xxix Part I: Acceleration 1Chapter 1: Art or Science? 3 1.1 Building a House 4 1.2 Growing a Garden 7 1.3 Towards Engineering 8 1.4 Conclusion 14 Chapter 2: Checklists 15 2.1 An Aid to Memory 15 2.2 Checklist for a New Code Base 17 2.3 Adding Checks to Existing Code Bases 29 2.4 Conclusion 32 Chapter 3: Tackling Complexity 33 3.1 Purpose 34 3.2 Why Programming Is Difficult 38 3.3 Towards Software Engineering 44 3.4 Conclusion 46 Chapter 4: Vertical Slice 49 4.1 Start with Working Software 50 4.2 Walking Skeleton 53 4.3 Outside-in 60 4.4 Complete the Slice 77 4.5 Conclusion 85 Chapter 5: Encapsulation 87 5.1 Save the Data 87 5.2 Validation 92 5.3 Protection of Invariants 105 5.4 Conclusion 108 Chapter 6: Triangulation 111 6.1 Short-Term versus Long-Term Memory 111 6.2 Capacity 114 6.3 Conclusion 127 Chapter 7: Decomposition 129 7.1 Code Rot 129 7.2 Code That Fits in Your Brain 136 7.3 Conclusion 153 Chapter 8: API Design 155 8.1 Principles of API Design 156 8.2 API Design Example 168 8.3 Conclusion 176 Chapter 9: Teamwork 177 9.1 Git 178 9.2 Collective Code Ownership 187 9.3 Conclusion 199 Part II: Sustainability 201Chapter 10: Augmenting Code 203 10.1 Feature Flags 204 10.2 The Strangler Pattern 209 10.3 Versioning 218 10.4 Conclusion 220 Chapter 11: Editing Unit Tests 223 11.1 Refactoring Unit Tests 223 11.2 See Tests Fail 233 11.3 Conclusion 234 Chapter 12: Troubleshooting 235 12.1 Understanding 235 12.2 Defects 240 12.3 Bisection 250 12.4 Conclusion 255 Chapter 13: Separation of Concerns 257 13.1 Composition 258 13.2 Cross-Cutting Concerns 267 13.3 Conclusion 274 Chapter 14: Rhythm 275 14.1 Personal Rhythm 276 14.2 Team Rhythm 282 14.3 Conclusion 285 Chapter 15: The Usual Suspects 287 15.1 Performance 288 15.2 Security 292 15.3 Other Techniques 300 15.4 Conclusion 308 Chapter 16: Tour 309 16.1 Navigation 309 16.2 Architecture 318 16.3 Usage 323 16.4 Conclusion 326 Appendix A: List of Practices 329 A.1 The 50/72 Rule 329 A.2 The 80/24 Rule 330 A.3 Arrange Act Assert 330 A.4 Bisection 330 A.5 Checklist for A New Code Base 331 A.6 Command Query Separation 331 A.7 Count the Variables 331 A.8 Cyclomatic Complexity 331 A.9 Decorators for Cross-Cutting Concerns 332 A.10 Devil's Advocate 332 A.11 Feature Flag 332 A.12 Functional Core, Imperative Shell 333 A.13 Hierarchy of Communication 333 A.14 Justify Exceptions from the Rule 333 A.15 Parse, Don't Validate 334 A.16 Postel's Law 334 A.17 Red Green Refactor 334 A.18 Regularly Update Dependencies 335 A.19 Reproduce Defects as Tests 335 A.20 Review Code 335 A.21 Semantic Versioning 335 A.22 Separate Refactoring of Test and Production Code 335 A.23 Slice 336 A.24 Strangler 336 A.25 Threat-Model 337 A.26 Transformation Priority Premise 337 A.27 X-driven Development 337 A.28 X Out Names 338 Bibliography 339Index 349
£28.49
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
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
£22.94
Barcharts, Inc Python Programming Advanced
£10.63
Barcharts, Inc Python Programming with Generative AI
£10.63
Pearson Education (US) Embracing Modern C Safely
Book SynopsisDr. John Lakos is a senior architect and mentor for software development at Bloomberg LP, where he created the BDE team (c. 2001), which maintains Bloomberg's open-source foundation libraries for C++ development worldwide. He is the author of Large-Scale C++ Software Design and Large-Scale C++ Volume I: Process and Architecture (both from Addison-Wesley), and is an active voting member of the C++ Standards Committee. Vittorio Romeo is a senior software engineer at Bloomberg, building mission-critical C++ middleware and training colleagues on modern C++. He is also the creator of many open-source C++ libraries and games. Dr. Rostislav Khlebnikov is a team lead and senior software engineer in Bloomberg's BDE team, where he directs the development of high-performance C++ foundation software. Alisdair Meredith is a senior software engineer in Bloomberg's BDE team and a long-standing member of the C++ Standards CommitteTable of ContentsForeword by Shawn Edwards xiiiForeword by Andrei Alexandrescu xvAcknowledgments xixAbout the Authors xxv Chapter 0: Introduction 1 What Makes This Book Different 1Scope for the First Edition 2The EMC++S Guiding Principles 3What Do We Mean by Safely? 4A Safe Feature 5A Conditionally Safe Feature 5An Unsafe Feature 6Modern C++ Feature Catalog 6How to Use This Book 8 Chapter 1: Safe Features 11 1.1 C++11 11Attribute Syntax | Generalized Attribute Support 12Consecutive >s | Consecutive Right-Angle Brackets 21decltype | Operator for Extracting Expression Types 25Defaulted Functions | Using = default for Special Member Functions 33Delegating Ctors | Constructors Calling Other Constructors 46Deleted Functions | Using = delete for Arbitrary Functions 53explicit Operators | Explicit Conversion Operators 61Function static '11 | Thread-Safe Function-Scope static Variables 68Local Types '11 | Local/Unnamed Types as Template Arguments 83long long | The long long (≥64 bits) Integral Type 89noreturn | The [[noreturn]] Attribute 95nullptr | The Null-Pointer-Literal Keyword 99override | The override Member-Function Specifier 104Raw String Literals | Syntax for Unprocessed String Contents 108static_assert | Compile-Time Assertions 115Trailing Return | Trailing Function Return Types 124Unicode Literals | Unicode String Literals 129using Aliases | Type/Template Aliases (Extended typedef) 133 1.2 C++14 138Aggregate Init '14 | Aggregates Having Default Member Initializers 138Binary Literals | Binary Literals: The 0b Prefix 142deprecated | The [[deprecated]] Attribute 147Digit Separators | The Digit Separator (') 152Variable Templates | Templated Variable Declarations/Definitions 157 Chapter 2: Conditionally Safe Features 167 2.1 C++11 167alignas | The alignas Specifier 168alignof | The alignof Operator 184auto Variables | Variables of Automatically Deduced Type 195Braced Init | Braced-Initialization Syntax: {} 215constexpr Functions | Compile-Time Invocable Functions 257constexpr Variables | Compile-Time Accessible Variables 302Default Member Init | Default class/union Member Initializers 318enum class | Strongly Typed, Scoped Enumerations 332extern template | Explicit-Instantiation Declarations 353Forwarding References | Forwarding References (T&&) 377Generalized PODs '11 | Trivial and Standard-Layout Types 401Inheriting Ctors | Inheriting Base-Class Constructors 535initializer_list | List Initialization: std::initializer_list 553Lambdas | Anonymous Function Objects (Closures) 573noexcept Operator | Asking if an Expression Cannot throw 615Opaque enums | Opaque Enumeration Declarations 660Range for | Range-Based for Loops 679Rvalue References | Move Semantics and Rvalue References (&&) 710Underlying Type '11 | Explicit Enumeration Underlying Type 829User-Defined Literals | User-Defined Literal Operators 835Variadic Templates | Variable-Argument-Count Templates 873 2.2 C++14 958constexpr Functions '14 | Relaxed Restrictions on constexpr Functions 959Generic Lambdas | Lambdas Having a Templated Call Operator 968Lambda Captures | Lambda-Capture Expressions 986 Chapter 3: Unsafe Features 997 3.1 C++11 997carries_dependency | The [[carries_dependency]] Attribute 998final | Prohibiting Overriding and Derivation 1007friend '11 | Extended friend Declarations 1031inline namespace | Transparently Nested Namespaces 1055noexcept Specifier | The noexcept Function Specification 1085Ref-Qualifiers | Reference-Qualified Member Functions 1153union '11 | Unions Having Non-Trivial Members 1174 3.2 C++14 1182auto Return | Function (auto) Return-Type Deduction 1182decltype(auto) | Deducing Types Using decltype Semantics 1205 Afterword: Looking Back and Looking Forward 1215 Glossary 1217Bibliography 1281Index 1305
£41.99
Microsoft Press,U.S. Code Complete
Book SynopsisSteve McConnell is recognized as one of the premier authors and voices in the development community. He is Chief Software Engineer of Construx Software and was the lead developer of Construx Estimate and of SPC Estimate Professional, winner of Software Development magazine's Productivity Award. He is the author of several books, including Code Complete and Rapid Development, both honored with Software Development magazine's Jolt Award.Table of ContentsWelcome to software construction Metaphors for a richer understanding of software development Measure twice, cut once: Upstream prerequisites Key construction decisions Design in construction Working classes High-Quality routines Defensive programming The Pseudocode programming process General issues in using variables The power of variable names Fundamental data types Unusual data types Organizing straight-line code Using conditionals Controlling loops Unusual control structures Table driven methods General control issues The software-quality landscape Collaborative construction Developer testing Debugging refactoring Code tuning strategies How program size affects construction Integration Programming tools Layout & style Self documenting code Personal character Themes in software craftsmanship
£36.44
John Wiley & Sons Inc SQL for Data Scientists
Book SynopsisJump-start your career as a data scientistlearn to develop datasets for exploration, analysis, and machine learning SQL for Data Scientists: A Beginner's Guide for Building Datasets for Analysis is a resource that's dedicated to the Structured Query Language (SQL) and dataset design skills that data scientists use most. Aspiring data scientists will learn how to how to construct datasets for exploration, analysis, and machine learning. You can also discover how to approach query design and develop SQL code to extract data insights while avoiding common pitfalls. You may be one of many people who are entering the field of Data Science from a range of professions and educational backgrounds, such as business analytics, social science, physics, economics, and computer science. Like many of them, you may have conducted analyses using spreadsheets as data sources, but never retrieved and engineered datasets from a relational database using SQL, which is a programming language designed for managing databases and extracting data. This guide for data scientists differs from other instructional guides on the subject. It doesn't cover SQL broadly. Instead, you'll learn the subset of SQL skills that data analysts and data scientists use frequently. You'll also gain practical advice and direction on how to think about constructing your dataset. Gain an understanding of relational database structure, query design, and SQL syntaxDevelop queries to construct datasets for use in applications like interactive reports and machine learning algorithmsReview strategies and approaches so you can design analytical datasetsPractice your techniques with the provided database and SQL code In this book, author Renee Teate shares knowledge gained during a 15-year career working with data, in roles ranging from database developer to data analyst to data scientist. She guides you through SQL code and dataset design concepts from an industry practitioner's perspective, moving your data scientist career forward!Table of ContentsIntroduction xix Chapter 1 Data Sources 1 Data Sources 1 Tools for Connecting to Data Sources and Editing SQL 2 Relational Databases 3 Dimensional Data Warehouses 7 Asking Questions About the Data Source 9 Introduction to the Farmer’s Market Database 11 A Note on Machine Learning Dataset Terminology 12 Exercises 13 Chapter 2 The SELECT Statement 15 The SELECT Statement 15 The Fundamental Syntax Structure of a SELECT Query 16 Selecting Columns and Limiting the Number of Rows Returned 16 The ORDER BY Clause: Sorting Results 18 Introduction to Simple Inline Calculations 20 More Inline Calculation Examples: Rounding 22 More Inline Calculation Examples: Concatenating Strings 24 Evaluating Query Output 26 SELECT Statement Summary 29 Exercises Using the Included Database 30 Chapter 3 The WHERE Clause 31 The WHERE Clause 31 Filtering SELECT Statement Results 32 Filtering on Multiple Conditions 34 Multi-Column Conditional Filtering 40 More Ways to Filter 41 BETWEEN 41 IN 42 LIKE 43 IS NULL 44 A Warning About Null Comparisons 44 Filtering Using Subqueries 46 Exercises Using the Included Database 47 Chapter 4 CASE Statements 49 CASE Statement Syntax 50 Creating Binary Flags Using CASE 52 Grouping or Binning Continuous Values Using CASE 53 Categorical Encoding Using CASE 56 CASE Statement Summary 59 Exercises Using the Included Database 60 Chapter 5 SQL JOINs 61 Database Relationships and SQL JOINs 61 A Common Pitfall when Filtering Joined Data 71 JOINs with More than Two Tables 74 Exercises Using the Included Database 76 Chapter 6 Aggregating Results for Analysis 79 GROUP BY Syntax 79 Displaying Group Summaries 80 Performing Calculations Inside Aggregate Functions 84 MIN and MAX 88 COUNT and COUNT DISTINCT 90 Average 91 Filtering with HAVING 93 CASE Statements Inside Aggregate Functions 94 Exercises Using the Included Database 96 Chapter 7 Window Functions and Subqueries 97 ROW NUMBER 98 RANK and DENSE RANK 101 NTILE 102 Aggregate Window Functions 103 LAG and LEAD 108 Exercises Using the Included Database 111 Chapter 8 Date and Time Functions 113 Setting datetime Field Values 114 EXTRACT and DATE_PART 115 DATE_ADD and DATE_SUB 116 DATEDIFF 118 TIMESTAMPDIFF 119 Date Functions in Aggregate Summaries and Window Functions 119 Exercises 126 Chapter 9 Exploratory Data Analysis with SQL 127 Demonstrating Exploratory Data Analysis with SQL 128 Exploring the Products Table 128 Exploring Possible Column Values 131 Exploring Changes Over Time 134 Exploring Multiple Tables Simultaneously 135 Exploring Inventory vs. Sales 138 Exercises 142 Chapter 10 Building SQL Datasets for Analytical Reporting 143 Thinking Through Analytical Dataset Requirements 144 Using Custom Analytical Datasets in SQL: CTEs and Views 149 Taking SQL Reporting Further 153 Exercises 157 Chapter 11 More Advanced Query Structures 159 UNIONs 159 Self-Join to Determine To-Date Maximum 163 Counting New vs. Returning Customers by Week 167 Summary 171 Exercises 171 Chapter 12 Creating Machine Learning Datasets Using SQL 173 Datasets for Time Series Models 174 Datasets for Binary Classification 176 Creating the Dataset 178 Expanding the Feature Set 181 Feature Engineering 185 Taking Things to the Next Level 189 Exercises 189 Chapter 13 Analytical Dataset Development Examples 191 What Factors Correlate with Fresh Produce Sales? 191 How Do Sales Vary by Customer Zip Code, Market Distance, and Demographic Data? 211 How Does Product Price Distribution Affect Market Sales? 217 Chapter 14 Storing and Modifying Data 229 Storing SQL Datasets as Tables and Views 229 Adding a Timestamp Column 232 Inserting Rows and Updating Values in Database Tables 233 Using SQL Inside Scripts 236 In Closing 237 Exercises 238 Appendix Answers to Exercises 239 Index 255
£30.39
Pearson Education Limited Java How to Program Late Objects Global Edition
Book SynopsisTable of Contents1. Introduction to Computers, the Internet and Java 2. Introduction to Java Applications; Input/Output and Operators 3. Control Statements: Part 1; Assignment, ++ and -- Operators 4. Control Statements: Part 2; Logical Operators 5. Methods 6. Arrays and ArrayLists 7. Introduction to Classes and Objects 8. Classes and Objects: A Deeper Look 9. Object-Oriented Programming: Inheritance 10. Object-Oriented Programming: Polymorphism and Interfaces 11. Exception Handling: A Deeper Look 12. JavaFX Graphical User Interfaces: Part 1 13. JavaFX GUI: Part 2 14. Strings, Characters, and Regular Expressions 15. Files, Input/Output Streams, NIO and XML Serialization 16. Generic Collections 17. Lambdas and Streams 18. Recursion 19. Searching, Sorting and Big O 20. Generic Classes and Methods: A Deeper Look 21. Custom Generic Data Structures 22. JavaFX Graphics and Multimedia 23. Concurrency 24. Accessing Databases with JDBC 25. Introduction to JShell: Java 9’s REPL Chapters on the Web A. Operator Precedence Chart B. ASCII Character Set C. Keywords and Reserved Words D. Primitive Types E. Using the Debugger Appendices on the Web Index Online Chapters and Appendices 26. Swing GUI Components: Part 1 27. Graphics and Java 2D 28. Networking 29. Java Persistence API (JPA) 30. JavaServer™ Faces Web Apps: Part 1 31. JavaServer™ Faces Web Apps: Part 2 32. REST-Based Web Services 33. (Optional) ATM Case Study, Part 1: Object-Oriented Design with the UML 34. (Optional) ATM Case Study, Part 2: Implementing an Object-Oriented Design 35. Swing GUI Components: Part 2 36. Java Module System and Other Java 9 Features F. Using the Java API Documentation G. Creating Documentation with javadoc H. Unicode® I. Formatted Output J. Number Systems K. Bit Manipulation L. Labeled break and continue Statements M. UML 2: Additional Diagram Types N. Design Patterns
£65.99
Manning Publications C++ Concurrency in Action,2E
Book SynopsisC++ 11 delivered strong support for multithreaded applications, andthe subsequent C++14 and 17 updates have built on this baseline. C++has better options for concurrency than ever before, which means it'san incredibly powerful option for multicore and parallel applications. This bestseller has been updated and revised to cover all the latestchanges to C++ 14 and 17! C++ Concurrency in Action, SecondEdition teaches readers everything they need to write robust andelegant multithreaded applications in C++17. Along the way, they’lllearn how to navigate the trickier bits of programming for concurrencywhile avoiding the common pitfalls. KEY FEATURES• Completely updated• Hands-on learning• In depth guide Written for C++ programmers who are new to concurrency and otherswho may have written multithreaded code using other languages, APIs,or platforms. ABOUT THE TECHNOLOGYConcurrency in terms of computers is a single system performingmultiple independent activities in parallel, rather than sequentially, orone after the other. AUTHOR BIOAnthony Williams is a UK-based developer and consultant with manyyears' experience in C++. He has been an active member of the BSI C++Standards Panel since 2001, and is the author or co-author of many of theC++ Standards Committee papers that led up to the inclusion of the threadlibrary in the C++11 Standard. He was the maintainer of the Boost Threadlibrary, and is the developer of the just::thread Pro extensions to the C++11thread library from Just Software Solutions Ltd.
£50.39
Manning Publications Python Workout: 50 Essential Exercises
Book SynopsisPython Workout presents 50 exercises designed to deepen the reader’s skill with Python. Readers will not only tackle exercises using built-in data structures, but also more advanced techniques, such as functional programming, object-oriented programming, iterators, and generators. With each engaging challenge, readers will practice a new skill and learn how to apply it to everyday coding tasks. Key Features 50 hands-on exercises and solutions Basic Python sequence types Python dictionaries and sets Functional programming in Python Creating your own classes Working with Python objects Generator functions Intended for readers with basic Python skills. About the technology Python is a versatile, elegant, general purpose programming language. Essential for data analysis, web development, artificial intelligence, games, desktop apps, and more, Python skills are a hot commodity. Reuven M. Lerner, an independent consultant for more than two decades, teaches Python, data science, and Git to companies around the world. His Better developers newsletter and blog are read by thousands of Python developers each week. Reuven has written a monthly column, “At the Forge,” for Linux Journal since 1996 and is a panellist on the weekly Freelancers Show podcast. Reuven lives with his wife and three children in Modi’in, Israel, and can be reached at https://lerner.co.il/ or on Twitter at @reuvenmlerner.
£35.99
Pearson Education (US) Go Programming Language The
Book SynopsisAlan A. A. Donovan is a member of Google's Go team in New York. He holds computer science degrees from Cambridge and MIT and has been programming in industry since 1996. Since 2005, he has worked at Google on infrastructure projects and was the co-designer of its proprietary build system, Blaze. He has built many libraries and tools for static analysis of Go programs, including oracle, godoc -analysis, eg, and gorename. Brian W. Kernighan is a professor in the Computer Science Department at Princeton University. He was a member of technical staff in the Computing Science Research Center at Bell Labs from 1969 until 2000, where he worked on languages and tools for Unix. He is the co-author of several books, including The C Programming Language, Second Edition (Prentice Hall, 1988), and The Practice of Programming (Addison-Wesley, 1999).Table of ContentsPreface xi Chapter 1: Tutorial 1 1.1 Hello, World 1 1.2 Command-Line Arguments 4 1.3 Finding Duplicate Lines 8 1.4 Animated GIFs 13 1.5 Fetching a URL 15 1.6 Fetching URLs Concurrently 17 1.7 A Web Server 19 1.8 Loose Ends 23 Chapter 2: Program Structure 27 2.1 Names 27 2.2 Declarations 28 2.3 Variables 30 2.4 Assignments 36 2.5 Type Declarations 39 2.6 Packages and Files 41 2.7 Scope 45 Chapter 3: Basic Data Types 51 3.1 Integers 51 3.2 Floating-Point Numbers 56 3.3 Complex Numbers 61 3.4 Booleans 63 3.5 Strings 64 3.6 Constants 75 Chapter 4: Composite Types 81 4.1 Arrays 81 4.2 Slices 84 4.3 Maps 93 4.4 Structs 99 4.5 JSON 107 4.6 Text and HTML Templates 113 Chapter 5: Functions 119 5.1 Function Declarations 119 5.2 Recursion 121 5.3 Multiple Return Values 124 5.4 Errors 127 5.5 Function Values 132 5.6 Anonymous Functions 135 5.7 Variadic Functions 142 5.8 Deferred Function Calls 143 5.9 Panic 148 5.10 Recover 151 Chapter 6:. Methods 155 6.1 Method Declarations 155 6.2 Methods with a Pointer Receiver 158 6.3 Composing Types by Struct Embedding 161 6.4 Method Values and Expressions 164 6.5 Example: Bit Vector Type 165 6.6 Encapsulation 168 Chapter 7: Interfaces 171 7.1 Interfaces as Contracts 171 7.2 Interface Types 174 7.3 Interface Satisfaction 175 7.4 Parsing Flags with flag.Value 179 7.5 Interface Values 181 7.6 Sorting with sort.Interface 186 7.7 The http.Handler Interface 191 7.8 The error Interface 196 7.9 Example: Expression Evaluator 197 7.10 Type Assertions 205 7.11 Discriminating Errors with Type Assertions 206 7.12 Querying Behaviors with Interface Type Assertions 208 7.13 Type Switches 210 7.14 Example: Token-Based XML Decoding 213 7.15 A Few Words of Advice 216 Chapter 8: Goroutines and Channels 217 8.1 Goroutines 217 8.2 Example: Concurrent Clock Server 219 8.3 Example: Concu rent Echo Server 222 8.4 Channels 225 8.5 Looping in Parallel 234 8.6 Example: Concurrent Web Crawler 239 8.7 Multiplexing with select 244 8.8 Example: Concurrent Directory Traversal 247 8.9 Cancellation 251 8.10 Example: Chat Server 253 Chapter 9: Concurrency with Shared Variables 257 9.1 Race Conditions 257 9.2 Mutual Exclusion: sync.Mutex 262 9.3 Read/Write Mutexes: sync.RWMutex 266 9.4 Memory Synchronization 267 9.5 Lazy Initialization: sync.Once 268 9.6 The Race Detector 271 9.7 Example: Concurrent Non-Blocking Cache 272 9.8 Goroutines and Threads 280 Chapter 10: Packages and the Go Tool 283 10.1 Introduction 283 10.2 Import Paths 284 10.3 The Package Declaration 285 10.4 Import Declarations 285 10.5 Blank Imports 286 10.6 Packages and Naming 289 10.7 The Go Tool 290 Chapter 11: Testing 301 11.1 The go test Tool 302 11.2 Test Functions 302 11.3 Coverage 318 11.4 Benchmark Functions 321 11.5 Profiling 323 11.6 Example Functions 326 Chapter 12: Reflection 329 12.1 Why Reflection? 329 12.2 reflect.Type and reflect.Value 330 12.3 Display, a Recursive Value Printer 333 12.4 Example: Encoding S-Expressions 338 12.5 Setting Variables with reflect.Value 341 12.6 Example: Decoding S-Expressions 344 12.7 Accessing Struct Field Tags 348 12.8 Displaying the Methods of a Type 351 12.9 A Word of Caution 352 Chapter 13: Low-Level Programming 353 13.1 unsafe.Sizeof, Alignof, and Offsetof 354 13.2 unsafe.Pointer 356 13.3 Example: Deep Equivalence 358 13.4 Calling C Code with cgo 361 13.5 Another Word of Caution 366 Index 367
£30.39
Pearson Education (US) Foundational Python for Data Science
Book Synopsis Kennedy Behrman is a veteran software and data engineer. He first used Python writing asset management systems in the Visual Effects industry. He then moved into the startup world, using Python at startups using machine learning to characterize videos and predict the social media power of athletes. Table of ContentsPreface xiii I: Learning Python in a Notebook Environment 1 1 Introduction to Notebooks 3 2 Fundamentals of Python 13 3 Sequences 25 4 Other Data Structures 37 5 Execution Control 55 6 Functions 67 II: Data Science Libraries 83 7 NumPy 85 8 SciPy 103 9 Pandas 113 10 Visualization Libraries 135 11 Machine Learning Libraries 153 12 Natural Language Toolkit 159 III: Intermediate Python 171 13 Functional Programming 173 14 Object-Oriented Programming 187 15 Other Topics 201 A Answers to End-of-Chapter Questions 215 Index 221
£42.74
MIT Press Types and Programming Languages
Book SynopsisA comprehensive introduction to type systems and programming languages.A type system is a syntactic method for automatically checking the absence of certain erroneous behaviors by classifying program phrases according to the kinds of values they compute. The study of type systems—and of programming languages from a type-theoretic perspective—has important applications in software engineering, language design, high-performance compilers, and security.This text provides a comprehensive introduction both to type systems in computer science and to the basic theory of programming languages. The approach is pragmatic and operational; each new concept is motivated by programming examples and the more theoretical sections are driven by the needs of implementations. Each chapter is accompanied by numerous exercises and solutions, as well as a running implementation, available via the Web. Dependencies between chapters are explicitly identified, allowing readers to choose a variety of paths through the material.The core topics include the untyped lambda-calculus, simple type systems, type reconstruction, universal and existential polymorphism, subtyping, bounded quantification, recursive types, kinds, and type operators. Extended case studies develop a variety of approaches to modeling the features of object-oriented languages.
£76.50
APress Modern C Up and Running
Book SynopsisLearn how to program in modern C, from the basics through the advanced topics required for proficiency. This book is the fastest path to C fluency for anyone experienced in a general-purpose programming language. From start to finish, code examples highlight the idioms and best practices behind efficient, robust programs in a variety of areas.The book opens with a thorough coverage of syntax, built-in data types and operations, and program structure. C has quirks and presents challenges, which are covered in detail. The coverage of advanced features is what sets this book apart from others. Among the advanced topics covered are floating-point representation in the IEEE 754 standard; embedded assembly language in C code for overflow detection; regular expressions, assertions, and internationalization; WebAssembly through C; and software libraries for C and other clients. Memory efficiency and safety are the two major challenges in C programming, andTable of Contents1. Program Structure2. Basic Data Types3. Aggregates and Pointers4. Storage Classes5. Input and Output6. Networking7. Concurrency and Parallelism8. Miscellaneous Topics
£49.49
No Starch Press,US Official Scratch Coding Cards, The (scratch 3.0):
Book SynopsisNow updated for Scratch 3.0, this 75-card deck features interactive programming projects you can make with Scratch, a free-to-use graphical programming language used by millions of kids around the world. The front of each card shows an activity, like Pong, Write an Interactive Story, Create a Virtual Pet, Play Hide and Seek. The back shows how to put code blocks together to make projects come to life! Along the way, kids learn coding concepts like sequencing, conditionals, and variables.
£17.09
Manning Publications ASP.NET Core in Action, Third Edition
Book SynopsisBuild professional-grade full-stack web applications using C# and ASP.NET Core. ASP.NET Core in Action, 3rd edition by Microsoft MVP Andrew Lock, is a fully updated edition, ideal for intermediate C# developers, and teaches you how to use your C# and .NET skills to build amazing cross-platform web applications. This revised bestseller reveals the latest .NET patterns, including minimal APIs and minimal hosting. Even if you have never worked with ASP.NET, you will soon start creating productive cross-platform web apps. Features include: Build minimal APIs for serving JSON to client-side applications Create dynamic, server-side rendered applications using Razor Pages User authentication and authorisation Store data using Entity Framework Core Unit and integration tests for ASP.NET Core applications Write custom middleware and components About the technology Developers love ASP.NET Core for its libraries and pre-built components that maximize productivity. This awesome web framework empowers you to build web applications using HTTP APIs, server-side rendered HTML, and long-running server processes - all by using the same familiar structure and components. Version 7.0 takes full advantage of new C# features, easy-to-build minimal APIs, and big performance upgrades.
£38.99
Springer International Publishing AG Fundamentals of Java Programming
Book SynopsisMaking extensive use of examples, this textbook on Java programming teaches the fundamental skills for getting started in a command-line environment. Meant to be used for a one-semester course to build solid foundations in Java, Fundamentals of Java Programming eschews second-semester content to concentrate on over 180 code examples and 250 exercises.Key object classes (String, Scanner, PrintStream, Arrays, and File) are included to get started in Java programming. The programs are explained with almost line-by-line descriptions, also with chapter-by-chapter coding exercises.Teaching resources include solutions to the exercises, as well as digital lecture slides.Table of Contents1) Programming Basics 1 a) Java and the Java Virtual Machine 3 1.1 Computers and Their Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 1.1.1 The computer programs in your machine . . . . . . . . . . . . . . . . . . . . 3 1.1.2 Java Virtual Machines - JVM . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 1.1.3 Code editing and code compiling . . . . . . . . . . . . . . . . . . . . . . . . . 6 b) Our First Programs 13 2.1 The First Program, “Hello, World!” . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 2.1.1 Method declaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 2.1.2 Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 2.1.3 System.out.println and System.out.print . . . . . . . . . . . . . . . . . . 17 2.1.4 Spacing in the source code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 2.2 Commenting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 2.3 Errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 2.4 Using Multiple Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 • println versus print revisited . . . . . . . . . . . . . . . . . . . . . . . . . . 23 • Printing multiple-line texts on the screen . . . . . . . . . . . . . . . . . . . . 25 2.4.3 Escaping characters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 2.4.4 Printing shapes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 c) Using Data for Computation 39 3.1 Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 3.1.1 Data and their taxonomy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 3.1.2 Literals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 3.1.3 Variable declarations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 3.1.4 Naming variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 3.1.5 Value assignments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 3.2 The primitive data types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 3.2.1 Quarterbacks program again . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 3.3 Using Variables for Computation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 3.3.1 Number arithmetics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 3.3.2 Formula evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 3.3.3 Our first calculation program . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 3.3.4 Mixing different number types . . . . . . . . . . . . . . . . . . . . . . . . . . 57 3.3.5 Computing the Body-Mass Index . . . . . . . . . . . . . . . . . . . . . . . . . 59 3.3.6 Sum of integers from 1 to 100 `a la Gauss . . . . . . . . . . . . . . . . . . . . 61 3.3.7 Simplified expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 3.4 An Introduction to String Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 3.4.1 String objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 3.4.2 String additions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 3.4.3 Escaping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 3.4.4 Connection with other types . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 4 Reading Keyboard Input 83 4.1 The Class Scanner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 4.2 Reading input with a Scanner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 5 Decomposing Code into Components 99 5.1 Code Decomposition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 5.1.1 Printing rectangles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 5.1.2 Quadrangle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 5.1.3 Old MacDonald Had a Farm . . . . . . . . . . . . . . . . . . . . . . . . . . . 108 5.1.4 The benefits of code decomposition . . . . . . . . . . . . . . . . . . . . . . . . 114 5.2 Using Multiple Program Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117 6 Passing Values to and from Methods 123 6.1 Passing Values to Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123 6.1.1 Methods that work with parameters . . . . . . . . . . . . . . . . . . . . . . . 123 6.1.2 Method overloading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128 6.2 Receiving a Value from a Method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132 6.3 Class Math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137 6.3.1 Mathematical functions in Java . . . . . . . . . . . . . . . . . . . . . . . . . . 137 6.3.2 Application using Math methods . . . . . . . . . . . . . . . . . . . . . . . . . 146 2) Loops and Conditional Execution 157 7 For-Loops 159 7.1 Repetitive Code Execution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159 7.2 Iteration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167 7.2.1 Simple iteration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167 7.2.2 Iteration with an auxiliary variable . . . . . . . . . . . . . . . . . . . . . . . . 173 7.3 Double For-Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 8 Using Conditions to Control the Flow 187 8.1 Condition and its evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187 8.2 The If Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 8.2.1 If . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 8.2.2 Else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201 8.2.3 Special conditional evaluation rules . . . . . . . . . . . . . . . . . . . . . . . . 209 8.3 Applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211 8.3.1 Computing max and min in a series of numbers . . . . . . . . . . . . . . . . . 211 8.3.2 A betting game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214 9 Formatted Printing using printf 225 9.1 Formatted Printing of Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225 9.2 Formatted Printing of Integers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228 9.3 Formatted Printing of Floating Point Numbers . . . . . . . . . . . . . . . . . . . . . 229 10 String Methods for Text Processing 237 10.1 String Methods for Information Extraction . . . . . . . . . . . . . . . . . . . . . . . 237 10.2 String Methods for Comparison . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239 10.3 String methods for Pattern Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244 10.4 String methods for creating new String objects . . . . . . . . . . . . . . . . . . . . 246 10.5 Class StringBuilder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249 11 Branching Using Switch Statements 259 11.1 Switch Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259 11.2 Switching on a Char or a String Value . . . . . . . . . . . . . . . . . . . . . . . . . . 266 12 While and Do-while Loops 277 12.1 The While Loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277 12.1.1 What is a while-loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277 12.1.2 Collect numbers until the total reaches a target . . . . . . . . . . . . . . . . . 279 12.1.3 Integer overflow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281 12.1.4 Vending machines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283 12.1.5 The Collatz Conjecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285 12.1.6 From decimal to binary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289 12.2 Do-while statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293 12.2.1 Do-while versus while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293 12.2.2 Waiting for Godot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294 12.2.3 Converting to binary, again . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295 12.3 Terminating a Scanner of Keyboard . . . . . . . . . . . . . . . . . . . . . . . . . . . 296 12.4 Approximating the Square Root . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301 III Arrays 311 13 Arrays 313 13.1 Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313 13.1.1 What is an array? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313 13.1.2 Counting the number of occurrences . . . . . . . . . . . . . . . . . . . . . . . 314 13.2 Offset Indexing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322 13.2.1 Offset indexing to avoid wasteful use of array elements . . . . . . . . . . . . . 322 13.2.2 Offset indexing for BMI calculation . . . . . . . . . . . . . . . . . . . . . . . . 323 13.2.3 Character occurrence counting . . . . . . . . . . . . . . . . . . . . . . . . . . 325 13.2.4 Negative offset indexing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330 13.3 Primality Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332 13.4 Using Multiple Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336 13.5 ArrayIndexOutOfBoundsException . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339 14 Class Arrays, Resizing Arrays, and Arrays with Capacity 347 14.1 Class Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347 14.2 Coordinated Array Modifications with Sustained Length . . . . . . . . . . . . . . . . 351 14.2.1 Reversing element order . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354 14.2.2 Cyclic shifting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356 14.3 Modifications That Require Resizing . . . . . . . . . . . . . . . . . . . . . . . . . . . 360 14.3.1 Insertion and deletion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360 14.3.2 Merging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367 14.4 args - the Argument Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368 14.5 Searching in an Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369 14.5.1 Sequential search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369 14.5.2 Sequential search in an array with elements in order . . . . . . . . . . . . . . 370 14.5.3 Binary search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371 14.6 Arrays with Capacity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372 15 Multidimensional Arrays 385 15.1 Two-dimensional Rectangular Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . 385 15.1.1 Multi-dimensional arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385 15.1.2 Summation of over subsequences . . . . . . . . . . . . . . . . . . . . . . . . . 386 15.2 Matrix multiplication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390 15.2.1 Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390 15.2.2 Two dimensional rotations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391 15.3 Jagged Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395 IV Object Classes 401 16 Class File 403 16.1 An Introduction to Object Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403 16.2 File Access . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403 16.3 File methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405 16.3.1 List of File methods we may use . . . . . . . . . . . . . . . . . . . . . . . . . 405 16.3.2 Error handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407 16.3.3 Listing of File objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417 16.4 Scanner of a File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420 16.5 Writing to Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427 17 Designing Object Classes 435 17.1 Using Object Classes for Packaging Data Elements . . . . . . . . . . . . . . . . . . . 435 17.1.1 The position of a game piece . . . . . . . . . . . . . . . . . . . . . . . . . . . 435 17.1.2 Private instance variables and the toString method . . . . . . . . . . . . . . 440 17.1.3 Using constants in an object class . . . . . . . . . . . . . . . . . . . . . . . . 442 17.1.4 Information hiding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447 17.2 Bank Account . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453 17.3 Array with Capacity (as an Object Class) . . . . . . . . . . . . . . . . . . . . . . . . 461 18 Interfaces, Subclasses, Inheritance, and Polymorphism 471 18.1 Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471 18.1.1 Interface as a template . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471 18.1.2 A simple pizza application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 472 18.1.3 The “simple” pizza collection class . . . . . . . . . . . . . . . . . . . . . . . . 473 18.1.4 The pizza collection main class . . . . . . . . . . . . . . . . . . . . . . . . . . 478 18.2 Subclasses and Superclasses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480 18.2.1 Extending existing classes and interfaces . . . . . . . . . . . . . . . . . . . . . 480 18.2.2 Writing extensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 482 18.3 Polymorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 490 18.4 Interface Comparable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493 V Advanced Concepts 499 19 Cumulative Algorithms 501 19.1 What is a Cumulative Algorithm? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501 19.2 Computing Recurrences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503 19.3 Computing the Factorial Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506 20 Recursive Algorithms 513 20.1 The Factorial Again . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513 20.2 GCD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 516 20.3 The Tower of Hanoi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521
£58.49
BPB Publications Microservices Design Patterns with Java
Book SynopsisMicroservices, a popular software architecture style, breaks down applications into small, independent services built with Java, a versatile and widely used programming language. This book serves as a roadmap for mastering design patterns that solve common problems encountered during microservices development in Java. Start with microservices setup for team success. Discover various architectural styles and communication approaches for seamless service interaction. Learn effective data management within microservices. Acquire skills for handling unforeseen scenarios in transactions and crafting secure APIs for user service access. Lastly, grasp crucial monitoring, testing, and deployment practices to identify and address issues, ensuring smooth production deployment.
£30.39
Pearson Education (US) Functional and Concurrent Programming
Book SynopsisMichel Charpentier is an associate professor with the Computer Science department at the University of New Hampshire (UNH). His interests over the years have ranged from distributed systems to formal verification and mobile sensor networks. He has been with UNH since 1999 and currently teaches courses in programming languages, concurrency, formal verification, and model-checking.Table of ContentsForeword by Cay Horstmann xxiii Preface xxv Acknowledgments xxxv About the Author xxxvii Part I. Functional Programming 1 Chapter 1: Concepts of Functional Programming 3 1.1 What Is Functional Programming? 3 1.2 Functions 4 1.3 From Functions to Functional Programming Concepts 6 1.4 Summary 7 Chapter 2: Functions in Programming Languages 9 2.1 Defining Functions 9 2.2 Composing Functions 10 2.3 Functions Defined as Methods 12 2.4 Operators Defined as Methods 12 2.5 Extension Methods 13 2.6 Local Functions 14 2.7 Repeated Arguments 15 2.8 Optional Arguments 16 2.9 Named Arguments 16 2.10 Type Parameters 17 2.11 Summary 19 Chapter 3: Immutability 21 3.1 Pure and Impure Functions 21 3.2 Actions 23 3.3 Expressions Versus Statements 25 3.4 Functional Variables 26 3.5 Immutable Objects 28 3.6 Implementation of Mutable State 29 3.7 Functional Lists 31 3.8 Hybrid Designs 32 3.9 Updating Collections of Mutable/Immutable Objects 35 3.10 Summary 36 Chapter 4: Case Study: Active–Passive Sets 39 4.1 Object-Oriented Design 39 4.2 Functional Values 41 4.3 Functional Objects 43 4.4 Summary 44 Chapter 5: Pattern Matching and Algebraic Data Types 47 5.1 Functional Switch 47 5.2 Tuples 48 5.3 Options 50 5.4 Revisiting Functional Lists 51 5.5 Trees 53 5.6 Illustration: List Zipper 56 5.7 Extractors 59 5.8 Summary 60 Chapter 6: Recursive Programming 63 6.1 The Need for Recursion 63 6.2 Recursive Algorithms 65 6.3 Key Principles of Recursive Algorithms 67 6.4 Recursive Structures 69 6.5 Tail Recursion 71 6.6 Examples of Tail Recursive Functions 73 6.7 Summary 77 Chapter 7: Recursion on Lists 79 7.1 Recursive Algorithms as Equalities 79 7.2 Traversing Lists 80 7.3 Returning Lists 82 7.4 Building Lists from the Execution Stack 84 7.5 Recursion on Multiple/Nested Lists 85 7.6 Recursion on Sublists Other Than the Tail 88 7.7 Building Lists in Reverse Order 90 7.8 Illustration: Sorting 92 7.9 Building Lists Efficiently 94 7.10 Summary 96 Chapter 8: Case Study: Binary Search Trees 99 8.1 Binary Search Trees 99 8.2 Sets of Integers as Binary Search Trees 100 8.3 Implementation Without Rebalancing 102 8.4 Self-Balancing Trees 107 8.5 Summary 113 Chapter 9: Higher-Order Functions 115 9.1 Functions as Values 115 9.2 Currying 118 9.3 Function Literals 120 9.4 Functions Versus Methods 123 9.5 Single-Abstract-Method Interfaces 124 9.6 Partial Application 125 9.7 Closures 130 9.8 Inversion of Control 133 9.9 Summary 133 Chapter 10: Standard Higher-Order Functions 137 10.1 Functions with Predicate Arguments 137 10.2 map and foreach 140 10.3 atMap 141 10.4 fold and reduce 146 10.5 iterate, tabulate, and unfold 148 10.6 sortWith, sortBy, maxBy, and minBy 149 10.7 groupBy and groupMap 150 10.8 Implementing Standard Higher-Order Functions 152 10.9 foreach, map, atMap, and for-Comprehensions 152 10.10 Summary 155 Chapter 11: Case Study: File Systems as Trees 157 11.1 Design Overview 157 11.2 A Node-Searching Helper Function 158 11.3 String Representation 158 11.4 Building Trees 160 11.5 Querying 164 11.6 Navigation 168 11.7 Tree Zipper 169 11.8 Summary 172 Chapter 12: Lazy Evaluation 173 12.1 Delayed Evaluation of Arguments 173 12.2 By-Name Arguments 174 12.3 Control Abstraction 176 12.4 Internal Domain-Specifc Languages 179 12.5 Streams as Lazily Evaluated Lists 180 12.6 Streams as Pipelines 182 12.7 Streams as Infinite Data Structures 184 12.8 Iterators 184 12.9 Lists, Streams, Iterators, and Views 187 12.10 Delayed Evaluation of Fields and Local Variables 190 12.11 Illustration: Subset-Sum 191 12.12 Summary 193 Chapter 13: Handling Failures 195 13.1 Exceptions and Special Values 195 13.2 Using Option 197 13.3 Using Try 198 13.4 Using Either 199 13.5 Higher-Order Functions and Pipelines 201 13.6 Summary 204 Chapter 14: Case Study: Trampolines 205 14.1 Tail-Call Optimization 205 14.2 Trampolines for Tail-Calls 206 14.3 Tail-Call Optimization in Java 207 14.4 Dealing with Non-Tail-Calls 209 14.5 Summary 213 A Brief Interlude 215 Chapter 15: Types (and Related Concepts) 217 15.1 Typing Strategies 217 15.2 Types as Sets 222 15.3 Types as Services 223 15.4 Abstract Data Types 224 15.5 Type Inference 225 15.6 Subtypes 229 15.7 Polymorphism 232 15.8 Type Variance 235 15.9 Type Bounds 241 15.10 Type Classes 245 15.11 Summary 250 Part II. Concurrent Programming 253 Chapter 16: Concepts of Concurrent Programming 255 16.1 Non-sequential Programs 255 16.2 Concurrent Programming Concepts 258 16.3 Summary 259 Chapter 17: Threads and Nondeterminism 261 17.1 Threads of Execution 261 17.2 Creating Threads Using Lambda Expressions 263 17.3 Nondeterministic Behavior of Multithreaded Programs 263 17.4 Thread Termination 264 17.5 Testing and Debugging Multithreaded Programs 266 17.6 Summary 268 Chapter 18: Atomicity and Locking 271 18.1 Atomicity 271 18.2 Non-atomic Operations 273 18.3 Atomic Operations and Non-atomic Composition 274 18.4 Locking 278 18.5 Intrinsic Locks 279 18.6 Choosing Locking Targets 281 18.7 Summary 283 Chapter 19: Thread-Safe Objects 285 19.1 Immutable Objects 285 19.2 Encapsulating Synchronization Policies 286 19.3 Avoiding Reference Escape 288 19.4 Public and Private Locks 289 19.5 Leveraging Immutable Types 290 19.6 Thread-Safety 293 19.7 Summary 295 Chapter 20: Case Study: Thread-Safe Queue 297 20.1 Queues as Pairs of Lists 297 20.2 Single Public Lock Implementation 298 20.3 Single Private Lock Implementation 301 20.4 Applying Lock Splitting 303 20.5 Summary 305 Chapter 21: Thread Pools 307 21.1 Fire-and-Forget Asynchronous Execution 307 21.2 Illustration: Parallel Server 309 21.3 Different Types of Thread Pools 312 21.4 Parallel Collections 314 21.5 Summary 318 Chapter 22: Synchronization 321 22.1 Illustration of the Need for Synchronization 321 22.2 Synchronizers 324 22.3 Deadlocks 325 22.4 Debugging Deadlocks with Thread Dumps 328 22.5 The Java Memory Model 330 22.6 Summary 335 Chapter 23: Common Synchronizers 337 23.1 Locks 337 23.2 Latches and Barriers 339 23.3 Semaphores 341 23.4 Conditions 343 23.5 Blocking Queues 349 23.6 Summary 353 Chapter 24: Case Study: Parallel Execution 355 24.1 Sequential Reference Implementation 355 24.2 One New Thread per Task 356 24.3 Bounded Number of Threads 357 24.4 Dedicated Thread Pool 359 24.5 Shared Thread Pool 360 24.6 Bounded Thread Pool 361 24.7 Parallel Collections 362 24.8 Asynchronous Task Submission Using Conditions 362 24.9 Two-Semaphore Implementation 367 24.10 Summary 368 Chapter 25: Futures and Promises 369 25.1 Functional Tasks 369 25.2 Futures as Synchronizers 371 25.3 Timeouts, Failures, and Cancellation 374 25.4 Future Variants 375 25.5 Promises 375 25.6 Illustration: Thread-Safe Caching 377 25.7 Summary 379 Chapter 26: Functional-Concurrent Programming 381 26.1 Correctness and Performance Issues with Blocking 381 26.2 Callbacks 384 26.3 Higher-Order Functions on Futures 385 26.4 Function atMap on Futures 388 26.5 Illustration: Parallel Server Revisited 390 26.6 Functional-Concurrent Programming Patterns 393 26.7 Summary 397 Chapter 27: Minimizing Thread Blocking 399 27.1 Atomic Operations 399 27.2 Lock-Free Data Structures 402 27.3 Fork/Join Pools 405 27.4 Asynchronous Programming 406 27.5 Actors 407 27.6 Reactive Streams 411 27.7 Non-blocking Synchronization 412 27.8 Summary 414 Chapter 28: Case Study: Parallel Strategies 417 28.1 Problem Definition 417 28.2 Sequential Implementation with Timeout 419 28.3 Parallel Implementation Using invokeAny 420 28.4 Parallel Implementation Using CompletionService 421 28.5 Asynchronous Implementation with Scala Futures 422 28.6 Asynchronous Implementation with CompletableFuture 426 28.7 Caching Results from Strategies 427 28.8 Summary 431 Appendix A. Features of Java and Kotlin 433 A.1 Functions in Java and Kotlin 433 A.2 Immutability 436 A.3 Pattern Matching and Algebraic Data Types 437 A.4 Recursive Programming 439 A.5 Higher-Order Functions 440 A.6 Lazy Evaluation 446 A.7 Handling Failures 449 A.8 Types 451 A.9 Threads 453 A.10 Atomicity and Locking 454 A.11 Thread-Safe Objects 455 A.12 Thread Pools 457 A.13 Synchronization 459 A.14 Futures and Functional-Concurrent Programming 460 A.15 Minimizing Thread Blocking 461 Glossary 463 Index 465
£37.79
Pearson Education (US) Captain Code
Book Synopsis Ben Forta is, first and foremost, an educator who has been teaching in some capacity since he was a teenager (many centuries ago). He is Adobe's Senior Director of Education Initiatives, and has more than three decades of experience in the technology sector in product development, support, training, and product marketing. Ben is the award-winning author of more than 40 books, some of which have been translated into 16 languages, and many of which have become college textbooks. Through his books, lectures, lessons, and videos, Ben has taught coding skills to over a million people. Ben lives in Oak Park, MI, with his wife Marcy and their children. He welcomes your emails at ben@forta.com and invites you to visit him online at http://forta.com/. Shmuel Forta is an engineer, coder, maker, tinkerer, and teacher. He is a software developer at General Motors and has years of programming experience, including both writingTrade Review" This is the book I needed that I did not know I needed. Having taught myself Python and having taught students, there are still some gaps in my knowledge that Captain Code quickly filled. The overall design of the book is wonderful and easy to read. All of the questions I have normally had when it comes to Python are answered on the pages. The code is cleanly written and the ability to scan a QR code so you can copy the code digitally is a major time-saver. What is most evident about this book is that it has been written by people that have worked with students. Too often books are written for students by people who have never taught and it never translates well on the pages. Captain Code is accessible for students and teachers and I think it is a must have for any classroom that is exploring Python. I know I will keep one at home for me and a few more in the classroom." ---Nicholas Provenzano, TheNerdyTeacher, MACUL OutstandingTechnology Using Teacher of the Year, and ISTE Outstanding Teacher of the YearTable of ContentsIntroduction xv PART I: IT'S ALL FUN AND GAMES 1 Chapter 1 Getting Started 3 Understanding Computer Programming 4 What is a computer? 4 How do we talk to computers? 5 What is Python? 8 Setting Things Up 9 Installing Python 9 Installing and Configuring Visual Studio Code 10 Creating a Work Folder 13 Writing Your First Python Program 15 Selecting Your Work Folder 16 It's Coding Time! 17 Summary 19 Chapter 2 Mad Libs 21 Understanding Functions 22 Using Variables 23 Creating a Variable 24 Using a Variable 24 Some Important Variable Rules 25 Variables, More Variables, and Even More Variables 26 Getting User Input 28 Playing Mad Libs 30 Write Your Story 30 Add Variables 30 Get User Input 32 Summary 33 Chapter 3 Roll the Dice 35 Using Libraries 36 The random Library 36 Generating Random Numbers 37 Choosing a Random Item 38 “3” Is Not 3 41 Commenting Your Code 43 One Die, Two Dice 45 Summary 49 Chapter 4 Calculate the Day 51 Working with Dates 52 The datetime Library 52 Using the datetime Class 55 Making Decisions 56 The if Statement 56 What else? 58 if Revisited 59 Testing for Other Options 61 Using in 62 Beating the Mathematician 63 Handling Numeric Inputs 63 Putting It All Together 64 An Alternate Solution 67 Summary 67 Chapter 5 Rock Paper Scissors 69 More Strings 70 Game Time 72 Handling User Input 72 The Game Code 74 One Last Tweak 76 Summary 77 Chapter 6 Secret Codes 79 Lists 80 Creating Lists 80 Accessing List Items 82 Changing List Items 83 Adding and Removing Items 84 Finding Items 85 Sorting 86 Loop-de-Loop 89 Looping Through Items 90 Looping Through Numbers 92 Nested Loops 93 Cracking the Code 95 Encrypting Characters 96 Modulus Math 97 Encryption Code 98 Decryption Code 102 Summary 104 Chapter 7 Guess the Number 105 Conditional Loops 106 Game Time 111 The Basic Game 111 Putting It All Together 116 Summary 120 Chapter 8 Becoming a Coder 121 How Coders Code 122 Have a Plan 122 Think Small 123 Game Components 124 Restricting User Input 125 Storing User Guesses 128 Displaying Lists 129 Masking Characters 131 Summary 136 Chapter 9 Hangman 137 Game Time 138 So How Does It Work? 141 Summary 148 Chapter 10 Keep Going 149 Birthday Countdown 150 Program Requirements 150 Program Flow 150 Some Tips 151 Tip Calculator 152 Program Requirements 152 Program Flow 153 Some Tips (Pun Intended) 153 Password Generator 154 Program Requirements 154 Program Flow 155 Some Tips 155 Summary 159 PART II: ON AN ADVENTURE 161 Chapter 11 Getting Func-ky 163 Functions Revisited 164 Creating a Function 165 Passing Arguments 167 Returning Values 171 Summary 175 Chapter 12 Exploring 177 Game Concept 178 Game Structure 179 Prompting for Options 181 Processing Options 182 Create a Work Folder 183 Game Time 184 Test It 189 Summary 191 Chapter 13 Cleanup Time 193 Optimizing Your Code 194 String Externalization 196 Creating the Strings File 196 Using Externalized Strings 200 Summary 201 Chapter 14 Reduce, Reuse, Recycle, Refactor 203 Understanding Refactoring 204 Identifying Refactoring Opportunities 205 Creating a User Choice Component 207 Designing a Reusable Component 208 Creating the User Options Function 213 Updating Your Code 218 Summary 221 Chapter 15 Carrying (and Using) Stuff 223 Planning the Inventory System 224 Creating a Dictionary 225 Working with Dictionaries 226 Lists of Dictionaries 228 The Inventory System 229 Creating an Inventory 230 Plugging In the Inventory System 232 Using the Inventory System 233 Displaying the Inventory 238 Summary 239 Chapter 16 Keeping It Classy 241 The Player System 242 Creating a Player Class 243 Creating the Class 243 Defining Properties 244 Creating Methods 247 Initializing the Class 250 Using Our New Class 251 Summary 255 Chapter 17 Color Your World 257 Installing Third-Party Libraries 258 Using Colorama 259 Importing and Initializing the Library 259 Coloring Your Output 260 Summary 264 Chapter 18 Keep Going 265 Health and Lives 266 Shopping for Items 271 Random Events 275 Battling Enemies 277 Saving and Restoring 280 Summary 282 PART III: RACING AROUND 283 Chapter 19 Crazy Driver 285 Introducing Pygame 286 Prepping the Game 286 Game Concept 286 Installing Pygame 288 Creating Work Folders 288 Obtaining Images 289 Getting Started 289 Initializing Pygame 290 Displaying Stuff 294 The Game Loop 295 Summary 300 Chapter 20 Image-ine the Possibilities 301 Files and Folders 302 Setting the Background 305 Placing the Cars 310 Summary 317 Chapter 21 We Like to Move It 319 Moving the Enemy 320 Moving the Player 323 Summary 327 Chapter 22 Crash, Bang, Boom 329 You Crashed, Game Over 330 Tracking Score 332 Increasing Difficulty 334 Summary 336 Chapter 23 Finishing Touches 337 Game Over Revisited 338 Pause 341 Varying Enemies 343 Ice Cubes 348 Summary 351 Chapter 24 Keep Going 353 Splash Screen 354 Scores and High Scores 354 Oil Slick 356 Multiple Enemies 357 And Then 358 Summary 359 What Next? 361 There's a Lot More to Python 362 Web Development 362 Mobile App Development 364 Game Development 364 And Then 365 Index 367 Bonus Online Chapter 25 Tinkering, Testing, and Debugging Revisited (Online Only)
£18.04
Elsevier Science Learning Processing
Book SynopsisTeaches you the basic building blocks of programming needed to create advanced graphics applications including interactive art, live video processing, and data visualization. This title offers graphic and web designers working with the Processing programming environment instructions on the basic principles of the language.Table of ContentsLesson 1: The Beginning1. Pixels2. Processing3. InteractionLesson 2: Everything You Need to Know4. Variables5. Conditionals6. LoopsLesson 3: Organization7. Functions8. ObjectsLesson 4: More of the Same9. ArraysLesson 5: Putting It All Together10. Algorithms11. Debugging12. LibrariesLesson 6: The World Revolves Around You13. Mathematics14. Translation and Rotation (in 3D!)Lesson 7: Pixels Under Microscope15. Images16. VideoLesson 8: The Outside World17. Text18. Data Input19. Data StreamsLesson 9: Making Noise20. Sound21. ExportingLesson 10: Beyond Processing22. Advanced Object-Oriented Programming23. JavaAppendix: Common ErrorsIndexwww.learningprocessing.com
£37.99
Pearson Education (US) Learning Deep Learning
Book SynopsisMagnus Ekman, Ph.D., is a director of architecture at NVIDIA Corporation. His doctorate is in computer engineering, and he is the inventor of multiple patents. He was first exposed to artificial neural networks in the late nineties in his native country, Sweden. After some dabbling in evolutionary computation, he ended up focusing on computer architecture and relocated to Silicon Valley, where he lives with his wife Jennifer, children Sebastian and Sofia, and dog Babette. He previously worked with processor design and R&D at Sun Microsystems and Samsung Research America, and has been involved in starting two companies, one of which (Skout) was later acquired by The Meet Group, Inc. In his current role at NVIDIA, he leads an engineering team working on CPU performance and power efficiency for system on chips targeting the autonomous vehicle market. As the Deep Learning (DL) field exploded the past few years, fueled by NVIDIA's GPU technology and CUDA, Dr. Ekman fTable of Contents Foreword by Dr. Anima Anandkumar xxiForeword by Dr. Craig Clawson xxiiiPreface xxvAcknowledgments liAbout the Author liii Chapter 1: The Rosenblatt Perceptron 1 Example of a Two-Input Perceptron 4 The Perceptron Learning Algorithm 7 Limitations of the Perceptron 15 Combining Multiple Perceptrons 17 Implementing Perceptrons with Linear Algebra 20 Geometric Interpretation of the Perceptron 30 Understanding the Bias Term 33 Concluding Remarks on the Perceptron 34 Chapter 2: Gradient-Based Learning 37 Intuitive Explanation of the Perceptron Learning Algorithm 37 Derivatives and Optimization Problems 41 Solving a Learning Problem with Gradient Descent 44 Constants and Variables in a Network 48 Analytic Explanation of the Perceptron Learning Algorithm 49 Geometric Description of the Perceptron Learning Algorithm 51 Revisiting Different Types of Perceptron Plots 52 Using a Perceptron to Identify Patterns 54 Concluding Remarks on Gradient-Based Learning 57 Chapter 3: Sigmoid Neurons and Backpropagation 59 Modified Neurons to Enable Gradient Descent for Multilevel Networks 60 Which Activation Function Should We Use? 66 Function Composition and the Chain Rule 67 Using Backpropagation to Compute the Gradient 69 Backpropagation with Multiple Neurons per Layer 81 Programming Example: Learning the XOR Function 82 Network Architectures 87 Concluding Remarks on Backpropagation 89 Chapter 4: Fully Connected Networks Applied to Multiclass Classification 91 Introduction to Datasets Used When Training Networks 92 Training and Inference 100 Extending the Network and Learning Algorithm to Do Multiclass Classification 101 Network for Digit Classification 102 Loss Function for Multiclass Classification 103 Programming Example: Classifying Handwritten Digits 104 Mini-Batch Gradient Descent 114 Concluding Remarks on Multiclass Classification 115 Chapter 5: Toward DL: Frameworks and Network Tweaks 117 Programming Example: Moving to a DL Framework 118 The Problem of Saturated Neurons and Vanishing Gradients 124 Initialization and Normalization Techniques to Avoid Saturated Neurons 126 Cross-Entropy Loss Function to Mitigate Effect of Saturated Output Neurons 130 Different Activation Functions to Avoid Vanishing Gradient in Hidden Layers 136 Variations on Gradient Descent to Improve Learning 141 Experiment: Tweaking Network and Learning Parameters 143 Hyperparameter Tuning and Cross-Validation 146 Concluding Remarks on the Path Toward Deep Learning 150 Chapter 6: Fully Connected Networks Applied to Regression 153 Output Units 154 The Boston Housing Dataset 160 Programming Example: Predicting House Prices with a DNN 161 Improving Generalization with Regularization 166 Experiment: Deeper and Regularized Models for House Price Prediction 169 Concluding Remarks on Output Units and Regression Problems 170 Chapter 7: Convolutional Neural Networks Applied to Image Classification 171 The CIFAR-10 Dataset 173 Characteristics and Building Blocks for Convolutional Layers 175 Combining Feature Maps into a Convolutional Layer 180 Combining Convolutional and Fully Connected Layers into a Network 181 Effects of Sparse Connections and Weight Sharing 185 Programming Example: Image Classification with a Convolutional Network 190 Concluding Remarks on Convolutional Networks 201 Chapter 8: Deeper CNNs and Pretrained Models 205 VGGNet 206 GoogLeNet 210 ResNet 215 Programming Example: Use a Pretrained ResNet Implementation 223 Transfer Learning 226 Backpropagation for CNN and Pooling 228 Data Augmentation as a Regularization Technique 229 Mistakes Made by CNNs 231 Reducing Parameters with Depthwise Separable Convolutions 232 Striking the Right Network Design Balance with EfficientNet 234 Concluding Remarks on Deeper CNNs 235 Chapter 9: Predicting Time Sequences with Recurrent Neural Networks 237 Limitations of Feedforward Networks 241 Recurrent Neural Networks 242 Mathematical Representation of a Recurrent Layer 243 Combining Layers into an RNN 245 Alternative View of RNN and Unrolling in Time 246 Backpropagation Through Time 248 Programming Example: Forecasting Book Sales 250 Dataset Considerations for RNNs 264 Concluding Remarks on RNNs 265 Chapter 10: Long Short-Term Memory 267 Keeping Gradients Healthy 267 Introduction to LSTM 272 LSTM Activation Functions 277 Creating a Network of LSTM Cells 278 Alternative View of LSTM 280 Related Topics: Highway Networks and Skip Connections 282 Concluding Remarks on LSTM 282 Chapter 11: Text Autocompletion with LSTM and Beam Search 285 Encoding Text 285 Longer-Term Prediction and Autoregressive Models 287 Beam Search 289 Programming Example: Using LSTM for Text Autocompletion 291 Bidirectional RNNs 298 Different Combinations of Input and Output Sequences 300 Concluding Remarks on Text Autocompletion with LSTM 302 Chapter 12: Neural Language Models and Word Embeddings 303 Introduction to Language Models and Their Use Cases 304 Examples of Different Language Models 307 Benefit of Word Embeddings and Insight into How They Work 313 Word Embeddings Created by Neural Language Models 315 Programming Example: Neural Language Model and Resulting Embeddings 319 King − Man + Woman! = Queen 329 King − Man + Woman ! = Queen 331 Language Models, Word Embeddings, and Human Biases 332 Related Topic: Sentiment Analysis of Text 334 Concluding Remarks on Language Models and Word Embeddings 342 Chapter 13: Word Embeddings from word2vec and GloVe 343 Using word2vec to Create Word Embeddings Without a Language Model 344 Additional Thoughts on word2vec 352 word2vec in Matrix Form 353 Wrapping Up word2vec 354 Programming Example: Exploring Properties of GloVe Embeddings 356 Concluding Remarks on word2vec and GloVe 361 Chapter 14: Sequence-to-Sequence Networks and Natural Language Translation 363 Encoder-Decoder Model for Sequence-to-Sequence Learning 366 Introduction to the Keras Functional API 368 Programming Example: Neural Machine Translation 371 Experimental Results 387 Properties of the Intermediate Representation 389 Concluding Remarks on Language Translation 391 Chapter 15: Attention and the Transformer 393 Rationale Behind Attention 394 Attention in Sequence-to-Sequence Networks 395 Alternatives to Recurrent Networks 406 Self-Attention 407 Multi-head Attention 410 The Transformer 411 Concluding Remarks on the Transformer 415 Chapter 16: One-to-Many Network for Image Captioning 417 Extending the Image Captioning Network with Attention 420 Programming Example: Attention-Based Image Captioning 421 Concluding Remarks on Image Captioning 443 Chapter 17: Medley of Additional Topics 447 Autoencoders 448 Multimodal Learning 459 Multitask Learning 469 Process for Tuning a Network 477 Neural Architecture Search 482 Concluding Remarks 502 Chapter 18: Summary and Next Steps 503 Things You Should Know by Now 503 Ethical AI and Data Ethics 505 Things You Do Not Yet Know 512 Next Steps 516 Appendix A: Linear Regression and Linear Classifiers 519 Linear Regression as a Machine Learning Algorithm 519 Computing Linear Regression Coefficients 523 Classification with Logistic Regression 525 Classifying XOR with a Linear Classifier 528 Classification with Support Vector Machines 531 Evaluation Metrics for a Binary Classifier 533 Appendix B: Object Detection and Segmentation 539 Object Detection 540 Semantic Segmentation 549 Instance Segmentation with Mask R-CNN 559 Appendix C: Word Embeddings Beyond word2vec and GloVe 563 Wordpieces 564 FastText 566 Character-Based Method 567 ELMo 572 Related Work 575 Appendix D: GPT, BERT, AND RoBERTa 577 GPT 578 BERT 582 RoBERTa 586 Historical Work Leading Up to GPT and BERT 588 Other Models Based on the Transformer 590 Appendix E: Newton-Raphson versus Gradient Descent 593 Newton-Raphson Root-Finding Method 594 Relationship Between Newton-Raphson and Gradient Descent 597 Appendix F: Matrix Implementation of Digit Classification Network 599 Single Matrix 599 Mini-Batch Implementation 602 Appendix G: Relating Convolutional Layers to Mathematical Convolution 607Appendix H: Gated Recurrent Units 613 Alternative GRU Implementation 616 Network Based on the GRU 616 Appendix I: Setting up a Development Environment 621 Python 622 Programming Environment 623 Programming Examples 624 Datasets 625 Installing a DL Framework 628 TensorFlow Specific Considerations 630 Key Differences Between PyTorch and TensorFlow 631 Appendix J: Cheat Sheets 637 Works Cited 647Index 667
£46.54
Pearson Education (US) Microsoft Visual C Step by Step
Book SynopsisJohn Sharp is a principal technologist for CM Group Ltd, part of the Civica Group, a software development and consultancy company in the United Kingdom. He is well versed as a software consultant, developer, author, and trainer, with more than 35 years of experience, ranging from Pascal programming on CP/M and C/Oracle application development on various flavors of UNIX to the design of C# and JavaScript distributed applications and development on Windows 11 and Microsoft Azure. He also spends much of his time writing courseware for Microsoft, focusing on areas such as data science using R and Python, big data processing with Spark and CosmosDB, SQL Server, NoSQL, web services, Blazor, cross-platform development with frameworks such as Xamarin and MAUI, and scalable application architectures with Azure.Table of ContentsIntroduction PART I INTRODUCING MICROSOFT VISUAL C# AND MICROSOFT VISUAL STUDIO CHAPTER 1 Welcome to C# CHAPTER 2 Working with variables, operators, and expressions CHAPTER 3 Writing methods and applying scope CHAPTER 4 Using decision statements CHAPTER 5 Using compound assignment and iteration statements CHAPTER 6 Managing errors and exceptions PART II UNDERSTANDING THE C# OBJECT MODEL CHAPTER 7 Creating and managing classes and objects CHAPTER 8 Understanding values and references CHAPTER 9 Creating value types with enumerations and structures CHAPTER 10 Using arrays CHAPTER 11 Understanding parameter arrays CHAPTER 12 Working with inheritance CHAPTER 13 Creating interfaces and defining abstract classes CHAPTER 14 Using garbage collection and resource management PART III DEFINING EXTENSIBLE TYPES WITH C# CHAPTER 15 Implementing properties to access fields CHAPTER 16 Handling binary data and using indexers CHAPTER 17 Introducing generics CHAPTER 18 Using collections CHAPTER 19 Enumerating collections CHAPTER 20 Decoupling application logic and handling events CHAPTER 21 Querying in-memory data by using query expressions CHAPTER 22 Operator overloading PART IV BUILDING UNIVERSAL WINDOWS PLATFORM APPLICATIONS WITH C# CHAPTER 23 Improving throughput by using tasks CHAPTER 24 Improving response time by performing asynchronous operations CHAPTER 25 Implementing the user interface for a Universal Windows Platform app CHAPTER 26 Displaying and searching for data in a Universal Windows Platform app CHAPTER 27 Accessing a remote database from a Universal Windows Platform app
£40.49
Pearson Education (US) Art of Computer Programming The
Book SynopsisDonald E. Knuth is known throughout the world for his pioneering work on algorithms and programming techniques, for his invention of the TEX and METAFONT systems for computer typesetting, and for his prolific and influential writing (26 books, 161 papers). Professor Emeritus of The Art of Computer Programming at Stanford University, he currently devotes full time to the completion of his seminal multivolume series on classical computer science, begun in 1962 when he was a graduate student at California Institute of Technology. Professor Knuth is the recipient of numerous awards and honors, including the ACM Turing Award, the Medal of Science presented by President Carter, the AMS Steele Prize for expository writing, and, in November, 1996, the prestigious Kyoto Prize for advanced technology. He lives on the Stanford campus with his wife, Jill.Table of ContentsPreface Notes on the Exercises Chapter 7: Combinatorial Searching 1 7.1: Zeros and Ones 47 7.2: Generating All Possibilities 281 Answers to Exercises 514 Appendix A: Tables of Numerical Quantities 818 Appendix B: Index to Notations 822 Appendix C: Index to Algorithms and Theorems 828 Appendix D: Index to Combinatorial Problems 830 Index and Glossary 834
£53.54
Taylor & Francis Ltd (Sales) Automated Software Testing with Cypress
Book SynopsisUnit Integration Testing (UIT) had been a challenge because there was no tool that could help in XHR programming and unit integration validations in an efficient way until Cypress arrived. Cypress started releasing versions in 2015 and became popular in 2018 with version 2.0.0.This book explores Cypress scripts that help implement âshift left testingâ, which is a dream come true for many software testers. Shift left occurs in the majority of testing projects, but could not be implemented fully because tools were unavailable and knowledge was lacking about the possibilities of testing early in the life cycle. Shift left is a key testing strategy to help testing teams focus less on defect identifications and more on developing practices to prevent defects. Cypress scripts can help front-end developers and quality engineers to work together to find defects soon after web components are built. These components can be tested immediately after they are built with Cypress Test Driven Development (TDD) scripts. Thus, defects can be fixed straight away during the development stage. Testing teams do not have to worry about finding these same defects in a later development stage because Cypress tests keep verifying components in the later stages. Defect fixing has become much cheaper with Cypress than when other tools are used. The book also covers Behaviour Driven Development (BDD)-based Gherkin scripts and the Cypress Cucumber preprocessor, which can improve test scenario coverage. Automated Software Testing with Cypress is written to fulfil the BDD and TDD needs of testing teams. Two distinct open source repositories are provided in Github to help start running Cypress tests in no time!Table of Contents1. Visual Regression. 2. Web Accessibility Testing. 3. Running Cypress Tests in Docker. 4. Test Reports. 5. Cypress Tests in Jenkins. 6. Behaviour Driven Developen (BDD)-based Feature File Writing Techniques using Cypress.io and Cucumber. 7. Differences Between Selenium and Cypress.io. 8. Cypress Cucumber Preprocessor Errors. 9. Device Compatibility Testing Using Cypress.io. 10. Disabled Object Verification Through Force: True. 11. Upload File Using Cypress.io. 12. Conditional Tests: A Comparison Between Selenium and Cypress.io. 13. Testing Dropdowns Using Cypress.io. 14. BeforeEach and AfterEach Hooks. 15. Generic Test Automation Architecture of Cypress.io. 16. Cypress-based API Testing. 17. BrowserStack-based Cypress Test Execution. 18. Capture/Playback Approach of Test Automation. 19. Test Applications with Slow Speed Using Cypress.io and URL Throttler. 20. DAST with Cypress.io and BurpSuite. 21. Click Function Using Cypress.io. 22. Adjusting Default Timeouts or Wait Times in Cypress.json. 23. Double Click Function Using Cypress.io. 24. Cypress Retry on Failed Tests. 25. Mouse Events Using Cypress.io. 26. Checkboxes Verification Using Cypress.io.
£38.99
John Wiley & Sons Inc Visual Basic .Net All in One Desk Reference for
Book SynopsisVisual Basic .NET made clear! Covers all aspects of VB .NET programming in seven self-contained minibooks: Visual Basic .NET Programming Fundamentals, Advanced Visual Basic .NET Programming, The .NET Editor, Object-Oriented Programming, Programming for the Web, Database Programming, and Graphics and Games Visual Basic is the primary tool of more than fifty percent of all professional developers, so the upgrade to VB .NET represents a major paradigm shift; this handy all-in-one guide gives them easy access to valuable information Guides the reader through getting integrated with the rest of Visual Studio .NET, covers programmatic encryption and other .NET security capabilities, and shows how to program for Web services with VB .NET and ASP.NET Companion Web site includes a must-have bonus appendix that provides parallel VB 6 and VB .NET sample code to help VB programmers make the somewhat difficult transition to .NET Table of ContentsIntroduction: Welcome to .NET 1 Book I The Fundamentals of Visual Basic .NET Programming 11 Chapter 1: Getting With the Program 13 Chapter 2: Common Tasks 21 Chapter 3: Managing Files and Directories 49 Chapter 4: Old Concepts in New Clothes 57 Book II Tapping the Power of .NET Editor 73 Chapter 1: Organizing Your Projects 75 Chapter 2: Viewing Your Work 85 Chapter 3: Investigating the Toolbox 97 Chapter 4: Windows, Windows Everywhere 113 Chapter 5: Customization — Doing It Your Way 125 Book III Advanced Visual Basic .NET Programming 133 Chapter 1: Understanding Variable Types 135 Chapter 2: Working with Arrays 157 Chapter 3: Serious Serialization and Streams 171 Chapter 4: Creating Runtime Controls 191 Chapter 5: Overloaded Functions and Parameters 207 Chapter 6: Smashing Bugs 217 Chapter 7: No More Paranoia — Programmatic Encryption 233 Book IV Programming for the Web 259 Chapter 1: Introduction to ASP.NET 261 Chapter 2: Everything’s Eventual 277 Chapter 3: Using ASP.NET Controls 291 Chapter 4: Making Database Connections on WebForms 303 Chapter 5: Creating a Web Service 317 Chapter 6: Bugs in the Web 335 Book V Visual Basic .NET Database Programming 351 Chapter 1: The Basics of Databases 353 Chapter 2: User Interface Techniques 377 Chapter 3: Managing DataSets 403 Chapter 4: Migrating to ADO.NET 429 Chapter 5: Deeper into ADO.NET 449 Chapter 6: Querying Data 463 Book VI Fun and Games with Graphics 489 Chapter 1: You Be Picasso 491 Chapter 2: The Creative Photographer 517 Chapter 3: Mastering .NET Printing (It’s Complicated Until You Know How) 527 Chapter 4: Constructing Wolfram Diagrams 541 Book VII Visual Basic .NET Object-Oriented Programming 559 Chapter 1: Introduction to OOP 561 Chapter 2: Creating Classes 571 Chapter 3: Inheritance 579 Chapter 4: Your First OOP Project 589 Chapter 5: Exploiting the .NET Framework 605 Appendix: Dictionary of VB.NET 623 Index 753
£31.19
John Wiley & Sons Inc Python for Cybersecurity
Book SynopsisTable of ContentsIntroduction xvii Chapter 1 Fulfilling Pre- ATT&CK Objectives 1 Active Scanning 2 Scanning Networks with scapy 2 Implementing a SYN Scan in scapy 4 Performing a DNS Scan in scapy 5 Running the Code 5 Network Scanning for Defenders 6 Monitoring Traffic with scapy 7 Building Deceptive Responses 8 Running the Code 9 Search Open Technical Databases 9 Offensive DNS Exploration 10 Searching DNS Records 11 Performing a DNS Lookup 12 Reverse DNS Lookup 12 Running the Code 13 DNS Exploration for Defenders 13 Handling DNS Requests 15 Building a DNS Response 15 Running the Code 16 Summary 17 Suggested Exercises 17 Chapter 2 Gaining Initial Access 19 Valid Accounts 20 Discovering Default Accounts 20 Accessing a List of Default Credentials 21 Starting SSH Connections in Python 22 Performing Telnet Queries in Python 23 Running the Code 24 Account Monitoring for Defenders 24 Introduction to Windows Event Logs 25 Accessing Event Logs in Python 28 Detecting Failed Logon Attempts 28 Identifying Unauthorized Access to Default Accounts 30 Running the Code 30 Replication Through Removable Media 31 Exploiting Autorun 31 Converting Python Scripts to Windows Executables 32 Generating an Autorun File 33 Setting Up the Removable Media 34 Running the Code 34 Detecting Autorun Scripts 34 Identifying Removable Drives 35 Finding Autorun Scripts 36 Detecting Autorun Processes 36 Running the Code 36 Summary 37 Suggested Exercises 37 Chapter 3 Achieving Code Execution 39 Windows Management Instrumentation 40 Executing Code with WMI 40 Creating Processes with WMI 41 Launching Processes with PowerShell 41 Running the Code 42 WMI Event Monitoring for Defenders 42 WMI in Windows Event Logs 43 Accessing WMI Event Logs in Python 45 Processing Event Log XML Data 45 Running the Code 46 Scheduled Task/Job 47 Scheduling Malicious Tasks 47 Checking for Scheduled Tasks 48 Scheduling a Malicious Task 48 Running the Code 49 Task Scheduling for Defenders 50 Querying Scheduled Tasks 51 Identifying Suspicious Tasks 52 Running the Code 52 Summary 53 Suggested Exercises 53 Chapter 4 Maintaining Persistence 55 Boot or Logon Autostart Execution 56 Exploiting Registry Autorun 56 The Windows Registry and Autorun Keys 57 Modifying Autorun Keys with Python 60 Running the Code 61 Registry Monitoring for Defenders 62 Querying Windows Registry Keys 63 Searching the HKU Hive 64 Running the Code 64 Hijack Execution Flow 65 Modifying the Windows Path 65 Accessing the Windows Path 66 Modifying the Path 67 Running the Code 68 Path Management for Defenders 69 Detecting Path Modification via Timestamps 69 Enabling Audit Events 71 Monitoring Audit Logs 73 Running the Code 75 Summary 76 Suggested Exercises 76 Chapter 5 Performing Privilege Escalation 77 Boot or Logon Initialization Scripts 78 Creating Malicious Logon Scripts 78 Achieving Privilege Escalation with Logon Scripts 79 Creating a Logon Script 79 Running the Code 79 Searching for Logon Scripts 80 Identifying Autorun Keys 81 Running the Code 81 Hijack Execution Flow 81 Injecting Malicious Python Libraries 82 How Python Finds Libraries 82 Creating a Python Library 83 Running the Code 83 Detecting Suspicious Python Libraries 83 Identifying Imports 85 Detecting Duplicates 85 Running the Code 86 Summary 86 Suggested Exercises 87 Chapter 6 Evading Defenses 89 Impair Defenses 90 Disabling Antivirus 90 Disabling Antivirus Autorun 90 Terminating Processes 93 Creating Decoy Antivirus Processes 94 Catching Signals 95 Running the Code 95 Hide Artifacts 95 Concealing Files in Alternate Data Streams 96 Exploring Alternate Data Streams 96 Alternate Data Streams in Python 97 Running the Code 98 Detecting Alternate Data Streams 98 Walking a Directory with Python 99 Using PowerShell to Detect ADS 100 Parsing PowerShell Output 101 Running the Code 102 Summary 102 Suggested Exercises 103 Chapter 7 Accessing Credentials 105 Credentials from Password Stores 106 Dumping Credentials from Web Browsers 106 Accessing the Chrome Master Key 108 Querying the Chrome Login Data Database 108 Parsing Output and Decrypting Passwords 109 Running the Code 109 Monitoring Chrome Passwords 110 Enabling File Auditing 110 Detecting Local State Access Attempts 111 Running the Code 113 Network Sniffing 114 Sniffing Passwords with scapy 114 Port- Based Protocol Identification 116 Sniffing FTP Passwords 116 Extracting SMTP Passwords 117 Tracking Telnet Authentication State 119 Running the Code 121 Creating Deceptive Network Connections 121 Creating Decoy Connections 122 Running the Code 122 Summary 123 Suggested Exercises 123 Chapter 8 Performing Discovery 125 Account Discovery 126 Collecting User Account Data 126 Identifying Administrator Accounts 127 Collecting User Account Information 128 Accessing Windows Password Policies 128 Running the Code 129 Monitoring User Accounts 130 Monitoring Last Login Times 130 Monitoring Administrator Login Attempts 131 Running the Code 132 File and Directory Discovery 133 Identifying Valuable Files and Folders 133 Regular Expressions for Data Discovery 135 Parsing Different File Formats 135 Running the Code 136 Creating Honeypot Files and Folders 136 Monitoring Decoy Content 136 Creating the Decoy Content 137 Running the Code 138 Summary 138 Suggested Exercises 139 Chapter 9 Moving Laterally 141 Remote Services 142 Exploiting Windows Admin Shares 142 Enabling Full Access to Administrative Shares 143 Transferring Files via Administrative Shares 144 Executing Commands on Administrative Shares 144 Running the Code 144 Admin Share Management for Defenders 145 Monitoring File Operations 146 Detecting Authentication Attempts 147 Running the Code 148 Use Alternative Authentication Material 148 Collecting Web Session Cookies 149 Accessing Web Session Cookies 150 Running the Code 150 Creating Deceptive Web Session Cookies 151 Creating Decoy Cookies 151 Monitoring Decoy Cookie Usage 153 Running the Code 153 Summary 154 Suggested Exercises 155 Chapter 10 Collecting Intelligence 157 Clipboard Data 158 Collecting Data from the Clipboard 158 Accessing the Windows Clipboard 159 Replacing Clipboard Data 159 Running the Code 160 Clipboard Management for Defenders 160 Monitoring the Clipboard 161 Processing Clipboard Messages 161 Identifying the Clipboard Owner 161 Running the Code 162 Email Collection 162 Collecting Local Email Data 162 Accessing Local Email Caches 163 Running the Code 163 Protecting Against Email Collection 164 Identifying Email Caches 165 Searching Archive Files 165 Running the Code 166 Summary 166 Suggested Exercises 166 Chapter 11 Implementing Command and Control 169 Encrypted Channel 170 Command and Control Over Encrypted Channels 170 Encrypted Channel Client 171 Encrypted Channel Server 172 Running the Code 173 Detecting Encrypted C2 Channels 174 Performing Entropy Calculations 175 Detecting Encrypted Traffic 175 Running the Code 176 Protocol Tunneling 176 Command and Control via Protocol Tunneling 176 Protocol Tunneling Client 177 Protocol Tunneling Server 177 Running the Code 179 Detecting Protocol Tunneling 179 Extracting Field Data 181 Identifying Encoded Data 181 Running the Code 181 Summary 182 Suggested Exercises 182 Chapter 12 Exfiltrating Data 183 Alternative Protocols 184 Data Exfiltration Over Alternative Protocols 184 Alternative Protocol Client 185 Alternative Protocol Server 186 Running the Code 188 Detecting Alternative Protocols 189 Detecting Embedded Data 190 Running the Code 191 Non- Application Layer Protocols 191 Data Exfiltration via Non- Application Layer Protocols 192 Non- Application Layer Client 193 Non- Application Layer Server 193 Running the Code 194 Detecting Non- Application Layer Exfiltration 195 Identifying Anomalous Type and Code Values 196 Running the Code 196 Summary 197 Suggested Exercises 197 Chapter 13 Achieving Impact 199 Data Encrypted for Impact 200 Encrypting Data for Impact 200 Identifying Files to Encrypt 201 Encrypting and Decrypting Files 202 Running the Code 202 Detecting File Encryption 203 Finding Files of Interest 204 Calculating File Entropies 204 Running the Code 205 Account Access Removal 205 Removing Access to User Accounts 205 Changing Windows Passwords 207 Changing Linux Passwords 207 Running the Code 207 Detecting Account Access Removal 208 Detecting Password Changes in Windows 209 Detecting Password Changes in Linux 210 Running the Code 211 Summary 211 Suggested Exercises 212 Index 213
£19.54
Pearson Education Limited Absolute C Global Edition
Book SynopsisTable of ContentsChapter 1 C++ BASICS 1 Chapter 2 FLOW OF CONTROL 45 Chapter 3 FUNCTION BASICS 99 Chapter 4 PARAMETERS AND OVERLOADING 145 Chapter 5 ARRAYS 185 Chapter 6 STRUCTURES AND CLASSES 239 Chapter 7 CONSTRUCTORS AND OTHER TOOLS 275 Chapter 8 OPERATOR OVERLOADING, FRIENDS, AND REFERENCES 321 Chapter 9 STRINGS 367 Chapter 10 POINTERS AND DYNAMIC ARRAYS 419 Chapter 11 SEPARATE COMPILATION AND NAMESPACES 471 Chapter 12 STREAMS AND FILE I/O 515 Chapter 13 RECURSION 571 Chapter 14 INHERITANCE 613 Chapter 15 POLYMORPHISM AND VIRTUAL FUNCTIONS 661 Chapter 16 TEMPLATES 693 Chapter 17 LINKED DATA STRUCTURES 731 Chapter 18 EXCEPTION HANDLING 825 Chapter 19 STANDARD TEMPLATE LIBRARY 857 Chapter 20 PATTERNS AND UML (online at www.pearsonhighered.com/savitch) Appendix 1 C++ KEYWORDS 915 Appendix 2 PRECEDENCE OF OPERATORS 917 Appendix 3 THE ASCII CHARACTER SET 919 Appendix 4 SOME LIBRARY FUNCTIONS 921 Appendix 5 OLD AND NEW HEADER FILES 929 INDEX 931
£71.99
Pearson Education Problem Solving with C Global Edition
Book Synopsis Walter Savitch is Professor Emeritus of Computer Science at the University of California at San Diego. His interests include complexity theory, formal language theory, computational linguistics, and the development of computer science education materials, including several leading textbooks. He holds a PhD in mathematics from the University of California at Berkeley.Table of Contents 1. Introduction to Computers and C++ Programming 2. C++ Basics 3. More Flow of Control 4. Procedural Abstraction and Functions That Return a Value 5. Functions for All Subtasks 6. I/O Streams as an Introduction to Objects and Classes 7. Arrays 8. Strings and Vectors 9. Pointers and Dynamic Arrays 10. Defining Classes 11. Friends, Overloaded Operators, and Arrays in Classes 12. Separate Compilation and Namespaces 13. Pointers and Linked Lists 14. Recursion 15. Inheritance 16. Exception Handling 17. Templates 18. Standard Template Library and C++11
£80.10
Pearson Education Limited Introduction to Python Programming and Data
Book SynopsisY. Daniel Liang earned his Ph.D. in Computer Science from the University of Oklahoma, USA in 1991, and an MS and BS in Computer Science from Fudan University, China, in 1986 and 1983. Prior to joining Armstrong, he was Associate Professor of Computer Science at Purdue University in Fort Wayne, where he twice received the Excellence in Research Award. Dr. Liang was trained in theoretical computer science. He was active in graph algorithms from 1990 to 1995 and published more than ten papers in several established journals such as SIAM Journal on Computing, Discrete Applied Mathematics, Acta Informatics, and Information Processing Letters. Since 1996, he has devoted to writing texts and published more than thirty books with Prentice Hall. His popular computer science texts are widely adopted in the world. Dr. Liang was elected a Java Champion in 2005 by Sun Microsystems and has given lectures on Java internationally.Table of Contents Introduction to Computers, Programs, and Python Elementary Programming Selections Mathematical Functions, Strings, and Objects Loops Functions Lists Multidimensional Lists Objects and Classes Basic GUI Programming Using Tkinter Advanced GUI Programming Using Tkinter Inheritance and Polymorphism Files and Exception Handling Tuples, Sets, and Dictionaries Recursion Developing Efficient Algorithms Sorting Linked Lists, Stacks, Queues, and Priority Queues Binary Search Trees AVL Trees Hashing Graphs and Applications Weighted Graphs and Applications Appendix A. Python Keywords Appendix B. The ASCII Character Set Appendix C. Number Systems Appendix D. Command Line Arguments Appendix E. Regular Expressions Appendix F. Bitwise Operations Appendix G. The Big-O, Big-Omega, and Big-Theta Notations Appendix H. Operator Precedence Chart Symbol Index Supplemental Material Glossary
£66.99
O'Reilly Media Web Development with Node and Express
Book SynopsisBuild dynamic web applications with Express, a key component of the Node/JavaScript development stack. In this updated edition, author Ethan Brown teaches you Express fundamentals by walking you through the development of an example application.
£33.74
Manning Publications Data Pipelines with Apache Airflow
Book SynopsisPipelines can be challenging to manage, especially when your data has to flow through a collection of application components, servers, and cloud services. Airflow lets you schedule, restart, and backfill pipelines, and its easy-to-use UI and workflows with Python scripting has users praising its incredible flexibility. Data Pipelines with Apache Airflow takes you through best practices for creating pipelines for multiple tasks, including data lakes, cloud deployments, and data science. Data Pipelines with Apache Airflow teaches you the ins-and-outs of the Directed Acyclic Graphs (DAGs) that power Airflow, and how to write your own DAGs to meet the needs of your projects. With complete coverage of both foundational and lesser-known features, when you’re done you’ll be set to start using Airflow for seamless data pipeline development and management. Key Features Framework foundation and best practices Airflow's execution and dependency system Testing Airflow DAGs Running Airflow in production For data-savvy developers, DevOps and data engineers, and system administrators with intermediate Python skills. About the technology Data pipelines are used to extract, transform and load data to and from multiple sources, routing it wherever it’s needed -- whether that’s visualisation tools, business intelligence dashboards, or machine learning models. Airflow streamlines the whole process, giving you one tool for programmatically developing and monitoring batch data pipelines, and integrating all the pieces you use in your data stack. Bas Harenslak and Julian de Ruiter are data engineers with extensive experience using Airflow to develop pipelines for major companies including Heineken, Unilever, and Booking.com. Bas is a committer, and both Bas and Julian are active contributors to Apache Airflow.
£46.93
No Starch Press,US Python Tools For Scientists: An Introduction to
Book SynopsisDoing Science With Python introduces readers to the most popular coding tools for scientific research, such as Anaconda, Spyder, Jupyter Notebooks, and JupyterLab, as well as dozens of important Python libraries for working with data, including NumPy, matplotlib, and pandas. No prior programming experience is required! You'll be guided through setting up a professional coding environment, then get a crash course on programming with Python, and explore the many tools and libraries ideal for working with data, designing visualisations, simulating natural events, and more.Trade Review"Python Tools for Scientists helps people get up and running in Python so that they can start solving their problems right away instead of being daunted by the dizzying array of tools available in the ecosystem. I wish something like this had been available when I first picked up Python as a scientist!" —James Bednar, Director of Custom Services, Anaconda, Inc.“Python has a wealth of scientific computing tools, so how do you decide which ones are right for you? This book cuts through the noise to help you deliver results." —Serdar Yegulalp, InfoWorld"The book [Python Tools for Scientists] by Lee Vaughan is a critical resource for anyone that is new to Python programming and intends to become a Python expert. It covers all of the critical topics in an easily understandable format and it goes deep enough to be helpful in navigating advanced topics. The book is also true to current Software Engineering standards and gives even new developers the tools to jump start their Python career."—Dr. Alec Yasinsac, Department of Computer Science, University of South Alabama"I wish there was a book like this when I started learning Python... [Python Tools for Scientists] is a practical, detailed, hands-on introduction to setting up a local Python workspace and getting started with the basics of Python programming. It was written for scientists, by a scientist who knows what the typical problems are when scientists and engineers start using Python tools in their everyday work. It also introduces the wide variety of packages that can be used in scientific programming and provides guidelines on when to use them. Matplotlib, numpy, and pandas are covered in much more detail - as they should be. The writing and the organization of the material are clear and easy to follow. I have been using Python for many years, but I know I will be using this book both in teaching and research."—Zoltán Sylvester, Senior Research Scientist, University of Texas at AustinTable of ContentsIntroductionPart 1: Setting up for ScienceChapter 1: Installing Anaconda and Launching NavigatorChapter 2: Keeping Organized with Conda EnvironmentsChapter 3: Simple Scripting in Jupyter Qt ConsoleChapter 4: Serious Scripting with SpyderChapter 5: Jupyter Notebook: An Interactive Journal for Computational ResearchChapter 6: JupyterLab: Your Center for SciencePart 2: Python PrimerChapter 7: Integers, Floats, and StringsChapter 8: VariablesChapter 9: The Container Data TypesChapter 10: Flow ControlChapter 11: Functions and ModulesChapter 12: Files and FoldersChapter 13: Object Oriented ProgrammingChapter 14: Documenting your WorkPart 3: The Scientific and Visualization LibrariesChapter 15: The Scientific LibrariesChapter 16: The InfoVis and SciVis Visualization LibrariesChapter 17: The GeoVis LibrariesPart 4: The Essential LibrariesChapter 18: Numpy: Numerical PythonChapter 19: Demystifying MatplotlibChapter 20: Pandas, Seaborn, and Scikit-learnChapter 21: Managing Dates and Times with Python and PandasAppendix A: Answers to the "Test your Knowledge" Challenges
£35.99
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.
£46.50
Pearson Education Python in Excel
a huge range and FREE tracked UK delivery on ALL orders.
£40.84
Pearson Education Quick Start Guide to Large Language Models
Book SynopsisSinan Ozdemir is currently the founder and CTO of LoopGenius and an advisor to several AI companies. Sinan is a former lecturer of Data Science at Johns Hopkins University and the author of multiple textbooks on data science and machine learning. Additionally, he is the founder of the recently acquired Kylie.ai, an enterprise-grade conversational AI platform with RPA capabilities. He holds a master's degree in Pure Mathematics from Johns Hopkins University and is based in San Francisco, CA.
£35.99
Pearson Education (US) C Core Guidelines Explained
Book SynopsisRainer Grimm has worked as a software architect, team lead, and instructor since 1999, and offered seminars on C++, Python, and proprietary software since 2002. He writes regularly on C++, Python, and Haskell, speaks at conferences on programming issues, and blogs weekly in English (modernescpp.com) and German (www.grimm-jaud.de/index.php/blog). Now an independent instructor, he offers seminars on modern C++ and Python. He has authored several books on modern C++, concurrency, and related topics.Table of ContentsList of selected C++ Core Guidelines xiii List of figures xxiii List of tables xxvii Foreword xxix Preface xxxi Acknowledgments xxxvii About the author xxxix Part I: The Guidelines 1 Chapter 1: Introduction 3 Target readership 3 Aim 4 Non-aims 4 Enforcement 4 Structure 4 Major sections 5 Chapter 2: Philosophy 7 Chapter 3: Interfaces 15 The curse of non-const global variables 16 Dependency injection as a cure 18 Making good interfaces 20 Related rules 25 Chapter 4: Functions 27 Function definitions 28 Parameter passing: in and out 32 Parameter passing: ownership semantics 38 Value return semantics 42 Other functions 46 Related rules 52 Chapter 5: Classes and Class Hierarchies 53 Summary rules 54 Concrete types 58 Constructors, assignments, and destructors 59 Class hierarchies 98 Overloading and overloaded operators 117 Unions 126 Related rules 129 Chapter 6: Enumerations 131 General rules 131 Related rules 137 Chapter 7: Resource Management 139 General rules 140 Allocation and deallocation 145 Smart pointers 150 Related rules 164 Chapter 8: Expressions and Statements 165 General 166 Declarations 168 Expressions 186 Statements 199 Arithmetic 204 Related rules 210 Chapter 9: Performance 213 Wrong optimizations 214 Wrong assumptions 214 Enable optimization 218 Related rules 230 Chapter 10: Concurrency 231 General guidelines 232 Concurrency 245 Parallelism 266 Message passing 269 Lock-free programming 273 Related rules 277 Chapter 11: Error Handling 279 Design 281 Implementation 283 If you can't throw 288 Related rules 292 Chapter 12: Constants and Immutability 293 Use const 294 Use constexpr 298 Chapter 13: Templates and Generic Programming 301 Use 302 Interfaces 305 Definition 320 Hierarchies 330 Variadic templates 332 Metaprogramming 336 Other rules 362 Related rules 372 Chapter 14: C-Style Programming 375 Entire source code available 376 Entire source code not available 378 Chapter 15: Source Files 383 Interface and implementation files 384 Namespaces 391 Chapter 16: The Standard Library 397 Containers 398 Text 404 Input and output 411 Related rules 419 Part II: Supporting Sections 421 Chapter 17: Architectural Ideas 423 Chapter 18: Nonrules and Myths 427 Chapter 19: Profiles 437 Pro.typeType safety 438 Pro.boundsBounds safety 439 Pro.lifetimeLifetime safety 439 Chapter 20: Guidelines Support Library 441 Views 441 Ownership pointers 442 Assertions 443 Utilities 443 Part III: Appendixes 445 Appendix A: Enforcing the C++ Core Guidelines 447 Visual Studio 448 clang-tidy 450 Appendix B: Concepts 453 Appendix C: Contracts 457 Index 459
£29.69
Manning Publications Rust in Action
Book SynopsisRust is a new systems programming language that gives you the low-level power of C with the elegance and ease of languages like Ruby and Python. Rust is thread safe, enabling "fearless concurrency". Rust in Action introduces the Rust programming language by exploring numerous systems programming concepts and techniques. You'll be learning Rust by delving into how computers work under the hood. You'll find yourself playing with persistent storage, memory, networking and even tinkering with CPU instructions. The book takes you through using Rust to extend other applications and teaches you tricks to write blindingly fast code. You'll also discover parallel and concurrent programming. · Concurrent and parallel programming Sharing resources with locks or atomic operations Avoiding programming with global state Message passing inside your applications Memory management and garbage collection Readers need intermediate programming skills and familiarity with general computer science concepts, the command line, and networking.
£43.19
Manning Publications Algorithms and Data Structures in Action
Book SynopsisAs a software engineer, you’ll encounter countless programming challenges that initially seem confusing, difficult, or even impossible. Don’t despair! Many of these “new” problems already have well-established solutions. Advanced Algorithms and Data Structures teaches you powerful approaches to a wide range of tricky coding challenges that you can adapt and apply to your own applications. Providing a balanced blend of classic, advanced, and new algorithms, this practical guide upgrades your programming toolbox with new perspectives and hands-on techniques. about the technology Data structures and algorithms are the foundations for how programs store and process information. Choosing the optimal algorithms ensures that your programs are fast, efficient, and reliable. about the book Algorithms and Data Structures in Action expands on the basic algorithms you already know to give you a better selection of solutions to different programming problems. In it, you’ll discover techniques for improving priority queues, efficient caching, clustering data, and more. Each example is fully illustrated with graphics, language agnostic pseudo-code, and code samples in various languages. When you’re done, you will be able to implement advanced and little-known algorithms to deliver better performance from your code. what's inside Improving on basic data structures Efficient caching Nearest neighbour search, including k-d trees and S-trees Full ‘pseudo-code’ and samples in multiple languages about the readerFor programmers with basic or intermediate skills. Written in a language-agnostic manner, no specific language knowledge is required. about the author Marcello La Rocca is a research scientist and a full-stack engineer focused on optimization algorithms, genetic algorithms, machine learning and quantum computing. He has contributed to large-scale web applications at companies like Twitter and Microsoft, has undertaken applied research in both academia and industry, and authored the Neatsort adaptive sorting algorithm.
£43.19
Manning Publications Time Series Forecasting Using Foundation Models
Book SynopsisMarco Peixeiro is a renowned data-science educator known for demystifying complex forecasting techniques. With years developing open-source libraries at Nixtla, Marco brings clarity, practicality, and enthusiasm to every page. He distills cutting-edge research into step-by-step guidance that helps readers deliver accurate forecasts quickly.
£44.99
Pearson Education C How to Program Global Edition
Book SynopsisAbout our authors Paul J. Deitel, CEO and Chief Technical Officer of Deitel & Associates, Inc., is an MIT graduate with 43 years in computing. He is one of the world's most experienced programming-languages trainers, having taught professional courses to software developers since 1992. He has delivered hundreds of programming courses to academic, industry, government and military clients of Deitel & Associates, Inc. internationally, including UCLA, SLB (formerly Schlumberger), 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, Puma, iRobot and many more. Dr. Harvey M. Deitel, Chairman and Chief Strategy Officer of Deitel & Associates, Inc., has 62 years of experience in computing. Dr. Deitel earned B.S. and M.S. degrees in Electrical Engineering from MIT and a Ph.D. in Mathematics from Bosto
£59.84
O'Reilly Media Practical Fraud Prevention
Book SynopsisOrganizations that conduct business online are constantly engaged in a cat-and-mouse game with these invaders. In this practical book, Gilit Saporta and Shoshana Maraney draw on their experience of fraud fighting to provide best practices, methodologies, and tools to help your organization detect and prevent fraud and other malicious activities.
£39.74
Manning Publications OCA Java SE 8 Programmer I Certification Guide
Book Synopsis DESCRIPTION To earn the OCA Java SE 8 Programmer I Certification, readers need to know Java inside and out, and to pass the exam it's good to understand the test itself. This book cracks open the questions, exercises, and expectations readers will face on the OCA exam so they’ll be ready and confident on test day. OCA Java SE 8 Programmer I Certification Guide prepares readers for the 1Z0-808 with complete coverage of all exam topics. The book explores important Java topics and systematically teaches what's required. Each chapter starts with a list of exam objectives mapped to section numbers, followed by sample questions and exercises designed to reinforce key concepts. It provides multiple ways to digest important techniques and concepts, including memorable analogies, diagrams, and flowcharts as well as lots of well-commented code. Along the way readers will also get the scoop on common mistakes and ways to avoid traps and pitfalls. KEY FEATURES 100% coverage of exam topics Hands-on coding examples and exercises Helps readers avoid exam traps and pitfalls Hundreds of sample questions Crib Sheets AUDIENCE Written for developers with a working knowledge of Java who want to earn the OCA Java SE 8 Programmer I Certification. ABOUT THE TECHNOLOGY The Oracle Certified Associate (OCA) Java SE 8 measures day-to-day programming and the ability to handle typical situations found in a variety of projects.
£43.19
Pearson Education Core Java for the Impatient
Book SynopsisCay S. Horstmann is author of Core Java, Volumes I and II, Thirteenth Edition (Pearson, 2025), Modern JavaScript for the Impatient (Addison-Wesley, 2020), and Scala for the Impatient, Third Edition (Addison-Wesley, 2023). He has written more than a dozen other books for professional programmers and computer science students. He is an emeritus professor of computer science at San Jose State University and a Java Champion.
£45.59
Oracle Press Core Java Vol. I Fundamentals
Book SynopsisCay S. Horstmann is author of Modern JavaScript for the Impatient (2020), Core Java(R) for the Impatient, Third Edition (2022), Scala for the Impatient, Second Edition (2016), and Java SE 8 for the Really Impatient (2014), all from Addison-Wesley. He has written more than a dozen books for professional programmers and computer science students. He is an emeritus professor of computer science at San Jose State University and a Java Champion.
£65.54