Mango

1
Mango

• A General Purpose Programming Language

2
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

3
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
• Its been a seven year voyage

4
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

5
A lack of alternatives

• Java, Python, Perl, Pascal, Ada, Modula, C
• Not viable replacements
• Lack Cs virtues in performance and flexibility
• Dependent on C for core tasks
• Lack of widespread appeal (clumsy, i.e. Ada?)
• Not sufficiently different to switch

6
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

7
Overview

• High level design goals and decisions
• Feature walk through
• Future directions

8
Design Goals
9
Design goals

• Syntax
• Static Typing vs. Dynamic Typing
• How Vs. What
• Large Languages Vs. Small Languages
• Object Orientation Yes or No

10
Goal 1 A Good Syntax

• Syntax is key
• Its 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

11
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

12
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 itll 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

13
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 APIs
• Intangible quality how the language corresponds
  to human cognition
• Open source makes compilers easier to write
• Open front end acts as the spec

14
Object-Orientation Yes or No?

• Stepanovs 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

15
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

16

• 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

17
Syntax
18
Mangos 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
• Users symbolic names cannot conflict with
  reserved words
• This makes the language easy to extend
• There are no exclusively reserved keywords
• Legacy of lex?

19
Modules and Naming
20
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)

21
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

22
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
• namespacekeyword_at_extensionauxiliary

23
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

24
Memory Model
25
Mangos 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

26
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

27
Sentries

• Pointer guards are called sentries
• Pointers to arbitrary datums are fat
• One address to the datum on the heap
• One address to the datums sentry
• Sentries live on the heap too
• Have a static lifetime (i.e. never deallocated)
• They are very small 5 bytes

28
Sentry Performance

• When sentries is small
• Good performance on modern hardware
• Sentries stay in the cache
• Half of the processors time is spent waiting on
  memory
• As sentries increases
• cache starts to overflow
• We need to reduce the number of sentries

29
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

30
Literals
31
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

32
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

33
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

34
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

35
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

36
Core Types
37
Core Types

• Primitives
• Tuples and Unions
• Addresses, Pointers, References
• Polymorphic Types
• Strings, Arrays and Buffers
• Collections
• Records and Abstracts

38
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

39
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

40
Primitives (contd)

• 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

41
Primitives (contd)

• Complex numbers
• Primitives qualified with units
• Enumerations
• Matrices
• Coordinates

42
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

43
Tuples and Unions

• Anonymous type products
• Fields can be labeled
• Unions
• Each term of product is overlapped
• Unsafe
• Elaborate types decompose into tuples

44
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

45
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

46
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

47
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

48
Collections (contd)

• 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

49
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

50
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

51
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

52
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

53
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

54
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

55
Built in I/O Devices

• Mangos 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)

56
Procedures and Functions
57
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

58
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

59
Procedures and Functions (contd)

• Mango supports function/procedure pointers
• Both global and local procedures
• Invokation through expressions or statements
• Statement invokations automatically infer return
  types
• Labeled arguments possible

60
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

61
Expressions
62
Arithmetic

• Addition, Subtraction, Negation, Identity
• Multiplication, Division (Truncate)
• Remainder, Division (Conserve)
• Apply (Exponent), Absolute Value
• Shift Left, Shift Right

63
Comparison/Logical

• Equal, Not Equal
• Less, Less Equal, Greater, Greater Equal
• Test, Not, And, Or, Exclusive Or, Reduce

64
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

65
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

66
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

67
Array

• Ax 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

68
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

69
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

70
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
• lta,bgt in x at h using u over p where z while q

71
Iterations

• Iterator targets
• String, array, buffer, entry, segment
• List, stack, queue, sequence
• Mask, range, set, table, graph
• File, text, stream, database, document
• Iterator construct

72
Statements
73
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

74
Overview (contd)

• Variables can be named anywhere
• Renaming can occur
• In current block
• In nested blocks
• No gotos
• Blocks can be labeled
• Blocks can be exited
• Block labels can be used to exit multiple levels

75
Overview Contd

• Conditional predication
• For many statements
• Often with alternate evaluation

76
Basic Blocks

• Execute nested block
• Exit exit blocks
• Return exit procedure and set results
• Repeat repeating block
• Continue repeat loop

77
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

78
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

79
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

80
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

81
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

82
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

83
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

84
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

85
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

86
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

87
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

88
Error Handling

• Activate active exception handler
• Try trap exceptions with block
• Throw throw exception
• Require assertion statement
• Quit quit program
• Raise rethrow exception

89
Iterators
90
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 ltstopgt
• Result type is tagged

91
Iterators (contd)

• 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

92
Exceptions
93
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

94
Exceptions (contd)

• 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

95
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

96
Global variables
97
Global Variables

• Variable global value
• Dataset string of values
• Symbol external (linked) value
• External external (linked) function

98
Global Constructors

• Global Initialization/Finalization code
• Executed before and after program
• Contents
• Local state
• Prelude procedure
• Finale procedure
• Priority value sorts contructors

99
Misc
100
Mutexes

• Formal means of acquiring locks
• Mutex object Acquire statement
• Object selected by name or by type

101
Mutex Components

• State local state
• Prelude initialization
• Acquire acquire lock
• Retry reacquire flag
• Release release lock
• Finale finalization

102
Packets

• Specialized record
• Header
• Payload of variable size
• Footer
• Packet type is polymorphic pointer
• Point to packet of any size

103
Devices

• Used to define set of hardware registers
• Record of records
• Register placement
• In sequence
• At specified offset

104
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

105
Genericity
106
Genericity
107
Builds
108
Builds

• Assemblies, Platforms, and Prologues

109
Module Suffixes

• Runtime type identification
• Requests types that are used
• Therefore not all types need to be instantiated

110
Future Directions
111
Future Directions

• Finish the compiler
• Mango is the first in a family of languages
• Sharing type system and syntax
• Targeting a virtual machine

112
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

113
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

114
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

115
Command Language

• Cross between TCL and LISP
• Can be used as OS shell
• Eliza MIT LL4 conference
• Classification of Functions into 4 TypesltGgt
  GeneratorltCgt ConcentratorltTgt TransformerltFgt
  Filter
• Connected with pipes (aka unix shells)

116
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

117
The End

• Thanks for listening