Introduction to Swift Workshop

If you are an experienced developer who hasn't had a chance to look at the Swift Programming Language, this workshop is for you.

We'll look at language fundamentals: functions, variables and constants, collections, control-flow, optionals, generics, and closures. We'll look at Swift classes, objects, protocols, structs, modules, and enumerations.

We'll use Swift Playgrounds to explore some of these aspects of the language including the latest additions to Swift 2.0.

Swift is scheduled to be open sourced this fall. You will be able to use it for development on Linux and OS X.

There will be several hands-on portions of this workshop. To fully participate in those, you must have the Xcode 7 beta installed on your Mac.

 
3 favorite thumb_down thumb_up 0 comments visibility_off  Remove from Watchlist visibility  Add to Watchlist
 

Outline/structure of the Session

The topics we will cover are:

* Introduction to Functions in Swift

* Variables and Constants

* Collections

* More Functions

* Map, Filter, Reduce and friends

* Classes and Objects

* Enumerations

* Structs

* Protocols

* Optionals

Learning Outcome

This is a quick, firehose approach to Swift. At the end of the day, attendees will be able to go to Apple's documentation and be able to start creating apps in Swift.

We don't cover any iOS or OS X development - this is a language tutorial.

Target Audience

Experienced developers who are new to Swift

schedule Submitted 2 years ago

Comments Subscribe to Comments

