Programming and scripting languages: general Books

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

Read more less

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

Read more less

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

Read more less

Book SynopsisRyan Stephens is an entrepreneur who has built his career and multiple IT companies around SQL, data, and relational databases. He has shared his knowledge and experience with organizations, students, and IT professionals all over the world. Two of the companies he has co-founded, Perpetual Technologies, Inc. (PTI), and Indy Data Partners, have provided expert database and IT services to large-scale government and commercial clients for more than 25 years. Ryan has authored several books for Pearson, including Sams Teach Yourself SQL in 24 Hours, 6th Edition; some of his books have been translated and published internationally. Additionally, Ryan has worked for large organizations and has consulted within the areas of SQL, database design, database management, and project management. He designed and taught a database management program for Indiana University-Purdue University in Indianapolis and currently teaches online SQL and database classes for Pearson Education. Table of ContentsHour 1: Understanding the Relational Database and SQL Thriving in a Data-Driven World Understanding the Relational Database The Relational Database Continues to Lead the Way Examples and Exercises Summary Q&A Workshop Hour 2: Exploring the Components of the SQL Language SQL Definition and History SQL: The Standard Language SQL Sessions Types of SQL Commands Summary Q&A Workshop Hour 3: Getting to Know Your Data The BIRD Database: Examples and Exercises in This Book How to Talk About the Data Entity Relationship Diagrams Examples and Exercises Summary Q&A Workshop Hour 4: Setting Up Your Database Locating the Files You Need Getting Set Up for Hands-on Exercises List of Data by Table Summary Q&A Workshop Hour 5: Understanding the Basics of Relational (SQL) Database Design Understanding What Database Design Has to Do with SQL The Database Design Process Choosing a Database Design Methodology Using a Simple Process to Think Through the Design of the BIRDS Database Logical Model vs. Physical Design Database Life Cycle Summary Q&A Workshop Hour 6: Defining Entities and Relationships Creating a Data Model Based on Your Data Defining Relationships Employing Referential Integrity Creating an Entity Relationship Summary Q&A Workshop Hour 7: Normalizing Your Database Defining Normalization Exploring the Most Common Normal Forms of the Normalization Process Denormalizing a Database Applying Normalization to Your Database Summary Q&A Workshop Hour 8: Defining Data Structures Defining Data Understanding Basic Data Types Using Data Types in the BIRDS Database Summary Q&A Workshop Hour 9: Creating and Managing Database Objects Database Objects and Schemas Tables: The Primary Storage for Data Integrity Constraints Summary Q&A Workshop Hour 10: Manipulating Data Getting an Overview of Data Manipulation Populating Tables with New Data Updating Existing Data Deleting Data from Tables Summary Q&A Workshop Hour 11: Managing Database Transactions Defining Transactions Controlling Transactions Dealing with Poor Transactional Control Summary Q&A Workshop Hour 12: Introduction to Database Queries Using the SELECT Statement Case Sensitivity Fundamentals of Query Writing Summary Q&A Workshop Hour 13: Using Operators to Categorize Data Defining an Operator in SQL Using Comparison Operators Using Logical Operators Using Conjunctive Operators Using Negative Operators Using Arithmetic Operators Summary Q&A Workshop Hour 14: Joining Tables in Queries Selecting Data from Multiple Tables Understanding Joins Join Considerations Summary Q&A Workshop Hour 15: Restructuring the Appearance of Data ANSI Character Functions Common Character Functions Miscellaneous Character Functions Mathematical Functions Conversion Functions Combined Character Functions Summary Q&A Workshop Hour 16: Understanding Dates and Times Understanding How a Date Is Stored Using Date Functions Converting Dates Summary Q&A Workshop Hour 17: Summarizing Data Results from a Query Using Aggregate Functions Grouping Data Using the GROUP BY Clause Understanding the Difference Between GROUP BY and ORDER BY Using CUBE and ROLLUP Expressions Using the HAVING Clause Summary Q&A Workshop Hour 18: Using Subqueries to Define Unknown Data Defining Subqueries Embedded Subqueries Using Correlated Subqueries Summary Q&A Workshop Hour 19: Combining Multiple Queries into One Differentiating Single Queries and Compound Queries Using Compound Query Operators Using ORDER BY with a Compound Query Using GROUP BY with a Compound Query Retrieving Accurate Data Summary Q&A Workshop Hour 20: Creating and Using Views and Synonyms Defining Views Creating Views Updating Data Through a View Dropping a View Understanding the Performance Impact of Nested Views Defining Synonyms Summary Q&A Workshop Hour 21: Managing Database Users and Security Managing Users in the Database Understanding the Management Process Maximizing Tools Utilized by Database Users Understanding Database Security Assigning Privileges Controlling User Access Controlling Privileges Through Roles Summary Q&A Workshop Hour 22: Using Indexes to Improve Performance Defining an Index Understanding How Indexes Work Using the CREATE INDEX Command Identifying Types of Indexes Knowing When to Consider Using an Index Knowing When to Avoid Indexes Altering an Index Dropping an Index Summary Q&A Workshop Hour 23: Improving Database Performance Defining SQL Statement Tuning Comparing Database Tuning and SQL Statement Tuning Formatting Your SQL Statement Running Full Table Scans Identifying Other Performance Considerations Using Cost-Based Optimization Summary Q&A Workshop Hour 24: Working with the System Catalog Defining the System Catalog Creating the System Catalog Determining What Is Contained in the System Catalog Identifying System Catalog Tables by Implementation Querying the System Catalog Updating System Catalog Objects Summary Q&A Workshop Hour 25: Bonus Workshop for the Road The BIRDS Database Predators of Birds Photographers of Birds Creating the New Tables Workshop: Describing Your Tables Workshop: Basic Queries Workshop: Adding Tables Workshop: Manipulating Data Workshop: Joining Tables Workshop: Comparison Operators Workshop: Logical Operators Workshop: Conjunctive Operators Workshop: Arithmetic Operators Workshop: Character Functions Workshop: Aggregating Data Workshop: GROUP BY and HAVING Workshop: Composite Queries Workshop: Creating Tables from Existing Tables Workshop: Inserting Data into a Table from Another Table Workshop: Creating Views Workshop: Embedding Subqueries Workshop: Creating Views from Subqueries Workshop: Generating SQL Code from a SQL Statement Summary Workshop Appendix A: Common SQL Commands SQL Statements SQL Query Clauses Appendix B: Popular Vendor RDBMS Implementations Installing the Oracle Database Software Used for Examples and Hands-On Exercises Appendix C: Answers to Quizzes and Exercises Hour 1, "Understanding the Relational Database and SQL" Hour 2, "Exploring the Components of the SQL Language" Hour 3, "Getting to Know Your Data" Hour 4, "Setting Up Your Database" Hour 5, "Understanding the Basics of Relational (SQL) Database Design" Hour 6, "Defining Entities and Relationships" Hour 7, "Normalizing Your Database" Hour 8, "Defining Data Structures" Hour 9, "Creating and Managing Database Objects" Hour 10, "Manipulating Data" Hour 11, "Managing Database Transactions" Hour 12, "Introduction to Database Queries" Hour 13, "Using Operators to Categorize Data" Hour 14, "Joining Tables in Queries" Hour 15, "Restructuring the Appearance of Data" Hour 16, "Understanding Dates and Times" Hour 17, "Summarizing Data Results from a Query" Hour 18, "Using Subqueries to Define Unknown Data" Hour 19, "Combining Multiple Queries into One" Hour 20, "Creating and Using Views and Synonyms" Hour 21, "Managing Database Users and Security" Hour 22, "Using Indexes to Improve Performance" Hour 23, "Improving Database Performance" Hour 24, "Working with the System Catalog" Hour 25, "Bonus Workshop for the Road" 9780137543120 TOC 11/8/2021

Read more less

