Mango

					       Mango
A General Purpose Programming
           Language
           My Background
 Early experience on Apple II
 University of Illinois – Champaign –
  Urbana.
 Bachelor's degree in computer
  engineering
 Three years at Neoglyphics: software
 Three years at Alpha: hardware
     How Mango Got Started
 Frustrated with C/C++/Java
 There had to be a better way
 Foolishly began designing my own
  language
 Foolishness can be a virtue
 It‟s been a seven year voyage
             The Problem
 Common computing infrastructure is
  written in C/C++
 C/C++ is inadequate
   Lack of higher level abstractions
   Programmers must use low level constructs
 Results of C/C++ use
   Unsafe/unstable software
   Slower development times
   Higher development costs
        A lack of alternatives
 Java, Python, Perl, Pascal, Ada, Modula,
 C#

 Not viable replacements
   Lack C‟s virtues in performance and flexibility
      Dependent on C for core tasks
   Lack of widespread appeal (clumsy, i.e. Ada?)
   Not sufficiently different to switch
     The Solution: Core Goals
 Provide higher level abstractions
   Avoid low level constructs when not needed
   Make programming easier, more enjoyable
 Retain performance and flexibility
   Allow unrestricted operations as necessary
   Avoid overhead
      Match machine execution model
 Overall: make a better experience for
 programmers
               Overview
 High level design goals and decisions
 Feature walk through
 Future directions
Design Goals
            Design goals
 Syntax
 Static Typing vs. Dynamic Typing
 How Vs. What
 Large Languages Vs. Small Languages
 Object Orientation: Yes or No
       Goal #1: A Good Syntax
 Syntax is key
     It‟s underrated (focus on semantics)
     Makes the language easier to learn
     Makes it accessible to non-programmers
     Makes the language self-documenting
 Marketing versus engineering
   Bad marketing of a good product will fail
   Bad syntax around good semantics will have
    a harder time gaining acceptance
 Static versus Dynamic Typing
 Dynamic languages are very popular
   Due to poor implementations of static
    languages
 Advantages of static typing
     Critical for performance
     Types act as documentation
     They catch many errors at compile time
     Types allows overloading of names
              How versus What
 CS fantasy to forget how and focus on what
    How is a hard problem
 Distinguish features that are theoretically
  equivalent but practically different
    Everything can be a list, but it‟ll be slow
 Rich set of primitive and aggregate types
 Side effects to use memory more effectively
    Reduce copying
 Manual memory management
    GC is not possible for some applications
    Done right beats a garbage collector
    Large Vs. Small Languages
 Small language
    Secondary features are in a standard library
    Advantages: easier to learn core features, make a compiler
 Large language
    First class treatment of secondary features
    Allows specialized operations, makes programs more readable
    Advantage: a smoother user experience
 Ease of learning is dependent on more than language
  size
    You still have to learn library API‟s
    Intangible quality: how the language corresponds to human
     cognition
 Open source makes compilers easier to write
    Open front end acts as the spec
 Object-Orientation: Yes or No?
 Stepanov‟s criticism
   programming = data structures + algorithms
   multi-sorted algebras
 Object orientation has shown itself useful in
  certain circumstances
 Offer OO as an option
 Leave inheritance behind
   Inheritance hierarchies are difficult to follow
   Fragile base class problem requires reanalysis of
    class behavior
                    Mango walk through
   Influences
   Syntax plus some basic examples
   Module system + incremental compilation (Include requires clause, parameter and options)
    (platform and foundation files)
   Naming and overloading
   Literals (include string format)
   Primitive Types
   Memory model (include pointer/reference syntax)
   Records and Abstracts
   Procedures, functions, constants (pure functions?)
   Statements: Control flow
   Statements: I/O
   Abstract Data Type (objects)
   Iterators and iteration operators
   Mutexes
   Exception Handling
   Strings, arrays, buffers
   Collection Types
   Global variables/External symbols/Module Constructors
        Calling convention part of the type system
   Packet/Device types
   Development aids
   Genericity
   SETL - set operations
   ALGOL - imperative block structure and syntax
   C - low level ops, low overhead
   ML - type inference, type syntax
   ADA - fine grained control over primitives
   PYTHON - indentation based syntax
   JAVA - interfaces
   C++ - STL, operator overloading, IO syntax
   CLU - iterators
   PASCAL - sets (bit masks)
   PERL - richness of expressibility
   COBOL - readable syntax
   SIMULA - objects
