Detailed session desc for CodeGen

docs/CodeGen2012_Proposal.txt

@@ -3,62 +3,73 @@ Code Generation 2012 - Session Proposal Form
 Submission Deadline: Friday December 9th 2011
 
 Session title:
-Creating DSLs in Kotlin
+
+DSLs in Kotlin
 
 Session type and duration:
+
 Tutorial, 60 min
 
 Session abstract:
-This should be a brief description of the session focusing on its content and objectives.  You will need to cut and paste this text into a web form as part of the submission process. The session abstract will be used on the event web site to promote your session.
 
-Kotlin is a statically typed programming language for the JVM proposed recently by JetBrains. The language is intended for industrial use as a safer and more convenient alternative to Java. One can even mix Kotlin and Java sources in the same project. Language documentation is available at http://jetbrains.com/kotlin.
+Kotlin is a statically typed programming language for the JVM proposed recently by JetBrains. The language is intended for industrial use as a safer and more convenient alternative to Java. The language is fully Java compatible, so one can mix Kotlin and Java sources in the same project. Language documentation is available at http://jetbrains.com/kotlin.
 
-In this session we will demonstrate Kotlin's abilities to define APIs as domain-specific languages (DSLs). This includes covering many interesting language features such as
-* type inference,
-* function literals (closures),
-* operator overloading/overriding,
-* extension functions
-* and more…
+In this session we will demonstrate Kotlin's abilities to define APIs as domain-specific languages (DSLs). This includes explanation of interesting language features illustrated with practical use-cases.
 
-As a flagship example we will present type-safe builders, a technique that improves upon Groovy builders (http://groovy.codehaus.org/Builders) by making them statically checked for correctness. Along with this example we'll demonstrate LINQ-like collection processing and a DSL for program module definitions.
+As a flagship example we will present type-safe builders, a technique that improves upon Groovy builders (http://groovy.codehaus.org/Builders) by making them statically checked for correctness. This enables specifying declarative data right inside the code. Want to describe a build file? Xml/HTML? Swing UI? Use builders!
 
 Benefits of participating:
-What will participants get out of taking part in the session? It is very important to think about this and describe it in your proposal.
+
+Participants will learn about Kotlin and how a few language features can be combined to create internal DSLs in a natural and flexible way.
 
 Process & timetable:
-How will the session work? You might want to describe any exercises or group working.  Consider providing a detailed timetable.  Indicate the way in which the audience is involved.
+
+Introduction to Kotlin — 7-10 minutes
+Q&A - 5 minutes
+DSL-enabling features - 15 minutes
+Q&A - 5 minutes
+Builders (live demo) - 20 minutes
+Q&A - 5 minutes
 
 Session outputs:
-Indicate the form of any outputs (e.g. web page, poster at conference, blog posting etc) and their likely content (summary, actions points etc.)
+
+Slides, example code
 
 Intended Audience:
-Note any required skills/knowledge/ experience.  What job roles would this session be particularly applicable to.
+
+The session is intended for developers and tech. leads.
+We expect the audience to be familiar with basic concepts of OOP and one of the statically typed languages (Java, Scala, C#, C++ etc)
 
 Availability:
-Indicate if there are any constraints in your participation or whether it makes sense to run your session before or after another session you've proposed
+
+No constraints
 
 Detailed Description / Supporting Information
+
 A fuller description of the session describing the content, rationale and describing any previous occasions on which the session has been run.
 
+Kotlin is a new statically typed JVM-targeted programming language developed by JetBrains and intended for industrial use. Kotlin is designed to be fully Java compatible, and at the same time safer, more concise than Java and way simpler than its main competitor, Scala. Also, IDE support is being developed in parallel with the language itself.
+
+This session focuses on the language features that enable DSL creation and corresponding patterns.
+
+During the introduction, we will give an overview of the language. The features we’re planning to cover include:
+* type inference;
+* function literals (closures);
+* extension functions;
+* operator overloading/overriding;
+* null safety and automatic casts.
+
+As a flagship example we will present type-safe builders, a technique that improves upon Groovy builders (http://groovy.codehaus.org/Builders) by making them statically checked for correctness. Builders are a flexible and clean way of describing declarative data in the code with very little syntactic overhead. The technique is so handy that Kotlin uses it instead of XML for compiler configuration, which we will show in action along with XML/HTML and Swing UI building.
+This part is presented as a live demo within the IntelliJ IDEA IDE for Kotlin. Along with this example we'll demonstrate a DSL for LINQ-like collection processing.
+
+This session has not been run before, but the material we use is partly taken from Kotlin talks from OSCON, StrangeLoop and Devoxx.
+
+
 Main presenter name, contact details and biography
 
-Name:
-Affiliation:
-Telephone / Skype:
-Email:
+Name: Andrey Breslav
+Affiliation: JetBrains
+Telephone / Skype: andrey.breslav @ skype
+Email: andrey.breslav@jetbrains.com
 Biography (up to 100 words):
-
-Additional Presenter(s) (if any)
-Name:
-Affiliation:
-Telephone / Skype:
-Email:
-Biography (up to 100 words):
-
-Name:
-Affiliation:
-Telephone / Skype:
-Email:
-Biography (up to 100 words):
-
-
+Andrey is the lead language designer working on Project Kotlin. He joined JetBrains in 2010.