DOCSLIB.ORG

4500/6500 Programming Languages What Are Types? Different Definitions

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
4500/6500 Programming Languages What Are Types? Different Definitions What are Types? ! Denotational: Collection of values from domain CSCI: 4500/6500 Programming » integers, doubles, characters ! Abstraction: Collection of operations that can be Languages applied to entities of that type ! Structural: Internal structure of a bunch of data, described down to the level of a small set of Types fundamental types ! Implementers: Equivalence classes 1 Maria Hybinette, UGA Maria Hybinette, UGA 2 Different Definitions: Types versus Typeless What are types good for? ! Documentation: Type for specific purposes documents 1. "Typed" or not depends on how the interpretation of the program data representations is determined » Example: Person, BankAccount, Window, Dictionary » When an operator is applied to data objects, the ! Safety: Values are used consistent with their types. interpretation of their values could be determined either by the operator or by the data objects themselves » Limit valid set of operation » Languages in which the interpretation of a data object is » Type Checking: Prevents meaningless operations (or determined by the operator applied to it are called catch enough information to be useful) typeless languages; ! Efficiency: Exploit additional information » those in which the interpretation is determined by the » Example: a type may dictate alignment at at a multiple data object itself are called typed languages. of 4, the compiler may be able to use more efficient 2. Sometimes it just means that the object does not need machine code instructions to be explicitly declared (Visual Basic, Jscript … ). ! Abstraction: Types allow programmer to think about programs at a higher level ! Polymorphism: when the compiler finds that it does not need to know certain things. Maria Hybinette, UGA 3 Maria Hybinette, UGA 4 What is type again? Weakly typed and Weak typing Looking at an object: ! Weakly typed: Can successfully perform an improper operation to an object ! Syntactically compatible: The object provides all the expected operations (type names, Type ! Weak typing (latent typing): Type constraints are function signatures, interfaces) relaxed to make programming more flexible and powerful (“no type at all typing”) ! Semantically compatible: The object's la·tent Class operations all behave in the expected way (state 1. Present or potential but not evident or active. In existence but semantics, logical axioms, proofs) not manifest. Latent talent. 2. Psychology. Present and accessible in the unconscious mind but not consciously expressed. ! Type: it provides a particular interface » Example: Duck typing: if it walks like a duck … ! Class: describes implementation constraints » Does not imply type safety or unsafety (later) Maria Hybinette, UGA 5 Maria Hybinette, UGA 6 Weak Type & Type Safety Weak Type & Type Safety ! Weak typing implicitly/automatically convert (or allow ! Weak typing implicitly/automatically convert (or allow cast) cast) when used. when used. var x = 5; // (1) var x = 5; // (1) int x = 5; var y = “hi” // (2) var y = “4” // (2) char y[] = “hi”; x + y ; // (3) x + y ; // (3) char *z = x + y; ! z points to a memory address 5 character beyond y (pointer ! Visual Basic (pre.net) arithmetic). » Left yields “5hi” » Content of that location may be outside addressable memory (dereferencing z may terminate program) » Right yields? 9 or “54”? » Unsafe ! Also program does not crash so in this respect Visual Basic appears “type-safe” Maria Hybinette, UGA 7 Maria Hybinette, UGA 8 Static versus Dynamic Type Strongly and Weakly Typed Checking ! Strongly typed typed languages prevents you from ! Static type checking: check constraints at applying an operation on data that is inappropriate compile time. » Ada, ML, Haskell ! Dynamic type checking: check constraints at » Example of not strongly typed: C’s cast operation: forces compiler to accept and allow the conversion at run-time run time even if it is in appropriate » Examples: Java, constrains the types and usage of ! Weakly typed languages: can successfully perform and all the symbols at compile time, but also has improper operation to an object (un-safe) enough runtime support to perform limited dynamic ! Weak (latently) typed languages (different checks. If it can't check something statically (array polymorphism) automatically convert (or casts) types bounds or null pointers, for example), it checks when used them dynamically. » Visual Basic (pre-.Net) Maria Hybinette, UGA 9 Maria Hybinette, UGA 10 Example: Static and Dynamic Type Checking Example Implementation var x = 5; // (1) var x; // (1) var y := “hi”; // (2) x := 5; // (2) var z = x + y; // (3) x := “hi” // (3) ! (1) declares the name x (2) associates integer ! (1) binds 5 to x (2) binds “hi” to y; and (3) value to x and (3) associates string value “hi” attempts to add x to y. to x ! Binding may be represented by pairs » Most statically typed languages illegal because (2) » (integer, 5) and (string, “hi”) and (3) bind x to values of inconsistent types ! Executing line 3 … error… » Pure dynamically typed languages would permit it because the name x would not have to have consistent type. – Dynamic languages catch errors related to misuse of values “type errors” at the time of the computation of the statement/expression. Maria Hybinette, UGA 11 Maria Hybinette, UGA 12 Advantages of Static Typing Implicit and Explicit Types ! More reliable [ ? ] ! Explicit (Manifest) Typing: Types appears as ! more efficient at run time [ yes! ] syntax in the program » int a, char b; C++/C ! Implicit Typing: Can infer type, not part of the text of the program » ML and Scheme Maria Hybinette, UGA 13 Maria Hybinette, UGA 14 Type Equivalence Structural Equivalence struct student { string name; string address;} ! Determining when the types of two values are struct school { string name; string address;} the same struct student { string name; string address;} ! The same component, put together the same struct school { string name; string address;} » Algol, early Pascal, C (with exception) and ML ! Straightforward and easy to implement ! Are these the same? ! Definition varies from language to language » Does ORDER of the fields matter ! Yes! Example is structurally equivalent Maria Hybinette, UGA 15 Maria Hybinette, UGA 16 Strict & Loose Name Name (Nominative) Equivalence Equivalence struct student { string name; string address;} ! Aliasing: Multiple names for the same type struct school { string name; string address;} » typdef in C/C++ ! More popular recently » TYPE new_type = old_type in Modula 2 ! A new name or definition = a new type ! Subtyping: explicit naming of parent » Java, current Pascal, Ada ! Assume that: if programmer wrote two ! Strict: aliases are distinct types different definitions, then wanted two types ! Loose: aliases are equivalent types » Is this a good or bad assumption to make? ! Example: No! not name equivalent Maria Hybinette, UGA 17 Maria Hybinette, UGA 18 Duck Typing Duck typing in Python ! Variable itself determines what it can do, if it ! Pythonic programming style that determines an implements a certain interface. object's type by inspection of its method or attribute signature rather than by explicit relationship to some ! Object is interchangeable with any object that type object implements the same interface, no matter whether the two have related inheritance ! By emphasizing interfaces rather than specific types, hierarchy well-designed code improves its flexibility by allowing polymorphic substitution. » Templates in C++ is similar but cannot do it at run-time ! Duck-typing avoids tests using type() or isinstance(). Instead, it typically employs hasattr() tests or EAFP if it walks like a duck, and talks like a duck, then it might as [Easier to Ask Forgiveness than Permission] well be a duck. One can also say that the language ducks programming. the issue of typing. “duck the issue of typing” Maria Hybinette, UGA 19 Maria Hybinette, UGA 20 Duck Typing: Python's File Like classes Duck typing in Java ! Classes can implement some or all of the methods of ! 2003, Dave Orme, leader of Eclipse's Visual Editor Project file and be used where files would normally be used. » Needed a generic way to bind any SWT control to any » For example, GzipFile implements a file-like object for JavaBeans-style object, accessing gzip-compressed data. » Observed SWT reuses names across its class hierarchy. » cStringIO allows treating a Python string as a file. – For example, to set captions set the “Text property” » Sockets and files share many of the same methods as ! true for an SWT Shell (window), a Text control, a Label, and many more well, however, SWT controls – sockets lack the tell() method and can't be used everywhere » Realized that if he could implement data binding in terms of the a GzipFile can be used. methods that are implemented on a control, » a file-like object can implement only methods it is able to, – could improve re-use instead of implementing separate data and consequently it can be only used in situations where binding for an SWT Shell, Text, Label, and so on. it makes sense. – Flexibility of Duck typing! » Created a class that makes duck typing simple and natural for Java programmers. Maria Hybinette, UGA 21 Maria Hybinette, UGA 22 Static Strong Nominative Language Safety Dynamic Weak Structural Assembly none weak unsafe structural BASIC static weak safe nominative C/C++ static weak unsafe structural Fortran static strong safe nominative Data Types Java static strong safe nominative C# static weak unsafe nominative ML static strong safe structural Scheme dynamic
Load more

