The Fantom language

http://www.fantom.org/

This presentation online:

http://colar.net/fantompres/

https://github.com/tcolar/fantompres

Thibaut Colar

tcolar @ colar.net

Why Fantom?

• In 1996 they founded Tridium, a Java framework for various markets(automation/aerospace...).
  They Used Java, but some companies where MS only (.Net) and integration can be difficult.
  Honeywell acquired Tridium in 2005. Brian And Andy Frank
• They Wanted java as well as .NET compatibility with a better concurrency model.
  Started with a pure OO language, added simpler compiler/build system, then moved to Fcode.
  Fantom became "public" in 2008. They worked on Fantom(OSS) during spare time, then full time (Fantom + SkyFoundry)
  JavaScript target added after 2008(unified frontend/backend - Andy). FWT -> unified UI code (JS/HTML5 + Swing). Short History
• Andy & Brian experience / needs.
  Quite open to ideas/discussions with quick fixes/ implementation Solve real Java and C# problems
• "Boring by design". It is not an academic language to explore bleeding edge theories,
  but based on solid real world experience (Obvious when you use it) Practical programming

What makes it special ?

• Compiles to Fcode bytecode, which can run on JVM, .NET and possibly more(LLVM).
  JavaScript target(Huge feature IMO! No Fcode when compiling to JS) Portability - JVM, .Net & more
• Underrated fact. Few powerful classes.
  Lots of cheap features (in part thanks to functions/closures). Clean API's
• Why have too choose one or the other? Choose as you please.
  Benefits of strong typing(type checking, tooling/IDE), plus flexibility of dynamic typing when needed.
  Type inference. Strong AND dynamic typing
• Bridge the gap between classes(inheritance issues) and interfaces(common code).
  Like interface but can have implementation.
  Mixins can have methods and fields without state(abstract only) Mixins
• Pods are the unit of versioning and deployment.
  They are combined together using clear dependencies. No Classpath / DLL hell. Modularity - pods
• pod::type.slot pod is unit of deployment/versioning - serialization.
  Cleaner than jars/classpath mess. Simple namespace
• Everything is an object (no primitives).
  Like C# ValueTypes.
  Automatically boxed/un-boxed when on JVM Truly object oriented

What makes it special ?