Book SynopsisJames W. Cooper holds a PhD in chemistry and worked in academia, for the scientific instrument industry, and for IBM for 25 years, primarily as a computer scientist at IBM's Thomas J. Watson Research Center. Now retired, he is the author of 20 books, including 3 on design patterns in various languages. His most recent books are Flameout: The Rise and Fall of IBM Instruments (2019) and Food Myths Debunked (2014). James holds 11 patents and has written 60 columns for JavaPro Magazine. He has also written nearly 1,000 columns for the now vanished Examiner.com on foods and chemistry, and he currently writes his own blog: FoodScienceInstitute.com. Recently, he has written columns on Python for Medium.com and Substack. He is also involved in local theater groups and is the treasurer for Troupers Light Opera, where he performs regularly.Table of ContentsPreface xxi PART I: INTRODUCTION 1 The tkinter Library 2 GitHub 2 Chapter 1 Introduction to Objects 5 The Class __init__ Method 6 Variables Inside a Class 6 Collections of Classes 7 Inheritance 8 Derived Classes Created with Revised Methods 8 Multiple Inheritance 8 Drawing a Rectangle and a Square 10 Visibility of Variables 12 Properties 13 Local Variables 13 Types in Python 13 Summary 14 Programs on GitHub 15 Chapter 2 Visual Programming in Python 17 Importing Fewer Names 19 Creating an Object-Oriented Version 19 Using Message Boxes 21 Using File Dialogs 22 Understanding Options for the Pack Layout Manager 23 Using the ttk Libraries 24 Responding to User Input 25 Adding Two Numbers 26 Catching the Error 26 Applying Colors in tkinter 27 Creating Radio Buttons 27 Using a Class-Level Variable 30 Communicating Between Classes 30 Using the Grid Layout 30 Creating Checkbuttons 32 Disabling Check Boxes 32 Adding Menus to Windows 35 Using the LabelFrame 39 Moving On 40 Examples on GitHub 40 Chapter 3 Visual Programming of Tables of Data 41 Creating a Listbox 42 Displaying the State Data 44 Using a Combobox 46 The Treeview Widget 47 Inserting Tree Nodes 50 Moving On 51 Example Code on GitHub 51 Chapter 4 What Are Design Patterns? 53 Defining Design Patterns 54 The Learning Process 55 Notes on Object-Oriented Approaches 56 Python Design Patterns 57 References 57 PART II: CREATIONAL PATTERNS 59 Chapter 5 The Factory Pattern 61 How a Factory Works 61 Sample Code 62 The Two Subclasses 62 Building the Simple Factory 63 Using the Factory 63 A Simple GUI 64 Factory Patterns in Math Computation 65 Programs on GitHub 65 Thought Questions 66 Chapter 6 The Factory Method Pattern 67 The Swimmer Class 68 The Event Classes 69 Straight Seeding 70 Circle Seeding 71 Our Seeding Program 72 Other Factories 74 When to Use a Factory Method 74 Programs on GitHub 74 Chapter 7 The Abstract Factory Pattern 75 A GardenMaker Factory 75 How the User Interface Works 77 Consequences of the Abstract Factory Pattern 77 Thought Questions 78 Code on GitHub 78 Chapter 8 The Singleton Pattern 79 Throwing the Exception 80 Creating an Instance of the Class 80 Static Classes As Singleton Patterns 81 Finding the Singletons in a Large Program 81 Other Consequences of the Singleton Pattern 82 Sample Code on GitHub 82 Chapter 9 The Builder Pattern 83 An Investment Tracker 84 Calling the Builders 86 The List Box Builder 87 The Checkbox Builder 88 Displaying the Selected Securities 89 Consequences of the Builder Pattern 89 Thought Questions 89 Sample Code on GitHub 89 Chapter 10 The Prototype Pattern 91 Cloning in Python 91 Using the Prototype 92 Consequences of the Prototype Pattern 94 Sample Code on GitHub 94 Chapter 11 Summary of Creational Patterns 95 PART III: STRUCTURAL PATTERNS 97 Chapter 12 The Adapter Pattern 99 Moving Data Between Lists 99 Making an Adapter 101 The Class Adapter 103 Two-Way Adapters 103 Pluggable Adapters 103 Programs on GitHub 103 Chapter 13 The Bridge Pattern 105 Creating the User Interface 107 Extending the Bridge 108 Consequences of the Bridge Pattern 109 Programs on GitHub 110 Chapter 14 The Composite Pattern 111 An Implementation of a Composite 112 Salary Computation 112 The Employee Classes 112 The Boss Class 113 Building the Employee Tree 114 Printing the Employee Tree 114 Creating a Treeview of the Composite 116 Using Doubly Linked Lists 117 Consequences of the Composite Pattern 118 A Simple Composite 119 Other Implementation Issues 119 Dealing with Recursive Calls 119 Ordering Components 120 Caching Results 120 Programs on GitHub 120 Chapter 15 The Decorator Pattern 121 Decorating a Button 121 Using a Decorator 122 Using Nonvisual Decorators 123 Decorated Code 124 The dataclass Decorator 125 Using dataclass with Default Values 126 Decorators, Adapters, and Composites 126 Consequences of the Decorator Pattern 126 Programs on GitHub 127 Chapter 16 The Facade Pattern 129 Building the Façade Classes 131 Creating Databases and Tables 135 Using the SQLite Version 136 Consequences of the Façade 137 Programs on GitHub 137 Notes on MySQL 137 Using SQLite 138 References 138 Chapter 17 The Flyweight Pattern 139 What Are Flyweights? 139 Example Code 140 Selecting a Folder 142 Copy-on-Write Objects 143 Program on GitHub 143 Chapter 18 The Proxy Pattern 145 Using the Pillow Image Library 145 Displaying an Image Using PIL 146 Using Threads to Handle Image Loading 146 Logging from Threads 149 Copy-on-Write 149 Comparing Related Patterns 149 Programs on GitHub 150 Chapter 19 Summary of Structural Patterns 151 PART IV: BEHAVIORAL PATTERNS 153 Chapter 20 Chain of Responsibility Pattern 155 When to Use the Chain 156 Sample Code 156 The Listboxes 159 Programming a Help System 160 Receiving the Help Command 161 The First Case 162 A Chain or a Tree? 163 Kinds of Requests 164 Consequences of the Chain of Responsibility 164 Programs on GitHub 165 Chapter 21 The Command Pattern 167 When to Use the Command Pattern 167 Command Objects 168 A Keyboard Example 168 Calling the Command Objects 170 Building Command Objects 171 The Command Pattern 172 Consequences of the Command Pattern 172 Providing the Undo Function 172 Creating the Red and Blue Buttons 175 Undoing the Lines 175 Summary 176 References 176 Programs on GitHub 176 Chapter 22 The Interpreter Pattern 177 When to Use an Interpreter 177 Where the Pattern Can Be Helpful 177 A Simple Report Example 178 Interpreting the Language 179 How Parsing Works 180 Sorting Using attrgetter() 181 The Print Verb 182 The Console Interface 182 The User Interface 183 Consequences of the Interpreter Pattern 184 Programs on GitHub 185 Chapter 23 The Iterator Pattern 187 Why We Use Iterators 187 Iterators in Python 187 A Fibonacci Iterator 188 Getting the Iterator 189 Filtered Iterators 189 The Iterator Generator 191 A Fibonacci Iterator 191 Generators in Classes 192 Consequences of the Iterator Pattern 192 Programs on GitHub 193 Chapter 24 The Mediator Pattern 195 An Example System 195 Interactions Between Controls 197 Sample Code 198 Mediators and Command Objects 199 Consequences of the Mediator Pattern 200 Single Interface Mediators 200 Programs on GitHub 201 Chapter 25 The Memento Pattern 203 When to Use a Memento 203 Sample Code 204 Consequences of the Memento Pattern 209 Programs on GitHub 209 Chapter 26 The Observer Pattern 211 Example Program for Watching Colors Change 212 The Message to the Media 215 Consequences of the Observer Pattern 215 Programs on GitHub 215 Chapter 27 The State Pattern 217 Sample Code 217 Switching Between States 221 How the Mediator Interacts with the State State Transitions 224 Programs on GitHub 224 Chapter 28 The Strategy Pattern 225 Why We Use the Strategy Pattern 225 Sample Code 226 The Context 227 The Program Commands 227 The Line and Bar Graph Strategies 228 Consequences of the Strategy Pattern 230 Programs on GitHub 231 Chapter 29 The Template Pattern 233 Why We Use Template Patterns 233 Kinds of Methods in a Template Class 234 Sample Code 234 Drawing a Standard Triangle 235 Drawing an Isosceles Triangle 236 The Triangle Drawing Program 237 Templates and Callbacks 238 Summary and Consequences 238 Example Code on GitHub 238 Chapter 30 The Visitor Pattern 239 When to Use the Visitor Pattern 239 Working with the Visitor Pattern 241 Sample Code 241 Visiting Each Class 242 Visiting Several Classes 242 Bosses Are Employees, Too 243 Double Dispatching 245 Traversing a Series of Classes 245 Consequences of the Visitor Pattern 245 Example Code on GitHub 245 PART V: A BRIEF INTRODUCTION TO PYTHON 247 Chapter 31 Variables and Syntax in Python 249 Data Types 250 Numeric Constants 250 Strings 250 Character Constants 251 Variables 252 Complex Numbers 253 Integer Division 253 Multiple Equal Signs for Initialization 254 A Simple Python Program 254 Compiling and Running This Program 255 Arithmetic Operators 255 Bitwise Operators 255 Combined Arithmetic and Assignment Statements 256 Comparison Operators 256 The input Statement 257 PEP 8 Standards 258 Variable and Function Names 258 Constants 258 Class Names 258 Indentation and Spacing 259 Comments 259 Docstrings 259 String Methods 260 Examples on GitHub 261 Chapter 32 Making Decisions in Python 263 elif is “else if” 263 Combining Conditions 264 The Most Common Mistake 264 Looping Statements in Python 265 The for Loop and Lists 265 Using range in if Statements 266 Using break and continue 266 The continue Statement 267 Python Line Length 267 The print Function 267 Formatting Numbers 268 C and Java Style Formatting 269 The format string Function 269 f-string Formatting 269 Comma-Separated Numbers 270 Strings 270 Formatting Dates 271 Using the Python match Function 271 Pattern Matching 272 Reference 273 Moving On 273 Sample Code on GitHub 273 Chapter 33 Development Environments 275 IDLE 275 Thonny 275 PyCharm 276 Visual Studio 276 Other Development Environments 276 LiClipse 276 Jupyter Notebook 277 Google Colaboratory 277 Anaconda 277 Wing 278 Command-Line Execution 278 CPython, IPython, and Jython 278 Chapter 34 Python Collections and Files 279 Slicing 279 Slicing Strings 280 Negative Indexes 281 String Prefix and Suffix Removal 281 Changing List Contents 281 Copying a List 282 Reading Files 282 Using the with Loop 283 Handling Exceptions 284 Using Dictionaries 284 Combining Dictionaries 286 Using Tuples 286 Using Sets 287 Using the map Function 287 Writing a Complete Program 288 Impenetrable Coding 288 Using List Comprehension 289 Sample Programs on GitHub 290 Chapter 35 Functions 291 Returning a Tuple 292 Where Does the Program Start? 292 Summary 293 Programs on GitHub 293 Appendix A Running Python Programs 295 If You Have Python Installed 295 Shortcuts 295 Creating an Executable Python Program 296 Command-Line Arguments 297 Index 299

