Who's speaking at CR17?

Take me to the schedule

Keynote Speaker

Jay Martin

Jay Martin

The Value of Learning (1 hr)

This talk focuses a spotlight on the subject of learning. Just how much do we value learning itself as a subject worthy of careful study? I propose that Clojure’s future success hinges on our collective response to this question.

My hope is that you’ll walk away from this talk with a fresh awareness of the value of learning in your own life, in the Clojure community and in the world at large. You will be offered a specific new habit to employ in your weekly routine to elevate learning to its deserved rank, exponentiating your productivity, not only in your studies, but in every project you touch.

About Jay

Jay studied Industrial Engineering and Sales in College. He worked as an IT Systems Administrator for a decade, and was recognized for outstanding customer service when his employer won the Malcolm Baldrige National Quality Award. He genuinely enjoys helping people and developing his new educational venture, webappzero.com. When not at the keyboard of his computer, Jay can be found in the backyard shooting free throws.

UTC -5, Eastern Standard Time | WebsiteGitHub

Workshop Presenters

Yehonathan Sharvit

Yehonathan Sharvit

Clojure.spec Workshop (2h)

The workshop will be split in two 1-hour sessions:

Part A. Intro to Clojure.Spec:

  • What is it?
  • How to use it?
  • Expect a lot of simple code examples

Part B. Amazing applications of Clojure.Spec:

  • Define custom defn (or let) like macros with a couple of lines of code
  • Define your own grammar
  • And more…

About Yehonathan

Yehonathan has been a SW developer since 2000. After 10 years of C/C++, a B.Sc. in Electrical engineering and a M.Sc. in mathematics, he joined web programming in 2010. He started to become a SW polyglot: javascript, python, ruby, java. But the real transformation happened in 2012, when he discovered LISP and Clojure.

He has been the principle engineer of a web-audio startup writing code in ClojureScript, and today he works at today he is a clojure[script] consultant  Since March 2016, he has developed KLIPSE: a multi-language embeddable interactive web repl – https://github.com/viebel/klipse.

As a mathematician, Yehonathan’s coding style turns around elegance and simplicity. He blogs about functional programming wonders at http://blog.klipse.tech and http://read.klipse.tech .

Yehonathan earned a M.Sc. in mathematics and a B.Sc. in electrical engineering.

UTC+2 | WebsiteGitHub

Eric Normand

Eric Normand

Building Composable Abstractions Workshop (1hr)

At the 2016 Clojure/conj, I gave a presentation called Building composable abstractions. I laid out a process for developing abstractions that are free from corner cases and compose well. This workshop is about helping you walk through the process yourself. I’ll be giving you a programming assignment and you will break up into groups to develop it. I’ll give you time for each step of the process. At the end, each group will quickly present what we have done.

Prerequisites

Because the time is so limited, it is imperative that you watch

I will assume that you have understood the process as I give it in the video.

The more preparation you do, the more you will get out of your time and expense of this workshop. As a bonus, if you’d like to get even more out of it, I suggest developing your own vector graphics system using the process. You can choose whatever metaphor you’d like.

Further, you can apply the process to something from your own life, be it a problem at work or elsewhere.

The Process

Just for reference, I will give the process here. One of the reasons I gave the talk at the Conj was to start discussions, and that certainly happened while I was still there. So this process is slightly different from the one you see on the slide, but basically the same as what I did on stage.

  1. Elaborate a physical metaphor
  2. Describe the meaning of your abstraction as mathematical statements
  3. Construct the meaning using constructs from your programming language
  4. Implement the abstraction by refactoring the meaning from Step 3.

About Eric

Eric Normand is a long time functional programmer excited to see it entering the mainstream. He loves teaching and cooking. You can learn Functional Programming from him at PurelyFunctional.tv and read his thoughts in The PurelyFunctional.tv Newsletter. If you visit him in New Orleans, you can meet his wife and daughter. He’ll even make you some gumbo if you tell him you’re coming.

UTC-6 Central Standard Time | WebsiteGitHub

Luke Vanderhart

Arachne Workshop (1h)

Speakers

Lucas Calvacanti

Lucas Calvacanti

Microservices in Clojure

There are plenty of patterns and literature about how to organize systems in traditional languages like Java or C#. The same isn’t exactly true for functional programming languages, specially Clojure. At Nubank we had to figure it out over 3 years of writing tens of microservices in Clojure, using some of our knowledge from other languages and some creativity.