Syntax
                Mango‟s Syntax
 Mango looks like pseudo code
 Indentation based syntax
    Reduces clutter and typing
    Allows more code to be shown on the screen
    Blocks can be enclosed with begin/end delimiters if desired
 All directives, definitions, statements begin with a
  keyword
    Simple style that is easy to remember
    User‟s symbolic names cannot conflict with reserved words
    This makes the language easy to extend
 There are no exclusively reserved keywords
    Legacy of lex?
Modules and Naming
                       Modules
   Module is a set of symbols
   Each file is a module
   Module name must correspond to pathname
   A modules symbols can be public or private
     Public: symbols are visible to other modules
     Private: symbols are invisible to other modules
 Modules may import and include other modules
     Import: foreign symbols are localized (private)
     Include: foreign symbols are exported (public)
      Incremental Compilation
 Mango supports incremental compilation
   Module has changed
   A dependency has changed
 Major or minor revision?
   Compares syntax trees
   Major revision: public change
   Minor revision: private change
 Comparing syntax
   Advantage: Eases implementation
   Disadvantage: Set of major revisions is obviously
    larger
                    Naming
 Naming is not hierarchical, but geometric
 Symbol names exist within a four-d grid
   Namespace, keyword, extension, auxiliary
   Only namespace and keyword are mandatory
 Each module is part of a namespace
   Public symbols use declared namespace
   Private symbols use special namespace “local”
 Format:
   namespace::keyword@extension$auxiliary
            Shallow Overloading
 Overloading occurs for every imported or included
    module
   4d namespace is collapsed into 1d namespace
      Utilizing keyword or extension
   Other partial namespaces as well
   Symbol can be access using proper name or alias
   Ensures all overloaded symbols have a unique name
   As a result, all overloading is superficial or shallow
   Operator overloading is also supported
Memory Model
      Mango‟s Memory Model
 Value semantics
   Put stuff on the stack, particularly primitives
   Key for performance
   Offers more flexibility
 Three types of memory
   Static:
      Compiled data, global variables
      Heap items that are never deleted
   Arbitrary:
      Heap items that are eventually deleted
   Local:
      Items that live on the stack
Safe manual memory management
 Static datums
   Always safe to use
 Arbitrary datums
   Need to be guarded to avoid dangling pointer
    references
 Local datums
   Compiler must enforce restrictions to avoid
    dangling pointer references
                   Sentries
 Pointer guards are called sentries
 Pointers to arbitrary datums are fat
   One address to the datum on the heap
   One address to the datum‟s sentry
 Sentries live on the heap too
   Have a static lifetime (i.e. never deallocated)
   They are very small ~= 5 bytes
         Sentry Performance
 When # sentries is small
   Good performance on modern hardware
   Sentries stay in the cache
   Half of the processor‟s time is spent waiting
    on memory
 As # sentries increases
   cache starts to overflow
 We need to reduce the number of sentries
         Arenas and Recycling
 Method #1: Allocate in pools
   A group of datums share a sentry
   Allocated arbitrarily, but deallocated at once
 Method #2: Recycling
   Use static datums instead
   When static datums are deleted
       Initialized to zero
       Stay on the heap until datum of the same type is requested
   Incorrect results are possible, catastrophic failures
    are not
   The program cannot break the type system