Read more less

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

Read more less

Book SynopsisLarry Rockoff has been involved with SQL and business intelligence development for many years. His main area of interest is in using reporting tools to explore and analyze data in complex databases. He holds an MBA from the University of Chicago and a BFA from the University of Illinois.   In addition to writing about SQL, he has also published books on MicrosofTable of Contents1 Relational Databases and SQL 2 Basic Data Retrieval 3 Calculated Fields and Aliases 4 Using Functions 5 Sorting Data 6 Selection Criteria 7 Boolean Logic 8 Conditional Logic 9 Summarizing Data 10 Subtotals and Crosstabs 11 Inner Joins 12 Outer Joins 13 Self Joins and Views 14 Subqueries 15 Set Logic 16 Stored Procedures and Parameters 17 Modifying Data 18 Maintaining Tables 19 Principles of Database Design 20 Strategies for Using ExcelAppendix A: Getting Started with Microsoft SQL Server Appendix B: Getting Started with MySQL Appendix C: Getting Started with Oracle

Read more less

Book SynopsisDonis Marshall has more than twenty years of experience in designing and building enterprise software with Microsoft technologies for leading companies in multiple industries. An endorsed trainer for Microsoft Global Learning Services, he has trained Microsoft developers and engineers for many years. His Microsoft Press books include Solid Code and Programming Microsoft Visual C#. Table of ContentsChapter 1: Introduction to Rust 1 Introduction 1 Features 4 Rust Terminology 6 Tools 7 Summary 8 Chapter 2: Getting Started 9 Preliminaries 9 Rust and Windows 10 Installing Rust 10 Advanced Rustup 11 “Hello, World” 11 Compile and Run 12 Cargo 13 Library 15 Comments 17 Published Crates 20 Main Function 21 Command-Line Arguments 22 Summary 23 Chapter 3: Variables 25 Terminology 25 Variables 26 Primitives 26 Integer Types 27 Overflow 28 Notations 29 Floating Point Types 30 Floating Point Constants 30 Infinity 31 NaN 31 Numeric Ranges 32 Casting 33 Boolean Types 34 Char 34 Pointers 35 Operators 37 Summary 40 Chapter 4: Strings 41 Str 41 String 42 Length 43 Extending a String 44 Capacity 45 Accessing a String Value 46 String Characters 48 Deref Coercion 48 Formatted String 49 Helpful Functions 49 Summary 52 Chapter 5: Console 53 Print 53 Positional Arguments 54 Variable Arguments 55 Named Arguments 55 Padding, Alignment, and Precision 56 Base 58 Developer Facing 59 Write! Macro 60 Display Trait 60 Debug Trait 62 Format! Macro 63 Console Read and Write 63 Summary 64 Chapter 6: Control Flow 65 The if Expression 65 The while Expression 68 The for Expression 70 The loop Expression 73 The Iterator Trait 76 Summary 78 Chapter 7: Collections 79 Arrays 79 Vectors 86 HashMap 91 Summary 95 Chapter 8: Ownership 97 Stack and Heap Memory 98 Shallow versus Deep Copy 98 Car Analogy 99 Move Semantics 99 Borrow 101 Copy Semantics 101 Clone Trait 102 Copy Trait 103 Clone Trait 104 Summary 105 Chapter 9: Lifetimes 107 Introduction to Lifetimes 108 Function Headers and Lifetimes 109 Lifetime Annotation 111 Lifetime Elision 112 Complex Lifetimes 113 Sharing a Lifetime 114 Static Lifetimes 115 Structs and Lifetimes 116 Methods and Lifetimes 116 Subtyping Lifetimes 118 Anonymous Lifetimes 120 Generics and Lifetimes 121 Summary 121 Chapter 10: References 123 Declaration 124 Borrowing 124 Dereferencing 125 Comparing References 126 Reference Notation 127 Reference to Reference 128 Mutability 129 Limits to Multiple Borrowers 130 Summary 131 Chapter 11: Functions 133 Function Definition 133 Parameters 134 Function Return 136 Const Functions 138 Nested Functions 139 Function Pointers 140 Function Aliases 142 Summary 143 Chapter 12: Error Handling 145 Handling Error Handling 145 The Result Enum 146 The Option Enum 147 Panics 148 Unwrapping 154 Match Pattern for Result and Option 156 Map 158 Rich Errors 160 Custom Errors 161 Summary 163 Chapter 13: Structures 165 Alternate Initialization 167 Move Semantics 169 Mutability 170 Methods 170 Self 172 Associated Functions 173 Impl Blocks 174 Operator Overloading 175 Tuple Struct 179 Summary 180 Chapter 14: Generics 181 Generic Functions 182 Bounds 186 The where Clause 188 Structs 190 Associated Functions 194 Enums 195 Generic Traits 197 Explicit Specialization 200 Summary 205 Chapter 15: Patterns 207 Let Statement 207 Wildcards 208 Complex Patterns 209 Ownership 210 Irrefutable 212 Ranges 213 Multiple Patterns 214 Control Flow 215 Structs 216 Functions 219 Match Expressions 220 Match Guards 224 Summary 227 Chapter 16: Closures 229 “Hello, World” 229 Closure Syntax 230 Closed Over 231 Closures as Function Arguments 233 Closures as Function Return Values 234 Implementation of Closures 235 Matrix Example 242 Summary 244 Chapter 17: Traits 245 Trait Definition 245 Default Functions 248 Marker Trait 249 Associated Functions 249 Associated Types 251 Extension Methods 253 Fully Qualified Syntax 254 Supertraits 257 Static Dispatch 260 Dynamic Dispatch 262 Enums and Traits 263 Summary 265 Chapter 18: Threads 1 267 Synchronous Function Calls 268 Threads 269 The Thread Type 273 Processor Time 274 Builder 275 Communicating Sequential Process 276 Asynchronous Channel 277 Synchronous Channel 279 Rendezvous Channel 280 The try Methods 281 Store Example 286 Summary 290 Chapter 19: Threads 2 291 Mutex 291 Nonscoped Mutex 294 Mutex Poisoning 296 Reader-Writer Lock 297 Condition Variables 299 Atomic Operations 301 Summary 305 Chapter 20: Memory 307 Stacks 307 Static Values 309 The Heap 310 Interior Mutability 312 RefCell 316 OnceCell 318 Summary 319 Chapter 21: Macros 321 Tokens 322 Declarative Macros 323 Repetition 325 Multiple Macro Matchers 327 Procedural Macros 328 Derive Macros 329 Attribute Macros 332 Function-Like Macros 334 Summary 335 Chapter 22: Interoperability 337 Foreign Function Interface 337 Basic Example 339 Libc Crate 341 Structs 342 Bindgen 346 C Calling Rust Functions 347 Cbindgen 348 Summary 351 Chapter 23: Modules 353 Module Items 354 Module Files 358 The path Attribute 360 Functions and Modules 361 The crate, super, and self Keywords 362 Legacy Model 363 Summary 365 Index 367

Read more less

