Facilitating the spread of knowledge and innovation in professional software development



Choose your language

InfoQ Homepage Presentations Expressing Abstraction - Abstracting Expression

Expressing Abstraction - Abstracting Expression



Ola Bini attempts to answer a few questions: Why are new languages still being created, Is it worth choosing languages strategically, and Does language actually matter?


Ola Bini works as a language geek for ThoughtWorks in Chicago. He is one of the JRuby core developers and has been involved in JRuby development since 2006. Ola has created two languages: Ioke and Seph. He’s author of Practical JRuby on Rails Projects and co-author of Using JRuby for the Pragmatic Programmers, a contributor to many open source projects, and a member of the JSR292 Expert Group.

About the conference

Strange Loop is a multi-disciplinary conference that aims to bring together the developers and thinkers building tomorrow's technology in fields such as emerging languages, alternative databases, concurrency, distributed systems, mobile development, and the web. Strange Loop was created in 2009 by software developer Alex Miller and is now run by a team of St. Louis-based friends and developers under Strange Loop LLC, a for-profit but not particularly profitable venture.

Recorded at:

Nov 01, 2012

Hello stranger!

You need to Register an InfoQ account or or login to post comments. But there's so much more behind being registered.

Get the most out of the InfoQ experience.

Allowed html: a,b,br,blockquote,i,li,pre,u,ul,p

Community comments

  • Very interesting talk

    by Faisal Waris,

    Your message is awaiting moderation. Thank you for participating in the discussion.

    I would have expected to see more prominent mention of "Pattern Matching" as an idiom/abstraction aiding expressability. ML style languages use that heavily and pattern matching (along with Union Types) can serve as an alternative for type classes (although that still does not solve the Expression Problem).

    To provide a flavor, below is the main recursive loop of an experimental HTML parser written with F# 'Active Patterns' (note WS=whitespace; GT = '>'; LT = '<'; Slash = '/', etc.)

    let rec (|Html|) inp acc =
    match inp with
    | WS (ws, rest) -> (|Html|) rest (WS(ws)::acc)
    | LT (Exclaim (PI (p, (GT rest)))) -> (|Html|) rest (PI(p)::acc)
    | Script (attrs,body,rest) -> (|Html|) rest (Script(attrs,body)::acc)
    | LT (Name (n, Attributes (attrs, IgnoreWS restof))) ->
    match restof with
    | Slash (GT rest) -> (|Html|) rest (Tag(n,attrs)::acc)
    | GT rest -> (|Html|) rest (StartTag(n,attrs)::acc)
    | _ -> errorOut restof acc
    | LT (Slash (Name (n, (IgnoreWS (GT rest))))) -> (|Html|) rest (EndTag(n)::acc)
    | Content (cntnt,rest) -> (|Html|) rest (Content(cntnt)::acc)
    | Eof _ -> acc|>List.rev
    | _ -> errorOut inp acc

    When a pattern is matched, the right side of the "->" is executed. In this case the loop is just collecting html tags in a structured way.

    More here

  • Re: Very interesting talk

    by Faisal Waris,

    Your message is awaiting moderation. Thank you for participating in the discussion.

    More recently, I had to implement the Porter Stemming Algorithm (an essential for natural language processing).

    I started with the algorithm paper by Michael Porter and just transcribed that to code, section by section. This is good example of expressability in my opinon.

    Details here:

Allowed html: a,b,br,blockquote,i,li,pre,u,ul,p

Allowed html: a,b,br,blockquote,i,li,pre,u,ul,p