DOCSLIB.ORG

Ios 11 Programming Fundamentals with Swift

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Ios 11 Programming Fundamentals with Swift Xcode Covers9, and SwiftiOS 11, 4 iOS 11 Programming Fundamentals with Swift SWIFT, XCODE, AND COCOA BASICS Matt Neuburg FOURTH EDITION iOS 11 Programming Fundamentals with Swift Swift, Xcode, and Cocoa Basics Matt Neuburg Boston iOS 11 Programming Fundamentals with Swift, Fourth Edition by Matt Neuburg Copyright © 2018 Matt Neuburg. All rights reserved. Printed in the United States of America. Published by O’Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472. O’Reilly books may be purchased for educational, business, or sales promotional use. Online editions are also available for most titles (http://oreilly.com/safari). For more information, contact our corporate/insti‐ tutional sales department: 800-998-9938 or [email protected]. Editor: Rachel Roumeliotis Cover Designer: Karen Montgomery Production Editor: Kristen Brown Interior Designer: David Futato Proofreader: O’Reilly Production Services Illustrator: Matt Neuburg Indexer: Matt Neuburg April 2015: First Edition October 2015: Second Edition October 2016: Third Edition October 2017: Fourth Edition Revision History for the Fourth Edition 2017-09-26: First release See http://oreilly.com/catalog/errata.csp?isbn=0636920107415 for release details. The O’Reilly logo is a registered trademark of O’Reilly Media, Inc. iOS 11 Programming Fundamentals with Swift, the image of a harp seal, and related trade dress are trademarks of O’Reilly Media, Inc. While the publisher and the author have used good faith efforts to ensure that the information and instructions contained in this work are accurate, the publisher and the author disclaim all responsibility for errors or omissions, including without limitation responsibility for damages resulting from the use of or reliance on this work. Use of the information and instructions contained in this work is at your own risk. If any code samples or other technology this work contains or describes is subject to open source licenses or the intellectual property rights of others, it is your responsibility to ensure that your use thereof complies with such licenses and/or rights. ISBN: 978-1-491-99931-8 [LSI] Table of Contents Preface. xiii Part I. Language 1. The Architecture of Swift. 3 Ground of Being 3 Everything Is an Object? 5 Three Flavors of Object Type 6 Variables 6 Functions 8 The Structure of a Swift File 9 Scope and Lifetime 11 Object Members 13 Namespaces 13 Modules 14 Instances 15 Why Instances? 17 The Keyword self 19 Privacy 20 Design 22 Object Types and APIs 23 Instance Creation, Scope, and Lifetime 25 Summary and Conclusion 26 2. Functions. 27 Function Parameters and Return Value 27 Void Return Type and Parameters 31 Function Signature 32 iii External Parameter Names 32 Overloading 34 Default Parameter Values 35 Variadic Parameters 35 Ignored Parameters 36 Modifiable Parameters 37 Function In Function 40 Recursion 42 Function As Value 42 Anonymous Functions 45 Define-and-Call 51 Closures 52 How Closures Improve Code 54 Function Returning Function 55 Closure Setting a Captured Variable 58 Closure Preserving Its Captured Environment 59 Escaping Closures 60 Curried Functions 61 Function References and Selectors 62 Function Reference Scope 64 Selectors 65 3. Variables and Simple Types. 69 Variable Scope and Lifetime 69 Variable Declaration 71 Computed Initializer 75 Computed Variables 75 Setter Observers 79 Lazy Initialization 80 Built-In Simple Types 82 Bool 82 Numbers 84 String 91 Character and String Index 96 Range 101 Tuple 103 Optional 106 4. Object Types. 119 Object Type Declarations and Features 119 Initializers 121 Properties 127 iv | Table of Contents Methods 130 Subscripts 132 Nested Object Types 135 Instance References 135 Enums 137 Raw Values 138 Associated Values 140 Enum Initializers 142 Enum Properties 143 Enum Methods 144 Why Enums? 145 Structs 146 Struct Initializers, Properties, and Methods 146 Struct As Namespace 148 Classes 148 Value Types and Reference Types 149 Subclass and Superclass 155 Class Initializers 160 Class Deinitializer 168 Class Properties and Methods 168 Polymorphism 170 Casting 174 Casting Down 175 Type Testing and Casting Down Safely 175 Type Testing and Casting Optionals 176 Bridging to Objective-C 177 Type Reference 178 Protocols 183 Why Protocols? 185 Protocol Type Testing and Casting 187 Declaring a Protocol 188 Protocol Composition 189 Optional Protocol Members 190 Class Protocol 192 Implicitly Required Initializers 192 Literal Convertibles 194 Generics 195 Generic Declarations 198 Type Constraints 200 Explicit Specialization 202 Associated Type Chains 204 Where Clauses 207 Table of Contents | v Extensions 211 Extending Object Types 211 Extending Protocols 213 Extending Generics 215 Umbrella Types 217 Any 217 AnyObject 219 AnyClass 221 Collection Types 222 Array 222 Dictionary 238 Set 245 5. Flow Control and More. 251 Flow Control 251 Branching 252 Loops 264 Jumping 268 Key Paths 284 Operators 286 Privacy 290 Private and Fileprivate 291 Public and Open 292 Privacy Rules 293 Introspection 293 Memory Management 294 Memory Management of Reference Types 295 Exclusive Access to Value Types 302 Part II. IDE 6. Anatomy of an Xcode Project. 307 New Project 307 The Project Window 309 The Navigator Pane 311 The Utilities Pane 316 The Editor 318 The Project File and Its Dependents 320 The Target 322 Build Phases 323 Build Settings 325 vi | Table of Contents Configurations 326 Schemes and Destinations 327 From Project to Running App 330 Build Settings 333 Property List Settings 333 Nib Files 334 Additional Resources 335 Code Files 338 Frameworks and SDKs 338 The App Launch Process 340 The Entry Point 341 UIApplicationMain 342 App Without a Storyboard 344 Renaming Parts of a Project 345 7. Nib Management. 347 The Nib Editor Interface 348 Document Outline 350 Canvas 352 Inspectors and Libraries 355 Nib Loading 356 When Nibs Are Loaded 356 Manual Nib Loading 358 Connections 360 Outlets 360 The Nib Owner 361 Automatically Configured Nibs 365 Misconfigured Outlets 366 Deleting an Outlet 368 More Ways to Create Outlets 368 Outlet Collections 372 Action Connections 372 More Ways to Create Actions 374 Misconfigured Actions 376 Connections Between Nibs — Not! 376 Additional Configuration of Nib-Based Instances 377 8. Documentation. 381 The Documentation Window 381 Class Documentation Pages 383 Quick Help 386 Symbol Declarations 388 Table of Contents | vii Header Files 389 Sample Code 390 Internet Resources 390 9. Life Cycle of a Project. 393 Runtime Environment 393 Backward Compatibility 394 Device Type 396 Version Control 397 Editing and Navigating Your Code 400 Autocompletion 401 Snippets 403 Structure Stubs 404 Fix-it and Live Syntax Checking 404 Navigation 405 Finding 407 Refactoring 408 Running in the Simulator 409 Debugging 410 Caveman Debugging 410 The Xcode Debugger 412 Testing 419 Clean 424 Running on a Device 425 Obtaining a Developer Program Membership 426 Signing an App 427 Automatic Signing 428 Obtaining a Development Certificate Manually 430 Obtaining a Development Provisioning Profile Manually 431 Running the App 434 Managing Development Certificates and Devices 434 Profiling 435 Gauges 435 Memory Debugging 436 Instruments 437 Localization 440 Distribution 445 Making an Archive 445 Obtaining a Distribution Certificate 446 Obtaining a Distribution Profile 447 Ad Hoc Distribution 448 Final App Preparations 450 viii | Table of Contents Screenshots and video previews 453 Property list settings 454 Submission to the App Store 455 Part III. Cocoa 10. Cocoa Classes. 461 Subclassing 461 Categories and Extensions 464 How Swift Uses Extensions 464 How You Use Extensions 465 How Cocoa Uses Categories 466 Protocols 467 Informal Protocols 469 Optional Methods 470 Some Foundation Classes 472 NSRange and NSNotFound 473 NSString and Friends 475 NSDate and Friends 478 NSNumber 480 NSValue 481 NSData 482 NSMeasurement and Friends 483 Equality and Comparison 484 NSArray and NSMutableArray 485 NSDictionary and NSMutableDictionary 487 NSSet and Friends 488 NSIndexSet 489 NSNull 489 Immutable and Mutable 490 Property Lists 491 Codable 492 Accessors, Properties, and Key–Value Coding 495 Swift Accessors 497 Key–Value Coding 498 Uses of Key–Value Coding 500 KVC and Outlets 501 Key Paths 502 Array Accessors 503 The Secret Life of NSObject 504 Table of Contents | ix 11. Cocoa Events. 507 Reasons for Events 508 Subclassing 508 Notifications 510 Receiving a Notification 511 Unregistering 513 Posting a Notification 514 Timer 515 Delegation 517 Cocoa Delegation 517 Implementing Delegation 519 Data Sources 521 Actions 522 The Responder Chain 525 Deferring Responsibility 526 Nil-Targeted Actions 526 Key–Value Observing 527 Swamped by Events 531 Delayed Performance 534 12. Memory Management. 537 Principles of Cocoa Memory Management 537 Rules of Cocoa Memory Management 538 What ARC Is and What It Does 539 How Cocoa Objects Manage Memory 540 Autorelease Pool 541 Memory Management of Instance Properties 543 Retain Cycles and Weak References 544 Unusual Memory Management Situations 546 Notification Observers 546 KVO Observers 548 Timers 548 Other Unusual Situations 550 Nib Loading and Memory Management 550 Memory Management of CFTypeRefs 551 Property Memory Management Policies 553 Debugging Memory Management Mistakes 555 13. Communication Between Objects. 557 Visibility by Instantiation 558 Visibility by Relationship 560 Global Visibility 561 x | Table of Contents Notifications and Key–Value Observing 563 Model–View–Controller 563 A. C, Objective-C, and Swift. 567 Index. 601 Table of Contents | xi Preface
Load more

Recommended publications
  • ML Module Mania: a Type-Safe, Separately Compiled, Extensible Interpreter
    ML Module Mania: A Type-Safe, Separately Compiled, Extensible Interpreter The Harvard community has made this article openly available. Please share how this access benefits you. Your story matters Citation Ramsey, Norman. 2005. ML Module Mania: A Type-Safe, Separately Compiled, Extensible Interpreter. Harvard Computer Science Group Technical Report TR-11-05. Citable link http://nrs.harvard.edu/urn-3:HUL.InstRepos:25104737 Terms of Use This article was downloaded from Harvard University’s DASH repository, and is made available under the terms and conditions applicable to Other Posted Material, as set forth at http:// nrs.harvard.edu/urn-3:HUL.InstRepos:dash.current.terms-of- use#LAA ¡¢ £¥¤§¦©¨ © ¥ ! " $# %& !'( *)+ %¨,.-/£102©¨ 3¤4#576¥)+ %&8+9©¨ :1)+ 3';&'( )< %' =?>A@CBEDAFHG7DABJILKM GPORQQSOUT3V N W >BYXZ*[CK\@7]_^\`aKbF!^\K/c@C>ZdX eDf@hgiDf@kjmlnF!`ogpKb@CIh`q[UM W DABsr!@k`ajdtKAu!vwDAIhIkDi^Rx_Z!ILK[h[SI ML Module Mania: A Type-Safe, Separately Compiled, Extensible Interpreter Norman Ramsey Division of Engineering and Applied Sciences Harvard University Abstract An application that uses an embedded interpreter is writ- ten in two languages: Most code is written in the original, The new embedded interpreter Lua-ML combines extensi- host language (e.g., C, C++, or ML), but key parts can be bility and separate compilation without compromising type written in the embedded language. This organization has safety. The interpreter’s types are extended by applying a several benefits: sum constructor to built-in types and to extensions, then • Complex command-line arguments aren’t needed; the tying a recursive knot using a two-level type; the sum con- embedded language can be used on the command line.
    [Show full text]
  • Working with System Frameworks in Python and Objective-C
    Working with System Frameworks in Python and Objective-C by James Barclay Feedback :) j.mp/psumac2015-62 2 Dude, Where’s My Source Code? CODE https://github.com/futureimperfect/psu-pyobjc-demo https://github.com/futureimperfect/PSUDemo SLIDES https://github.com/futureimperfect/slides 3 Dude, Where’s My Source Code? CODE https://github.com/futureimperfect/psu-pyobjc-demo https://github.com/futureimperfect/PSUDemo SLIDES https://github.com/futureimperfect/slides 3 Dude, Where’s My Source Code? CODE https://github.com/futureimperfect/psu-pyobjc-demo https://github.com/futureimperfect/PSUDemo SLIDES https://github.com/futureimperfect/slides 3 Agenda 1. What are system frameworks, and why should you care? 2. Brief overview of the frameworks, classes, and APIs that will be demonstrated. 3. Demo 1: PyObjC 4. Demo 2: Objective-C 5. Wrap up and questions. 4 What’s a System Framework? …and why should you care? (OS X) system frameworks provide interfaces you need to write software for the Mac. Many of these are useful for Mac admins creating: • scripts • GUI applications • command-line tools Learning about system frameworks will teach you more about OS X, which will probably make you a better admin. 5 Frameworks, Classes, and APIs oh my! Cocoa CoreFoundation • Foundation • CFPreferences - NSFileManager CoreGraphics - NSTask • Quartz - NSURLSession - NSUserDefaults • AppKit - NSApplication 6 CoreFoundation CoreFoundation is a C framework that knows about Objective-C objects. Some parts of CoreFoundation are written in Objective-C. • Other parts are written in C. CoreFoundation uses the CF class prefix, and it provides CFString, CFDictionary, CFPreferences, and the like. Some Objective-C objects are really CF types behind the scenes.
    [Show full text]
  • Tierless Web Programming in ML Gabriel Radanne
    Tierless Web programming in ML Gabriel Radanne To cite this version: Gabriel Radanne. Tierless Web programming in ML. Programming Languages [cs.PL]. Université Paris Diderot (Paris 7), 2017. English. tel-01788885 HAL Id: tel-01788885 https://hal.archives-ouvertes.fr/tel-01788885 Submitted on 9 May 2018 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. Distributed under a Creative Commons Attribution - NonCommercial - ShareAlike| 4.0 International License Thèse de doctorat de l’Université Sorbonne Paris Cité Préparée à l’Université Paris Diderot au Laboratoire IRIF Ecole Doctorale 386 — Science Mathématiques De Paris Centre Tierless Web programming in ML par Gabriel Radanne Thèse de Doctorat d’informatique Dirigée par Roberto Di Cosmo et Jérôme Vouillon Thèse soutenue publiquement le 14 Novembre 2017 devant le jury constitué de Manuel Serrano Président du Jury Roberto Di Cosmo Directeur de thèse Jérôme Vouillon Co-Directeur de thèse Koen Claessen Rapporteur Jacques Garrigue Rapporteur Coen De Roover Examinateur Xavier Leroy Examinateur Jeremy Yallop Examinateur This work is licensed under a Creative Commons “Attribution- NonCommercial-ShareAlike 4.0 International” license. Abstract Eliom is a dialect of OCaml for Web programming in which server and client pieces of code can be mixed in the same file using syntactic annotations.
    [Show full text]
  • Seaflow Language Reference Manual Rohan Arora, Junyang Jin, Ho Sanlok Lee, Sarah Seidman Ra3091, Jj3132, Hl3436, Ss5311
    Seaflow Language Reference Manual Rohan Arora, Junyang Jin, Ho Sanlok Lee, Sarah Seidman ra3091, jj3132, hl3436, ss5311 1 Introduction 3 2 Lexical Conventions 3 2.1 Comments 3 2.2 Identifiers 3 2.3 Keywords 3 2.4 Literals 3 3 Expressions and Statements 3 3.1 Expressions 4 3.1.1 Primary Expressions 4 3.1.1 Operators 4 3.1.2 Conditional expression 4 3.4 Statements 5 3.4.1 Declaration 5 3.4.2 Immutability 5 3.4.3 Observable re-assignment 5 4 Functions Junyang 6 4.1 Declaration 6 4.2 Scope rules 6 4.3 Higher Order Functions 6 5 Observables 7 5.1 Declaration 7 5.2 Subscription 7 5.3 Methods 7 6 Conversions 9 1 Introduction Seaflow is an imperative language designed to address the asynchronous event conundrum by supporting some of the core principles of ReactiveX and reactive programming natively. Modern applications handle many asynchronous events, but it is difficult to model such applications using programming languages such as Java and JavaScript. One popular solution among the developers is to use ReactiveX implementations in their respective languages to architect event-driven reactive models. However, since Java and JavaScript are not designed for reactive programming, it leads to complex implementations where multiple programming styles are mixed-used. Our goals include: 1. All data types are immutable, with the exception being observables, no pointers 2. The creation of an observable should be simple 3. Natively support core principles in the ReactiveX specification 2 Lexical Conventions 2.1 Comments We use the characters /* to introduce a comment, which terminates with the characters */.
    [Show full text]
  • Vmware Fusion 12 Vmware Fusion Pro 12 Using Vmware Fusion
    Using VMware Fusion 8 SEP 2020 VMware Fusion 12 VMware Fusion Pro 12 Using VMware Fusion You can find the most up-to-date technical documentation on the VMware website at: https://docs.vmware.com/ VMware, Inc. 3401 Hillview Ave. Palo Alto, CA 94304 www.vmware.com © Copyright 2020 VMware, Inc. All rights reserved. Copyright and trademark information. VMware, Inc. 2 Contents Using VMware Fusion 9 1 Getting Started with Fusion 10 About VMware Fusion 10 About VMware Fusion Pro 11 System Requirements for Fusion 11 Install Fusion 12 Start Fusion 13 How-To Videos 13 Take Advantage of Fusion Online Resources 13 2 Understanding Fusion 15 Virtual Machines and What Fusion Can Do 15 What Is a Virtual Machine? 15 Fusion Capabilities 16 Supported Guest Operating Systems 16 Virtual Hardware Specifications 16 Navigating and Taking Action by Using the Fusion Interface 21 VMware Fusion Toolbar 21 Use the Fusion Toolbar to Access the Virtual-Machine Path 21 Default File Location of a Virtual Machine 22 Change the File Location of a Virtual Machine 22 Perform Actions on Your Virtual Machines from the Virtual Machine Library Window 23 Using the Home Pane to Create a Virtual Machine or Obtain One from Another Source 24 Using the Fusion Applications Menus 25 Using Different Views in the Fusion Interface 29 Resize the Virtual Machine Display to Fit 35 Using Multiple Displays 35 3 Configuring Fusion 37 Setting Fusion Preferences 37 Set General Preferences 37 Select a Keyboard and Mouse Profile 38 Set Key Mappings on the Keyboard and Mouse Preferences Pane 39 Set Mouse Shortcuts on the Keyboard and Mouse Preference Pane 40 Enable or Disable Mac Host Shortcuts on the Keyboard and Mouse Preference Pane 40 Enable Fusion Shortcuts on the Keyboard and Mouse Preference Pane 41 Set Fusion Display Resolution Preferences 41 VMware, Inc.
    [Show full text]
  • JNI – C++ Integration Made Easy
    JNI – C++ integration made easy Evgeniy Gabrilovich Lev Finkelstein [email protected] [email protected] Abstract The Java Native Interface (JNI) [1] provides interoperation between Java code running on a Java Virtual Machine and code written in other programming languages (e.g., C++ or assembly). The JNI is useful when existing libraries need to be integrated into Java code, or when portions of the code are implemented in other languages for improved performance. The Java Native Interface is extremely flexible, allowing Java methods to invoke native methods and vice versa, as well as allowing native functions to manipulate Java objects. However, this flexibility comes at the expense of extra effort for the native language programmer, who has to explicitly specify how to connect to various Java objects (and later to disconnect from them, to avoid resource leak). We suggest a template-based framework that relieves the C++ programmer from most of this burden. In particular, the proposed technique provides automatic selection of the right functions to access Java objects based on their types, automatic release of previously acquired resources when they are no longer necessary, and overall simpler interface through grouping of auxiliary functions. Introduction The Java Native Interface1 is a powerful framework for seamless integration between Java and other programming languages (called “native languages” in the JNI terminology). A common case of using the JNI is when a system architect wants to benefit from both worlds, implementing communication protocols in Java and computationally expensive algorithmic parts in C++ (the latter are usually compiled into a dynamic library, which is then invoked from the Java code).
    [Show full text]
  • Difference Between Method Declaration and Signature
    Difference Between Method Declaration And Signature Asiatic and relaxed Dillon still terms his tacheometry namely. Is Tom dirt or hierarchal after Zyrian Nelson hasting so variously? Heterozygous Henrique instals terribly. Chapter 15 Functions. How junior you identify a function? There play an important difference between schedule two forms of code block seeing the. Subroutines in C and Java are always expressed as functions methods which may. Only one params keyword is permitted in a method declaration. Complex constant and so, where you declare checked exception parameters which case, it prompts the method declaration group the habit of control passes the positional. Overview of methods method parameters and method return values. A whole object has the cash public attributes and methods. Defining Methods. A constant only be unanimous a type explicitly by doing constant declaration or. As a stop rule using prototypes is the preferred method as it. C endif Class HelloJNI Method sayHello Signature V JNIEXPORT. Method signature It consists of the method name just a parameter list window of. As I breathe in the difference between static and dynamic binding static methods are. Most electronic signature solutions in the United States fall from this broad. DEPRECATED Method declarations with type constraints and per source filter. Methods and Method Declaration in Java dummies. Class Methods Apex Developer Guide Salesforce Developers. Using function signatures to remove a library method Function signatures are known important snapshot of searching for library functions The F libraries. Many different kinds of parameters with rather subtle semantic differences. For addition as real numbers the distinction is somewhat moot because is.
    [Show full text]
  • Data Types Are Values
    Data Types Are Values James Donahue Alan Demers Data Types Are Values James Donahue Xerox Corporation Palo Alto Research Center 3333 Coyote Hill Road Palo Alto, California 94304 Alan Demers Computer Science Department Cornell University Ithaca, New York 14853 CSL -83-5 March 1984 [P83-00005] © Copyright 1984 ACM. All rights reserved. Reprinted with permission. A bst ract: An important goal of programming language research is to isolate the fundamental concepts of languages, those basic ideas that allow us to understand the relationship among various language features. This paper examines one of these underlying notions, data type, with particular attention to the treatment of generic or polymorphic procedures and static type-checking. A version of this paper will appear in the ACM Transact~ons on Programming Languages and Systems. CR Categories and Subject Descriptors: 0.3 (Programming Languages), 0.3.1 (Formal Definitions and Theory), 0.3.3 (Language Constructs), F.3.2 (Semantics of Programming Languages) Additional Keywords and Phrases: data types, polymorphism XEROX Xerox Corporation Palo Alto Research Center 3333 Coyote Hill Road Palo Alto, California 94304 DATA TYPES ARE VALVES 1 1. Introduction An important goal of programming language research is to isolate the fundamental concepts of languages, those basic ideas that allow us to understand the relationship among various language features. This paper examines one of these underlying notions, data type, and presents a meaning for this term that allows us to: describe a simple treatment of generic or polymorphic procedures that preserves full static type-checking and allows unrestricted use of recursion; and give a precise meaning to the phrase strong typing, so that Language X is strongly typed can be interpreted as a critically important theorem about the semantics of the language.
    [Show full text]
  • Exploring Languages with Interpreters and Functional Programming Chapter 22
    Exploring Languages with Interpreters and Functional Programming Chapter 22 H. Conrad Cunningham 5 November 2018 Contents 22 Overloading and Type Classes 2 22.1 Chapter Introduction . .2 22.2 Polymorphism in Haskell . .2 22.3 Why Overloading? . .2 22.4 Defining an Equality Class and Its Instances . .4 22.5 Type Class Laws . .5 22.6 Another Example Class Visible ..................5 22.7 Class Extension (Inheritance) . .6 22.8 Multiple Constraints . .7 22.9 Built-In Haskell Classes . .8 22.10Comparison to Other Languages . .8 22.11What Next? . .9 22.12Exercises . 10 22.13Acknowledgements . 10 22.14References . 11 22.15Terms and Concepts . 11 Copyright (C) 2017, 2018, H. Conrad Cunningham Professor of Computer and Information Science University of Mississippi 211 Weir Hall P.O. Box 1848 University, MS 38677 (662) 915-5358 Browser Advisory: The HTML version of this textbook requires use of a browser that supports the display of MathML. A good choice as of November 2018 is a recent version of Firefox from Mozilla. 1 22 Overloading and Type Classes 22.1 Chapter Introduction Chapter 5 introduced the concept of overloading. Chapters 13 and 21 introduced the related concepts of type classes and instances. The goal of this chapter and the next chapter is to explore these concepts in more detail. The concept of type class was introduced into Haskell to handle the problem of comparisons, but it has had a broader and more profound impact upon the development of the language than its original purpose. This Haskell feature has also had a significant impact upon the design of subsequent languages (e.g.
    [Show full text]
  • Bridging the Realism Gap for CAD-Based Visual Recognition
    University of Passau Faculty of Computer Science and Mathematics (FIM) Chair of Distributed Information Systems Computer Science Bridging the Realism Gap for CAD-Based Visual Recognition Benjamin Planche A Dissertation Presented to the Faculty of Computer Science and Mathematics of the University of Passau in Partial Fulfillment of the Requirements for the Degree of Doctor of Natural Sciences 1. Reviewer Prof. Dr. Harald Kosch Chair of Distributed Information Systems University of Passau 2. Reviewer Prof. Dr. Serge Miguet LIRIS Laboratory Université Lumière Lyon 2 Passau – September 17, 2019 Benjamin Planche Bridging the Realism Gap for CAD-Based Visual Recognition Computer Science, September 17, 2019 Reviewers: Prof. Dr. Harald Kosch and Prof. Dr. Serge Miguet University of Passau Chair of Distributed Information Systems Faculty of Computer Science and Mathematics (FIM) Innstr. 33 94032 Passau Abstract Computer vision aims at developing algorithms to extract high-level information from images and videos. In the industry, for instance, such algorithms are applied to guide manufacturing robots, to visually monitor plants, or to assist human operators in recognizing specific components. Recent progress in computer vision has been dominated by deep artificial neural network, i.e., machine learning methods simulating the way that information flows in our biological brains, and the way that our neural networks adapt and learn from experience. For these methods to learn how to accurately perform complex visual tasks, large amounts of annotated images are needed. Collecting and labeling such domain-relevant training datasets is, however, a tedious—sometimes impossible—task. Therefore, it has become common practice to leverage pre-available three-dimensional (3D) models instead, to generate synthetic images for the recognition algorithms to be trained on.
    [Show full text]
  • Cross-Platform Language Design
    Cross-Platform Language Design THIS IS A TEMPORARY TITLE PAGE It will be replaced for the final print by a version provided by the service academique. Thèse n. 1234 2011 présentée le 11 Juin 2018 à la Faculté Informatique et Communications Laboratoire de Méthodes de Programmation 1 programme doctoral en Informatique et Communications École Polytechnique Fédérale de Lausanne pour l’obtention du grade de Docteur ès Sciences par Sébastien Doeraene acceptée sur proposition du jury: Prof James Larus, président du jury Prof Martin Odersky, directeur de thèse Prof Edouard Bugnion, rapporteur Dr Andreas Rossberg, rapporteur Prof Peter Van Roy, rapporteur Lausanne, EPFL, 2018 It is better to repent a sin than regret the loss of a pleasure. — Oscar Wilde Acknowledgments Although there is only one name written in a large font on the front page, there are many people without which this thesis would never have happened, or would not have been quite the same. Five years is a long time, during which I had the privilege to work, discuss, sing, learn and have fun with many people. I am afraid to make a list, for I am sure I will forget some. Nevertheless, I will try my best. First, I would like to thank my advisor, Martin Odersky, for giving me the opportunity to fulfill a dream, that of being part of the design and development team of my favorite programming language. Many thanks for letting me explore the design of Scala.js in my own way, while at the same time always being there when I needed him.
    [Show full text]
  • A Framework for Compiling C++ Programs with Encrypted Operands
    1 E3: A Framework for Compiling C++ Programs with Encrypted Operands Eduardo Chielle, Oleg Mazonka, Homer Gamil, Nektarios Georgios Tsoutsos and Michail Maniatakos Abstract In this technical report we describe E3 (Encrypt-Everything-Everywhere), a framework which enables execution of standard C++ code with homomorphically encrypted variables. The framework automatically generates protected types so the programmer can remain oblivious to the underlying encryption scheme. C++ protected classes redefine operators according to the encryption scheme effectively making the introduction of a new API unnecessary. At its current version, E3 supports a variety of homomorphic encryption libraries, batching, mixing different encryption schemes in the same program, as well as the ability to combine modular computation and bit-level computation. I. INTRODUCTION In this document, we describe the E3 (Encrypt-Everything-Everywhere) framework for deploying private computation in C++ programs. Our framework combines the properties of both bit-level arithmetic and modular arithmetic within the same algorithm. The framework provides novel protected types using standard C++ without introducing a new library API. E3 is developed in C++, is open source [2], and works in Windows and Linux OSes. Unique features of E3: 1) Enables secure general-purpose computation using protected types equivalent to standard C++ integral types. The protected types, and consequently the code using them, do not depend on the underlying encryption scheme, which makes the data encryption independent of the program. 2) Allows using different FHE schemes in the same program as well as the same FHE scheme with different keys. E. Chielle, O. Mazonka, H. Gamil, and M. Maniatakos are with the Center for Cyber Security, New York University Abu Dhabi, UAE.
    [Show full text]