Book SynopsisMark Bates is co-founder and instructor at Gopher Guides, the industry leader for Go training, consulting, and conference workshops. Since 2000, he has worked with some of the world's largest, most innovative companies, including Apple, Uber, and Visa. Mark discovered Go in 2013 and has attended GopherCon and hosted their lightning talks. He has spoken at conferences around the world and is a regular on the Go Time podcast. Cory LaNou, Gopher Guides cofounder and instructor, is a full stack technologist who has specialized in start-ups for the last 20 years. Cory has deep ties to the Go community, having started one of the very first Go meetups in the world, Denver Gophers. Using his real world experience from working on projects such as InfluxDB, a highly scalable database written in Go, he has published numerous practical Go training courses and articles.Table of ContentsForeword xxiPreface xxiiiAcknowledgments xxxiAbout the Authors xxxv Chapter 1: Modules, Packages, and Dependencies 1Modules 1Packages 4Folders, Files, and Organization 6Importing Packages and Modules 13Dependencies 16Summary 25 Chapter 2: Go Language Basics 27Go Language Overview 27Numbers 31Strings 35UTF-8 37Variables 40Constants 48Naming Identifiers 51Printing and Formatting 57Summary 75 Chapter 3: Arrays, Slices, and Iteration 77List Types: Arrays and Slices 77How Slices Work 90Iteration 104Summary 110 Chapter 4: Maps and Control Structures 111Maps 111If Statements 129Switch Statements 135Summary 140 Chapter 5: Functions 141Function Definitions 141Variadic Arguments 151Deferring Function Calls 156Init 162Summary 166 Chapter 6: Structs, Methods, and Pointers 167Structs 167Methods 176Pointers 182Nil Receivers 191Summary 193 Chapter 7: Testing 195Testing Basics 195Code Coverage 202Table Driven Testing 206Running Tests 213Test Helpers 222Summary 229 Chapter 8: Interfaces 231Concrete Types versus Interfaces 231Explicit Interface Implementation 233Implicit Interface Implementation 234Before Interfaces 235Using Interfaces 237Implementing io.Writer 239Multiple Interfaces 241Asserting Interface Implementation 241The Empty Interface 242Defining Interfaces 243Embedding Interfaces 249Type Assertion 250Assertions through Switch 252Using Assertions 255Summary 257 Chapter 9: Errors 259Errors as Values 259Panic 264Don't Panic 273Custom Errors 289Wrapping and Unwrapping Errors 294Errors As/Is 301Stack Traces 307Summary 309 Chapter 10: Generics 311What Are Generics? 311Summary 334 Chapter 11: Channels 335Concurrency and Parallelism 335Go's Concurrency Model 338Communicating with Channels 342Unidirectional Channels 351Closing Channels 352Buffered Channels 358Capturing System Signals with Channels 363Summary 371 Chapter 12: Context 373The Context Interface 374Context Rules 380Context Nodal Hierarchy 381Context Values 384Problems with String Keys 388Securing Context Keys and Values 393Cancellation Propagation with Contexts 396Timeouts and Deadlines 405Context Errors 408Listening for System Signals with Context 411Summary 416 Chapter 13: Synchronization 419Waiting for Goroutines with a WaitGroup 419Error Management with Error Groups 433Data Races 443Synchronizing Access with a Mutex 447Performing Tasks Only Once 459Summary 466 Chapter 14: Working with Files 467Directory Entries and File Information 467Walking Directories 473Skipping Directories and Files 477Creating Directories and Subdirectories 481File Path Helpers 484Creating Multiple Directories 489Creating Files 492Fixing the Walk Tests 497Appending to Files 500Reading Files 503Beware of Windows 505The FS Package 506Using the FS Interface 510Mocking a File System 513Embedding Files 517Summary 522 Index 523

Read more less

Book SynopsisKhalid A. Mughal is associate professor (emeritus) in the Department of Informatics, University of Bergen, Norway. During his extensive career, he has designed and implemented many courses on Java, object-oriented system development, web application development, software security, and compiler techniques. He has also given seminars for the IT industry. He is the principal author of several books on Java. Vasily A. Strelnikov is a senior principal Oracle Cloud Infrastructure solutions specialist at Oracle. Strelnikov's specialties are large-scale system design and integration using Java. He has created training courses for Java and Java EE. He co-created the OCP certification exam and has developed official Oracle University training videos for it.

Read more less

Book SynopsisJohn Capobianco has a dynamic and multifaceted career in IT and networking, marked by significant contributions to both the public and private sectors. Beginning his journey in the field as an aluminum factory worker, Capobianco's resilience and dedication propelled him through college, earning a diploma as a Computer Programmer Analyst from St. Lawrence College. This initial phase set the foundation for a career underpinned by continuous learning and achievement, evident from his array of certifications, including multiple Cisco certifications as well as Microsoft certification.   Transitioning from his early educational accomplishments, Capobianco's professional life has spanned over two decades, featuring roles that showcased his technical prowess and strategic vision. His work has significantly impacted both the public and private sectors, including notable positions at the Parliament of Canada, where he served as a Senior IT Planner and Integ

Read more less

Book SynopsisMichael Hartl created the legendary Ruby on Rails Tutorial that helped jumpstart thousands of web development careers. A cofounder and principal author at Learn Enough, Hartl previously earned a Ph.D. in physics at the California Institute of Technology (Caltech), where he received a Lifetime Achievement Award for Excellence in Teaching. He is also an alumnus of Harvard University and the world-renowned Y Combinator entrepreneur program.Trade ReviewPraise for Michael Hartl's Books and Videos on Ruby on Rails "My former company (CD Baby) was one of the first to loudly switch to Ruby on Rails, and then even more loudly switch back to PHP. (Google me to read about the drama.) This book by Michael Hartl came so highly recommended that I had to try it, and the Ruby on RailsTM Tutorial is what I used to switch back to Rails again."--From the Foreword by Derek Sivers (sivers.org)Formerly: founder of CD Baby; Currently: founder of Thoughts Ltd. "I started working on a project but didn't quite understand some rails concepts. Needed a good tutorial and found lots of recommendations for @mhartl's rails tutorial . . . and man it's so good. The hype def matches the product."--Pratik Tamang, https://twitter.com/codingkrazy "The rails tutorial by @mhartl is the best web dev resource ever written."--Daniel Gamboa, Product Manager, Figment "My first programming book was the Ruby on Rails Tutorial from @mhartl. The best part was it taught me general skills to be an effective developer."--Jack Gray, staknine.com "Michael Hartl's Rails Tutorial book is the #1 (and only, in my opinion) place to start when it comes to books about learning Rails. . . . It's an amazing piece of work and, unusually, walks you through building a Rails app from start to finish with testing. If you want to read just one book and feel like a Rails master by the end of it, pick the Ruby on RailsTM Tutorial."--Peter Cooper, editor, Ruby Inside "Michael Hartl's Ruby on RailsTM Tutorial seamlessly taught me about not only Ruby on Rails, but also the underlying Ruby language, HTML, CSS, a bit of JavaScript, and even some SQL--but most importantly it showed me how to build a web application (Twitter) in a short amount of time."--Mattan Griffel, cofounder & CEO of One Month "Although I'm a Python/Django developer by trade, I can't stress enough how much this book has helped me. As an undergraduate, completely detached from industry, this book showed me how to use version control, how to write tests, and, most importantly--despite the steep learning curve for setting up and getting stuff running--how the end result of perseverance is extremely gratifying. It made me fall in love with technology all over again. This is the book I direct all my friends to who want to start learning programming/building stuff. Thank you, Michael!"--Prakhar Srivastav, software engineer, Xcite.com, Kuwait "It has to be the best-written book of its type I've ever seen, and I can't recommend it enough."--Daniel Hollands, administrator of Birmingham.IO "For those wanting to learn Ruby on Rails, Hartl's Ruby on RailsTM Tutorial is (in my opinion) the best way to do it."--David Young, software developer and author at deepinthecode.com "This is a great tutorial for a lot of reasons, because aside from just teaching Rails, Hartl is also teaching good development practices."--Michael Denomy, full-stack web developer "Without a doubt, the best way I learned Ruby on Rails was by building an actual working app. I used Michael Hartl's Ruby on RailsTM Tutorial, which showed me how to get a very basic Twitter-like app up and running from scratch. I cannot recommend this tutorial enough; getting something up and going fast was key; it beats memorization by a mile."--James Fend, serial entrepreneur, JamesFend.com "The book gives you the theory and practice, while the videos focus on showing you in person how it's done. Highly recommended combo."--Antonio Cangiano, software engineer, IBM "The author is clearly an expert at the Ruby language and the Rails framework, but more than that, he is a working software engineer who introduces best practices throughout the text."--Gregory Charles, principal software developer at Fairway TechnologiesTable of ContentsForeword xviiPreface xixAcknowledgments xxvAbout the Author xxvii Chapter 1: From Zero to Deploy 11.1 Up and Running 51.2 The First Application 141.3 Version Control with Git 351.4 Deploying 521.5 Conclusion 611.6 Conventions Used in This Book 62 Chapter 2: A Toy App 652.1 Planning the Application 662.2 The Users Resource 712.3 The Microposts Resource 872.4 Conclusion 104 Chapter 3: Mostly Static Pages 1073.1 Sample App Setup 1073.2 Static Pages 1153.3 Getting Started with Testing 1263.4 Slightly Dynamic Pages 1353.5 Conclusion 1523.6 Advanced Testing Setup 153 Chapter 4: Rails-Flavored Ruby 1594.1 Motivation 1594.2 Strings and Methods 1654.3 Other Data Structures 1774.4 Ruby Classes 1924.5 Conclusion 204 Chapter 5: Filling in the Layout 2075.1 Adding Some Structure 2075.2 Sass and the Asset Pipeline 2325.3 Layout Links 2425.4 User Signup: A First Step 2555.5 Conclusion 260 Chapter 6: Modeling Users 2636.1 User Model 2646.2 User Validations 2796.3 Adding a Secure Password 3036.4 Conclusion 313 Chapter 7: Sign Up 3157.1 Showing Users 3167.2 Signup Form 3377.3 Unsuccessful Signups 3467.4 Successful Signups 3617.5 Professional-Grade Deployment 3747.6 Conclusion 380 Chapter 8: Basic Login 3818.1 Sessions 3818.2 Logging In 3988.3 Logging Out 4378.4 Conclusion 443 Chapter 9: Advanced Login 4459.1 Remember Me 4459.2 "Remember Me" Checkbox 4709.3 Remember Tests 4769.4 Conclusion 489 Chapter 10: Updating, Showing, and Deleting Users 49310.1 Updating Users 49310.2 Authorization 50910.3 Showing All Users 52610.4 Deleting Users 54410.5 Conclusion 556 Chapter 11: Account Activation 55911.1 Account Activations Resource 56011.2 Account Activation Emails 56811.3 Activating the Account 58511.4 Email in Production 61011.5 Conclusion 619 Chapter 12: Password Reset 62112.1 Password Resets Resource 62312.2 Password Reset Emails 63412.3 Resetting the Password 64112.4 Email in Production (Take 2) 65812.5 Conclusion 65912.6 Proof of Expiration Comparison 661 Chapter 13: User Microposts 66313.1 A Micropost Model 66313.2 Showing Microposts 67913.3 Manipulating Microposts 69313.4 Micropost Images 72613.5 Conclusion 752 Chapter 14: Following Users 75514.1 The Relationship Model 75614.2 A Web Interface for Following Users 77414.3 The Status Feed 80514.4 Conclusion 821 Index 825