Several patterns emerged, several mistakes were made and eventually we came up with a very sustainable and scalable way to write new code even for developers which are new to Clojure. This talk will explore those learnings.

About Lucas

Lucas Cavalcanti is the Lead Software Engineer of Nubank, the most influential Brazilian Fintech built as a service oriented architecture leveraging Clojure and Datomic. Lucas is a functional programming enthusiast, and proponent of best practices in software development, with a vast experience in real production applications written in Java, Scala, Ruby and now Clojure. He holds a BS in Computer Science from the University of Sao Paulo.

BRST UTC-2 | WebsiteGitHub

Anatoly Polinsky

Anatoly Polinsky

Config You Know Plus Some Love

The talk is about often “left for later” concern when creating things. It is about application configuration. There is no unique way to do it right, but there definitely are concerns caused by environmental differences, configuration data structures, validation, versioning and security.

There is a well known Config section in twelve-factor methodology, but as I mentioned, there is no unique way to “do it right”, and I believe in Clojure, with rich data structures and ubiquitous reach of JVM libraries, we can do much better than that.

This talk will expand the meaning behind the word “configuration”, will apply words such as programmable, functional, queryable and secure to it, and will take you on a journey to explore the universe nebula by nebula with cprop, envoy and friends.

About Anatoly

Anatoly loves people, music, and coding. He went from “ZX Spectrum The Great” to IBM z/Series and then back to human oriented hardware. He works at Chariot Solutions where he has an opportunity to hack on Clojure, Scala, Java, Mobile and this thing people call big data. In his free time, he drinks scotch, smokes hookah, jams some guitar chords with others, and then some.

UTC-5, Eastern Standard Time | WebsiteGitHub

 

Nicholas Shook

Nicholas Shook

Serverless Clojure on AWS

In college while studying rhetoric, I came across the epiphany that everything in this world is a trope. As it pertains to software development, specifically web development, patterns like load balancing, SSL, authentication, authorization, param sanitization, process monitoring and accessing a SQL database are omnipresent motifs that nearly every developer has to tackle. With serverless architecture, cloud companies, like Amazon Web Services, have abstracted many of these problems so we as developers do not need to solve them anymore.

In this talk, I will go over how to set up a serverless architecture on AWS using Cloudformation, and how to leverage Clojure to write AWS Lambda. We will be creating a web application to host dinner parties to showcase how many of the tropes of web development can be handled by Amazon so you can focus on the narrowly tailored application logic that makes your system unique.

About Nicholas

Nicholas Shook is a developer and lawyer from Las Vegas. He has worked most recently as the technical founder of Stealth Worker and has created the website for the Vendor Security Alliance using serverless architecture.

UTC-8 Pacific Standard Time| WebsiteGitHub

Yoav Rubin

Yoav Rubin

Designing a Database like an Archaeologist

500 Lines or less is the 4th book is the series The Architecture of Open Source Applications, in which each chapter presents a program solving a problem or describing a system, using at most 500 lines of code.

In the chapter “An Archaeology-Inspired Database” I showed how to build an in-memory functional database (that follows the ideas in Datomic) which provides ACI and What-If transactions, graph and simple datalog queries, all using 360 lines of Clojure. I’ll present the design, considerations, and the implementation of the database, and talk about the key points I learned from this work.

About Yoav

Yoav Rubin is a Senior Software Engineer at Microsoft, and prior to that was a Research Staff Member and a Master Inventor at IBM Research. His recent work revolved around data security of cloud databases, and in the past his work focused on developing cloud or web based development environments. Yoav holds an M.Sc. in Medical Research in the field of Neuroscience and B.Sc in Information Systems Engineering.

UTC-8 Pacific Standard Time | WebsiteGitHub

Conor White-Sullivan

Building Web Apps for Small Problems

Daniel Solano-Gomez

Daniel Solano-Gomez

Tooling Matters

Tooling matters. Developer experience matters.

Great tooling makes our lives as developers better: It helps us be more productive and happier and can help us better understand the technologies we work with. Conversely, inadequate tooling frustrates our lives and creates barriers for newcomers.