• Built-in. Closures support.
  Functions are a first class object.
  API's make heavy/good use of closures(huge benefit).
  While Fantom provides functional programming features it does not feel like am intimidating "requirement" (as for Haskell/Scala),
  but rather a huge simplicity bonus (API's) Functional programming
• Built-in. Lists, maps, ranges, durations, serialization(JSON like "[0, 1, 2]".in.readObj).
  Reduces need for config files. Declarative programming
• Actors model. More details later. Concurrency
• Generics greatly complicate the language.
  List, Maps and Functions can be parameterized. Controversial subject.
  Good concept but most implementations are too complex/painful Limited generics
• Default parameters, type inference, Field Accessors, Nullable types, All numbers are 64bits. Syntax sugar
• Feels a lot like a boilerplate-less version of java. Not as complex/intimidating like Scala, Clojure.
  Feels more like Groovy/Python but with strong types. Intuitive syntax for Java / C# programmers
• All you need in one small standalone package: module system, build framework, unit testing, documentation, tools,
  basic web framework and web server, desktop UI(FWT), JavaScript, ajax, email, SQL, common formats: xml, json, csv "Full" stack

Getting started

• Have Java 6+ JVM installed (or .NET)
• Download and extract Fantom from http://www.fantom.org/
• If on Linux/Mac, setup the environment:

  
  chmod +x fantom-1.0.65/adm/unixsetup
  ./fantom-1.0.65/adm/unixsetup
  export PATH=$PATH:/home/me/fantom-1.0.65/bin
                          

• You can also try online at http://www.fanzy.net/

Fantom tools

• Mention fanzy.net
  Show a mini hello world demo.
  Str name := 23; name := "john"; echo("$name"); scope; Fansh - Fantom shell
• Show a fan script. class Hello{static Void main() { echo("hello world #!")}}
  Explain pod later Fan - Fantom launcher
• Show Demo unit test. (Show Verify** ,methods in Netbeans) Fant - Unit test
• View/debug generated bytecode. fanp hello::Main.main Fanp - FCode decompiler
• Possibility of compiling Fantom from sources. Bootstrap

Fantom code structure

• Fantom's namespace as well as the unit of deployment(pod::Type.slot).
  A pod's name is globally unique. Also does Dependency management(show meta in build.fan).
  Plain zip file. Reflection: Demo: Pod.list, Pod.of("sys").types Pods
• Show hello pod example. Show explain pod folders(src, tst etc...).
  Show/explain CompUnit.fan. Show/Explain pod meta (build.fan) Compilation Unit
• Can have multiple in single fan file.
  A Type is an object oriented class which encapsulates state and behavior.
  Demo: Type.of("sys::Str").slots Types

Type system : Concepts

• Demo with fansh (Int, Bool etc..).
  Explain value-types(Int, Bool, Float) Purely object oriented
• Show in fansh: Bool, Int(64 bits, chars, 0x, underscores), Float, Decimal(4d - bigdecimal),
  Str(multi-line, interpolation, triple quotes, locale($<>), Duration(day, hr, ms), Uri(can do interpolation),
  Type(Str#), Slot(Int#plus), Range((0..3).contains(2), 0..<3), List(add,first), Map(put,get) Fantom Literals
• Compiler warns you about simple mistakes.
  Runtime checks for null coercing - fail fast.
  Show default values of Int vs Int? for example. (Non)Nullable Types
• But inference for local vars, maps, list. dynamic call operator(->).
  Better tooling, error reporting. Statically typed
• A.fits(B)->ok B.fits(A)-> implicit cast otherwise->error.
  Allows dynamic calls(obj?) cast: Str name := x->person->name.
  "Liskov Substitution Principle" Implicit casts
• Limited for simplicity. List(V,L), Maps(K,V,M), Funcs(A-H, R). Functions explained more later. Generics

Statement / Expressions

• Semi-columns optional. Show/explain examples in OtherThings.statements Statements
• All exceptions inherit from Err(useful methods).
  Show/explain examples in OtherThings.exceptions Exception Handling
• Show/explain examples in OtherThings.operators.
  Mapped to methods (and, or etc...). No bitwise ops(use methods) Expressions/Operators

Type System

• Types
• Demo classes.fan. Can Inherit from One superclass and 0+ mixins.
  Can be public/internal abstract/final. Const(Const fields only) Classes
• Demo Enumerations.fan. Normal class: (enum class but const & final with fixed instances.
  Inherit sys::Enum. Can have methods. private constructors. Enumerations
• Demo Facets.fan. (~ annotations).
  Facets are defined as normal classes(Implied const) using the facet positional keyword Facets
• Demo Mixins.fan. Like interfaces but can have methods (code reuse).
  Abstract, can't create instances. can't store state (can have abstract fields). Mixins
• Demo inheritance.fan. Base class first(if any) then 'n' mixins Covariance allowed for methods
  Fantom avoids the diamond inheritance problem.
  First mixins can't declare concrete fields, which mean they never store state.
  Second any ambiguity that arises from diamond inheritance or otherwise requires the subclass to explicitly disambiguate (or if the inherited slots are not virtual,
  then the subtype simply cannot be created). Inheritance

• Slots
• Slots: Unique name(no overloading) but allows easy/fast reflection etc... (helped by lack of primitives)
  Demo/explain Slots.fan. No inference. Storage + [getter/setter](automatic).
  Const fields (pre-assigned or in constructor)
  static(must be const, thread safety), abstract, public, protected, internal
  readonly, virtual(getter/setter can be overriden) Fields
• Demo/explain Slots.fan. A method is a slot which defines a function within a class or mixin.
  Covariance OK - allows an overridden method to narrow the return type of the inherited method. Methods
  • Demo/explain Slots.fan. Use the "new" keyword. By convention make** Constructors

Advanced topics

• Functional Programming
• Show Functions.fan
  First class objects(sys::Func). Created through: methods, closures, binding.
  Explain parameterized with Builtin generic syntax |A-H->R|
  Instance methods map to a function where the first argument is the implicit this parameter Functions
• Show Closures.fan
  Closures are an expression to create a function inside the body of a method.
  Have own scope, but can reference local variables from their scope.
  Makes it easy to use closures as method arguments (used extensively in API's, to good effect)
  Example: iteration mechanism Closures
• Java/.Net Interaction
• .Net FFI are a work in progress.
  Java, done, a few limitations: Multi-dimensional arrays, Sub-classing a Java class more than one level deep,
  can't override java overLOADED methods -> can be an issue, my solution -> create a java "pass-through" method.
  You may not subclass from a Fantom class which itself subclasses from a Java class(constructors issue) Java / .Net FFI
• Show Hello:BuildJar task.
  Class naming Rule: fan.pod.class.method Using Fantom code from Java (jarDistEnv)
• Persistance / also used with actors as a safe way to pass messages between actors.
  Fantom serialization uses a human friendly text format (subset of fantom grammar).
  Tree based, not Graph based. Do cross-reference yourself(Uri's)
  Literal/simple/complex(collections). @Serializable facet. Show FWT/demo: text and serialization tabs Serialization
• Show NativeClassExample, NativeExample.
  Don't use, except when If you need to call out native APIs, but still wish your Fantom pod to be portable across multiple platforms Natives
• Show JsExamples.fan(show generated source) and standard Fantom examples.
  Very cool: Fantom provides support for compiling/running in JavaScript VMs(Rhino, browsers)
  Use @Js facet. Can be run outside Fantom. Most sys API's are available, however not all (JavaScript limitations).
  JavaScript
• Show Dsls.fan. Domain Specific Languages - Allow you to embed other languages into your Fantom source code. Built-in: Str, Regex. Dsl's

Concurrency

• An object is said to be immutable if we can guarantee that once constructed it never changes state.
  Immutability(embedded into the language). Immutable data can be efficiently and safely shared between threads (static/const) Any object instance of a const class
  The result of Obj.toImmutable on a List, Map(read only deep copy), or Func(depends if uses mutable state)
  Otherwise can use serialization
  Can check with : Obj.IsImmutable
  Immutability
• No Shared Mutable State.
  ActorPool control background threads and has actor process messages
  Actor are guaranteed to receive its messages atomically and process(not receive) in order
  Unbounded queues ActorPool
• Show Actors.fan, HockeyActor
  Actors are given work by sending them asynchronous message.
  Use Actor.locals for mutable state
  Messages need to be immutable or serializable Actors
• A Future is used to deal with a sent message.
  It allows waiting for the message to be processed and retrieving a result.
  Also allows chaining calls and managing the process(cancel, isDone etc...). Futures
• Group / process by key
  An actor can have its messages automatically coalesced using the makeCoalescing() constructor. Coalescing messages

Features / API's

• Fantom Env (customizable)
  Show Otherthings.fan : EnvExample Env
• Uri schemes(Can make your own)
  Fantom scheme: fan://mypod/res/file.txt
  Show Otherthings.fan : NamingExample Naming
• Built-in log4J style logging
  Show OtherThings : LoggingExample
  Can be configured in etc/sys/log.props Logging
• Built-in locale/properties support.
  Show OtherThings : LocalizationExample Localization
• cleaner than Java(doh !). Base on 'ticks' (nanoseconds since 1/1/200)
  Immutable: Duration/DateTime/TimeZone Date/Time/Month/Weekday
  TimeZones In Fantom are both: offset from UTC AND daylight saving time rules. Uses ZoneInfo DB
  Gregorian calendar only
  Show OtherThings : DateExamples DateTime
• demo: FWT(show examples/fwt/demo.fan), File/Buf(Show API's), Dom, Xml
  Few classes but feature full Useful and simple API's

The Tales Framework

• Will demo it
  Simple/Practical.
  Convention over configuration / good feedback(error messages etc...)
  Clean "pure" HTML Same philosophy as Fantom.
• client, server, SQL DSL's
  JavaScript, code reload.
  Write all in one file. Takes full advantage of Fantom features
• Similar to Play!
  Hot reload, great error reporting. Very productive
• Simple ORM, Data mapping, JavaScript, SQL, Ajax ... Full stack
• Similar to Guice. Dependency Injection

Resources

• This presentation: http://colar.net/fantompres/
• Fantom.org
• Fantom.org - API's Reference / Documentation
• Fantom.org - Examples
• Fantom.org - Discussions
• Fantom Cheat sheet
• List of Fantom IDE's
• Fantom online playground
• Rosetta code examples

Third party projects

• Pod repo.
• Tales framework
• Draft lightweight web framework
• afioc (IOC/ DI)
• Fantomongo MongoDb driver
• Mustache Logic-less templates