Read more less

Book SynopsisMichael Hartl created the legendary Ruby on Rails Tutorial that helped jumpstart thousands of web development careers. A cofounder and principal author at Learn Enough, Hartl previously earned a Ph.D. in physics at the California Institute of Technology (Caltech), where he received a Lifetime Achievement Award for Excellence in Teaching. He is also an alumnus Harvard University and the world-renowned Y Combinator entrepreneur program.Trade Review"Just started the #100DaysOfCode journey. Today marks day 1. I have completed @mhartl's great Ruby tutorial at @LearnEnough and am looking forward to starting on Ruby on Rails from tomorrow. Onwards and upwards."--Optimize Prime (@_optimize), Twitter post "Ruby and Sinatra and Heroku, oh my! Almost done with this live web application. It may be a simple palindrome app, but it's also simply exciting! #100DaysOfCode #ruby @LearnEnough #ABC #AlwaysBeCoding #sinatra #heroku"--Tonia Del Priore (@toninjaa), Twitter post; Software Engineer for a FinTech Startup for 3+ years "I have nothing but fantastic things to say about @LearnEnough courses. I am just about finished with the #javascript course. I must say, the videos are mandatory because @mhartl will play the novice and share in the joy of having something you wrote actually work!"--Claudia Vizena "I must say, this Learn Enough series is a masterpiece of education. Thank you for this incredible work!"--Michael King "I want to thank you for the amazing job you have done with the tutorials. They are likely the best tutorials I have ever read."--Pedro IatzkyTable of ContentsPreface xiiiAcknowledgments xviiAbout the Author xix Chapter 1: Hello, World! 11.1 Introduction to Python 61.2 Python in a REPL 111.3 Python in a File 131.4 Python in a Shell Script 161.5 Python in a Web Browser 18 Chapter 2: Strings 352.1 String Basics 352.2 Concatenation and Interpolation 382.3 Printing 442.4 Length, Booleans, and Control Flow 462.5 Methods 562.6 String Iteration 62 Chapter 3: Lists 693.1 Splitting 693.2 List Access 713.3 List Slicing 743.4 More List Techniques 773.5 List Iteration 833.6 Tuples and Sets 86 Chapter 4: Other Native Objects 914.1 Math 914.2 Times and Datetimes 974.3 Regular Expressions 1034.4 Dictionaries 1094.5 Application: Unique Words 115 Chapter 5: Functions and Iterators 1215.1 Function Definitions 1215.2 Functions in a File 1305.3 Iterators 138 Chapter 6: Functional Programming 1496.1 List Comprehensions 1506.2 List Comprehensions with Conditions 1566.3 Dictionary Comprehensions 1596.4 Generator and Set Comprehensions 1636.5 Other Functional Techniques 165 Chapter 7: Objects and Classes 1697.1 Defining Classes 1697.2 Custom Iterators 1767.3 Inheritance 1797.4 Derived Classes 183 Chapter 8: Testing and Test-Driven Development 1918.1 Package Setup 1928.2 Initial Test Coverage 1978.3 Red 2098.4 Green 2148.5 Refactor 220 Chapter 9: Shell Scripts 2319.1 Reading from Files 2319.2 Reading from URLs 2409.3 DOM Manipulation at the Command Line 245 Chapter 10: A Live Web Application 25510.1 Setup 25610.2 Site Pages 26310.3 Layouts 27110.4 Template Engine 28010.5 Palindrome Detector 29310.6 Conclusion 316 Chapter 11: Data Science 31911.1 Data Science Setup 32011.2 Numerical Computations with NumPy 32711.3 Data Visualization with Matplotlib 33811.4 Introduction to Data Analysis with pandas 35311.5 pandas Example: Nobel Laureates 36111.6 pandas Example: Titanic 37711.7 Machine Learning with scikit-learn 38611.8 Further Resources and Conclusion 403 Index 405

Read more less

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

Read more less

