Melanie Mitchell is Professor of Computer Science at Portland State University, and External Professor at the Santa Fe Institute. She has also held faculty or professional positions at the Univ. of Michigan, the Santa Fe Institute, Los Alamos National Lab, and the OGI School of Science and Engineering. She is the author or editor of five books and over 70 scholarly papers in the fields of artificial intelligence, cognitive science, and complex systems. Her most recent book, Complexity: A Guided Tour won the 2010 Phi Beta Kappa Science Book Award. Melanie directs the Santa Fe Institute's Complexity Explorer project for the field of complex systems.
Visual Situation Recognition: An Integration of Deep Networks and Analogy-Making
I will describe my current research on building computer systems that can recognize visual situations. While much effort in computer vision has focused on identifying isolated objects in images, what people actually do is recognize coherent situations—collections of objects and their interrelations that, taken together, correspond to a known concept, such as “a child’s birthday party”, or “a man walking a dog on the beach”, or “two people about to fight”, or “a blind person crossing the street”. Enabling computers to flexibly recognize visual situations would create a flood of important applications in fields as diverse as medical diagnosis, interpretation of scientific imagery, enhanced human-computer interaction, and personal information organization.
Situation recognition by humans may appear on the surface to be effortless, but it relies on a complex dynamic interplay among human abilities to perceive objects, systems of relationships among objects, and analogies with stored knowledge and memories. No computer vision system yet comes close to capturing these human abilities. In this talk I will describe research—currently in early stages—on bridging the gap between low-level perception and higher-level image understanding by integrating a cognitive model of concepts and analogy-making with a brain-inspired “deep network” for lower-level vision.
Boot is a radically different JVM build tool written in Clojure. Where most build tools are their own environments, Boot is a library you can use on the JVM and within Clojure to automate builds the way you'd automate anything else: with programming. Boot is really easy to get started with and is growing in popularity. In our talk, we'll describe abstractions unique to boot, including pods, filesets, and tasks. We'll also demonstrate how they can be combined to solve complicated build problems in simple, straightforward ways, making new things possible and old things easy.
About the speakers: Alan Dipert has contributed to Clojure, ClojureScript, and several Clojure projects. Alan is a developer at Adzerk, where he builds ad servers and services. He lives in Durham, North Carolina.
Micha lives in Durham, NC, where he develops software at Adzerk. Clojure helps him to believe that Lisp Can Do It.
There are many resources to help you build Clojure applications. Most however use trivial examples that rarely span more than one project. What if you need to build a big clojure application comprising many projects? Over the three years that we've been using Clojure at WalmartLabs, we've had to figure this stuff out. In this session, I'll discuss some of the challenges we've faced scaling our team and code base as well as our experience using Clojure in the enterprise.
About the speaker: I'm a developer at WalmartLabs. Over the last 3 years, I've been slowly growing a team of Clojurists to attack some of Walmart's core tech problems. Previously, I co-founded Aussie startup Grabble, a digital receipts company that forms the basis of many of Walmart's products today.
Although sound is not uncommon within the Clojure community, this talk will present a more embodied approach to creating and interacting with it through wearables. The talk will consist of a live demo and a quick dive into the code that powers it.
The demo will contain live sound and video generated from a set of wearable sensors.
Code examples will focus on:
ClojureScript on Node.js communicating with the set of wearables and dealing with the flood of live data that they provide.
Clojure on the JVM transforms this stream into a multitude of possible events. These events are passed to Overtone and through it generate a highly responsive soundscape. At the same time, these events are also used to construct projected visuals.
This could not be achieved without Clojure's ability to inter-operate with its host platforms, provide tools for live prototyping, and the incredible diversity of interests within the Clojure community.
Work presented here stems from the Quipucamayoc project. It will culminate in 2016 with an interwoven performance between two communities on both sides of the Andes.
About the speaker: Boris Kourtoukov is a Toronto-based wearable technology developer currently working at OCAD University. There he is involved with the Social Body Lab, and the Quipucamayoc project from the Ayllu Iintiwatana team. Boris uses Clojure to create a variety of output in the range between art and design. The focus on live coding environments, host symbiosis, and coherent ideals are his favorite aspects of Clojure as a language.
CircleCI's frontend is a large, production-caliber, open-source Om project. CircleCI has long enjoyed the benefits of Clojure to power our CI platform, so we jumped at the opportunity to be ClojureScript + Om pioneers as well. Om represents both a significant step forward in UI development and considerable new opportunities for improvements. This talk will explore the benefits and challenges we've encountered, as well as provide a roadmap for using Om in your own projects.
About the speaker: Brandon Bloom has worn a variety of fancy hats for a variety of big companies, startups, non-profits, and consulting clients. His recent work includes Code.org's Hour of Code campaign and CircleCI's ClojureScript-based frontend. When he's not-so-secretly applying computer science to business problems, he tinkers with languages, contributes to Clojure(Script) and builds other crazy things with Clojure.
Figwheel is a tool that helps ClojureScript programmers. It facilitates a live interactive programming workflow and much more. In this talk, I will go over the main ideas behind Figwheel and demonstrate how it works. I will explore several tricks to help people get the most out of using it. The goal of this talk is for attendees to walk away with a solid understanding of Figwheel and its use.
About the speaker: Bruce has hiked the Appalachian Trail, and enjoys living in a demountable Dome of his own design.
He is the author of the blog rigsomelight.com, and the figwheel library for ClojureScript.
He is just plain addicted to programming.
Gather round and hear the harrowing tale of how Chris saved his Chickens from the evil raccoons using Clojure on a BeagleBone Black to automatically shut and lock the coop door at night and open it in the morning, using ambient light sensors to ascertain the time of day. Learn what it took to get Clojure running on the BBB, what some of the challenges were, and how Clojure handled for device programming. Get a sneak peak of libraries being extracted from this project, which you'll be able to use for general purpose device programming. Bask in glorious victory with Clojure and the dancing chickens.
About the speaker: Chris is a computational biologist and data scientist in love with Clojure. He spent a few years working at Fred Hutchinson Cancer Research Center in Seattle applying Computational Biology to the study of viral transmissions patterns and host defense mechanisms against viruses such as HIV. While there, he began using Clojure to build the mathematical engine behind pol.is, a startup app using data visualization and machine learning to make large scale conversations make sense. On the side, he enjoys making and tinkering.
Debugging Clojure code has traditionally been something of a black art. Cursive provides a complete JVM debugger based on the one provided in IntelliJ, including breakpoints, stepping and expression evaluation. In this talk, we'll see some of the features that Cursive provides to make debugging easy and discuss some tricks and tips for debugging Clojure code. We'll also discuss the JDI that the debugger is based on, and how some of its limitations affect debugging functional languages.
About the speaker: Colin is the developer of Cursive. He has programmed things for a long time now, and came to Clojure from Java via Scheme a few years ago. When he's not hacking on Cursive he's mostly waiting for his daughter to get old enough to program robots together.
Because they are computed, generative art systems necessarily explore a state space, but many of their state spaces exhibit wild variations in visual interestingness across their domain. This makes them unsatisfying to use in live performance, since they'll lapse into the boring parts and resetting the state to restore it is visually unpleasant.
In this talk I'll give an introduction to generative art with a focus on iterated fractal systems in particular, which have some absolutely fascinating portions of state space alongside very boring ones. I'll present Many Worlds, a system that visualizes state space traversals ahead of time remotely to allow the user to find a compelling state path in an interactive, iterative way
About the speaker: Dan works on Clojure services at Puppet Labs. He is lucky enough to have been using Clojure professionally for nearly four years. When he's not writing Clojure, he enjoys playing board and card games. He is perpetually afraid he will be kicked out of Portland for being unable to grow attractive facial hair.
While the software industry contemplates how to increase diversity in its ranks, what if Clojure could be the very tool to spread Clojure (and programming in general) to the world of non-English speakers? By seriously considering the macro perspective, we can see how simple ideas can lead to opportunities for lasting change. How far could we extend these efforts in Clojure-esque simplicity? Find out what makes Clojure uniquely suited to supporting other human languages.
About the speaker: Elango came to Clojure 3 years as a skeptic and now thinks it can solve the world's problems. Or at least it can raise the average standard of programming simplicity. He has taught workshops for both human and computer languages. He currently enjoys taking on the big data challenges at Nest.
Lisps are a great starting point for teaching computer science since they allow introduction of essential concepts, such as functional abstraction, recursion, and higher-order functions. Clojure provides additional benefits for novice programmers due to its rich set of data structures and predefined functions, easy access to concurrent processing, and an active open source and industry community. However, in order to introduce Clojure in an introductory programming class for students with no programming experience, one has to address several challenges, such as non-beginner-friendly error messages and a lack of a beginner-friendly IDE. In this talk I will discuss progress that my students and I have made towards filling in the missing pieces for incorporating Clojure into an introductory class.
About the speaker: Elena Machkasova is an associate professor at University of Minnesota, Morris, an undergraduate public liberal arts college, where she's been teaching for 12 years. Her Ph.D. in computer science is from Boston University. For the last couple of years she has been working with students on a project ClojureEd that focuses on incorporating Clojure into a CS1 course: a first course that students would take in a CS major or a minor.
At World Singles, HoneySQL is used to construct over a hundred queries with a dozen filters on the fly for graphing purposes. HoneySQL allows you to represent SQL queries as Clojure data structures, which make it easier to read and debug, simpler to modify, and faster to add more queries. In this talk, we'll build example queries step-by-step with HoneySQL, walk you through from our graph menu setup to how a request is processed on the backend at runtime. We will also cover how filters and joins are handled as well as how the data is customized to be graphed (with highcharts on the front-end).
By the end of this talk, you will feel confident about writing elegant, modestly complex queries in Clojure.
About the speaker: Fumiko is a developer at World Singles where she programs mostly in Clojure and recently in ClojureScript. She ponders Elm is probably the next language she will learn and possibly fall in love with as much as Clojure. The other areas she lives life to the fullest with love are parenting, cooking, and knitting. While chasing her twins, she is dreaming of someday hiking in the mountains with them.
Random number generation is unsettled territory in the Clojure ecosystem. The language's built-in mutable random number generator is not helpful for more purely functional approaches. An immutable, splittable RNG has an ideal interface, but is challenging to implement robustly. This talk will motivate the topic by showing how switching to splittable RNGs makes the implementation of test.check (the property-based testing library) more solid, and describe an implementation of a splittable RNG in Clojure based on recent research.
About the speaker: Gary Fredericks lives in Chicago, writes Clojure at Groupon, and is primarily known as the Joe Biden of test.check. His only notable accomplishment is discovering Swearjure.
Zelkova is a library for Functional Reactive Programming (FRP) that lets you compose your Clojure or ClojureScript application as a graph of "signals" defined using pure functions. It is heavily inspired by Elm, a language which embraces an innovative flavour of first-order FRP as its central paradigm.
This talk will show Zelkova in action, demonstrating how it can be used together with GUI libraries like Om and Reagent to solve practical problems while making state management unexpectedly fun.
Have you ever wanted to try your hand at designing and building a language, only to be driven away by ancient and obtuse tools? Clojure makes an excellent sandbox for quickly designing and prototyping new language ideas. This talk lays out a roadmap for the aspiring language inventor, from design to parsing to building a runtime.
About the speaker: Jeanine loves designing languages, tools, and libraries. She tries to learn all languages, and it is her professional opinion that every one of them is terrible, but most of them are good at something.
This talk will try to demystify the path between a simple piece of Clojure code and its execution. We'll follow a single expression-from text, to parsed form, to analyzed expression, to byte-code, to execution. We'll look at a lot of code, including some highlights from the 8500+ lines of love that are Compiler.java. Hopefully Clojurists will come out of the talk better understanding how their code works and more willing to dig into the guts the next time it doesn't work as they'd expect.
About the speaker: John is a software engineer at DRW Trading Group, where he spent enough time profiling Clojure applications to finally dig into the bytecode behind the curtain.
One of the best parts about Clojure is its support for parallelism, and understanding that support (including the quirks) lets us do great things. This talk will explain Clojure parallelism by showing how future and pmap work, discussing their limitations, and introducing advanced alternatives like reducers, tesser, and claypoole. Come deref the future!
About the speaker: Leon Barrett has been writing Clojure for the past three years at The Climate Corporation, making parallel, statistical weather models that help farmers grow crops more efficiently. Leon values elegance in both code and prose, and his articles have been featured on the first page of Hacker News. Leon is also the author of the threadpool library claypoole (https://github.com/TheClimateCorporation/claypoole). Prior to The Climate Corporation, he earned a Ph.D. in Artificial Intelligence at UC Berkeley and worked on Google search quality.
ReactJS! Om! Reagent! Quiescent! ReactJS and ensemble have made a big splash in the ClojureScript world in the past year, but what exactly is it all about? It's exciting, but it's moving so fast that it can be overwhelming to keep up with. This talk is a refresher on what ReactJS is, and why it is a good fit for ClojureScript. It concludes with a survey of the three primary CLJS interfaces to React (Om, Reagent and Quiescent) and provides code samples and walkthroughs of example applications, comparing and contrasting the different approaches.
About the speaker: Luke is a Clojure Consultant currently working with Cognitect. He is the co-author of Practical Clojure (Apress 2010), ClojureScript: Up and Running (O'Reilly 2012) and the Clojure Cookbook (O'Reilly, 2014). He is also the author of several Clojure(Script) libraries including Quiescent, Domina and Prolin.
Perhaps contrary to popular belief, there is a rich history of lisp and other functional languages in game development. How can the choice of programming language inform game design and empower the artist? What properties of lisp, and Clojure in particular, make it suitable for building games? This talk will start by considering the wisdom of our ancestors before diving into an exploration of the application of functional programming as engineering practice to the art of game design.
About the speaker: By day, Morgan ponders deep philosophical questions about Truth in datasets at Factual. Under the midnight oil, she hacks on games in Clojure. She's been exploring the intersection of functional programming and game development ever since someone in college told her the two don't mix.
When writing DSLs, we sometimes forget we're not stuck with the type system of the host language. We may be in a situation where dynamic or gradual types don't give us the best power-to-weight ratio for our specific use case. This talk will show how macros enable localized forms of static checking that go beyond vanilla Clojure or core.typed. We'll tackle the gnarly problems of error messages (what good is a statically-checked error we can't understand?) and interoperability (what good is code that can't interact safely with other libraries?) Practicality will be paramount as we show these ideas at work in a typed query DSL for Datomic.
About the speaker: Nathan works at SparkFund, where he uses Clojure and Datomic to help finance energy efficiency projects. His long-term mission is to bear PL theory along the slow, treacherous path from the lofty peaks of ICFP preprints to the grimy streets of industry practice.
Trapperkeeper is an open source services framework for large scale Clojure applications. Trapperkeeper is used for decomposing application code into reusable, swappable, and composable components. At Puppet Labs, we now use it as the basis for all of our backend development. Come hear an introduction to Trapperkeeper and a tour of all of its core services including our new transparent RPC capability.
About the speakers: Nathaniel Smith is a full time Clojure developer for Puppet Labs living in Portland, OR. When not writing backend services for Puppet Enterprise he is thinking about generative poetry and how to make the tech industry a more welcoming place for all.
Ruth Linehan is a software engineer at Puppet Labs, where she works on Clojure services. When not spelunking in the depths of Puppet’s code bases, finding weird bugs, she runs long distances, rides bikes, and works on learning Irish (Gaelic).
Clojurescript community has been slow to embrace Garden, a simple library for rendering CSS in Clojure/ClojureScript. Conceptually similar to Hiccup, Garden allows you to design pages and layouts like a functional programmer: plain-old data structures, functions, and abstractions.
In this talk I will focus on responsive grid techniques popularized by Bootstrap, Susy, Flexbox, followed by a live-coding session. We will explore how to implement fluid, responsive, nested, and even DIY grids with Garden, and render CSS3 on the server or client. We will end with a demo of a page designed in Garden, rendered with Om, to showcase the benefits of using Clojurescript all the way.
About the speaker: Priyatam is a writer and polyglot engineer specializing in web apis and user-interface design. After building software for twelve years in Fortune 500 companies and creative agencies, he found his passion at the intersection of literature and lisp. He's the founder/principal at Facjure and is currently working on a novel.
This talk will introduce the cloxp Clojure development kit. Cloxp aims to combine ideas first found in some of the original Smalltalk and Lisp environments with the possibilities of a modern web-based infrastructure. The tool is build around the fact that Clojure provides rich runtime and meta-programming facilities that enable a highly interactive workflow. Instead of being focused on a file-centric development approach, code exploration, modification, and versioning happens on the level of code entities.
About the speaker: Robert is a software engineer and researcher at CDG Labs. He is passionate about computer languages and software creation kits that facilitate liveness and interactivity. Since several years Robert is one of the main contributors of the Lively Web project (http://lively-web.org), a web-based development and runtime environment. He lately started experimenting with Clojure(Script) to explore how a more functional approach can enhance the architecture of software development tools in terms of simplicity and extensibility.
Sonian's been using Clojure in production, at large scale, for 6 years. In that time, we've developed a common foundation for back-end Clojure services, embodied in our SAFE codebase.
For this talk, I'll walk through the major features of that foundation, explaining the reasons each was chosen and how they work together to make building new Clojure services easier.
About the speaker: Ron Toland started out as a front-end web developer in 2007, and has been steadily moving down the stack ever since.
Two years ago he burrowed into the role of building back-end services in Clojure, and refuses to budge from there.
As a community, we talk a lot about generative testing, especially in the small. What happens when we apply these approaches at the systems level? (Hint, it's Simulant!) In this talk, we'll explore how we applied Simulation Testing to a modern financial system. At the end, you'll have a cursory idea how to model and implement a simulation test for a multi-actor system.
About the speaker: Ryan is a polyglot software developer and architect. Whether it's a tough technical issue or one of the softer elements of software engineering, Ryan relishes the opportunity to deliver results for clients. Ryan is also an author, having recently finished co-writing and editing the crowd-sourced Clojure Cookbook.
Good Clojure practice emphasizes programming with immutable data. Another practice which can greatly simplify your code is declarative programming via pattern matching. Powerful pattern matching libraries such as core.match and defun give Clojure pattern matching abilities that rival Prolog and Erlang. This session is an experience report and best practices from extensive use of pattern matching libraries in recent open source Clojure projects.
About the speaker: Sean is an Engineering Director at Path where he runs the remote engineering team. He lives in Chapel Hill with his family and ferrets. When not programming... OK... let's be honest, he's mostly just programming.
Yieldbot's data platform is built on top of clojure. I will cover some of our experience using clojure for data (sciencing and platform). I will cover our two major open source projects, marceline, a clojure dsl for apache storm/trident, and flambo, a clojure dsl for apache spark.
About the speaker: Soren is Chief Data Scientist at level 50 necromancer at Yieldbot.
He has lives in Portland, OR and has two cats, two chicken, two rabbits, and a fish.
He enjoys writing about himself in the third person, and oxford commas.
Arcadia is the integration of Clojure into the Unity 3D game engine and development environment. Unity exports to nearly all major gaming platforms, while Clojure's functional data and capacity for live programming and optimizing macros provide unique benefits to game developers. We will discuss progress since our last release, the internals of the Arcadia compiler, and the ramifications of industrial game development in Clojure, with live usage demos.
About the speakers: Tims is a Clojure hacker in Brooklyn interested in games and 3D graphics.
Ramsey Nasser, also a Clojure hacker in Brooklyn interested in games and 3D graphics.
Programmers hate Excel, but we often have to deliver results as spreadsheets. This is what we miss: used correctly Excel is a tool of tremendous expository power that can enable richer communication.
I'm going to show you what makes a spreadsheet beautiful and how you can create beautiful spreadsheets from pure Clojure data structures using the Excel templates library. Along the way, we'll discuss how to use spreadsheets to enhance understanding of quantitative data throughout our organizations.
About the speaker: Tom is principal at Infolace, a consultancy that builds data and analytic platforms for data-driven organizations. He uses Clojure to tackle analytics and visualizations of complex data in a wide variety of domains. He is also the author of the Clojure pretty printer and autodoc tool.
To reach a diagnosis, a medical professional must now consider not only a sea of symptoms, but also an increasing number of factors: genotypes, functional genetics, proteomics, etc.. Caretakers, insurers, governments, medical researchers and most of all patients are looking technology satisfy their disparate goals. I will describe how our team is using Clojure, Datomic and React to provide a more humane medium for real-time collaboration. The primary focus of is to propose systems that scale well with high intrinsic sociological complexity. I will give a development log of how we are attempting to enable all parties in the healthcare ecosystem to create interactions, giving agency to the machine to participate on their behalf in the moment medical encounter.
About the speaker: Tyler is the project manager at Breeze EHR where he laments the state of health data exchange. Splitting his time between New Orleans and Lafayette Louisiana he enjoys the unique southern Louisiana food and culture. He also loves to jeep and build things with his 5 year old son.
Suppose you'd like to teach Clojure in your local community and are the first person to do--where would you start? You'd need a nice and clear curriculum with focused exercises and simple-but-engaging apps; however, soon, you'd find that writing such curriculum on your own is a difficult task. That's why ClojureBridge curriculum team has been collaborating on its own new Clojure curriculum, so that people from all backgrounds can enjoy coding in Clojure. It is as if the team is walking, sometimes staggering, on a long and winding road leads to a better curriculum for beginners. In this presentation, you'll learn what the curriculum team has accomplished so far, what work is on the horizon, and how you can offer your input, ideas, and help now.
About the speaker: Yoko Harada is a long time Java developer and a JVM language lover. She has been a ClojureBridge board member since beginning. Yoko volunteered as a TA for the first ever ClojureBridge workshop and is writing apps and documents as a ClojureBridge curriculum team member. Prior to the ClojureBridge, she firstly organized RailsGirls in Japan, which grew to a big part of Ruby Community in there now. Yoko is a developer at Cognitect, Inc. She enjoys watching musics and movies at her spare time.
Queues, it seems, are back in fashion. This is exciting, as queues let us explore problem spaces that were unreachable by pure, immutable primitives.
But queues, and the execution models that drive them, are very different than what we're used to. Naive use of libraries like core.async will create brittle, unpredictable systems that fall over when we least expect.
This talk will cover the basics of queueing theory, and its practical application in Clojure systems large and small.
About the speaker: In Zach Tellman the forward moving force of time (or time-force expressed as an ergic field) has ceased. All changes result from that. Forms regress. The substrate is revealed. Cooling (entropy) is allowed to set in unimpeded. Equilibrium is affected by the vanishing of the forward-moving time force-field. The bare bones, so to speak, of the world, our world, are revealed. We see the Logos addressing the many living entities. Assisting and advising them. We are now aware of the Tellman everywhere. The press of time on everything, having been abolished, reveals many elements underlying our phenomena.
Mobile development is the next great frontier for the Clojure ecosystem. Traditionally, mobile Clojure apps have been trapped in a WebView, resulting in limited capabilities and a less-than-steallar user experience. This is no longer the case. Come hear about production examples leveraging the existing Clojure ecosystem to build real, native mobile applications. No strings, caveats, or restrictions.
About the speaker: Zachary Kim is the CTO of Zaarly, a services marketplace company based in San Francisco, CA. He has been part of the Clojure community since 2010, mostly lurking, but has helped out a bit as one of the authors and maintainers of the community documentation project, ClojureDocs.