Design, Composition, and Performance
Design, composition and performance are critical in creating software. What are we doing when we design software? In what ways is design taking things apart? What does this have to do with Clojure, languages and libraries in general? This talk will explore the nature of design and composition and how it impacts our approach to software development practice and tools.
by Rich Hickey (@richhickey) - Datomic, Clojure
Rich Hickey, the author of Clojure and designer of Datomic, is a software developer with over 20 years of experience in various domains. Rich has worked on scheduling systems, broadcast automation, audio analysis and fingerprinting, database design, yield management, exit poll systems, and machine listening, in a variety of languages.
Racket: Metaprogramming Time!
Racket is an extensible programming language: it allows programmers to define new syntactic forms and construct entirely new programming languages. While Racket inherits its basic approach to extensibility from Lisp and Scheme, Racket pushes extensibility into the realms of build management, documentation, testing, and the development environment. These frontiers require new language constructs both to create a time and place for everything and to keep everything in its time and place.
by Matthew Flatt - UT professor and Racket developer
Matthew Flatt is an associate professor in the School of Computing at the University of Utah, where he works on extensible programming languages, run-time systems, and applications of functional programming. He is one of the developers of the Racket programming language and a co-author of the introductory programming textbook How to Design Programs.
Introducing Pedestal: Architecture and Services
Pedestal is a set of libraries for building rich interactive Web applications using Clojure, ClojureScript and EDN. This talk starts with the big picture: problems Pedestal is designed to solve and the typical architecture of a Pedestal application. Then it dives into HTTP services, covering the details of the plumbing, including its relationship to Ring, and how they enable collaborative applications.
by Brenton Ashworth (@brentonashworth) and Tim Ewald - Relevance, Inc.
Brenton Ashworth is a developer at Relevance, Inc. He was involved in the development of ClojureScript, building some of its first tools, as well as working on the first ClojureScript application, TwitterBuzz. Since then, he created ClojureScript One, with the help of many people at Relevance, and has been building applications for clients which leverage Clojure from the database to the UI.
Tim Ewald is an architect and developer at Relevance, Inc, with more than 20 years experience building systems. He has used Clojure on a wide range of projects, including helping get the initial release of Datomic out the door. More recently, he's provided lead the effort to create Pedestal, a set of libraries for building web apps and services. Tim has also lead Relevance's Architecture Practice.
Introducing Pedestal: Rich Client Applications
This talk will build on part 1, starting with a statement of the problems faced when building large interactive applications in the browser. The talk will then show how the ideas behind Clojure can be used to solve these problems. Finally, it will introduce a model and tools for building applications which make them easier to build, test and reason about.
by Brenton Ashworth (@brentonashworth) and Tim Ewald - Relevance, Inc.
Clojure and LLVM
LLVM is a compiler toolkit for developing native languages. With companies from NVidia, to Apple pouring resources into this project, how can we leverage these libraries in Clojure?
In this talk, I will show my work writing a compiler in Clojure that uses LLVM for code generation. This project is known as clojure-py2. This from-the-ground re-write of clojure-py uses LLVM to create native (machine-code) Python extension modules on the fly. The resulting code is not only faster than python, but with proper type hints can approach the speed of ClojureScript and Clojure.
Running Clojure on Python opens up new areas to explore. Systems like the Raspberry Pi are often too memory constrained to run a JVM language. Python fills this gap by running closer to the metal, while also providing an extremely rich set of libraries to pull from.
by Timothy Baldridge (@timbaldridge) - Relevance Inc.
Timothy Baldridge is a developer at Relevance Inc. He enjoys studying compilers, low level optimization and new programming paradigms.
Functional Infrastructures: It's all fn until you hit production
We Clojurians live a privileged life for most of our days: quick REPL prototyping, immutable data structures, abstractions, declarative statements, multi-methods, you name it, it's all fn!
But this fn stops when we are to deploy our beautifully crafted functional applications inside a larger infrastructure. Then it's all pain: setting up servers, installing the right versions of server software, updating configuration files... Ugh! No more quick REPL prototyping, abstractions, code reuse, declarative statements, immutability; all gone! It gets worse though. We now use platforms like Hadoop, HBase or Cassandra that require complex cross-node configurations. We have multiple developers wanting to test on different versions of the software and infrastructure. There are also many environments to deploy on: Integration, QA, Stage, Production, and There are different OS distros and versions to support, each with their own quirks and bugs. Oh!, and different hardware options too: cloud, virtualized, or even bare metal. You get the gist: a combinatorial explosion of complexity.
You say "Automate it with scripts!", but I say "Automation not enough!". "Scripts + database then!" you say... "Are you paying attention!?" Why should we develop in LISP-land but deploy Perl-land? Can't the same principles of functional programming make infrastructure automation as pleasant and productive as coding in Clojure? It is possible, and this talk is about what it takes to build and grow such stress-free Functional Infrastructures.
Antoni Batchelli started programming computers for fun when he was eight years old with a ZX Spectrum and has not stopped since then. Over the years, Toni has worked in consulting, startups, academia and corporations. He has gone back and forth between coding, architecting and managing, having fun in each role, while always working on large software installations. In 2009, Toni started Disclojure ( http://disclojure.org ), a website devoted to news about Clojure. in 2009, Toni met Hugo Duncan, with whom he has since them been working full time on Pallet ( http://palletops.com ) , an Open Source, Clojure-based DevOps platform; and VMFest, a Virtual Machine automation library.
clj-v8 and the Dieter Asset Pipeline
Lots of web front-ends are written in DSLs such as CoffeeScript, Less and Haml. Dieter and clj-v8 combine to provide a fast, effective asset pipeline for Clojure web apps.
A tale of low-level integration, optimization, beautiful code and clean abstractions.
It's said that if Lisp is the ultimate high-level language, then Forth is the ultimate low-level one. The Clojure community is on the cutting edge when it comes to embracing good ideas from the full-spectrum of programming paradigms. While core.logic looks up the spectrum to import good ideas from Logic Programming, Factjor looks down the spectrum to import good ideas from Concatenative and Stack-oriented Programming.
This talk begins with a brief history and background of concatenative programming and why it matters. Then, we'll take a whirlwind tour of the Factor language. Factor is to Forth what Clojure is to Common Lisp. The remainder of the talk will be a demonstration of Factjor, a concatenative programming DSL embedded in Clojure, and DomScript, a new Browser DOM manipulation library for ClojureScript that takes full advantage of the concatenative style.
Brandon discovered Clojure during his never halting breadth first search throughout all of computer science and has become a frequent ClojureScript contributor. Along the way, he has built software for embedded devices, desktops, web browsers, web servers, and data centers. With one exit notch on his entrepreneurial belt, Brandon is currently searching for what's next.
Core.logic and SQL Killed my ORM
The relational programming model provided by core.logic frees developers from the impedance mismatch, and other limitations of Object Relational Mapping systems (ORMs). This allows for massive gains in write speed and schema flexibility, avoids the rigidity of a single entity-relationship model and artifical notions like object identity, and greatly reduces the complexities of modeling time and change.
By extending core.logic defrel/fact we were able to define a set of relations that worked both with core.logic, and also mapped naturally to SQL tables. A single data model was used to build our rule system for identifying malware behavior, as well as being the schema for our analysis and correlation database which is served up via a Clojure web app.
In this talk we will be presenting the tradeoffs involved with moving to a purely relational model, and ditching your ORM. We will also introduce some of the tools we built to facilitate this.
Craig has been hacking lisp web apps since before the turn of the century, first in Common Lisp and now Clojure. He currently works for ThreatGRID Inc as a senior research engineer for their malware analysis and intelligence product.
Beyond Contracts: An exploration into unified specifications
Clojure's rich interactive development encourages developers to explore a solution space while experimenting within a problem domain. But what if those explorations could be captured as tangible specifications, and used to automatically generate tests and documentation, be applied as contracts for functions, and even used in external verification systems?
This talk dives into such a system, illustrating the advantages of unifying core.contracts, test.generative, and external systems under a single common specification, captured as a value.
Specification-as-a-value serves as a useful tool that guides developers through all phases of the software development lifecycle: from design to deployment. A single specification could ensure your conceptual design is complete, that your functions conform to the design at runtime, and the functions pass an array of automatically generated tests.
Paul deGrandis lives for magnificent engineering. Elegant, well-founded, useful solutions to problems that say something about engineering's beauty. He loves metrics, taking on the impossible, and making lives better through technology. Currently he is the VP of Engineering at Tutorspree. Previously he worked at PushButton Labs, Etsy.com, OurShelf, and SilverCloud Software as well as working in advanced research.
FRP in ClojureScript with Javelin
Functional Reactive programming (FRP) is a paradigm that holds great promise in the ClojureScript world as a way to mitigate the difficulty of modeling control flow and side effects in the browser. FRP techniques allow one to write "reactive" code in terms of dependency relations instead of in terms of callbacks or watches.
I'll introduce Javelin, a ClojureScript library, and demonstrate how it can be used to express a variety of asynchronous workflows in concise and composable ways.
Along the way, I’ll compare FRP with spreadsheets, contrast FRP with Clojure's sequences, and cover some of the ideas, implementation techniques, and vocabulary common to many FRP libraries.
Alan Dipert has contributed to Clojure, ClojureScript, and several Clojure projects including Leiningen and clojure-tco. Alan is a developer at The Fresh Diet, where he builds systems for delivering fresh food to customers across North America. He lives in Durham, North Carolina, where he helps run Splat Space, the local hackerspace.
Engines of Abstraction
"If I have seen further it is by standing on the shoulders of giants.", a quote by Isaac Newton, succinctly expresses the art of programming. We build software on a foundation made with layers of abstractions that others have built.
This talk surveys several abstraction techniques that can help us build sound applications on the foundation of Clojure and highlights how we're already using specific examples of such abstractions in ad hoc fashion today.
Jim is a 20+ years professional programmer with the last 4 being in Clojure. He’s done work with embedded systems in multiple industries and languages like Forth, Delphi and C++. He currently works at Lonocloud and his blog on Clojure programming is at http://clojure.net.
Ritz - the missing Clojure tooling
Developing in clojure is fun, and enables you to get into that productive flow state. That is until you hit that tricky bug, and start peppering your code with println statements when a debugger might be easier. Or you trigger one of those compilation errors where clojure doesn't give you a source location. Or when you need to add a new library to your project, and you don't want to restart your REPL. Or maybe you'ld like to see how the function you're editing has changed over time.
Ritz is a set of tools for debugging, inspecting, project reloading, codeq integration, lein integration, etc, for both nrepl and swank based tooling. This talk will show how ritz can be used with nrepl.el in emacs.
Hugo Duncan is the founder of the Pallet project, an open source library for the provisioning configuration and orchestration of servers, in the cloud, on your desktop, or in your data center. He is also the author of many open source libraries in Clojure, including ritz, zi, and criterium.
Securing Clojure webapps and services with Friend
Friend is "an extensible authentication and authorization library for Clojure Ring web applications and services".
We'll take a look at Friend's overall design and how you can use it to model and implement authentication and authorization for your app within the Ring tradition. We'll also go beyond well-worn paths like interactive form login and role-based authorization to see how Friend may be extended to implement things like multi-factor authentication, phishing prevention, and arbitrary authorization schemes.
Chas Emerick is a coauthor of Clojure Programming from O'Reilly, and a contributor to Clojure itself and dozens of open source Clojure projects. He writes about software development, entrepreneurship, and other passions at cemerick.com.
Macros: Why, When, and How
Macros are the classic meta-feature of lisps, enabling the implementation of nearly anything imaginable. On the other hand they're frequently overused and their overuse is frequently complained about. Against all good judgment, we will give an intuitive account of what macros are, how they work, and how to analyze their behavior; give advice for when to use them or avoid them, and how to write good ones when you need to; and show off some of the wilder possibilities.
Gary Fredericks is a software developer at Groupon in Chicago. He's been using Clojure professionally since 2009, and spends half of his free time trying to write code that visualizes and explains concepts from pure math and computer science.
PuppetDB: Sneaking Clojure into Sysadmins' Toolkits
Puppet is the most widely deployed open-source configuration management tool on the planet, written in Ruby. As deployments got bigger, people began demanding more of Puppet: store more data, store it more reliably, store it more quickly, and give us better ways to access it.
Thus, PuppetDB was born. It's an open-source, centralized storage system for Puppet users; it persists object graphs, key-value data, and time-series logging information. Ruby wouldn't cut it for us. Written in Clojure, it features a bespoke query language and compiler, exploits and embeds a wide variety of JVM libraries such as ActiveMQ and Jetty, uses a whole ton of Clojure libraries for things ranging from cheshire to ring to clojureql to slingshot and so on.
In this talk we'll discuss a few major topics: what PuppetDB does and how it does it, the experience of bringing Clojure to a Ruby shop (comparing and contrasting the toolchains), and things we learned from having thousands of non-developers consuming our Clojure code.
by Deepak Giridharagopal (@grim_radical) - Puppet Labs
Deepak is Director of Engineering at Puppet Labs and the lead engineer for PuppetDB. Prior to joining Puppet Labs, he was Principal Engineer at Dell/MessageOne, using Clojure to manage and monitor thousands of production systems.
Nick Lewis is a Lead Engineer at Puppet Labs, and the co-author of PuppetDB.
Why are you excited about Clojurescript? Is it the promise of one language to rule them all or the allure of Clojure style, repl driven development for the browser? Unfortunately this dream is not reality, yet. To port your clj libs/apps to cljs you must walk a long path, with many obstacles: host specific apis that lead to code forks and other annoyances. There is shorter path.
- Help you use the same codebase for both clj and cljs.
- Shorten your clojurescript development/test cycle.
- Automatically run your tests on the JVM and on multiple browsers in parallel.
Roman Gonzalez is a software developer who is passionate about functional languages (Stockholm syndrome?).
Piplin – A DSL for describing silicon in Clojure
Designing hardware is a fascinating and frustrating procress–the virtually unlimited parallelism and customizability are often outweighed by the simple, relatively inexpressive languages would-be hardware programmers must use. Piplin is an open-source DSL that allows a subset of Clojure to be automatically converted into a hardware description, which can then be placed onto an FPGA or made into a silicon chip.
Piplin has several interesting features: it provides polymorphic implementation of the standard Clojure library, along with a flow-typing and inference system that allows for libraries to define new numeric and structural types. Piplin also takes an atypical approach to embedding–it can actually produce hardware descriptions or Clojure functions without any performance penalty due to an innovative internal representation.
This talk will discuss the design of Piplin, focusing on how it leverages Clojure's polymorphic capabilities to provide an extremely flexible system for simulating and synthesizing hardware modules in Clojure.
David Greenberg is a Research Methodologist and Clojurist at Two Sigma, a Hedge Fund in SoHo, NYC. At work, he builds data visualization and cluster computing applications in Clojure; at night, he hacks on Clojure tooling, FPGAs, and libraries for making things on 3d printers and laser cutters.
Simulation Testing with Simulant
Simulation allows a rigorous, scalable, and reproducible approach to testing. Simulation breaks the testing process into distinct steps: modeling, defining activity streams, execution, result capture, and validation. Artifacts from each step are captured in a time-aware database, so steps can be run (and re-run, and enhanced) independently of each other.
This talk will introduce simulation testing, walking through a complete example using Simulant, an open-source simulation library.
@stuarthalloway is a founder and President of Relevance. He is a Clojure committer, and a developer of the Datomic database. Stuart has spoken at a variety of industry events, including StrangeLoop, Clojure/conj, EuroClojure, ClojureWest, SpeakerConf, QCon, GOTO, OSCON, RailsConf, RubyConf, JavaOne, and NFJS. Stuart has written a number of books and technical articles. Of these, he is most proud of Programming Clojure.
Global Forest Watch: an open source Clojure project to monitor deforestation from satellite imagery
Deforestation accounts for 15% of annual greenhouse gas emissions, more than the entire global transportation sector. We will all die if carbon emissions continue apace. Any viable effort to curb the rate of deforestation depends on open and transparent monitoring of forest clearing activity.
We have developed an algorithm to parse terabytes of NASA satellite imagery toward a tractable estimate of deforestation at 500-meter resolution, updated every 16 days. The algorithm is now the basis for Global Forest Watch, which will be released in April 2013 by the World Resources Institute.
We rely on Clojure and Cascalog to analyze and classify the spectral time series of each pixel in the humid tropics. A few off-shoot Clojure projects support the data processing, including lein-emr to manage an Amazon Web Services cluster and cartodb-clj to interact with a large-scale spatial database directly from the Clojure environment.
Dan Hammer is a PhD candidate at UC Berkeley, studying environmental economics and information theory. He has been developing in Clojure for two years, and enjoys self-introductions written in the third person. He is developing a library for large-scale, econometric simulations in Cascalog/Clojure.
macros vs monads
The syntactic threading macros (-> and friends) hint at a whole new context for code that may be especially useful for network or other IO-related programs. Is it coincidence that the resulting code has a shape very much like state monad comprehension? We'll look at some code that can benefit from both approaches, weigh the benefits of each, and speculate about what could be done to make them better.
Chouser has been a Clojure user and contributor since 2008. He currently writes in Clojure full time at LonoCloud, where he has been known to sometimes choose poor names for his functions.
by Jonathan Claggett - LonoCloud
Everyone knows the value of exposing their web APIs to internal and external clients. A well written web API is a great asset to any organization and to all that use it.
Now, there’s been enough written and said about this topic, so what new ground could we cover here? The question we’ll try to answer is, “then why do most web APIs suck so bad?"
This talk is about a holistic, end-to-end approach on how to build good web APIs using Resource Oriented Architecture (ROA) and Clojure. I’ll talk about the importance of ROA, and then show to build an awesome web APIs example Clojure code. And yes, it will be Richardson Maturity Model Level 3 compliant. Don’t know what that is? You’ll learn that too!
CTO, Zolo Labs, a new Clojure/Datomic/Storm startup. Their first product is Zolodeck: a personal digital assistant for professional networking. Previously: Chief Architect & Director of Engg @ Runa (a Clojure/big-data/machine-learning startup that increases e-commerce conversions through real-time dynamic pricing), Lead Consultant @ ThoughtWorks
I would like to introduce you to a new compiler that I have been working on: ClojureScript-in-ClojureScript. The current ClojureScript compiler leverages the regular Clojure compiler for much of the heavy lifting. ClojureScript-in-ClojureScript (cljs-in-cljs) is a port of ClojureScript (including the Clojure top-half and other JVM specific code) entirely to ClojureScript.
This talk will describe the process of creating cljs-in-cljs and the missing pieces that had to be ported or created from scratch. I will walk through the read/analyze/emit/eval process for several common Clojure forms and describe the difference in handling between the three compilers (Clojure, Cljs, cljs-in-cljs). Along the way I will discuss some of the deep dark magic at the heart of both the Clojure and ClojureScript compilers (namely vars and namespaces) and I will describe the alternate solutions I used for cljs-in-cljs.
I will also demonstrate the cljs-in-cljs port in action and give an idea of where and why it is useful. Finally I will discuss where I would like to see cljs-in-cljs go in the future and what it will take to merge it upstream.
Joel Martin grew up in the tropical paradise of Papua New Guinea where he was first introduced to the joy of creating computer software and to his future online alias "kanaka" (or "bus_kanaka"). Joel is best known for creating noVNC, an HTML5 VNC client that has been adopted by many projects inluding OpenStack, Ganeti Web Manager and libvncserver. He is also known for creating websockify, a TCP to WebSocket bridge that is commonly used with noVNC and was also recently adopted by emscripten to provide networking support. His day jobs have ranged across the software stack and at many different companies including Compaq, HP, Red Hat, SiCortex, and Sentry Data Systems. He is currently a Principal Software Engineer at LonoCloud, where he is using Clojure and ClojureScript to build an operating system for cloud applications.
The Data-Reader's Guide to The Galaxy
Don't panic if you're unsure about picking up data-readers. It turns out that tagged literals are mostly harmless. Much as Douglas Adams produced "The Hitchhicker's Guide" material in multiple forms, a Clojure programmer can assign data-readers to process tagged literals with customized implementations. Clojure 1.5 adds a new feature that makes dealing with unknown tags simple and convenient. We'll also talk about the Extensible Data Notation (EDN), which aims to be the Babel fish of data transfer. Finally, we will explore a few unorthodox uses for data-readers.
Steve Miner is a software developer with a fondness for Clojure. He has programmed professionally in many languages, including Common Lisp, Smalltalk, Objective-C and Java. Most of his career has been with Silicon Valley companies such as SRI International, Xerox PARC, ParcPlace and Apple. Steve received his B.S. in Electrical Engineering from Stanford University. He now resides in South Carolina.
Editing Clojure Effectively with Emacs
In the Clojure world, Emacs is king. From Paredit to nREPL, Emacs and Clojure are a match made in heaven. Find out how the experts use Emacs to bring joy to their Clojure. Let me help you set up an effective minimal emacs config, go beyond the basics with paredit and make nREPL free your code.
Ryan Neufeld is a software craftsman at Relevance, where he spends his time sussing solutions out of customer problems. A polyglot programmer, Ryan has worked with everything from Clojure to C to Scala to proprietary languages, always favoring the right tool for the job. In his relatively short career Ryan has worked at a number of established companies and startups, and is always hungry to learn more.
Domain Driven Design with Clojure
For a lot of us, Clojure is very different from anything we’ve used before. The syntax is different, the functional paradigm is different, multimethods are new, the macro system is alien, immutability, side-effects, mutating state, protocols, data-types, reify... oh my!
Even after understanding the basics of the language, there’s often uncertainty about how to go about writing programs. How to structure applications? What goes where? What kind of layers? What about I/O? What’s the scene with TDD? Mocking or stubbing? What about distributed computation? How to organize namespaces? What’s this bottom-up thing? Composition? Meta-linguistic abstraction? Really?
This talk is drawn from multiple large-scale Clojure systems, across nearly 5 years of real-world Clojure usage. You’ll see how to get started with designing non-trivial applications, how to ensure the code communicates to anyone reading it, and how to ensure you can grow the code-base and the team, with some level of sanity.
CEO, Zolo Labs, a new Clojure/Datomic/Storm startup. Their first product is Zolodeck: a personal digital assistant for professional networking. Amit is the author of Clojure in Action, and to also the Chief Technologist at Runa, another Clojure-based big-data startup that uses machine learning, predictive modeling, and real-time targeted offers to increase eCommerce sales; Previously: ThoughtWorks, IBM.
Cascalog: Logic programming over Hadoop
Cascalog is a clojure library that makes it easier to write distributed batch processing jobs. It is built on top of Hadoop, but allows computations and queries to be written at a much higher level of abstraction. Cascalog allows large, distributed processing jobs to be written in a declarative manner, greatly shortening and simplifying writing many Hadoop tasks.
This talk will provide an introduction to Cascalog, a brief tour of its features, and finish with writing a sample application using some live coding. The intent is to help people unfamiliar with Cascalog to identify places it could be of use in their systems.
by Alex Robbins - Factual
Alex Robbins is a developer at Factual, where he uses Cascalog and Clojure to wrangle data. He lives in Dallas, Texas with his better half, Sally, and a boston terrier. When not programming, he enjoys riding his bike, playing board games and doing krav maga. He co-organizes the Dallas/Fort Worth Clojure user group and can't wait for Dallas to become the center of the Clojure world.
Building a PaaS in Clojure
We built a Platform-as-a-Service written entirely in Clojure. CircleCI has run hundreds of thousands of builds for thousands of customers and every line is written in Clojure.
PaaSs tend to be written in a combination of scripting languages and bash. However, Clojure's features were uniquely well-suited for the task. Clojure allowed us to compose high level features such as DSLs, threading macros, multithreading, middleware with very low-level concepts such as EC2 machine managment, VM building, filesystem twiddling, and running arbitrary user commands over SSH.
We discuss what went and well, and problems we faced, including JVM OOMs, horizontal scaling and distributed systems headaches.
Clojure in the Large
Having an expressive programming language like Clojure comes with a price: it's not always clear how programs should be structured. Without classes in the traditional OOP sense, what are the fundamental building blocks of an application? How do we divide up our source files? Where do different kinds of state and behavior "belong"? These problems become more acute as programs grow larger and more complex.
This talk will present patterns for building Clojure programs out of independent components. Topics will include:
- Achieving modularity with protocols and dependency injection.
- Managing startup / shutdown of components.
- When (not) to use dynamic binding.
- Interactive development with tools.namespace.
- Testing and mocking.
Stuart Sierra is a developer at Relevance, Inc., a member of Clojure/core, and the co-author of "Practical Clojure" (Apress, 2010) and "ClojureScript: Up and Running" (O'Reilly, 2012). He has been involved with many open-source technologies including Clojure, ClojureScript, Ruby on Rails, Hadoop, and Solr.
clojure-scheme: Compiling Clojure to Native Code via Scheme
Clojure's targeting of the JVM makes a vast array of libraries readily available. However, this dependency puts certain platforms, such as iOS mobile devices, out of reach. With the advent of cross-compilation approaches such as ClojureScript, these limitations are starting to lessen. This talk will focus on clojure-scheme, a recent fork of the ClojureScript compiler that translates Clojure code to Scheme code. In combination with the mature and robust Gambit Scheme compiler, it now becomes possible to compile this Schemified Clojure code to raw C. This talk will show how to use this trick to perform stunning feats never seen before, such as creating tiny and efficient executables or running Clojure code natively on iOS with full access to Objective-C libraries. We will also look behind the curtain and see the semantic similarities between Scheme and Clojure that make this technique straightforward, as well as the differences that pose more difficulty.
From his early experiences creating "Take-out Weight Curling," the smash-hit video game (in Canada at least), to his recently completed M.Sc. research on computational creativity and AI-driven art design, Nathan Sorenson has learned that computing is an expressive medium like no other. An eloquent language like Clojure is a godsend for someone whose daily routine can include weaving together genetic algorithms, parallel autonomous agents, and constraint-solvers. Nathan currently works at Vancouver-based startup Kibooco, where he seeks to make the creative power of computers tangible for the next generation by crafting intelligent and enchanting software for kids to create their own storybooks.
Sadly, though, he could do little about the preexisting APIs, which embody none of those principles. The DOM and its equally vile cousins are all stubbornly object oriented, referentially opaque, and for the most part splendid examples of how not to design clean and friendly APIs.
Don't worry, though: Clojure is a language flexible enough to overcome any adversity. In this talk, Bodil shares with you the interop horrors she faced building the Catnip web based editor and the Dog Fort web server, and the tools and abstractions that came out of the process of having to deal with Node and the browser, both single threaded and staunchly object oriented environments.
Bodil is a developer, frequent speaker and occasional teacher of web technology and anything that favours s-expressions. She is currently leading the web dev team at Arktekk, a charming little consultancy in Oslo, Norway. She is best known as the creator of the Catnip IDE for Clojure, and for her contributions to the field of programming language theory, especially the Facial Hair Theory of Language Design. She holds a doctorate in metaphysics and a religious title from some dubious site on the internets.
Code Execution as Data
A system in motion generates tremendous amounts of ephemeral data.
We put some of it our logs, trying to capture as much context as we can without drowning in it, but this gives us only glimpses of what's actually going on. We can use the logs and source code to guess, but this remains a painful, error-prone process.
This talk will discuss how to instrument and analyze running systems, using real world examples from Factual's production systems.
Zach Tellman is a software engineer at Factual. Sometimes, when he meets someone for the first time, he tries to guess what their voice will sound like. He's almost never right.
Tom White studied visual design and user interaction at the MIT media lab, and has since been prototyping emerging technologies at various Los Angeles establishments. Tom enjoys exploring the intersection of computation, interaction, and visual design, and has produced interactive artworks exhibited in Monoco, Japan, Los Angeles, Linz, and Taiwan. Over the last year he has been learning Clojure and applying it to an exploration of gigapixel imagery called design landscapes. He's also trying to live with less irony in his life. Seriously.
Note: The miniKanren Confo will be held in the evening of Tues March 19th at the conference hotel. The Confo is optional and can be added when you register for Clojure/West (or separately) for $50.
The Unreasonable Schemers
okay, not the real title... still TBD
Intro to CLP with core.logic
Traditional logic programming allows only a single constraint via equality. Until recently, this was the only option in core.logic. Constraint Logic Programming (CLP) allows the user to declare more specific information about the possible values of a variable. A variable could be declared as a number in a specific range, for example. This goes beyond a basic equality check and allows for efficient higher level operations, such as arithmetic. With features inspired by cKanren, core.logic now has support for CLP. This opens up another large set of problems that core.logic can help solve efficiently. This talk will introduce CLP using core.logic through examples and live coding. The coding and examples will build to some logic puzzles and give attendees the essential background to have some fun with core.logic and CLP.
Ryan Senior is a Senior Engineer at Revelytix Inc writing Semantic Web software in Clojure. He has worked in many other industries including healthcare, insurance, finance and manufacturing. His main interests are logic programming, programming languages and the semantic web.
Nominal logic simplifies reasoning about scope and binding, so that implementing interpreters and type inferencers is almost as easy as on paper. Inspired by alphaKanren, we embed nominal logic programming into Clojure. Unlike alphaKanren, which is incompatible with cKanren, core.logic.nominal extends core.logic. In this talk, I will introduce the core.logic.nominal primitives (fresh, tie, hash), show some examples (quine generator, typed lambda calculus, theorem prover) and highlight our implementation.
by Nada Amin (@nadamin) - EPFL
Nada Amin is a PhD student at EPFL, advised by Martin Odersky. Previously, she was a software engineer at Google, in the Gmail and Closure compiler teams. She holds bachelor and master degrees in Computer Science from the Massachusetts Institute of Technology.
Logic programming in the wild
Logic programming may be powerful, but it is hard to apply. Even experienced developers get tripped up by unwelcome surprises time and again. Accordingly, hardly any real software gets written in Prolog -- and many who do work with logic programming focus on very clever (but at times contrived) toy problems.
miniKanren and kin are an exciting development because they integrate well with their functional host language and get many things right, promising to get more actual work done. Nevertheless I believe there still is room for development.
In my talk I will focus on LP in two core areas that should matter strongly to working software developers: metaprogramming and data access (both in a wide sense). I will outline the potential LP has in these areas and study some major roadblocks to realizing this potential, with respect to formalisms and cognitive load.
We will proceed to take apart the core components of logic programming and look at ways to reassemble them with more leverage. Using that leverage we can introduce features to guide and assist developers avoiding everyday LP madness. I will provide a survey of new and well-known techniques to deal with some of the most pressing usability issues in logic programming.
I might claim that LP language designers have yet been neither crazy and nor considerate enough to both sufficiently empower and shield users and victims of logic programming in the wild.
by Gabriel Pickard (@werg) - White Paper Analytics Ltd.
Gabriel graduated MSc in Cognitive Science, focusing in Machine Learning and AI research. Prolog was one of his first programming languages. His industry experience encompasses building realtime systems using Node.js and Erlang as well as data-processing in Hadoop. Most recently he co-founded White Paper Analytics with a few friends, doing Machine Learning and data analytics consulting, as well as product development.
The Architecture of core.logic
core.logic is designed to be extended to whatever constraint domain you please. We'll examine the various design decisions that allow different constraint solvers to peacefully coexist under the same framework.
by David Nolen (@swannodette) - The New York Times
David Nolen spends far too much of his free time having fun hacking on core.logic, core.match, and ClojureScript.
Molog: Typed Functional Logic Programming in Haskell
Molog is an experimental derivative of miniKanren embedded in Haskell, designed to bring to bear the power of Haskell's type system on logic programs. In this talk, I will show Molog versions of familiar examples, give an overview of the distinction between relational and functional logic programs, describe how Molog's core persistent heap monad enables optimizations like path compression, and survey the challenges and benefits of insisting on strong types for a logic programming language.
by Adam C. Foltzer (@acfoltzer) - Galois, Inc.
Adam C. Foltzer is a life-long Schemer and current Haskeller who works in Research and Engineering at Galois, Inc. He learned relational programming from Professor Dan Friedman and Dr. Will Byrd while at Indiana University, and continues to work on it professionally and as a hobby.
Lightning talks are limited to 6 minutes and will be given after lunch each day.
Functional reactive programming is one approach for mitigating accidental complexity, using a declarative and composable data-flow model. During this talk, we will look at shafty, an open source ClojureScript project which explores using the functional reactive programming model for building dynamic user interfaces.
Do you use (J)Ruby or Rails at work? How about TorqueBox for serving Rack-based JRuby apps? If so, then you need to know about Immutant and the Immutant Overlay project. Combined with HornetQ messaging and RedHat's OpenShift platform, this might just be the perfect way to sneak some Clojure into your day job!
Surprising images can be generated from random S-expressions. We can then mutate or cross-breed them for more functional fun.
Despite Clojure's reputation for not being Perl, there's a surprising amount that you can accomplish by writing Clojure code without alphanumeric characters. We'll demonstrate some of the tricks you can leverage to get the most out of your obfuscated code.
We've been using VMFest for almost 3 years now to speed up the development and test of Pallet. It has made a world of difference to our workflow. Most importantly though, it is fun to operate with virtual hardware in a functional manner, as the possibilities are endless.
Checkout a git project with a pallet.clj file. Run `lein pallet up`. Get working project infrastructure. Multiple infrastructure targets are possible - run integration tests, build a dev environment, deploy to production. Your imagination is the limit with pallet 0.8.
Using the marvelous clj-http library, a handful of threading macros, JSoup, and a couple of maps, clj-mook provides a session abstraction for client interactions with a web application, with an eye towards testing. We use it to login to our app, retain the auth cookies, and poke around.
Clojure and Erlang are both functional languages with an emphasis on concurrency. We'll quickly cover what Clojure developers can learn from Erlang's particularly breed of concurrency and fault-tolerance.
The Clojure community has become one where anti-anti-intellectualism is welcome, where mathematical, computer-sciencey ideas find fertile ground, and many of them bloom into something practical. Sometimes, those ideas find their way into codebases written by folks who'd run screaming from anything that smells like a Lisp.
Get a taste for how RxJava in Clojure can be used to build non-blocking "Observable APIs" and efficiently compose asynchronous flows together using functional reactive operators. Rx extends the observer pattern to support sequences of data/events and adds operators for composing sequences together declaratively while abstracting away low-level threading, synchronization, thread-safety, concurrent data structures, non-blocking IO and other such concerns. More information here: https://github.com/Netflix/RxJava/tree/master/language-adaptors/rxjava-clojure"
Are you a student looking to get paid to work on a cool Clojure project? Do you have a Clojure project that could use a little help from a full time worker? If so, then find out how you can help Clojure participate in the Google Summer of Code 2013.
Unsessions will be held on the evening of Monday, March 18th at the conference hotel (Courtyard City Portland) from 6-10 pm. The schedule is here.