As Clojure approaches its tenth year, let us take a moment to review the state of tooling in Clojure:

  • Are we, as a language community, creating the right tools to make Clojure easy to learn and a delight to work with?
  • What are the inherent strengths and weaknesses in Clojure with respect to tooling?
  • What can we do to improve the tooling story in Clojure?

Join me in starting a conversation around these questions with the goal of making the Clojure development experience better.

About Daniel

Daniel is a developer at Outpace Systems and a long-time member of the Clojure community. He has contributed to Clojure and maintains several open source projects, such as neko, tacular, liberator-transit, and leinjacker. Additionally, Daniel is a member of the Clojars Community Committee and a long-time participant in Clojure’s Google Summer of Code efforts.

UTC-6 Central Standard Time | GitHub

Robert Stuttaford

Robert Stuttaford

Lessons from 4 years with Datomic

We’ll starting with a crash course on the Datomic data model, and then switch gears to talking about all sorts of data-modeling problems and their solutions. Also included will be a number of gotchas we learned the hard way in our time with Datomic at Cognician.

About Robert

Robert has been coding for two decades and is still not dead. Having worked in all facets of web development for a wide variety of use cases and people, he is happily astonished at how much fun he’s still having, thanks in no small part to the Clojure language and its philosophy and community.

Robert is CTO for Cognician is a mature product start-up (stay-up?) in the corporate learning space. Our team is composed of a variety of “good-weird” people, all focused on solving the big problems of digital coaching in the workplace.

UTC+2 | WebsiteGitHub

Paulus Esterhazy

Paulus Esterhazy

Creating Mobile Apps Interactively

Creative work requires immediate feedback, especially when you’re building UIs. Boot React Native extends ClojureScript’s reach, offering a way to build apps for iOS and Android with a focus on short feedback cycles. In this demo, I’ll live-code a simple mobile game, starting from scratch. In the process, I’ll demonstrate how to set up Reagent for live reloading and how to style React Native components.

About Paulus

Before he was a programming for a living, Paulus completed a PhD in philosophy. Now he’s busy building apps and sites in ClojureScript and Clojure. He’s the maintainer of Boot React Native.

Paulus is Head of Engineering at Fy in Berlin.

CET UTC+1 | WebsiteGitHub

Dave Yarwood

Dave Yarwood

ZeroMQ for Clojurists

ZeroMQ is an open-source messaging protocol and networking library that makes it very easy to network threads and processes together using sockets. There are implementations available in a variety of programming languages, including Java, but the use of ZeroMQ in Clojure is an under-explored territory.

After using ZeroMQ in a number of personal projects and contributing to a Java ZeroMQ library, I have identified some of the strengths and pitfalls of using ZeroMQ in Clojure. In my talk, I will share with you some of the things I’ve learned and my recommended approach to writing distributed Clojure applications via ZeroMQ.

For those with less experience with ZeroMQ or inter-process communication, this talk will also serve as a quick introduction to these topics. I will talk briefly about what ZeroMQ is, why it’s awesome, and what you can do with it. If you’re interested in building distributed Clojure programs that talk to each other over sockets, then ZeroMQ might be just what you need!

About Dave

Dave Yarwood is a composer, musician, and software engineer at Adzerk, where he uses Clojure and ClojureScript to build UIs, APIs, and backend services. In his free time, he maintains Alda, a programming language for music composition. Dave holds a Bachelor of Music degree from the University of North Carolina at Chapel Hill.

Developing Alda’s components led Dave to explore inter-process communication via ZeroMQ and to search for the best way to use ZeroMQ in a Clojure program. With this goal, Dave has been contributing to JeroMQ (a pure Java implementation of the ZeroMQ protocol) and developing his own library for idiomatic ZeroMQ usage in Clojure.

UTC-5 Eastern Standard Time | WebsiteGitHub

Dmitri Sotnikov

Dmitri Sotnikov

ClojureScript ♥ Node.js

The talk will explore the Macchiato project that aims to provide a Ring compatible stack for Node.js. I’ll discuss differences from using the JVM, challenges facing the project, potential benefits for the Clojure community, and end with a quick demo of the project.

About Dmitri

Dmitri is the author of Web Development with Clojure and Luminus framework.

UTC-5 | WebsiteGitHub

Tom Coupland

Tom Coupland

Putting It All Together

