Permalink
Browse files

add Talks I've Given post, make the post-snippeting delimited on a HR…

… rather than hard-coded to 2-nodes
  • Loading branch information...
Li Haoyi
Li Haoyi committed Feb 14, 2016
1 parent 9eef820 commit 325f74286854a461a2ac432eae12bb0f5e5431f6
View
@@ -8,9 +8,9 @@ import scalatags.Text.all.{width, height, _}
import scalatags.Text._
import ammonite.ops._
import collection.JavaConversions._
import collection.JavaConverters._
import org.pegdown.{PegDownProcessor, ToHtmlSerializer, LinkRenderer, Extensions}
import org.pegdown.ast.{VerbatimNode, ExpImageNode, HeaderNode, TextNode}
import org.pegdown.ast.{VerbatimNode, ExpImageNode, HeaderNode, TextNode, SimpleNode}
val postsFolder = cwd/'posts
@@ -51,7 +51,7 @@ val posts = {
for ((index, name, path) <- split.sortBy(_._1.toInt)) yield {
val processor = new PegDownProcessor(Extensions.FENCED_CODE_BLOCKS)
val ast = processor.parseMarkdown(read! path toArray)
object serializer extends ToHtmlSerializer(new LinkRenderer){
class Serializer extends ToHtmlSerializer(new LinkRenderer){
override def printImageTag(rendering: LinkRenderer.Rendering) {
printer.print("<div style=\"text-align: center\"><img")
printAttribute("src", rendering.href)
@@ -72,6 +72,7 @@ val posts = {
val id =
node
.getChildren
.asScala
.collect{case t: TextNode => t.getText}
.mkString
@@ -93,13 +94,19 @@ val posts = {
printer.print("</code></pre>");
}
}
val rawHtmlContent = serializer.toHtml(ast)
if (ast.getChildren.size > 0) {
val firstNode = ast.getChildren.get(0)
ast.getChildren.clear()
ast.getChildren.add(firstNode)
}
val rawHtmlSnippet = serializer.toHtml(ast)
val rawHtmlContent = new Serializer().toHtml(ast)
val snippetNodes =
ast.getChildren
.asScala
.takeWhile{
case n: SimpleNode if n.getType == SimpleNode.Type.HRule => false
case _ => true
}
ast.getChildren.clear()
snippetNodes.foreach(ast.getChildren.add)
val rawHtmlSnippet = new Serializer().toHtml(ast)
val updates = DatesFor(s"posts/$index - ").toSeq
(name, rawHtmlContent, rawHtmlSnippet, updates)
}
@@ -8,6 +8,8 @@ I am not the first person to have a blog, nor the first person to have a
programming blog, nor is this my first blog. Nevertheless, for me, doing
this is a mix of new and old ideas.
-------------------------------------------------------------------------------
## The Old
This is not the first time I have had a blog/site. I had built one back
@@ -11,6 +11,8 @@ or
Sometimes to realize later that the *they* is in fact, yourself!
-------------------------------------------------------------------------------
You learn things to get the job done: the code's purpose, it's constraints and
abilities. Often though, you learn more than that: you feel the thoughts,
feelings and characters of the people who wrote it. You feel their
@@ -7,6 +7,8 @@ aiming to provide style guidelines at a "strategic" level. Above the level of
a developer working with the Scala language choose from the buffet of possible
solutions.
-------------------------------------------------------------------------------
## About Strategic Scala Style
These guidelines are based on my own experience working on open- and
@@ -0,0 +1,172 @@
I've given a bunch of talks at meetup groups, industry conferences and academic
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.
-------------------------------------------------------------------------------
## Metascala: a tiny DIY JVM
*Scala Exchange 2 Dec 2013*
[Video](https://skillsmatter.com/skillscasts/4916-metascala-a-tiny-diy-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
## 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.
## Fun Functional-Reactive Programming with Scala.Rx
*Scaladays 17 Jun 2014*
[Video](https://vimeo.com/98477272)
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.
## Cross-platform development with Scala.js
*Scala by the Bay 9 Aug 2014*
[Video](https://www.youtube.com/watch?v=Ksoi6AG9nbA)
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.
## Hands-On Scala.js
*Pacific-North-West Scala 14 Nov 2014*
[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*
[Video](https://vimeo.com/113967983)
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*
[Video](https://vimeo.com/124702603)
Developing for the web platform has historically been a slow, painful,
fragile experience. You write code in multiple different languages, work
with undocumented APIs, and are forced to implement things twice to have
them work on both client and server. Lastly, you had better be the
meticulous sort, because a single typo will bring down your site: at
runtime, in production!
Scala.js is an attempt to fix this problem. Like other compile-to-JS languages,
it provides a concise, expressive language to do your work. Unlike others, it
also promises seamless interop with Javascript, a ready-to-go ecosystem, tool
support, and a smooth development experience. Above all, Scala.js provides
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)
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.
## Beyond Bash
*Scala by the Bay 12 Aug 2015*
[Video](https://www.youtube.com/watch?v=dP5tkmWAhjg)
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?
## FastParse: Fast, Modern Parser Combinators
*SF Scala Meetup 13 Oct 2015*
[Video](https://vimeo.com/142341803)
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.
## Fast, Modern, OO Parser Combinators
*Parsing@SLE, SPLASH 24 Oct 2015*
[Video](https://vimeo.com/143572750)
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
## Shell-scripting in a Typed, OO Language
*New Object Oriented Languages, SPLASH 28 Oct 2015*
[Video](https://vimeo.com/143819744)
Talk given 27 October 2015 at the Zeroth Workshop for New Object Oriented
Languages.
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.

0 comments on commit 325f742

Please sign in to comment.