Book SynopsisDavid Mertz has been a member of the Python community for 25 years. He has taught Python to scientists, developers coming from other languages, and to programming neophytes. He was a director of the Python Software Foundation (PSF) for six years and continues to serve on, or chair, a variety of PSF working groups. David is the author of several technical books and has given keynote addresses at numerous international programming conferences.Trade Review"You'll not just be aspiring to be an expert anymore after practicing through Better Python Code: A Guide for Aspiring Experts, you'll be one of them! Learn from David Mertz, who's been making experts through his writing and training for the past 20 years."--Iqbal Abdullah, past Chair, PyCon Asia Pacific, and past board member, PyCon Japan "In Better Python Code: A Guide for Aspiring Experts, David Mertz serves up bite-sized chapters of Pythonic wisdom in this must-have addition to any serious Python programmer's collection. This book helps bridge the gap from beginner to advanced Python user, but even the most seasoned Python programmer can up their game with Mertz's insight into the ins and outs of Python."--Katrina Riehl, President, NumFOCUS "What separates ordinary coders from Python experts? It's more than just knowing best practices--it's understanding the benefits and pitfalls of the many aspects of Python, and knowing when and why to choose one approach over another. In this book David draws on his more than 20 years of involvement in the Python ecosystem and his experience as a Python author to make sure that the readers understand both what to do and why in a wide variety of scenarios."--Naomi Ceder, past Chair, Python Software Foundation "Like a Pythonic BBC, David Mertz has been informing, entertaining, and educating the Python world for over a quarter of a century, and he continues to do so here in his own pleasantly readable style."--Steve Holden, past Chair, Python Software Foundation "Being expert means someone with a lot of experience. David's latest book provides some important but common problems that folks generally learn only after spending years of doing and fixing. I think this book will provide a much quicker way to gather those important bits and help many folks across the world to become better."--Kushal Das, CPython Core Developer and Director, Python Software Foundation "This book is for everyone: from beginners, who want to avoid hard-to-find bugs, all the way to experts looking to write more efficient code. David Mertz has compiled a great set of useful idioms that will make your life as a programmer easier and your users happier."--Marc-André Lemburg, past Chair, EuroPython, and past Director, Python Software FoundationTable of ContentsForeword xviiPreface xixAcknowledgments xxvAbout the Author xxvii Introduction 1 Chapter 1: Looping Over the Wrong Things 31.1 (Rarely) Generate a List for Iteration 31.2 Use enumerate() Instead of Looping Over an Index 61.3 Don't Iterate Over dict.keys() When You Want dict.items() 81.4 Mutating an Object During Iteration 91.5 for Loops Are More Idiomatic Than while Loops 121.6 The Walrus Operator for "Loop-and-a-Half" Blocks 131.7 zip() Simplifies Using Multiple Iterables 151.8 zip(strict=True) and itertools.zip_longest() 171.9 Wrapping Up 20 Chapter 2: Confusing Equality with Identity 212.1 Late Binding of Closures 212.2 Overchecking for Boolean Values 252.3 Comparing x == None 282.4 Misunderstanding Mutable Default Arguments 292.5 Copies versus References to Mutable Objects 332.6 Confusing is with == (in the Presence of Interning) 352.7 Wrapping Up 37 Chapter 3: A Grab Bag of Python Gotchas 393.1 Naming Things 393.2 Quadratic Behavior of Naive String Concatenation 523.3 Use a Context Manager to Open a File 563.4 Optional Argument key to .sort() and sorted() 593.5 Use dict.get() for Uncertain Keys 623.6 Wrapping Up 64 Chapter 4: Advanced Python Usage 674.1 Comparing type(x) == type(y) 674.2 Naming Things (Revisited) 714.3 Keep Less-Used Features in Mind 794.4 Type Annotations Are Not Runtime Types 984.5 Wrapping Up 105 Chapter 5: Just Because You Can, It Doesn't Mean You Should... 1075.1 Metaclasses 1075.2 Monkeypatching 1125.3 Getters and Setters 1155.4 It's Easier to Ask for Forgiveness Than Permission 1185.5 Structural Pattern Matching 1215.6 Regular Expressions and Catastrophic Backtracking 1235.7 Wrapping Up 126 Chapter 6: Picking the Right Data Structure 1296.1 collections.defaultdict 1296.2 collections.Counter 1326.3 collections.deque 1356.4 collections.ChainMap 1386.5 Dataclasses and Namedtuples 1416.6 Efficient Concrete Sequences 1466.7 Wrapping Up 150 Chapter 7: Misusing Data Structures 1537.1 Quadratic Behavior of Repeated List Search 1537.2 Deleting or Adding Elements to the Middle of a List 1577.3 Strings Are Iterables of Strings 1637.4 (Often) Use enum Rather Than CONSTANT 1667.5 Learn Less Common Dictionary Methods 1697.6 JSON Does Not Round-Trip Cleanly to Python 1747.7 Rolling Your Own Data Structures 1787.8 Wrapping Up 187 Chapter 8: Security 1898.1 Kinds of Randomness 1908.2 Putting Passwords or Other Secrets in "Secure" Source Code 1958.3 "Rolling Your Own" Security Mechanisms 1988.4 Use SSL/TLS for Microservices 2018.5 Using the Third-Party requests Library 2058.6 SQL Injection Attacks When Not Using DB-API 2088.7 Don’t Use assert to Check Safety Assumptions 2128.8 Wrapping Up 215 Chapter 9: Numeric Computation in Python 2179.1 Understanding IEEE-754 Floating Point Numbers 2179.2 Numeric Datatypes 2289.3 Wrapping Up 239 Appendix: Topics for Other Books 241A.1 Test-Driven Development 241A.2 Concurrency 242A.3 Packaging 243A.4 Type Checking 243A.5 Numeric and Dataframe Libraries 244 Index 245

Read more less

