Permalink
Browse files

re-order list of talks in reverse-chronological, add ForwardJS talk

  • Loading branch information...
Li Haoyi
Li Haoyi committed Feb 14, 2016
1 parent 325f742 commit a346a010e44401c5cdfcc8fc71d42f98aa2841a9
@@ -40,7 +40,7 @@ object DatesFor{
}
val (markdownFiles, otherFiles) = ls.rec! postsFolder partition (_.ext == "md")
val (markdownFiles, otherFiles) = ls! postsFolder partition (_.ext == "md")
// Walk the posts/ folder and parse out the name, full- and first-paragraph-
// HTML of each post to be used on their respective pages and on the index
val posts = {
@@ -3,87 +3,118 @@ workshops. Most of them are about my work in the Scala programming language.
The actual recordings for these are slightly scattered, over a mix of Youtube
videos, Vimeo, and some conference sites.
Here's a consolidated list of their abstracts and videos. I'll keep this
updated as time goes on.
Here's a consolidated list of their abstracts and videos, most recent first.
I'll keep this updated as time goes on.
-------------------------------------------------------------------------------
## Metascala: a tiny DIY JVM
*Scala Exchange 2 Dec 2013*
[Video](https://skillsmatter.com/skillscasts/4916-metascala-a-tiny-diy-jvm)
## Isomorphic client-side web dev without Javascript, with Scala.js
**ForwardJS Summit** *10 Feb 2016*
Metascala is a tiny metacircular Java Virtual Machine (JVM) written in the
Scala programming language. Metascala is barely 3000 lines of Scala, and is
complete enough that it is able to interpret itself metacircularly. Being
written in Scala and compiled to Java bytecode, the Metascala JVM requires a
host JVM in order to run.
- [Video](https://vimeo.com/154932681)
- [Slides](../post/slides/Isomorphic-Client-side-web-dev-without-Javascript.pdf)
The goal of Metascala is to create a platform to experiment with the JVM: a
3000 line JVM written in Scala is probably much more approachable than the
1,000,000 lines of C/C++ which make up HotSpot, the standard implementation,
and more amenable to implementing fun features like continuations, isolates or
value classes. The 3000 lines of code gives you:
Functional programming is all the rage now: promising concise, simple code with
fewer bugs. Isomorphic web development, on the other hand, has a different set
of promises: letting you share logic between client and server without
duplication of code, ensurign that they will always stay in sync.
- The bytecode interpreter, together with all the run-time data structures
- A stack-machine to SSA register-machine bytecode translator
- A custom heap, complete with a stop-the-world, copying garbage collector
- Implementations of parts of the JVM's native interface
Scala.js is a new take on these ideas: rather than bringing your front-end code
to the server, we bring your back-end code to the browser! In this talk, I'll
demonstrate how to get started with Scala.js to build client-side web
applications. We'll see how Scala.js gives you functional programming and
isomorphic web development almost for free, and brings with it additional
bonuses like tooling and safety far beyond anything available in Javascript
land.
## Live-Coding Scala.js
*SF Scala Meetup 28 Feb 2014*
[Video](https://vimeo.com/87845442)
Scala like you've never seen it before! Live reloading, in the browser, on the
canvas, with the DOM.
## Shell-scripting in a Typed, OO Language
**New Object Oriented Languages, SPLASH** *28 Oct 2015*
## Fun Functional-Reactive Programming with Scala.Rx
*Scaladays 17 Jun 2014*
- [Video](https://vimeo.com/143819744)
- *Presented without slides*
[Video](https://vimeo.com/98477272)
Talk given 27 October 2015 at the Zeroth Workshop for New Object Oriented
Languages.
Scala.Rx is a change propagation library for Scala, that provides reactive
values that save you the hassle of having to keep mutable variables in sync
manually. This goes into the motivation behind the library, shows off some cool
demos, and hopefully persuades you that Scala.Rx is a useful tool in managing
messy, stateful applications.
What if instead of Bash, you could use a real, modern programming language to
use as your systems shell? I'll spend 30 minutes talking about why people use
Bash over other contemporary languages, how the Ammonite Scala REPL plays
catch-up, and highlight various ways in which the experience benefits from
using a statically-typed, object-oriented language running on the JVM.
## Cross-platform development with Scala.js
*Scala by the Bay 9 Aug 2014*
[Video](https://www.youtube.com/watch?v=Ksoi6AG9nbA)
## Fast, Modern, OO Parser Combinators
**Parsing@SLE, SPLASH** *24 Oct 2015*
This talk will explore the developer experience of using ScalaJS, from the
boring-but-important cross-JVM/JS libraries, to pure-Scala client-server web
applications, to whiz-bang ScalaJS games and animations. As the person who has
written more ScalaJS code than anyone on the planet (!) I will go through the
ups and downs of ScalaJS development, and demonstrate why you may want to try
it out for your next round of web development.
- [Video](https://vimeo.com/143572750)
- [Slides](../post/slides/Parsing-SLE-FastParse.pdf)
## Hands-On Scala.js
*Pacific-North-West Scala 14 Nov 2014*
A quick, 30 minute overview of the features and usage of the FastParse parser
combinator library lihaoyi.github.io/fastparse, allowing you to quickly write
high-performance, debuggable, fail-friendly parsers
[Video](https://vimeo.com/111978847)
A talk I gave at pnwscala.org/2014. This is a hands-on tutorial that goes
through what it's like getting started with Scala.js, introducing the project
and walking through the experience of how to do common things on the Scala.js
platform.
## Bootstrapping the Scala.js Ecosystem
*Scala Exchange 7 Dec 2014*
## FastParse: Fast, Modern Parser Combinators
**SF Scala Meetup** *13 Oct 2015*
[Video](https://vimeo.com/113967983)
- [Video](https://vimeo.com/142341803)
- [Slides](../post/slides/FastParse.pdf)
Parsing text is typically difficult. As a programmer you have tools ranging
from String#split (convenient and fast but inflexible) to Lex/Yacc/Antlr (fast
and flexible but inconvenient) and parser combinators (convenient, flexible
but very slow!)
This talk introduces FastParse, a parser-combinator library for the Scala
programming language, that aims to find a middle ground between all these
alternatives. Convenient, flexible and fast, I'll show how code using FastParse
looks almost the same as code using the in-built parser-combinators, but comes
with an 85x (8500%!) speedup at run-time. I'll talk about how FastParse
provides unprecedentedly good, structured error reporting for you to use to
debug your parser (or help your users debug their input) and finish off with
some demo live-coding of a language of the audience's choice.
## Beyond Bash
**Scala by the Bay** *12 Aug 2015*
- [Video](https://www.youtube.com/watch?v=dP5tkmWAhjg)
- [Slides](../post/slides/Beyond-Bash.pdf)
The Scala REPL has been often touted as an advantage for the language: an
interactive, exploratory experience very different from the static,
often-IDE-based experience that for many is the bulk of their experience
using Scala. Nevertheless, in comparison, the Scala REPL really sucks: buggy
& unfriendly, it is not a place you want to spend most of your time.
What if the Scala REPL had the same autocomplete as you'd get in Eclipse or
IntelliJ? What if it had syntax-highlighting for everything? What if you could
load libraries like Shapeless or Akka-HTTP to try out, without needing to muck
with SBT? What if your Scala REPL was as versatile, usable and configurable as
Bash or Zsh, and could be used as your home on the command line?
## Why (You might like) Scala.js
**Scaladays SF** *17 Mar 2015*
- [Video](https://vimeo.com/122611959)
- [Slides](../post/slides/Why-You-Might-Like-Scala.js.pdf)
Scala.js compiles Scala to Javascript. Why should you, as an individual, care?
This talk discusses the things you can get out of Scala.js, starting from
three main archetypes: Scala web developer, Scala non-web developer, and
compiler-writer.
What does it take to go from a working compiler to a workable, productive
platform? This presentation explores the range of libraries that needed to
be built in order to turn Scala.js from a prototype to a product
## Scala.js - Safety & Sanity in the wild west of the web
*PhillyETE 8 Mar 2015*
**PhillyETE** *8 Mar 2015*
[Video](https://vimeo.com/124702603)
- [Video](https://vimeo.com/124702603)
- [Slides](../post/slides/PhillyETE-Scala.js.pdf)
Developing for the web platform has historically been a slow, painful,
fragile experience. You write code in multiple different languages, work
@@ -100,73 +131,82 @@ Safety: an extreme level of safety that goes far beyond any competitor. Not
only is your Scala.js code checked, but any use of Javascript APIs is also
checked, and so are your Ajax calls between client and server!
## Why (You might like) Scala.js
*Scaladays 17 Mar 2015*
[Video](https://vimeo.com/122611959)
## Bootstrapping the Scala.js Ecosystem
**Scala Exchange** *7 Dec 2014*
Scala.js compiles Scala to Javascript. Why should you, as an individual, care?
This talk discusses the things you can get out of Scala.js, starting from
three main archetypes: Scala web developer, Scala non-web developer, and
compiler-writer.
- [Video](https://vimeo.com/113967983)
- [Slides](../post/slides/Bootstrapping-the-Scala.js-Ecosystem.pdf)
What does it take to go from a working compiler to a workable, productive
platform? This presentation explores the range of libraries that needed to
be built in order to turn Scala.js from a prototype to a product
## Beyond Bash
*Scala by the Bay 12 Aug 2015*
[Video](https://www.youtube.com/watch?v=dP5tkmWAhjg)
## Hands-On Scala.js
**Pacific-North-West Scala** *14 Nov 2014*
The Scala REPL has been often touted as an advantage for the language: an
interactive, exploratory experience very different from the static,
often-IDE-based experience that for many is the bulk of their experience
using Scala. Nevertheless, in comparison, the Scala REPL really sucks: buggy
& unfriendly, it is not a place you want to spend most of your time.
- [Video](https://vimeo.com/111978847)
- [Slides](../post/slides/Hands-on-Scala.js.pdf)
What if the Scala REPL had the same autocomplete as you'd get in Eclipse or
IntelliJ? What if it had syntax-highlighting for everything? What if you could
load libraries like Shapeless or Akka-HTTP to try out, without needing to muck
with SBT? What if your Scala REPL was as versatile, usable and configurable as
Bash or Zsh, and could be used as your home on the command line?
A talk I gave at pnwscala.org/2014. This is a hands-on tutorial that goes
through what it's like getting started with Scala.js, introducing the project
and walking through the experience of how to do common things on the Scala.js
platform.
## FastParse: Fast, Modern Parser Combinators
*SF Scala Meetup 13 Oct 2015*
## Cross-platform development with Scala.js
**Scala by the Bay** *9 Aug 2014*
[Video](https://vimeo.com/142341803)
- [Video](https://www.youtube.com/watch?v=Ksoi6AG9nbA)
- [Slides](../post/slides/Cross-Platform-Development-in-Scala.js.pdf)
Parsing text is typically difficult. As a programmer you have tools ranging
from String#split (convenient and fast but inflexible) to Lex/Yacc/Antlr (fast
and flexible but inconvenient) and parser combinators (convenient, flexible
but very slow!)
This talk will explore the developer experience of using ScalaJS, from the
boring-but-important cross-JVM/JS libraries, to pure-Scala client-server web
applications, to whiz-bang ScalaJS games and animations. As the person who has
written more ScalaJS code than anyone on the planet (!) I will go through the
ups and downs of ScalaJS development, and demonstrate why you may want to try
it out for your next round of web development.
This talk introduces FastParse, a parser-combinator library for the Scala
programming language, that aims to find a middle ground between all these
alternatives. Convenient, flexible and fast, I'll show how code using FastParse
looks almost the same as code using the in-built parser-combinators, but comes
with an 85x (8500%!) speedup at run-time. I'll talk about how FastParse
provides unprecedentedly good, structured error reporting for you to use to
debug your parser (or help your users debug their input) and finish off with
some demo live-coding of a language of the audience's choice.
## Fun Functional-Reactive Programming with Scala.Rx
**Scaladays** *17 Jun 2014*
## Fast, Modern, OO Parser Combinators
*Parsing@SLE, SPLASH 24 Oct 2015*
- [Video](https://vimeo.com/98477272)
- [Slides](../post/slides/Fun-Functional-Reactive-Programming-with-Scala.Rx.pdf)
[Video](https://vimeo.com/143572750)
Scala.Rx is a change propagation library for Scala, that provides reactive
values that save you the hassle of having to keep mutable variables in sync
manually. This goes into the motivation behind the library, shows off some cool
demos, and hopefully persuades you that Scala.Rx is a useful tool in managing
messy, stateful applications.
A quick, 30 minute overview of the features and usage of the FastParse parser
combinator library lihaoyi.github.io/fastparse, allowing you to quickly write
high-performance, debuggable, fail-friendly parsers
## Live-Coding Scala.js
**SF Scala Meetup** *28 Feb 2014*
- [Video](https://vimeo.com/87845442)
- [Slides](../post/slides/Live-Coding-Scala.js.pdf)
## Shell-scripting in a Typed, OO Language
*New Object Oriented Languages, SPLASH 28 Oct 2015*
Scala like you've never seen it before! Live reloading, in the browser, on the
canvas, with the DOM.
[Video](https://vimeo.com/143819744)
## Metascala: a tiny DIY JVM
**Scala Exchange** *2 Dec 2013*
Talk given 27 October 2015 at the Zeroth Workshop for New Object Oriented
Languages.
- [Video](https://skillsmatter.com/skillscasts/4916-metascala-a-tiny-diy-jvm)
- [Slides](../post/slides/Metascala-a-Tiny-DIY-JVM.pdf)
What if instead of Bash, you could use a real, modern programming language to
use as your systems shell? I'll spend 30 minutes talking about why people use
Bash over other contemporary languages, how the Ammonite Scala REPL plays
catch-up, and highlight various ways in which the experience benefits from
using a statically-typed, object-oriented language running on the JVM.
Metascala is a tiny metacircular Java Virtual Machine (JVM) written in the
Scala programming language. Metascala is barely 3000 lines of Scala, and is
complete enough that it is able to interpret itself metacircularly. Being
written in Scala and compiled to Java bytecode, the Metascala JVM requires a
host JVM in order to run.
The goal of Metascala is to create a platform to experiment with the JVM: a
3000 line JVM written in Scala is probably much more approachable than the
1,000,000 lines of C/C++ which make up HotSpot, the standard implementation,
and more amenable to implementing fun features like continuations, isolates or
value classes. The 3000 lines of code gives you:
- The bytecode interpreter, together with all the run-time data structures
- A stack-machine to SSA register-machine bytecode translator
- A custom heap, complete with a stop-the-world, copying garbage collector
- Implementations of parts of the JVM's native interface
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.

0 comments on commit a346a01

Please sign in to comment.