Literals
                         Literals
 Definition
    A value which is known at compile time
 Types
    Immediate values
       Numeric primitives and text
    Literal expressions
       Interpreted during compilation
    Parameters
       Values used to configure the compiler
    Options
       User supplied values to customize a build
 Literals can be named
                Numeric Literals
 Six types
    Integer, Decimal, Hex, Address, Binary, Signal
    Integers and decimals also include complex plane signifiers
 Can be anonymous
    Anonymous literals are stored as untyped strings
    Converted to a real value when type is known
    There are no constraints on range
 Can be typed
    Type is specified with value
    Converted immediately to the desire type value
    There are no constraints on range
                      Text Literals
 Two types
    Characters and Strings
    Stored as untyped strings until desired type is known
 Characters enclosed with the back tick
 Text string enclosed with the double quote
 Literals can be inserted into characters and text strings
      Named literals
      Parameters
      Options
      Character codes
      Character aliases
         Literal Expressions
 Two forms of literal expressions
   Normal literals: immediate evaluation
   Macro literals: deferred evaluation
 Macros are evaluated over arguments
 Result value is optionally typed
 Expressions can include
   Condition construct
   Conversion construct
   Local aliasing
     Parameters and Options
 Changes cause recompilation of module
 Part of the public interface of the module
 Checked when comparing syntax
 Only options that are used included in
  dependency analysis
 Parameters included in dependency
  analysis
   Specified by user
   Have a major impact on compilation
Core Types
             Core Types
 Primitives
 Tuples and Unions
 Addresses, Pointers, References
 Polymorphic Types
 Strings, Arrays and Buffers
 Collections
 Records and Abstracts
            Type Qualifiers
 Pliancy: Immutable, Mutable
 Reactivity: Volatile, Inert
 Duration: Local, Static, Arbitrary
 Memory: IO, Virtual, Physical?
   Useful for embedded system with multiple
    memories
   Undecided: means to access hardware
    registers directly
                    Primitives
 Logical
   Bit (2 State), Boolean (3 State), Signal (4 state)
 Ordinal
   Range from 0 to N, where N is user specified
 Character
   ASCII, UTF 8, UTF 16, UTF 32, 8 Bit Data
 Register
   Binary register, user specified dimensions
 Signal
   Signal bus, user specified dimensions
               Primitives (cont‟d)
 Cardinal
    Unsigned integer, 1/2/4/8/16/32/64 bits
 Subrange
    Signed range, upper/lower bound, default value
 Integer
    Signed integer, 8/16/32/64 bits
 Rational
    Signed rational, fixed or floating denominator
 Decimal
    Fixed point decimal number
    Whole and fractional component
 Number
    Floating point number, specified size
          Primitives (cont‟d)
 Complex numbers
 Primitives qualified with units
 Enumerations
 Matrices
 Coordinates
           Primitive Modifiers
 Conversion
   Automatic, manual, none, universal
 Evaluation
   None, Fixed, Fluid
 Approximation
   Round, Truncate, Conserve
 Overflow
   Check, Limit, Wrap
 Byte Order
   Big, Little, Host, Network
         Tuples and Unions
 Anonymous type products
 Fields can be labeled
 Unions
   Each term of product is overlapped
   Unsafe
 Elaborate types decompose into tuples
 Addresses, Pointers, References
 Addresses have bitwise resolution
 Address is 2 product tuple
   Upper value: byte count
   Lower value: bit count
 Addresses still optimal
   types with byte-wise alignment will drop bit count
 Pointers
   Address of type where address is significant
 References
   Address of type where type is significant
           Polymorphic Types
 Sums
   Superposition of multiple types
   Qualified with type tag to ensure safety
 Handle
   Anonymous pointer (points to anything)
 Anything
   Stores any type value
       Strings, Arrays, Buffers
 Arrays
   Dimension type can be customized
   Slices of arrays preserve range information
 Strings
   Array of items from 1 to x
   Dimension type can be customized
   Slices of strings begin at 1
 Buffers
   Fixed length string that wraps around itself
   Varying start and end positions
   Dimension type can be customized
                            Collections
 Entry
        a node of a linked list
 Segment
        a combination of string and pointer
 List
    appends new data at the end
    elements allocated in pages
 Stack
    FIFO
    Can be prioritized
 Sequence
        inserts new data
        elements allocated in pages
 Queue
    LIFO
    Can be prioritized
            Collections (cont‟d)
 Mask
   A bit mask
 Range
   A numeric range with upper and lower bounds
 Set
   A hashed set
   Doubles as a one-to-one map
 Table
   A hashed one-to-many mapping
 Group
   A special collected used for comparisons
 Graph
   Used for frequency tables
                   Records
 Three visibility states
   Public: accessible anywhere
   Protected: accessible by modules that declare
    access
   Private: accessible within the module
 Two layout types
   Fixed: in order of declaration
   Packed: ordered to reduce record size
 Fields can be qualified to remove them
  from the build
                        Abstracts
 Interface to multiple record types
 Records mapped to abstracts using link directive
   Gives more flexibility in mapping abstracts
   Mappings can occur after declaration
      i.e. library types can still be mapped to abstracts
   Simplifies remapping of fields
 Fields can be qualified to remove them from the
  build
 Medley: combines abstract with a group of
  records
         Abstract Data Types
 Mango can bind any type to a class
 Objects: Classes + Record
 Properties
   getter/setter methods
 Parameters
   Properties that can only be set at instantiation
 Delegates
   Multiple dispatch for aspects and aggregates
 Normal classes do not support inheritence
        Object Construction
 Constructor (prelude)
 Destructor (finale)
 New style constructor
   Parameters and properties can be set before
    the constructor is called
   Only one constructor per class – no
    overloading
   Constructor spans entire object.
      Variable initialization at declaration
           Object Interfaces
 Interfaces (mixins)
   Separates sub typing concerns from
    implementation
 Interfaces are purely abstract. No
  associated code
 Uses link directive like record abstracts
 Bind operator links types to interfaces
  automatically
               Aggregates
 Composition instead of hierarchical
  inheritance
 Flattens the hierarchy: easier to
  understand and maintain
 Overriding of methods is explicit
   Compiler can statically check for problems
 All publicly accessible methods must
 explicitly exported
            Built in I/O Devices
 Mango‟s built in I/O devices are typed
 Six types of I/O devices
     file: an operating system file
     text: a line oriented text file
     stream: an I/O stream
     port: a connection listener
     database: a database
     document: a document (XML)