comment Comment on this Proposal

  • Liked Morten Kromberg
    keyboard_arrow_down

    Morten Kromberg - Parallel Programming in Dyalog using Futures and Isolates

    Morten Kromberg
    Morten Kromberg
    CXO
    Dyalog
    schedule 2 years ago
    Sold Out!
    45 Mins
    Keynote
    Beginner

    Dyalog is an array first multi-paradigm language based on an APL language kernel. In APL, it is common for the application of primitive functions to arrays of conforming shape to imply a map; the function is applied item-wise to corresponding elements of the arguments, producing a result of the same shape. APL also provides a variety of explicit operators that provide different mappings of user-defined functions, or more generally functional compositions, to multi-dimensional and nested arrays.

    One might expect that such language features would provide a complete framework for parallel programming. In practice, writing programs that can be efficiently executed in parallel on current hardware is extremely difficult, if implicit or explicit maps are the only parallel language feature available and an interpreter or compiler needs to deduce where to introduce the asynchronicity that is required in order to take advantage of the hardware.

    This talk will present Futures and Isolates, and related parallel operators constructed upon them, which were added to Dyalog version 14.0 in 2014. The goal has been to provide explicit forms of deterministic asynchronous execution, designed to be very familiar to APL users, and continue to allow them to view the language as an executable mathematical notation, while taking advantage of parallel hardware that is now readily available.

  • Liked Amit Rathore
    keyboard_arrow_down

    Amit Rathore - Functional Programming and the Battle for Survival

    Amit Rathore
    Amit Rathore
    Founder & CEO
    Quintype
    schedule 2 years ago
    Sold Out!
    60 Mins
    Keynote
    Beginner

    Startups are hot. They're fun. They're exciting, challenging, and romantic. They're also brutal. Only 1 in 20 startups succeed. 

    This talk is about how functional programming gives startups an advantage. Because every advantage is critical, in the fight to survive. And then to scale up, and thrive.

  • Liked Viral B. Shah
    keyboard_arrow_down

    Viral B. Shah - Why Julia?

    60 Mins
    Keynote
    Beginner

    In this talk, I will talk about our motivation for creating Julia. Julia is a high-level, high-performance dynamic programming language. It provides a sophisticated compiler, distributed parallel execution, numerical accuracy, and an extensive mathematical function library. Julia’s Base library, largely written in Julia itself, also integrates mature, best-of-breed open source C and Fortran libraries for linear algebra, random number generation, signal processing, and string processing. In addition, the Julia developer community is contributing a number of external packages through Julia’s built-in package manager at a rapid pace. This is why Julia is seeing rapid adoption in universities for teaching and research, as well as in businesses.

    I will discuss what makes Julia fast. Julia's ability to combine these levels of performance and productivity in a single language stems from the choice of a number of features that work well with each other:

    1. An expressive parametric type system, allowing optional type annotations;
    2. Multiple dispatch using those types to select implementations;
    3. A dynamic dataflow type inference algorithm allowing types of most expressions to be inferred;
    4. Aggressive code specialization against run-time types;
    5. Metaprogramming;
    6. Just-In-Time compilation using the LLVM compiler framework; and
    7. Careful design of the language and standard library to be amenable to type analysis;

    I will also touch upon how the language design has made it possible to explore many parallel programming models in Julia, completely within the language.

    See: http://www.julialang.org/

  • Liked Naresh Jain
    keyboard_arrow_down

    Naresh Jain / Dhaval Dalal - Live Code Jugalbandi

    90 Mins
    Event
    Beginner

    In Indian classical music, we have Jugalbandi, where two lead musicians or vocalist engage in a playful competition. There is jugalbandi between Flutist and a Percussionist (say using Tabla as the instrument). Compositions rendered by flutist will be heard by the percussionist and will replay the same notes, but now on Tabla and vice-versa is also possible.

    In a similar way, we will perform Code Jugalbandi to see how the solution looks using different programming languages and paradigms.

    During the session, conference attendees will take turns at coding the same problem using different languages and paradigms. There would be multiple such attempts by different participants during the Jugalbandi.

  • Liked Morten Kromberg
    keyboard_arrow_down

    Morten Kromberg / Jay Foad - Array Oriented Functional Programming with Dyalog

    Morten Kromberg
    Morten Kromberg
    CXO
    Dyalog
    Jay Foad
    Jay Foad
    Software Developer
    Dyalog Ltd
    schedule 2 years ago
    Sold Out!
    480 Mins
    Workshop
    Beginner

    Dyalog is a modern, array-first, multi-paradigm programming language, which supports functional, object-oriented and imperative programming based on an APL language kernel. During the morning and early afternoon, Dyalog's functional language guru John Scholes will introduce the fundamentals of functional programming in APL. At the end of the day, Dyalog CTO Morten Kromberg will round off with an application development session, showing how a simple web application with a HTML5/JS front-end and a RESTful web service can be used to deliver the power of APL to end users, or as embeddable components for other application tools. The "hands on" sections of the workshop can be followed under Mac OS X, Linux, or Microsoft Windows.

  • Liked KC Sivaramakrishnan
    keyboard_arrow_down

    KC Sivaramakrishnan - Introduction to OCaml

    KC Sivaramakrishnan
    KC Sivaramakrishnan
    Research Associate
    University of Cambridge
    schedule 2 years ago
    Sold Out!
    240 Mins
    Tutorial
    Beginner

    OCaml is a statically typed functional language with a fast native code compiler and incremental garbage collector. In this tutorial, we will first introduce the basics of OCaml using an interactive environment running in a web browser, as well as a local install of OCaml using the OPAM package manager. We will also explore how to compile OCaml to JavaScript using the js_of_ocaml tool.

    This tutorial is aimed at people with programming experience. Previous experience with a functional language will be useful but is not required. No prior knowledge of OCaml is assumed.

  • Liked Shashi Gowda
    keyboard_arrow_down

    Shashi Gowda / Viral B. Shah - Julia - A Lisp for Fast Number Crunching

    240 Mins
    Workshop
    Beginner

    Julia is a programming language for data science and numerical computing. Julia is a high-level, high-performance dynamic language, it uses just-in-time compilation to provide fast machine code - dynamic code runs at about half the speed of C, and orders of magnitude faster than traditional numerical computing tools.

    Julia borrows two main ideas from Lisp lore:

    1. Multiple-dispatch: a method is identified by a name and the types of all of its arguments (traditional OOP only uses the type of a single argument) multiple-dispatch allows for a natural programming model suitable for mathematics and general purpose programming. Interestingly, the same feature is responsible for Julia's ability to generate really fast machine code.
    2. Macros: Julia has syntax that is familiar to users of other technical computing environments, however, Julia expressions are homoiconic -- Julia code can be represented as Julia data structures, and transformed from one form to another via hygienic macros. There are some very interesting uses of macros to create domain-specific languages for effective programming. 

    (I will be presenting this workshop along with Viral B Shah - co-creator of Julia)

  • Liked Ravi Mohan
    keyboard_arrow_down

    Ravi Mohan - Building a General Game Playing Engine with OCaml and Erlang

    Ravi Mohan
    Ravi Mohan
    CEO
    AxiomChoice
    schedule 2 years ago
    Sold Out!
    90 Mins
    Experience Report
    Beginner

    "General Game Playing  is the design of artificial intelligence programs that play more than one game"  Wikipedia [1]

    In other words, one program has to be able to play (and win!) multiple games ( Chess, checkers, Go, Othello etc).

    Summary: This experience report is about my  "Forever Project" [2,3,4] to build such a system in OCaml, and the problems (theoretical and practical) and will include a demo of the program, warts and all.

    Detail: GGP is an active CS research area [5]Annual competitions are held every year where  ggp programs compete against each other[6], playing games which they have never seen before (the rules are supplied as an input file for the system to consume five minutes before the match begins).

    Over the last year, in my non-existent spare time, I've been building a GGP engine to compete in a GGP competition.

    Most such engines are written in Java, C++  etc.. I'm using OCaml for the game playing agent, and Manoj is building the backend in Erlang.

    As mentioned above this is our "Forever Project"  We've made some decent progress.

    Come, see, laugh, jeer!

  • Liked Bhasker Kode
    keyboard_arrow_down

    Bhasker Kode - Workshop: Erlang by example

    Bhasker Kode
    Bhasker Kode
    Building stuff
    Helpshift
    schedule 2 years ago
    Sold Out!
    480 Mins
    Workshop
    Beginner

    From fundamentals to deploying Erlang micro-service.