Types are like the Weather, Type Systems are like Weathermen
Whether you checked the weather app or not on the day before 22 Jan 2016, a huge snow storm covered the Eastern United States that weekend. If you lived in New York or DC, you had to dig out from under a large load of snow the next morning.
In the face of such storms, the good news is that people have almost perfected the art of weather prediction over the past few decades. A snow storm or hurricane will no longer catch anyone by surprise. If we act on these predictions in time, we can easily prevent the bad disasters of the days gone by.
My keynote will expand on this theme. Bring an umbrella.
Bio: Matthias Felleisen is the Chief Philosopher and Shepherd (CPS) of PLT, the research group behind Racket. As such he is responsible for thinking deep thoughts about the language, pronouncing his insights in obscure email messages, and herding cats while increasing their numbers.
After spending 10 years on mathematical models of programming and languages, Felleisen set out in 1994 to convince middle schools, high schools, and colleges to ditch dysfunctional programming and introduce functional programming instead as a straight extension and reinforcement of basic school algebra. Racket, the * Student Languages, DrRacket, "How to Design Programs", Typed Racket, and many more pieces of practical software are side-effects of this 20-year outreach project.
Years ago, Felleisen collaborated with Daniel Friedman on "little" books, especially the Little Schemer (nee Lisper). More recently, he co-authored Realm of Racket with eight freshman students. ACM and its organizations have honored Felleisen's work with some awards.
Sharing the many joys and challenges of building a game engine in a functional style using Clojure and ClojureScript. Over the course of 2+ years, the speaker has been actively writing (and rewriting) a functional game engine to find the ideal combination of a quick feedback loop, testing with data, and performance. Join in the sorrows and triumphs of bringing functional programming to web-based game development for fun and zero profit!
About the speaker: Alex Kehayias is the CTO at Shareablee and works on biggish data problems to help brands and publishers win the social web. Clojure and Python are his weapons of choice by day and by night. He is an active musician, organizer of Clojure NYC meetup group (over 1000 members), and mentor of people learning to code.
The concept of what makes something a work of art has always been a contentious topic. As technology has advanced, so have the ideas of what constitutes art and the mediums with which art is created. From Clojure performance artists REPL Electric and Meta-ex to artists of the Fluxus movement, the medium and act of creation has been intrinsically tied to the piece itself. Moving backwards through history from today's interactive works created with Clojure and Overtone to Lisp AI painters of the 90s and multimedia auteurs of the 70s, let's explore how art has evolved into its current landscape.
About the speaker: As a student of Digital Media and Computer Science, Allison has always been fascinated by the intersection of computing and art. Her work has included mixed and augmented reality games and interactive digital installations. She has been fascinated by Lisp since first learning Scheme at Georgia Tech, and is currently a software engineer at Houseplans in San Francisco.
The simplicity of the Clojure language and the supportive, collaborative spirit of its community played a pivotal role in my success as a junior engineer. I felt frustrated with cryptic 'method_missing' stack traces in my first years of programming, and Clojure reshaped the way I saw code and data. We will examine elements of the language that help and hinder newcomers, ways in which teams can better support junior developers, and how companies can create value by investing in upcoming talent. Living wage apprenticeships for developers can provide opportunities for a richer, more diverse tech industry.
About the speaker: This past year, my Little Bird team and I rewrote our social network graph analysis application with Clojure and ClojureScript. I started as an intern and built internal tools that eventually became user-facing features. I currently write product specification software with React.js at Jama. I play violin, and lived in a cabin in the Cascade mountains for 4 years before moving to Portland, OR to code.
Loom is an open-source Clojure library that provides many graph algorithms and visualizations. Loom's graph API focuses on generality and simplicity of integration, which enables other graph representations to be ported to Loom. In this talk, we'll look at how Loom's API and graph implementations evolved in the past 2 years since being presented at Clojure/West 2014. We'll also discuss complexities of maintaining an open-source library.
About the speaker: Aysylu Greenberg works at Google on their distributed build system. In her spare time, she ponders the design of systems that deal with inaccuracies, paints and sculpts.
Old-school adventure games were infamous for their mind-bending logic. While you might pull quite a bit of hair playing one, writing one can be a lot more fun, especially when written in Clojure. We will embark on a quest, examining how some of Clojure's features, libraries, and functional paradigms can bring some sanity and simplicity into the otherwise complex world of game development. We'll look at how to model SCUMM-style dialogue trees, write in-game cutscene scripts, and build a game while it's running using an nREPL server.
About the speaker: Bryce's interest in software development began while playing old-school adventure games in the early nineties. He's been busy writing code ever since -- by day a web application developer, and by night a game developer. After being enthralled by learning Clojure at a startup two years ago, he decided to go back to his roots and make a classic adventure game in Clojure, which he is now putting his finishing touches on.
Bryce works at LIFFFT in Seattle, and is the creator of Tick's Tales: Up All Knight.
This talk is about building Clojure/Clojurescript web applications with Datomic and DataScript. In addition to covering the basics of syncing data between client and server, we'll look at how reactive Datalog queries simplify front end code, how Datomic's flexible and queryable schema lets us describe UI with data, and how we can handle authorization in this setting. In closing, we'll reflect on the big picture of this architecture in relation to current trends in FRP.
About the speaker: Chris is a computational biologist, data scientist, web developer and Clojure enthusiast. In the past he worked for Fred Hutch Cancer Research Center studying the host defense mechanisms and transmission patterns associated with viruses such as HIV. He got into Clojure building the math behind pol.is, an app using data visualization and machine learning to make sense of large scale conversations. Currently, he does Clojure consulting and teaches computation courses for biologists.
Datomic has a fantastic Clojure API that is simple and data-driven, but too low level to directly express certain restrictions on the shape and types of data living on the database.
spec-tacular is a DSL that lives between Clojure and Datomic and enforces extra restrictions on data types (via a specification language) by providing concise syntactic shortcuts to create, update, and query those well-typed entities from Clojure. Unfortunately, the resulting language (as implemented) has unreasonable restrictions that do not compensate for the corresponding loss of expressive power.
In this talk, I'll present the design of spec-tacular and describe how well it lives up to my vision of a healthy layer of abstraction over Datomic. I'll discuss the success of spec-tacular features in production, and trace failures back to poor language design.
About the speaker: Claire works at SparkFund, where she develops software in Clojure that schedules and executes financial transactions. She has a background in functional programming language design and implementation, and used Racket and Scheme for several years before discovering Clojure.
If you don't know your work/span from your fork/join, this talk is for you! By attending this introduction to "thinking parallel," you'll learn why parallel programming matters, how to think about performance, and how to tackle real-world concerns. You'll learn about how the fork/join framework embodies best practices. And of course, you'll learn how Clojure implements these ideas with reducers.
About the speaker: Daniel Higginbotham is an engineer at Adzerk. He provides resources for Clojurists at Brave Clojure (braveclojure.com), including the book Clojure for the Brave and True, a job board, and a directory of active open source Clojure projects. Daniel loves to help programmers learn and offers on-site Clojure training.
We feed 300K messages per second into Kafka. This stream describes the activity of tens of millions of users on our customers' sites. This talk follows the evolution of our Kafka and Clojure use, and the lessons we learned as we built a contextual site overlay which tracks internal traffic at a rate of over one million clicks per minute in real time.
About the speaker: Sr. Backend Engineer and Team Lead at Chartbeat with an obsession with performance.
This talk discusses the development of a feature-rich onboard application for the Boeing 737 Max. We structured our application with a service framework and message queues to enable communication between disparate parts of the service while preserving separation of concerns.
The onboard diagnostic system designed for the Boeing 737 MAX checks and reports on over 6,000 faults, giving airplane technicians and maintenance crew a critical window to the health and performance of the aircraft.
About the speaker: Donevan Dolby is a Seattle area software engineer and technical lead at Base2 Solutions. His experience includes managing the design, engineering, integration and delivery of complex software projects in aerospace, defense, law enforcement, and military.
We'll introduce PAMELA (Probabalistic Advanced Modeling and Execution Learning Architecture) which is a new declarative language and framework for process modeling. We'll also give a live demo of PLANVIZ - the PAMELA visualization tool to visualize Temporal Planning Networks (TPNs) and Hierarchical Task Networks (HTNs). PLANVIZ is written in ClojureScript, is based on om.text and leverages schema to parse and render TPNs and HTNs as interactive, resolution independent SVG graphs. Multiple users can collaboratively view the same perspective of a graph and even watch progress as the temporal plan is executed in real time. Dynamic Object Language Labs uses PAMELA to support automated reasoning about systems, to plan for mission implementations, and to diagnose and track model state at run time.
About the speakers: Tom Marble is the founder of Informatique, Inc., a consultancy which leverages his hardware, software and open source legal experiences. He is working to improve diversity as an Outreachy coordinator for Debian and as one of the organizers of ClojureBridge Minneapolis.
Dr. Robertson is president of Dynamic Object Language Labs, a small research company near Boston.Formerly he worked at BBN Technologies and at MIT. At MIT he designed and implemented a Java version of RMPL, a predecessor to PAMELA.
Dr. Robertson has over 15 years of Computer Vision experience with more than 15 years’ experience in advanced language implementation, self-adaptive software, artificial intelligence, and knowledge-based systems.Dr Robertson developed Yolambda, a small portable object oriented Lisp Dialect that was used in multiple research projects including GRAVA, a reflective architecture for image understanding which he has applied to a number of areas including the interpretation of satellite and aerial images and to the interpretation of ancient documents.
As the saying goes, all the good ideas in computer science came from the 1970s. We'll explore a new library for parsing text that calls upon an old, unconventional approach: compiling parsers to custom bytecode and then running it through an interpreter. Along the way, we'll learn about how PEGs fit a sweet spot between regular expressions and heavier parsers, and how Clojure is an ideal language for writing simple compilers.
About the speaker: Ghadi Shayban is an engineer at PokitDok, working on bringing the future to healthcare. He spent ten years in conservatory training as classical pianist, and currently has an active schedule as a chamber and symphony musician. Ghadi lives in Charleston, SC and is a contributor to Clojure and core.async.
Distributed systems are hard. om.next makes them simpler making state transfer and state transitions idiomatic. With synchronization out of the way a developer can finally focus on testing business logic. In this talk we will explore a lightweight method of property based testing for the business logic that spans client and server. Talk will include a demo using your favorite tools like om.next, component, datomic, test.check, and the reader conditional.
About the speaker: Jack is a Bay Area developer excited about solving problems with technology. Building single-page applications at Dropbox lead him to functional programming and ClojureScript. With these newly found immutable tools like om.next and datomic Jack is building the next generation of life insurance at Ladder Life. In his free time Jack watches talks from clojure conferences, reads short stories, and struggles against the hot sun and sand in the board game Forbidden Desert.
In the process of litigation, parties must sift through and classify massive piles of data - anything from emails to spreadsheets with millions of rows to entire databases.
In this experience report, I'll share how Cicayda has used the familiar principles of Clojure - immutability by default, simplicity, and thinking concurrently - to build a robust, multi-tenant cloud hosted SaaS that allows clients to manage diverse data and load profiles. Datomic has given us a ton of leverage, including being able to track how things happened and taking read scaling for granted. ClojureScript has provided us with a unified development environment on both sides of the wire and has helped us push toward a data-oriented UI.
I'll also talk about some of the challenges we've encountered with a write-heavy application on top of Datomic and the various generations of UI libraries that live in our app.
About the speakers: Jonathan Boston is a software engineer at Cicayda and has been writing Clojure/ClojureScript for a few years. He enjoys introducing developers to the simplicity of ClojureScript, writing at clojurescriptmadeeasy.com, and making the development community a welcoming place. When he's not programming, he loves traveling with his wife and laughing with his daughter.
Caleb is a software developer who enjoys challenging problems and making people happy. He likes his software to run well so that he can spend a good portion of his time not thinking about it. He's been pursuing those goals for the last three years at Cicayda.
ClojureBridge is a nonprofit organization that provides free, inclusive workshops in Clojure to women. Over the past two years, the Clojure community has written a curriculum, developed an organizing guide, and started teaching workshops--but, how have those workshops played out in practice? In this talk, we'll look at what it takes to organize and run a successful ClojureBridge workshop, hearing from those who have done it, themselves!
About the speakers: kf is a data engineer at Simple in Portland, OR, working in Scala and Clojure. In her spare time, she serves on the boards of ClojureBridge and Bridge Foundry, makes questionable hair decisions, and collects Selena Gomez gifs to use in code reviews.
Anna is a Clojure engineer for WalmartLabs. She serves on the board of the ClojureBridge organization, enjoys playing board games and programming robots to do her bidding.
We are at the dawn of a new paradigm of human-computer interaction, where humans speak to computers in the cloud and the computers talk back. Amazon's Alexa platform offers technologies for adding a voice interface to mobile applications. This talk will introduce an open source Clojure library (Boomhauer) that simplifies tying voice commands to service interfaces via the Alexa Skills Kit. With example code in Clojure running on AWS Lambda, this talk will give you a peek into how accessible voice interfaces can be and how easy it is to add another dimension of usability to your application. The next generation user interface is invisible.
About the speaker: Mario Aquino is a developer from St. Louis who spends his days thinking in Clojure about geospatial queries for The Climate Corporation. He also helps organize The Strange Loop conference as well as a user group called The Lambda Lounge. His passions include human decision making, cognitive biases, evolutionary forces, and Cuban food.
Onyx is a high performance, fault tolerant, distributed computation platform written purely in Clojure. It couples an all-data API with thoughtful streaming primitives to encourage flexible application design. But how does it work?
In this talk, we're going to dive into Onyx's architecture and discuss its most unique trait - its "masterless" coordination scheme. In other words, we'll look at how Onyx uses Clojure to achieve consensus and safety, even when networks partition and machines fail.
About the speaker: Michael is the creator of Onyx and the cofounder of Distributed Masonry - the company that commercially supports Onyx. He has spoken StrangeLoop, Lambda Jam, and Clojure/conj.
Practising Clojurians rely on facilities implemented in terms of deftype and defrecord every day - data structures, channels and buffers, transducible contexts, custom control structures... This talk aims to draw lessons on the most effective use of both from several examples of effective use in Clojure and in ClojureScript, as well as a closer look at some of the most interesting details of their own implementation and their relationship to protocols and interfaces.
About the speaker: Long-time contributor to all parts of ClojureScript, including the compiler and the core library; most notably, author of the ClojureScript ports of the persistent map and set types and PDS-related functionality such as transients. Author and maintainer of core.rrb-vector, data.avl and ctries.clj.
Web development has an undeserved reputation. Many in our industry hesitate to call it "real programming," yet designing even the simplest web application draws upon deep traditions in networked computing.
In this webdev real talk, we are going back to the beginning. We will graph out the advancement of web systems from their humble origins, and, with each new storage and rendering component, watch the architectures of today's massive web systems emerge. Then, we will explore recent works from members of the greater Clojure community that push the boundaries of this era in our distributed web.
About the speaker: Mikaela Patella is a meat computer who produces multimedia works, software, and screencasts . She also works with Yet Analytics as a Senior Software Engineer to help make collecting, exploring, and interacting with data more humane.
When writing Clojure or ClojureScript, it is very common to make use of data structures that are combinations of maps, lists, vectors, and other data structures. It is very common to query for nested elements in a data structure, or to transform only parts of a data structure. This kind of code tends to be highly nested, hard to follow, and error-prone. Specter is a library that gives you the power to write these queries and transformations concisely and elegantly - with performance rivaling hand-optimized code. In this session you will learn the basics of Specter and why it has near-universal applicability for Clojure and ClojureScript programming.
About the speaker: Nathan has been programming Clojure for over 90% of his work for over 5 years. He used Clojure to create the Apache Storm project, one of the most popular Big Data processing frameworks in the world. The companies using Storm as core infrastructure include Yahoo!, Spotify, Groupon, Alibaba, Yelp, The Weather Channel, WebMD, and many more. In 2015 he published the book "Big Data: principles and best practices of scalable realtime data systems". He advises companies in areas such as virtual reality, education, and health, and he is currently working on a new startup.
Functional programming suggests that the best way to comprehend a world in flux is with abstractions that are declarative and immutable. However, most of the approaches we have at hand are suited for discrete changes: tools like refs, atoms, and agents can't effectively describe continuous or gradual change. Hybrid automata combine the discrete nature of finite automata with the continuous nature of differential equations to offer a powerful and succinct way to describe continuous systems, and they have been used to model everything from microbial ecosystems to macroeconomic equilibria. In this talk we will see how hybrid automata provide a programming model that helps us manage the complexity of flowing time without a calculus degree. We will also show how SparkFund uses hybrid automata and Clojure to navigate a world of cash flows, interest rates, and financial contracts.
About the speaker: Nathan works at SparkFund, where he uses Clojure and Datomic to help finance energy efficiency projects. Throughout his career he has exclaimed many times: "I can't believe I've made it this far without knowing about X!" He hopes that giving the occasional talk about X will help those who feel similarly.
A visit to CIDER's brewery where all the magic is happening. On this exciting journey you'll learn more about the current state and the future of the CIDER project. We'll examine recently added features and CIDER's next release. We'll also take some time to speculate about the future and we'll go over some of the more ambitious plans lying around in our cellar. But above else - we'll have some fun while doing so!
About the speaker: Bozhidar is the maintainer of CIDER and the editor of the community Clojure style guide. Most people would probably describe him as an Emacs zealot (and they would be right). He's also quite fond of the Lisp family of languages, functional programming in general and Clojure in particular. Believe it or not, Bozhidar has hobbies and interests outside the realm of computers, but we won't bore with those here.
Since it's invention the Hash Array Mapped Trie has grown to become the defacto Immutable Hash Map implementation. However there is still room for big improvements with this central data structure. It's possible to get speedups of 100% for iteration and equality checking. Great, more complex algorithms and bit twiddling, you say. Balderdash! We make some simplifications to the underlying data structure making the operations on it simpler and faster.
About the speaker: Peter is a developer at Bendyworks. He's contributed ClojureScript and to other Clojure projects. He enjoys teaching people programming and getting chased by his niece with a foam sword.
While many robust Cache libraries exists, understanding cache invalidation and cache-misses in a distributed platform requires a deeper understanding of your data access patterns. At Level Money we built our own caching solution, backed by a Memcached Cluster. In this talk I will share our story: how we name and version our caches, grow dependency graphs, find expensive computations, avoid race conditions, and define compute functions to serialize financial data using a simple Protocol.
What's more-there's a happy ending!
About the speaker: Priyatam is a fiction writer, clojure engineer, and clojurescript designer. After a decade of experience in creative agencies, enterprises, and early-stage startups he found his passion at the intersection of literature and lisp. He runs a tiny studio, and is currently a principal engineer and architect at Level Money.
The ability to interact with and modify a running program is one of the great strengths of modern programming languages. But runtime modification forces us to make trade-offs at every stage of a program's design. After several years of work on tools to mitigate this problem - Lazytest, tools.namespace, Component, the 'reloaded' pattern - this is the story of what I've learned, mistakes I made, and the problems that still need to be solved.
About the speaker: Stuart Sierra is a Clojure developer and consultant at Cognitect. He is the author of several open-source Clojure libraries and the books "Practical Clojure" (Apress) and "ClojureScript: Up and Running" (O'Reilly).