Recommended publications
  • Functional Pls Introduction to Haskell
    Thoughts on Assignment 4 PL Category: Functional PLs Introduction to Haskell CS F331 Programming Languages CSCE A331 Programming Language Concepts Lecture Slides Friday, February 22, 2019 Glenn G. Chappell Department of Computer Science University of Alaska Fairbanks [email protected] © 2017–2019 Glenn G. Chappell Thoughts on Assignment 4 Introduction In Assignment 4 you will be writing a Recursive-Descent parser, in the form of Lua module parseit. It will be similar to module rdparser4 (written in class), but it will involve a different grammar & AST specification. In Assignment 6 you will write an interpreter that takes, as input, an AST of the form your parser returns. The result will be an implementation of a programming language called Jerboa. Module parseit is to parse a complete programming language, while module rdparser4 only parses expressions. Nonetheless, Jerboa has expressions, and they work in much the same way as those handled by rdparser4. I suggest using file rdparser4.lua as a starting point for Assignment 4. 22 Feb 2019 CS F331 / CSCE A331 Spring 2019 2 Thoughts on Assignment 4 The Goal Here is a sample Jerboa program, again. # Function fibo # Main Program # Given k, return F(k), where # F(n) = nth Fibonacci no. # Get number of Fibos to output def fibo() write("How many Fibos to print? ") a = 0 # Consecutive Fibos n = readnum() b = 1 write(cr) i = 0 # Loop counter while i < k # Print requested number of Fibos c = a+b # Advance j = 0 # Loop counter a = b while j < n b = c k = j i = i+1 # ++counter write("F(",j,")
    [Show full text]
  • Safe, Fast and Easy: Towards Scalable Scripting Languages
    Safe, Fast and Easy: Towards Scalable Scripting Languages by Pottayil Harisanker Menon A dissertation submitted to The Johns Hopkins University in conformity with the requirements for the degree of Doctor of Philosophy. Baltimore, Maryland Feb, 2017 ⃝c Pottayil Harisanker Menon 2017 All rights reserved Abstract Scripting languages are immensely popular in many domains. They are char- acterized by a number of features that make it easy to develop small applications quickly - flexible data structures, simple syntax and intuitive semantics. However they are less attractive at scale: scripting languages are harder to debug, difficult to refactor and suffers performance penalties. Many research projects have tackled the issue of safety and performance for existing scripting languages with mixed results: the considerable flexibility offered by their semantics also makes them significantly harder to analyze and optimize. Previous research from our lab has led to the design of a typed scripting language built specifically to be flexible without losing static analyzability. Inthis dissertation, we present a framework to exploit this analyzability, with the aim of producing a more efficient implementation Our approach centers around the concept of adaptive tags: specialized tags attached to values that represent how it is used in the current program. Our frame- work abstractly tracks the flow of deep structural types in the program, and thuscan ii ABSTRACT efficiently tag them at runtime. Adaptive tags allow us to tackle key issuesatthe heart of performance problems of scripting languages: the framework is capable of performing efficient dispatch in the presence of flexible structures. iii Acknowledgments At the very outset, I would like to express my gratitude and appreciation to my advisor Prof.
    [Show full text]
  • Comparison of Programming Languages
    ECE326 PROGRAMMING LANGUAGES Lecture 1 : Course Introduction Kuei (Jack) Sun ECE University of Toronto Fall 2019 Course Instructor Kuei (Jack) Sun Contact Information Use Piazza Send me (Kuei Sun) a private post Not “Instructors”, otherwise the TAs will also see it http://piazza.com/utoronto.ca/fall2019/ece326 Sign up to the course to get access Office: PRA371 (office hours upon request only) Research Interests Systems programming, software optimization, etc. 2 Course Information Course Website http://fs.csl.toronto.edu/~sunk/ece326.html Lecture notes, tutorial slides, assignment handouts Quercus Grade posting, course evaluation, lab group sign-up! Piazza Course announcement, course discussion Assignment discussion Lab TAs will read and answer relevant posts periodically 3 Course Information No required textbook Exam questions will come from lectures, tutorials, and assignments See course website for suggested textbooks Lab sessions Get face-to-face help from a TA with your assignments Tutorials Cover supplementary materials not in lectures Go through sample problems that may appear on exams 4 Volunteer Notetakers Help your peers Improve your own notetaking skills Receive Certificate of Recognition Information: https://www.studentlife.utoronto.ca/as/note-taking Registration: https://clockwork.studentlife.utoronto.ca/custom/misc/home.aspx Notetakers needed for lectures and tutorials 5 Background Programming Languages A formal language consisting of a instructions to implement algorithms and perform
    [Show full text]
  • Comparative Studies of Programming Languages; Course Lecture Notes
    Comparative Studies of Programming Languages, COMP6411 Lecture Notes, Revision 1.9 Joey Paquet Serguei A. Mokhov (Eds.) August 5, 2010 arXiv:1007.2123v6 [cs.PL] 4 Aug 2010 2 Preface Lecture notes for the Comparative Studies of Programming Languages course, COMP6411, taught at the Department of Computer Science and Software Engineering, Faculty of Engineering and Computer Science, Concordia University, Montreal, QC, Canada. These notes include a compiled book of primarily related articles from the Wikipedia, the Free Encyclopedia [24], as well as Comparative Programming Languages book [7] and other resources, including our own. The original notes were compiled by Dr. Paquet [14] 3 4 Contents 1 Brief History and Genealogy of Programming Languages 7 1.1 Introduction . 7 1.1.1 Subreferences . 7 1.2 History . 7 1.2.1 Pre-computer era . 7 1.2.2 Subreferences . 8 1.2.3 Early computer era . 8 1.2.4 Subreferences . 8 1.2.5 Modern/Structured programming languages . 9 1.3 References . 19 2 Programming Paradigms 21 2.1 Introduction . 21 2.2 History . 21 2.2.1 Low-level: binary, assembly . 21 2.2.2 Procedural programming . 22 2.2.3 Object-oriented programming . 23 2.2.4 Declarative programming . 27 3 Program Evaluation 33 3.1 Program analysis and translation phases . 33 3.1.1 Front end . 33 3.1.2 Back end . 34 3.2 Compilation vs. interpretation . 34 3.2.1 Compilation . 34 3.2.2 Interpretation . 36 3.2.3 Subreferences . 37 3.3 Type System . 38 3.3.1 Type checking . 38 3.4 Memory management .
    [Show full text]
  • Static Analyses for Stratego Programs
    Static analyses for Stratego programs BSc project report June 30, 2011 Author name Vlad A. Vergu Author student number 1195549 Faculty Technical Informatics - ST track Company Delft Technical University Department Software Engineering Commission Ir. Bernard Sodoyer Dr. Eelco Visser 2 I Preface For the successful completion of their Bachelor of Science, students at the faculty of Computer Science of the Technical University of Delft are required to carry out a software engineering project. The present report is the conclusion of this Bachelor of Science project for the student Vlad A. Vergu. The project has been carried out within the Software Language Design and Engineering Group of the Computer Science faculty, under the direct supervision of Dr. Eelco Visser of the aforementioned department and Ir. Bernard Sodoyer. I would like to thank Dr. Eelco Visser for his past and ongoing involvment and support in my educational process and in particular for the many opportunities for interesting and challenging projects. I further want to thank Ir. Bernard Sodoyer for his support with this project and his patience with my sometimes unconvential way of working. Vlad Vergu Delft; June 30, 2011 II Summary Model driven software development is gaining momentum in the software engi- neering world. One approach to model driven software development is the design and development of domain-specific languages allowing programmers and users to spend more time on their core business and less on addressing non problem- specific issues. Language workbenches and support languages and compilers are necessary for supporting development of these domain-specific languages. One such workbench is the Spoofax Language Workbench.
    [Show full text]
  • Blossom: a Language Built to Grow
    Macalester College DigitalCommons@Macalester College Mathematics, Statistics, and Computer Science Honors Projects Mathematics, Statistics, and Computer Science 4-26-2016 Blossom: A Language Built to Grow Jeffrey Lyman Macalester College Follow this and additional works at: https://digitalcommons.macalester.edu/mathcs_honors Part of the Computer Sciences Commons, Mathematics Commons, and the Statistics and Probability Commons Recommended Citation Lyman, Jeffrey, "Blossom: A Language Built to Grow" (2016). Mathematics, Statistics, and Computer Science Honors Projects. 45. https://digitalcommons.macalester.edu/mathcs_honors/45 This Honors Project - Open Access is brought to you for free and open access by the Mathematics, Statistics, and Computer Science at DigitalCommons@Macalester College. It has been accepted for inclusion in Mathematics, Statistics, and Computer Science Honors Projects by an authorized administrator of DigitalCommons@Macalester College. For more information, please contact [email protected]. In Memory of Daniel Schanus Macalester College Department of Mathematics, Statistics, and Computer Science Blossom A Language Built to Grow Jeffrey Lyman April 26, 2016 Advisor Libby Shoop Readers Paul Cantrell, Brett Jackson, Libby Shoop Contents 1 Introduction 4 1.1 Blossom . .4 2 Theoretic Basis 6 2.1 The Potential of Types . .6 2.2 Type basics . .6 2.3 Subtyping . .7 2.4 Duck Typing . .8 2.5 Hindley Milner Typing . .9 2.6 Typeclasses . 10 2.7 Type Level Operators . 11 2.8 Dependent types . 11 2.9 Hoare Types . 12 2.10 Success Types . 13 2.11 Gradual Typing . 14 2.12 Synthesis . 14 3 Language Description 16 3.1 Design goals . 16 3.2 Type System . 17 3.3 Hello World .
    [Show full text]
  • Analytická Řešení Vybraných Typů Diferenciálních Rovnic
    VYSOKÉ UČENÍ TECHNICKÉ V BRNĚ BRNO UNIVERSITY OF TECHNOLOGY FAKULTA STROJNÍHO INŽENÝRSTVÍ FACULTY OF MECHANICAL ENGINEERING ÚSTAV AUTOMATIZACE A INFORMATIKY INSTITUTE OF AUTOMATION AND COMPUTER SCIENCE ANALYTICKÁ ŘEŠENÍ VYBRANÝCH TYPŮ DIFERENCIÁLNÍCH ROVNIC: SOFTWAROVÁ PODPORA PRO STUDENTY TECHNICKÝCH OBORŮ ANALYTICAL SOLUTIONS FOR SELECTED TYPES OF DIFFERENTIAL EQUATIONS: SOFTWARE SUPPORT TOOL FOR STUDENTS IN TECHNICAL FIELDS BAKALÁŘSKÁ PRÁCE BACHELOR'S THESIS AUTOR PRÁCE Daniel Neuwirth, DiS. AUTHOR VEDOUCÍ PRÁCE Ing. Jan Roupec, Ph.D. SUPERVISOR BRNO 2017 ABSTRAKT Cílem této práce bylo vytvořit počítačovou aplikaci s jednoduchým uživatelským rozhraním, určenou pro řešení vybraných typů diferenciálních rovnic, jejíž výstup není omezen na prosté zobrazení konečného výsledku, nýbrž zahrnuje i kompletní postup výpočtu, a díky tomu může sloužit jako podpůrná výuková pomůcka pro studenty vysokých škol. ABSTRACT The aim of this thesis was to create a computer application with a simple user interface for solving selected types of differential equations, whose output is not limited to display a final result only, but also includes a complete calculation procedure and therefore can serve as a supportive teaching aid for university students. KLÍČOVÁ SLOVA diferenciální rovnice, počítačový algebraický systém, programovací jazyk C++ KEYWORDS differential equation, computer algebra system, C++ programming language BIBLIOGRAFICKÁ CITACE NEUWIRTH, Daniel. Analytická řešení vybraných typů diferenciálních rovnic: softwarová podpora pro studenty technických oborů. Brno: Vysoké učení technické v Brně, Fakulta strojního inženýrství, 2017. 77 s. Vedoucí bakalářské práce Ing. Jan Roupec, Ph.D. PODĚKOVÁNÍ Rád bych poděkoval vedoucímu své bakalářské práce Ing. Janu Roupcovi, Ph.D. za odborné vedení při tvorbě této práce, za cenné rady a návrhy ke zlepšení, drobné korektury a zejména za jeho entuziasmus, se kterým k tomuto procesu přistupoval.
    [Show full text]
  • BEGINNING OBJECT-ORIENTED PROGRAMMING with JAVASCRIPT Build up Your Javascript Skills and Embrace PRODUCT Object-Oriented Development for the Modern Web INFORMATION
    BEGINNING OBJECT-ORIENTED PROGRAMMING WITH JAVASCRIPT Build up your JavaScript skills and embrace PRODUCT object-oriented development for the modern web INFORMATION FORMAT DURATION PUBLISHED ON Instructor-Led Training 3 Days 22nd November, 2017 DESCRIPTION OUTLINE JavaScript has now become a universal development Diving into Objects and OOP Principles language. Whilst offering great benefits, the complexity Creating and Managing Object Literals can be overwhelming. Defining Object Constructors Using Object Prototypes and Classes In this course we show attendees how they can write Checking Abstraction and Modeling Support robust and efficient code with JavaScript, in order to Analyzing OOP Principles in JavaScript create scalable and maintainable web applications that help developers and businesses stay competitive. Working with Encapsulation and Information Hiding Setting up Strategies for Encapsulation LEARNING OUTCOMES Using the Meta-Closure Approach By completing this course, you will: Using Property Descriptors Implementing Information Hiding in Classes • Cover the new object-oriented features introduced as a part of ECMAScript 2015 Inheriting and Creating Mixins • Build web applications that promote scalability, Implementing Objects, Inheritance, and Prototypes maintainability and usability Using and Controlling Class Inheritance • Learn about key principles like object inheritance and Implementing Multiple Inheritance JavaScript mixins Creating and Using Mixins • Discover how to skilfully develop asynchronous code Defining Contracts with Duck Typing within larger JS applications Managing Dynamic Typing • Complete a variety of hands-on activities to build Defining Contracts and Interfaces up your experience of real-world challenges and Implementing Duck Typing problems Comparing Duck Typing and Polymorphism WHO SHOULD ATTEND Advanced Object Creation Mastering Patterns, Object Creation, and Singletons This course is for existing developers who are new to Implementing an Object Factory object-oriented programming in the JavaScript language.
    [Show full text]
  • Multiparadigm Programming with Python 3 Chapter 5
    Multiparadigm Programming with Python 3 Chapter 5 H. Conrad Cunningham 7 September 2018 Contents 5 Python 3 Types 2 5.1 Chapter Introduction . .2 5.2 Type System Concepts . .2 5.2.1 Types and subtypes . .2 5.2.2 Constants, variables, and expressions . .2 5.2.3 Static and dynamic . .3 5.2.4 Nominal and structural . .3 5.2.5 Polymorphic operations . .4 5.2.6 Polymorphic variables . .5 5.3 Python 3 Type System . .5 5.3.1 Objects . .6 5.3.2 Types . .7 5.4 Built-in Types . .7 5.4.1 Singleton types . .8 5.4.1.1 None .........................8 5.4.1.2 NotImplemented ..................8 5.4.2 Number types . .8 5.4.2.1 Integers (int)...................8 5.4.2.2 Real numbers (float)...............9 5.4.2.3 Complex numbers (complex)...........9 5.4.2.4 Booleans (bool)..................9 5.4.2.5 Truthy and falsy values . 10 5.4.3 Sequence types . 10 5.4.3.1 Immutable sequences . 10 5.4.3.2 Mutable sequences . 12 5.4.4 Mapping types . 13 5.4.5 Set Types . 14 5.4.5.1 set ......................... 14 5.4.5.2 frozenset ..................... 14 5.4.6 Other object types . 15 1 5.5 What Next? . 15 5.6 Exercises . 15 5.7 Acknowledgements . 15 5.8 References . 16 5.9 Terms and Concepts . 16 Copyright (C) 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 a browser that supports the display of MathML.
    [Show full text]
  • Reducing Costs with Structural Typing.Key
    Reducing Costs with StructuralDuck Typing 1 “Duck Typing” In computer programming with object-oriented programming languages, duck typing is a layer of programming language and design rules on top of typing. Typing is concerned withvacuous! assigning a type to any object. Duckunnecessary! typing is concerned with establishing the suitability of an object for some purpose. With normalclass typing, suitability is assumed to be determined by an object’s typeclass only. With nominal typing, suitability is assumed to depend on the claims made when the object was created In contrast in duck typing, an object's suitability is determined by the presence of certain methods and properties (with appropriate meaning), rather than the actual type of the object. The name of the concept refers to the duck test, attributed to James Whitcomb Riley, which may be phrased as follows: When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.[1] Some confusion present here 2 Metz: • Duck types are public interfaces that are not tied to any specific class • A Ruby object is like a partygoer at a masquerade ballGrace that changes masks to suit the theme. It can expose a different face to every viewer; it can implement many different interfaces. • … an object’s type is in the eye of the beholder. Users of an object need not, and should not, be concerned about its class. • It’s not what an object is that matters, it’s what it does. 3 Structural vs. Nominal • Structural typing (Duck Typing) ✦ a type T describes a set of properties (so, it’s like a predicate).
    [Show full text]
  • Sqlite 1 Sqlite
    SQLite 1 SQLite SQLite Developer(s) D. Richard Hipp Initial release August 2000 [1] Latest stable 3.8.4.2 (March 26, 2014) [±] Written in C Operating system Cross-platform Size 658 KiB Type RDBMS (embedded) License Public domain [2] Website sqlite.org SQLite (/ˌɛskjuːɛlˈlaɪt/ or /ˈsiːkwəl.laɪt/) is a relational database management system contained in a C programming library. In contrast to other database management systems, SQLite is not a separate process that is accessed from the client application, but an integral part of it. SQLite is ACID-compliant and implements most of the SQL standard, using a dynamically and weakly typed SQL syntax that does not guarantee the domain integrity. SQLite is a popular choice as embedded database for local/client storage in application software such as web browsers. It is arguably the most widely deployed database engine, as it is used today by several widespread browsers, operating systems, and embedded systems, among others. SQLite has many bindings to programming languages. The source code for SQLite is in the public domain. Design Unlike client–server database management systems, the SQLite engine has no standalone processes with which the application program communicates. Instead, the SQLite library is linked in and thus becomes an integral part of the application program. (In this, SQLite follows the precedent of Informix SE of c. 1984 [3]) The library can also be called dynamically. The application program uses SQLite's functionality through simple function calls, which reduce latency in database access: function calls within a single process are more efficient than inter-process communication.
    [Show full text]
  • Gradual Security Typing with References
    2013 IEEE 26th Computer Security Foundations Symposium Gradual Security Typing with References Luminous Fennell, Peter Thiemann Dept. of Computing Science University of Freiburg Freiburg, Germany Email: {fennell, thiemann}@informatik.uni-freiburg.de Abstract—Type systems for information-flow control (IFC) The typing community studies a similar interplay between are often inflexible and too conservative. On the other hand, static and dynamic checking. Gradual typing [25], [26] is dynamic run-time monitoring of information flow is flexible and an approach where explicit cast operations mediate between permissive but it is difficult to guarantee robust behavior of a program. Gradual typing for IFC enables the programmer to coexisting statically and dynamically typed program frag- choose between permissive dynamic checking and a predictable, ments. The type of a cast operation reflects the outcome of conservative static type system, where needed. the run-time test performed by the cast: The return type of We propose ML-GS, a monomorphic ML core language with the cast is the compile-time manifestation of the positive test; references and higher-order functions that implements gradual a negative outcome of the test causes a run-time exception. typing for IFC. This language contains security casts, which enable the programmer to transition back and forth between Disney and Flanagan propose an integration of security static and dynamic checking. types with dynamic monitoring via gradual typing [11]. Such In particular, ML-GS enables non-trivial casts on reference an integration enables the stepwise introduction of checked types so that a reference can be safely used everywhere in a security policies into a software system.
    [Show full text]