Book SynopsisHow `mirror worlds' programming can be structured and used based on current and presently developing computer components and technology.Trade Review'This is a fascinating book, and important from the point of view of thinking about the future of software. It's also very easy to read, being written in a conversational style, not American academic jargon.' The Guardian'most unusual and perhaps most speculative' Clifford A. Pickover, NatureTable of ContentsMirror worlds?; The orb; Disembodied machines; Space, time and multi-time; The deluge; Simple mind machines; Building mirror worlds; Epilogue; Notes; Index.

Read more less

Book SynopsisFortran marches on, remaining one of the principal programming languages used in high-performance scientific, numerical, and engineering computing. A series of significant revisions to the standard versions of the language have progressively enhanced its capabilities, and the latest standard - Fortran 2018 - includes many additions and improvements.This edition of Modern Fortran Explained expands on the last. Given the release of updated versions of Fortran compilers, the separate descriptions of Fortran 2003 and Fortran 2008 have been incorporated into the main text, which thereby becomes a unified description of the full Fortran 2008 version of the language. This clearer standard has allowed many deficiencies and irregularities in the earlier language versions to be resolved.Four new chapters describe the additional features of Fortran 2018, with its enhancements to coarrays for parallel programming, interoperability with C, IEEE arithmetic, and various other improvements.Written by Trade ReviewAn excellent, authoritative and complete reference book on the modern Fortran language, where all its possibilities are collected and any detail of the language can be clearly consulted. * European Mathematical Society *Well organized and equipped with good examples, the text can be used as both a tutorial and a reference. It describes each of the language elements and explains where FORTRAN 2018 differs from its predecessors. A thorough index is provided; all illustrations are clear and concise. The language used in descriptions and explanations throughout the book is clear and easy to follow. This book is an excellent resource for all practitioners. * F. H. Wild III, University of Rhode Island, CHOICE Connect *Table of Contents1: Whence Fortran? 2: Language elements 3: Expressions and assignments 4: Control constructs 5: Program units and procedures 6: Allocation of data 7: Array features 8: Specification statements 9: Intrinsic procedures and modules 10: Data transfer 11: Edit descriptors 12: Operations on external files 13: Advanced type parameter features 14: Procedure pointers 15: Object-oriented programming 16: Submodules 17: Coarrays 18: Floating-point exception handling 19: Interoperability with C 20: Fortran 2018 coarray enhancements 21: Fortran 2018 enhancements to interoperability with C 22: Fortran 2018 conformance with ISO/IEC/IEEE 60559:2011 23: Minor Fortran 2018 features

Read more less

Book SynopsisDavid R. Hanson is a Professor of Computer Science at Princeton University with more than 20 years of research experience in programming languages. He has conducted research in conjunction with Bell Laboratories and is the co-author of lcc, a production quality, research compiler for the C language that is popular with the Unix community. lcc is presented and analyzed in the book A Retargetable C Compiler: Design and Implementation, by Christopher Fraser and David Hanson (c) 1995, Addison-Wesley. 0201498413AB04062001Table of ContentsPreface xi Organization xiii Instructional Use xiv How to Get the Software xvi Acknowledgments xvii Chapter 1: Introduction 1 1.1 Literate Programs 2 1.2 Programming Style 8 1.3 Efficiency 11 Further Reading 12 Exercises 13 Chapter 2: Interfaces and Implementations 15 2.1 Interfaces 15 2.2 Implementations 18 2.3 Abstract Data Types 21 2.4 Client Responsibilities 24 2.5 Efficiency 30 Further Reading 30 Exercises 31 Chapter 3: Atoms 33 3.1 Interface 33 3.2 Implementation 34 Further Reading 42 Exercises 42 Chapter 4: Exceptions and Assertions 45 4.1 Interface 47 4.2 Implementation 53 4.3 Assertions 59 Further Reading 63 Exercises 64 Chapter 5: Memory Management 67 5.1 Interface 69 5.2 Production Implementation 73 5.3 Checking Implementation 76 Further Reading 85 Exercises 86 Chapter 6: More Memory Management 89 6.1 Interface 90 6.2 Implementation 92 Further Reading 98 Exercises 100 Chapter 7: Lists 103 7.1 Interface 103 7.2 Implementation 108 Further Reading 113 Exercises 114 Chapter 8: Tables 115 8.1 Interface 115 8.2 Example: Word Frequencies 118 8.3 Implementation 125 Further Reading 132 Exercises 133 Chapter 9: Sets 137 9.1 Interface 138 9.2 Example: Cross-Reference Listings 140 9.3 Implementation 148 Further Reading 158 Exercises 158 Chapter 10: Dynamic Arrays 161 10.1 Interfaces 162 10.2 Implementation 165 Further Reading 169 Exercises 169 Chapter 11: Sequences 171 11.1 Interface 171 11.2 Implementation 174 Further Reading 180 Exercises 180 Chapter 12: Rings 183 12.1 Interface 183 12.2 Implementation 187 Further Reading 196 Exercises 197 Chapter 13: Bit Vectors 199 13.1 Interface 199 13.2 Implementation 202 Further Reading 213 Exercises 213 Chapter 14: Formatting 215 14.1 Interface 216 14.2 Implementation 224 Further Reading 238 Exercises 239 Chapter 15: Low-Level Strings 241 15.1 Interface 243 15.2 Example: Printing Identifiers 249 15.3 Implementation 251 Further Reading 264 Exercises 265 Chapter 16: High-Level Strings 269 16.1 Interface 269 16.2 Implementation 276 Further Reading 293 Exercises 294 Chapter 17. Extended-Precision Arithmetic 297 17.1 Interface 297 17.2 Implementation 303 Further Reading 321 Exercises 322 Chapter 18: Arbitrary-Precision Arithmetic 323 18.1 Interface 323 18.2 Example: A Calculator 327 18.3 Implementation 334 Further Reading 353 Exercises 354 Chapter 19: Multiple-Precision Arithmetic 357 19.1 Interface 358 19.2 Example: Another Calculator 365 19.3 Implementation 373 Further Reading 402 Exercises 402 Chapter 20: Threads 405 20.1 Interfaces 408 20.2 Examples 418 20.3 Implementations 431 Further Reading 463 Exercises 465 Appendix: Interface Summary 469 Bibliography 497 Index 505

Read more less

Book Synopsis

Read more less

Book SynopsisA new edition of a textbook that provides students with a deep, working understanding of the essential concepts of programming languages, completely revised, with significant new material.This book provides students with a deep, working understanding of the essential concepts of programming languages. Most of these essentials relate to the semantics, or meaning, of program elements, and the text uses interpreters (short programs that directly analyze an abstract representation of the program text) to express the semantics of many essential language elements in a way that is both clear and executable. The approach is both analytical and hands-on. The book provides views of programming languages using widely varying levels of abstraction, maintaining a clear connection between the high-level and low-level views. Exercises are a vital part of the text and are scattered throughout; the text explains the key concepts, and the exercises explore alternative designs and other issues.

Read more less

Book SynopsisThe notion that thinking about computing is one of the most exciting things the human mind can do sets both The Little Schemer (formerly known as The Little LISPer) and its new companion volume, The Seasoned Schemer, apart from other books on LISP. The authors' enthusiasm for their subject is compelling as they present abstract concepts in a humorous and easy-to-grasp fashion. Together, these books will open new doors of thought to anyone who wants to find out what computing is really about. The Little Schemer introduces computing as an extension of arithmetic and algebra; things that everyone studies in grade school and high school. It introduces programs as recursive functions and briefly discusses the limits of what computers can do. The authors use the programming language Scheme, and interesting foods to illustrate these abstract ideas. The Seasoned Schemer informs the reader about additional dimensions of computing: functions as values, change o

Read more less

Book Synopsis

Read more less

Book SynopsisDouglas Bell and Mike Parr have many years experience teaching programming in the UK. They have written a number of programming books, including the bestselling Java for Students, Visual Basic for Students and C# for Students. They continue to teach and learn about programming with enthusiasm.Trade Review'The best book for my first year programming students'Gary Hill, The University of Northampton 'It is really hard to fault it or find a better book' Ken Chisholm, Edinburgh Napier University 'An excellent rewarding introduction to Java programming’Dr Simon Jones, University of StirlingTable of ContentsDetailed contentsIntroductionGuided tour The background to Java First programs Using graphics methods Variables and calculations Methods and parameters Using objects Selection Repetition Writing classes Inheritance Calculations Array lists Arrays Arrays - two dimensional String manipulation Exceptions Files and console applications Object-oriented design Program style Testing Debugging Threads Interfaces Programming in the large - packages Polymorphism Java in context Appendices: A. Java libraries B. The Abstract Window Toolkit C. Applets D. Glossary E. Rules for names F. Keywords G. Scope rules (visibility) H. Bibliography I. Installing and using Java Index

Read more less

Book Synopsis

Read more less

Book SynopsisTable of ContentsPart I Fundamentals of ProgrammingChapter 1 Introduction to Computers, Programming, and C++ Chapter 2 Elementary Programming Chapter 3 Selections Chapter 4 Mathematical Functions, Characters, and Strings Chapter 5 Loops Chapter 6 Functions Chapter 7 Single-Dimensional Arrays and C-Strings Chapter 8 Multidimensional Arrays Part II Object-Oriented ProgrammingChapter 9 Objects and Classes Chapter 10 Object-Oriented Thinking Chapter 11 Pointers and Dynamic Memory Management Chapter 12 Templates, Vectors, and Stacks Chapter 13 File Input and Output Chapter 14 Operator Overloading Chapter 15 Inheritance and Polymorphism Chapter 16 Exception Handling Part III Data Structures and Advanced Topics Chapter 17 Recursion Bonus ChaptersChapter 18 Developing Efficient Algorithms Chapter 19 Sorting Chapter 20 Linked Lists, Queues, and Priority Queues Chapter 21 Binary Search Trees Chapter 22 STL Containers Chapter 23 STL Algorithms Chapter 24 Graph Applications Chapter 25 Weighted Graph Applications Chapter 26 AVL Trees and Splay Trees Appendixes Chapters 18-26 are bonus chapters available from http://www.pearsonhighered.com/liang. Login or register under VideoNotes and Web Chapters.

Read more less

Book SynopsisScott Meyers is one of the world's foremost authorities on C++, providing training and consulting services to clients worldwide. He is the author of the best-selling Effective C++ series of books (Effective C++, More Effective C++, and Effective STL) and of the innovative Effective C++ CD. He is consulting editor for Addison Wesley's Effective Software Development Series and is a founding member of the Advisory Board for The C++ Source (http://www.artima.com/cppsource). He holds a Ph.D. in Computer Science from Brown University. His web site is http://www.aristeia.com.Table of ContentsPreface xv Acknowledgments xvii Introduction 1 Chapter 1: Accustoming Yourself to C++ 11 Item 1: View C++ as a federation of languages. 11 Item 2: Prefer consts, enums, and inlines to #defines. 13 Item 3: Use const whenever possible. 17 Item 4: Make sure that objects are initialized before they’re used. 26 Chapter 2: Constructors, Destructors, and Assignment Operators 34 Item 5: Know what functions C++ silently writes and calls. 34 Item 6: Explicitly disallow the use of compiler-generated functions you do not want. 37 Item 7: Declare destructors virtual in polymorphic base classes. 40 Item 8: Prevent exceptions from leaving destructors. 44 Item 9: Never call virtual functions during construction or destruction. 48 Item 10: Have assignment operators return a reference to *this. 52 Item 11: Handle assignment to self in operator=. 53 Item 12: Copy all parts of an object. 57 Chapter 3: Resource Management 61 Item 13: Use objects to manage resources. 61 Item 14: Think carefully about copying behavior in resource-managing classes. 66 Item 15: Provide access to raw resources in resource-managing classes. 69 Item 16: Use the same form in corresponding uses of new and delete. 73 Item 17: Store newed objects in smart pointers in standalone statements. 75 Chapter 4: Designs and Declarations 78 Item 18: Make interfaces easy to use correctly and hard to use incorrectly. 78 Item 19: Treat class design as type design. 84 Item 20: Prefer pass-by-reference-to-const to pass-by-value. 86 Item 21: Don’t try to return a reference when you must return an object. 90 Item 22: Declare data members private. 94 Item 23: Prefer non-member non-friend functions to member functions. 98 Item 24: Declare non-member functions when type conversions should apply to all parameters. 102 Item 25: Consider support for a non-throwing swap. 106 Chapter 5: Implementations 113 Item 26: Postpone variable definitions as long as possible. 113 Item 27: Minimize casting. 116 Item 28: Avoid returning “handles” to object internals. 123 Item 29: Strive for exception-safe code. 127 Item 30: Understand the ins and outs of inlining. 134 Item 31: Minimize compilation dependencies between files. 140 Chapter 6: Inheritance and Object-Oriented Design 149 Item 32: Make sure public inheritance models “is-a.” 150 Item 33: Avoid hiding inherited names. 156 Item 34: Differentiate between inheritance of interface and inheritance of implementation. 161 Item 35: Consider alternatives to virtual functions. 169 Item 36: Never redefine an inherited non-virtual function. 178 Item 37: Never redefine a function’s inherited default parameter value. 180 Item 38: Model “has-a” or “is-implemented-in-terms-of” through composition. 184 Item 39: Use private inheritance judiciously. 187 Item 40: Use multiple inheritance judiciously. 192 Chapter 7: Templates and Generic Programming 199 Item 41: Understand implicit interfaces and compile-time polymorphism. 199 Item 42: Understand the two meanings of typename. 203 Item 43: Know how to access names in templatized base classes. 207 Item 44: Factor parameter-independent code out of templates. 212 Item 45: Use member function templates to accept “all compatible types.” 218 Item 46: Define non-member functions inside templates when type conversions are desired. 222 Item 47: Use traits classes for information about types. 226 Item 48: Be aware of template metaprogramming. 233 Chapter 8: Customizing new and delete 239 Item 49: Understand the behavior of the new-handler. 240 Item 50: Understand when it makes sense to replace new and delete. 247 Item 51: Adhere to convention when writing new and delete. 252 Item 52: Write placement delete if you write placement new. 256 Chapter 9: Miscellany 262 Item 53: Pay attention to compiler warnings. 262 Item 54: Familiarize yourself with the standard library, including TR1. 263 Item 55: Familiarize yourself with Boost. 269 Appendix A: Beyond Effective C++ 273 Appendix B: Item Mappings Between Second and Third Editions 277 Index 280

Read more less

Book Synopsis Laura Thomson is director of engineering at Mozilla Corporation. She was formerly a principal at both OmniTI and Tangled Web Design, and she has worked for RMIT University and the Boston Consulting Group. She holds a Bachelor of Applied Science (Computer Science) degree and a Bachelor of Engineering (Computer Systems Engineering) degree with honors. Luke Welling is a software engineer and regularly speaks on open source and web development topics at conferences such as OSCON, ZendCon, MySQLUC, PHPCon, OSDC, and LinuxTag. He has worked for OmniTI, for the web analytics company Hitwise.com, at the database vendor MySQL AB, and as an independent consultant at Tangled Web Design. He has taught computer science at RMIT University in Melbourne, Australia, and holds a Bachelor of Applied Science (Computer Science) degree. Table of ContentsPHP and MySQL Web Development, 5th Edition Part I: Using PHP 1 PHP Crash Course 2 Storing and Retrieving Data 3 Using Arrays 4 String Manipulation and Regular Expressions 5 Reusing Code and Writing Functions 6 Object-Oriented PHP 7 Error and Exception Handling Part II: Using MySQL 8 Designing Your Web Database 9 Creating Your Web Database 10 Working with Your MySQL Database 11 Accessing Your MySQL Database from the Web with PHP 12 Advanced MySQL Administration 13 Advanced MySQL Programming Part III: Web Application Security 14 Web Application Security Risks 15 Building a Secure Web Application 16 Implementing Authentication Methods with PHP Part IV: Advanced PHP Techniques 17 Interacting with the File System and the Server 18 Using Network and Protocol Functions 19 Managing the Date and Time 20 Internationalization and Localization 21 Generating Images 22 Using Session Control in PHP 23 Integrating JavaScript and PHP 24 Other Useful Features Part V: Building Practical PHP and MySQL Projects 25 Using PHP and MySQL for Large Projects 26 Debugging and Logging 27 Building User Authentication and Personalization 28 (PDFs with Product Registration) Building a Web-Based Email Client with Laravel Part I 29 (PDFs with Product Registration) Building a Web-Based Email Client with Laravel Part II 30 (PDFs with Product Registration) Social Media Integration Sharing and Authentication 31 (PDFs with Product Registration) Building a Shopping Cart Part VI: Appendix A Installing Apache, PHP, and MySQL

Read more less

Book SynopsisWILLIAM BUCHANAN is a Senior Lecturer at Napier University. He is an experienced author who has written a number of computing books. He acts as a consultant, and is a founding partner of Real-Time Technologies, a start-up company within Napier University.

Read more less

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.

Read more less

Book SynopsisThis book meant for those who seek to apply evolutionary algorithms to problems in engineering and science. To this end, it provides the theoretical background necessary to the understanding of the presented evolutionary algorithms and their shortcomings, while also discussing themes that are pivotal to the successful application of evolutionary algorithms to real-world problems. The theoretical descriptions are illustrated with didactical Python implementations of the algorithms, which not only allow readers to consolidate their understanding, but also provide a sound starting point for those intending to apply evolutionary algorithms to optimization problems in their working fields. Python has been chosen due to its widespread adoption in the Artificial Intelligence community. Those familiar with high level languages such as MATLABâ will not have any difficulty in reading the Python implementations of the evolutionary algorithms provided in the book.Instead of attempting to encompass most of the existing evolutionary algorithms, past and present, the book focuses on those algorithms that researchers have recently applied to difficult optimization problems, such as control problems with continuous action spaces and the training of high-dimensional convolutional neural-networks. The basic characteristics of real-world optimization problems are presented, together with recommendations on its proper application to evolutionary algorithms. The applied nature of the book is reinforced by the presentation of successful cases of the application of evolutionary algorithms to optimization problems. This is complemented by Python source codes, giving users an insight into the idiosyncrasies of the practical application of evolutionary algorithms.Table of ContentsPreface. SECTION I: INTRODUCTION. Evolutionary Algorithms and Difficult Optimization Problems. Introduction to Optimization. Introduction to Evolutionary Algorithms. SECTION II: SINGLE-OBJECTIVE EVOLUTIONARY ALGORITHMS. Swarm Optimization. Evolution Strategies. Genetic Algorithms. Differential Evolution. SECTION III: MULTI-OBJECTIVE EVOLUTIONARY ALGORITHMS. Non-Dominated Sorted Genetic Algorithm II. Multiobjective Evolutionary Algorithm Based on Decomposition. SECTION IV: APPLYING EVOLUTIONARY ALGORITHMS. Solving Optimization Problems with Evolutionary Algorithms. Assessing the Performance of Evolutionary Algorithms. Case Study - Optimal Design of a Gear Train System. Case Study - Teaching a Legged Robot How to Walk. References.

Read more less

Book SynopsisThis updated and reorganized Fifth edition of Software Testing: A Craftsman''s Approach continues to be a valuable reference for software testers, developers, and engineers, by applying the strong mathematics content of previous editions to a coherent treatment of software testing. Responding to instructor and student survey input, the authors have streamlined chapters and examples. The Fifth Edition: Has a new chapter on feature interaction testing that explores the feature interaction problem and explains how to reduce tests Uses Java instead of pseudo-code for all examples including structured and object-oriented ones Presents model-based development and provides an explanation of how to conduct testing within model-based development environments Explains testing in waterfall, iterative, and agile software development projects Explores test-driven development,Table of ContentsPart I. A Mathematical Context. Chapter 1. A Perspective on Testing. Chapter 2. Examples. Chapter 3. Discrete Math for Testers. Chapter 4. Graph Theory for Testers. Part II. Unit Testing. Chapter 5. Boundary Value Testing. Chapter 6. Equivalence Class Testing. Chapter 7. Decision Table-Based Testing. Chapter 8. Code-Based Testing. Chapter 9 Testing Object-Oriented Software. Chapter 10. Retrospective on Unit Testing. Part III. Beyond Unit Testing. Chapter 11. Life Cycle-Based Testing. Chapter 12. Integration Testing. Chapter 13. System Testing. Chapter 14. Model-Based Testing. Chapter 15. Software Complexity. Chapter 16. Testing Systems of Systems. Chapter 17. Feature Interaction Testing. Chapter 18. Case Study: Testing Event-Driven Systems. Chapter 19. A Closer Look at All Pairs Testing. Chapter 20. Software Technical Reviews. Chapter 21. Epilogue: Software Testing Excellence.

Read more less

Book SynopsisA Tour of Data Science: Learn R and Python in Parallel covers the fundamentals of data science, including programming, statistics, optimization, and machine learning in a single short book. It does not cover everything, but rather, teaches the key concepts and topics in Data Science. It also covers two of the most popular programming languages used in Data Science, R and Python, in one source.Key features: Allows you to learn R and Python in parallel Cover statistics, programming, optimization and predictive modelling, and the popular data manipulation tools – data.table and pandas Provides a concise and accessible presentation Includes machine learning algorithms implemented from scratch, linear regression, lasso, ridge, logistic regression, gradient boosting trees, etc. Appealing to data scientists, statisticians, quantitative analysts, and others who want to learn progrTable of ContentsAssumptions about the reader’s backgroundBook overview Introduction to R/Python Programming Calculator Variable and TypeFunctions Control flowsSome built-in data structures Revisit of variables Object-oriented programming (OOP) in R/Python Miscellaneous More on R/Python Programming Work with R/Python scripts Debugging in R/Python Benchmarking Vectorization Embarrassingly parallelism in R/Python Evaluation strategySpeed up with C/C++ in R/PythonA first impression of functional programming Miscellaneous data.table and pandasSQL Get started with data.table and pandas Indexing & selecting data Add/Remove/UpdateGroup by Join Random Variables, Distributions & Linear Regression A refresher on distributions Inversion sampling & rejection sampling Joint distribution & copula Fit a distribution Confidence intervalHypothesis testing Basics of linear regression Ridge regression Optimization in PracticeConvexity Gradient descent Root-finding General purpose minimization tools in R/Python Linear programming Miscellaneous Machine Learning - A gentle introduction Supervised learning Gradient boosting machine Unsupervised learning Reinforcement learning Deep Q-Networks Computational differentiation Miscellaneous

Read more less

Book Synopsis

Read more less