Procedures and Functions
               Procedures
 Multiple inputs and output
 Call by localized reference
   Compiler makes a duplicate of a value on the
    stack if necessary
 Nested procedures
   Can reference variables within parents scope
 Return values are held in a named
 variable
   Possible to return values with assignment
       Functions and Constants
 Real functions
   Essentially a single expression
   Extended with two case constructs
      Condition and conversion
 Constants
     Similar format to functions
     Evaluated only once, result is cached
     AKA Eiffel once function
     Clean way to instantiate global variables
Procedures and Functions (cont‟d)
 Mango supports function/procedure
 pointers
   Both global and local procedures
 Invokation through expressions or
 statements
   Statement invokations automatically infer
    return types
   Labeled arguments possible
           Method Pointers
 Method pointers
   combine class state with class method
 When a method is selected from a class
   Result is a method pointer
 Special attribute and receptor pointers
   Automatically evaluated
 Method pointers are a supertype of
 function pointers
   Will absorb function pointers
Expressions
                Arithmetic
 Addition, Subtraction, Negation, Identity
 Multiplication, Division (Truncate)
 Remainder, Division (Conserve)
 Apply (Exponent), Absolute Value
 Shift Left, Shift Right
        Comparison/Logical
 Equal, Not Equal
 Less, Less Equal, Greater, Greater Equal
 Test, Not, And, Or, Exclusive Or, Reduce
                     Casting
 Static casting
   Type is specified
 Dynamic casting
   Type is infered
   Cast is specified with dynamic cast operator
 Implicit casting
   From subtype to supertype
   Class to interface, Function to method, etc
   Polymorphic types
                   Membership
 in, not_in
    String, array, buffer, entry, segment
    List, stack, queue, sequence
    Mask, range, set, table, graph
 is, is_not
    Evaluates left value with right function
    Returns boolean
 like, not_like
    Tests left value is equivalent to right hand type
                 Selections
 Selection of record fields/class methods
   By name
   By number (access to anonymous fields)
 Class fields
   Special attribute operator
 Dynamic method operator
   Looks for class that can operate on target
    type, with named method
                    Array
 A[x] to index an array
 Slice operator
   Before and after some position
   Within a range
 ~=, /= for string comparisons
 Size operator returns size (# elements)
 Domain operator returns dimensions
                      Production
 Create and initialize data types
   Local stack, static heap, dynamic heap
 Production arguments
   Where clause
      Initialize class properties/record fields
   With clause
      Class constructor arguments
      Aggregate members
   Within/upto
      Dynamic string/array dimensions
   From
      Target arena
        Sequence Operators
 Generate sequence
   Pick: select one value
   Every: select group values
 Test sequence
   Some: one term in set matches
   All: all terms in set match
 Compute sequence
   Product: product of terms
   Sum: sum of terms
       General Iteration Form

[a of t] in x at h using u over p where z
   while q

a in x at h using u over p where z while q

<a,b> in x at h using u over p where z while q
                   Iterations
 Iterator targets
     String, array, buffer, entry, segment
     List, stack, queue, sequence
     Mask, range, set, table, graph
     File, text, stream, database, document
     Iterator construct
Statements
       Statements Overview
 Sequence of statements
 Nested block delimitation
   Begin/end pair
   Indentation
 Each statement begins with keyword
   Possible to group statements under a single
    keyword
   Delimited with indentation or begin/end pair
           Overview (cont‟d)
 Variables can be named anywhere
 Renaming can occur
   In current block
   In nested blocks
 No goto‟s
 Blocks can be labeled
 Blocks can be exited
   Block labels can be used to exit multiple
    levels
           Overview: Cont‟d
 Conditional predication
   For many statements
   Often with alternate evaluation
             Basic Blocks
 Execute: nested block
 Exit: exit blocks
 Return: exit procedure and set results
 Repeat: repeating block
 Continue: repeat loop
               Production
 Declare: declare local variable
 Allocate: make temporary
   Deallocated when leaving block
 Get: declare static type
 New: declare dynamic type
 Delete: recycle or delete heap type
 Trash: delete static heap type
              Placement
 Overlay: place a type over another type
 Create: create a type from string
 Place: place a type at an address
 Map: map a device type
 Open: open an I/O type
 Close: close an I/O type
               Assignment
 Assign: copy value
   Optional declared result with inferred type
 Swap: swap two values
 Let: reference alias of value
 Refine: update multiple fields of a record
 Touch: Mark variable as used
 Nothing: Do nothing
               Arithmetic
 Reset: reset value to default
 Set: set value to 1
 Incr: Increment by target, else 1
 Decr: Decrement by target, else 1
 Magnify: Multiply by target
 Reduce: Reduce by target
                Invokations
 Call: call function with arguments
   Optional declared result with inferred type
 Eval: evaluate arguments with function
   Optional declared result with inferred type
 Initialize: initialize object with arguments
 Finalize: finalize object
 Function: local function
 Procedure: local procedure
         Conditional Blocks
 If: If-then-else
 Select: Multiple conditions
 When: Defers compilation
 During: Conditional debug block
   Compiler option removes them
 While: Loop on pre-condition
 Until: Loop on post-condition
             Case Constructs
 Where: case of values
     Handles multiple matched terms
     Case values can include ranges and groups
     Character strings have contents compared
     Wild cards: Case value can be ignored
 Convert: covert one value into another
   Case values can include ranges and groups
   Character strings have contents compared
         Specialized Blocks
 Given: Reduces polymorphic type
   Handles multiple matched terms\
   Wild cards: Case value can be ignored
 Cast: Cast value, Execute Block
 Foreach: Iterate and execute block
 Acquire: Acquire mutex and execute block
       Collection Operators
 Add: add item into set
 Replace: exchange item with another
 Remove: remove items from set
 Take: take (arbitrary) item from set
 Trim: reduce set y by set x
 Filter: intersect set y by set x
         Collection Iterators
 Find: Return item
   Option to insert and return new item
 Extract: Remove and return item
 Fill: Populate collection with iterator
 Compute: Arithmetic sum over iteration
 Copy: Copy from one set to another
 Modify: Update items within collection
                      I/O
 Write: write terms to I/O device
 Read: read term from I/O device
   Strings, Buffers, Lists read series of terms
   Continue/Stop masks for character devices
 Print: write to standard out
 Log: Atomic write to I/O device
 Accept: accept stream from listener
 Monitor: monitor group of listeners
            Error Handling
 Activate: active exception handler
 Try: trap exceptions with block
 Throw: throw exception
 Require: assertion statement
 Quit: quit program
 Raise: rethrow exception
Iterators
                  Iterators
 Procedures to iterate over type
 Consists of operand and result type
 Iterator activation:
   By name
   By type (operand and/or result)
 Iteration deactivation
   Result is <stop>
   Result type is tagged
              Iterators (cont‟d)
 Iterator sections
     State: local state while iterator active
     Prelude: initialization segment
     Query: compute result or signal stop
     Finale: finalization segment
 Local state is pushed on stack
Exceptions
      Activated Handler Style
 Exception event code contained in global
  handler object
 Handler object pushed onto activation
  stack
 On exception, handlers are processed
  until exception is handled
 Exception handling is immediate, before
  stack is unwound
           Exceptions (cont‟d)
 Four exception flavors:
     Fatal: Quit program without unwinding stack
     Severe: Quit program but unwind stack
     Normal: Unwind stack to last trap
     Soft: Program can continue
               Advantages
 Exception is processed before unwinding
   No side effects before exception handling
 Exception code can be pushed into
 libraries
   Still possible to localize with arguments
    passed during activation
 Reduces clutter
   No need for try-catch blocks
 No need for „throws‟ clauses
Global variables
           Global Variables
 Variable: global value
 Dataset: string of values
 Symbol: external (linked) value
 External: external (linked) function
         Global Constructors
 Global Initialization/Finalization code
 Executed before and after program
 Contents:
   Local state
   Prelude procedure
   Finale procedure
 Priority value sorts contructors
Misc
               Mutexes
 Formal means of acquiring locks
 Mutex object + Acquire statement
 Object selected by name or by type
         Mutex Components
 State: local state
 Prelude: initialization
 Acquire: acquire lock
 Retry: reacquire flag
 Release: release lock
 Finale: finalization
                  Packets
 Specialized record
   Header
   Payload of variable size
   Footer
 Packet type is polymorphic pointer
   Point to packet of any size
                   Devices
 Used to define set of hardware registers
 Record of records
 Register placement:
   In sequence
   At specified offset
                Package
 Used to define group of related functions
 Elements of packages pushed into
  extended namespace
 Particularly useful for operators
 Means of reducing namespace clutter
 Means of grouping related generic
  operators
Genericity
Genericity
Builds
                 Builds
 Assemblies, Platforms, and Prologues
            Module Suffixes
 Runtime type identification
   Requests types that are used
   Therefore not all types need to be instantiated
Future Directions
          Future Directions
 Finish the compiler
 Mango is the first in a family of languages
   Sharing type system and syntax
   Targeting a virtual machine
       Application Language
 In the spirit of C# or Java
 Reference semantics
   i.e. no user defined pointers
 Automated memory management
   With user intervention
 Less complicated type system
   More accessible language
       Functional Language
 Functional/Dataflow semantics
 Strong focus on doing distributed
  computations
 Gateway to bring functional programming
  to the masses
   Accessible because of shared syntax and
    types
 Record Processing Language
 Basically a replacement for COBOL
   “The use of COBOL cripples the mind”
   “working within the limitations of the original
    COBOL programming model can make for
    robust and maintainable code”
 Overlooked area by language designers
        Command Language
 Cross between TCL and LISP
 Can be used as OS shell
 Eliza – MIT LL4 conference
   Classification of Functions into 4 Types:
    <G> Generator
    <C> Concentrator
    <T> Transformer
    <F> Filter
   Connected with pipes (aka unix shells)
               Miscellaneous
 Standard Development Environment
   Text Editor, Debugger, Static Analysis, Etc.
 Programming is about community
 Programmers Organization
     Builds community
     Standards body
     Funds open source projects
     Earns revenue by supplying directory services
  The End
Thanks for listening

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:29
posted:9/6/2011
language:English
pages:117