There are a myriad of Clojure libraries in the world, each providing a solution for one part or another of what it takes to create a fully-fledged feature delivering system. There are also a great many combinations of these libraries working together as complete systems, providing value for business and user as like, but these complete systems can rarely be seen. The vast majority being developed behind closed doors, as is the norm in our industry. However, in this talk I’d like to show you something abnormal, a complete system that is not hidden, but being created completely in the open.

The kixi.datastore is a system that is being built by MastodonC as open source software. Not necessarily for others to make direct use of, though you’d be more than welcome, but because we believe that open development contributes to the community as a whole. I would like to describe this system to you. After spending as little time as possible on the context of the system, I’ll talk about the Event Sourcing style of the design, the libraries we use, and, most importantly, how we put it all together to create the system.

About Tom

Tom Coupland is a Data Engineer at MastodonC. After subjective eons working with Java, through transaction processors, accounting systems, user collections, he was left exhausted and bewildered at his life choices. Then Clojure appeared and the scales fell from his eyes. Leading to wonderful years of highly concurrent programming, determining peoples’ musical tastes, recommendation engine creation, and many other marvelous things.

Currently he can be found basking in the joy that is Clojure during the day, while keeping an eye out for other suitors in the evening. When not trying to make his bit of the software world a better place, he can be found out in the real one, running around, preferably in the mud, wind, and rain.

UTC-7 Greenwich Mean Time | GitHub

Matt Ratzke

Hoplon Tutorial

This will be a guided walkthrough of building a chat application using Hoplon/Javelin and Feathers.js.

The theme of this tutorial will be the Structure of Applications. I believe that many of the developers using ClojureScript are coming to the language from other JS languages. These languages do not share the same philosophies when it comes to the structure of applications. I highly recommend any ClojureScript developer watch the MIT Video Lectures on the Structure and Interpretation of Computer Programs.

Our chat application will look at the structure of applications using Hoplon, which allows you to design your client applications using abstractions over the DOM. These abstractions interact with Javelin cells and our Feathers.js client to provide reactive features and spreadsheet data-flow. Our Feathers.js server applications mirrors the structure of our client and provides in-memory data storage for services.

Conference attendees will learn how to:

  • Initialize a Hoplon/Feathers application using Boot
  • Build a Feathers.js client/server application using FeatherScript
  • Build a Hoplon/Javelin client application

About Matt

Founder and CEO of Degree9 Solutions Inc. (degree9)

We build DevOps solutions using ClojureScript. Our mandate is to “Clojure(Script) all the things”.

The tools and technologies used in this presentation are part of our goal to build a cross platform ClojureScript framework for IT Automation.

UTC-7 Mountain Standard Time | WebsiteGitHub

Simon Belak

Simon Belak

Spec + Onyx Experience Report

Clojure has always been good at manipulating data. With the release of spec and Onyx (“a masterless, cloud scale, fault tolerant, high performance distributed computation system”) good became best. In this talk you will learn about a data layer architecture build around Kafka and Onyx that is self-describing, declarative, scalable and convenient to work with for the end user. The focus will be on the power and elegance of describing data and computation with data; and the inferences and automations that can be built on top of that.

About Simon

Simon Belak is the Chief Analytics Officer at GoOpti where he is in charge of making the company data-driven; building analytics infrastructure (end goal: provide any answer stemming from data in 2 min or less); and developing a predictive real-time pricing engine. Before GoOpti he worked with over 20 startups and growth companies helping them become data driven and set up (or level up) their analytics departments.

UTC +1 | Twitter

Priyatam Mudivarti

Priyatam Mudivarti

Data Pipelines in core.async

Our systems are built on processes carrying state and their transitions can be triggered by thousands of external (and internal) events. Managing them via core.async with stateful channel management, no persistence, and limited exception handling in a distributed environment can be cumbersome. In this talk, I will share my experience on building core.async in production, and present a library that aims to provide higher level abstractions for building robust data pipelines.

About Priyatam

Priyatam writes short stories, builds user interfaces, and designs distributed apis. After crafting software for fifteen years in creative agencies, enterprises, and early-stage startups he found his passion at the intersection of literature and lisp. He is currently a principal engineer at Capital One and tends a tiny publishing studio.

UTC -8, Pacific Standard Time | WebsiteGitHub

Panelists

John Stevenson

Panel: Building a Community Through Events

Ryan Neufeld

Panel: Building a Community Through Events