Formal specification of software systems is an old endeavor that is now yielding striking successes, in large part due to the availability of powerful new techniques for coupling specifications with running code via formal verification or automated testing. This talk surveys what’s happening in the area broadly and presents one example in more detail: a formal specification of the core behavior of a synchronization service and a specification-based random testing framework for applying it to real-world synchronizers.
About the speaker: Benjamin Pierce is Henry Salvatori Professor of Computer and Information Science at the University of Pennsylvania and a Fellow of the ACM. His research interests include programming languages, type systems, language-based security, computer-assisted formal verification, differential privacy, and synchronization technologies. He is the author of the widely used graduate textbooks Types and Programming Languages and Software Foundations. He has served as co-Editor in Chief of the Journal of Functional Programming, as Managing Editor for Logical Methods in Computer Science, and as editorial board member of Mathematical Structures in Computer Science, Formal Aspects of Computing, and ACM Transactions on Programming Languages and Systems. He is also the lead designer of the popular Unison file synchronizer.
About the speaker: Stuart Halloway (@stuarthalloway) is a founder and President of Cognitect (formerly Relevance). He is a Clojure committer, and a developer of the Datomic database. Stuart has spoken at a variety of industry events, including Strange Loop, 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.
About the speaker: Formerly founder and CTO of CircleCI, now founder of Rasterize. Allen has been using Clojure professionally since 2009. Allen has shipped 3 startups in Clojure, and written numerous OSS libraries.
With the release of AWS' API Gateway and the Lambda service, it is now possible to write scalable microservices without an application server--rather than being charged by the server-hour, you can create a server process that is charged by the processor-millisecond. Adam and Ben will walk through the process (and trade-offs) of defining and deploying an API service backed by Clojure components deployed into Lambda. Initial specification, authentication via an API token and SSO system, retrieval of data, and transformation of that data using the API Service will be covered, along with logging, exception handling, and monitoring.
About the speakers: Ben Vandgrift struggles with a problem solving compulsion. He writes software when he is not being mauled by his rescue panther. Co-author of Clojure Applied: from Practice to Practitioner, and currently at Aerostat.
Adam Hunter's appetite for new technologies is insatiable. Adam and Ben work daily to bring sanity and efficiency to the process of governance and taxation. Adam is currently at Aerostat.
Have you ever hit a wall with REST? Does modeling your problem domain into CRUD-able entities feel like fitting a square peg into a round hole? Have you ever tried implementing a PATCH request (without going crazy), or debated PUT vs. POST for resource updates?
An alternative to CRUD-flavored REST is CQRS (Command and Query Responsibility Segregation). In this talk, I'll discuss the advantages and trade-offs of CQRS (and its cousin, Event Sourcing), and demonstrate them using an implementation of CQRS based on Clojure microservices, Kafka, and Datomic. These advantages include:
- Operational simplicity, flexibility, and extensibility
- Applying Clojure's sound model of state transitions to the resources exposed by your web application
- Simplified client implementation
BONUS: We'll even be able to keep the best parts of REST!
I'll also discuss how this technique dovetails nicely with other good ideas in the Clojure community like the design of Datomic and the ideas behind Om.Next.
About the speaker: Bobby is a member of the Technology Fellows team at Capital One, where he designs and develops solutions to difficult problems, influences the technical direction of Capital One while helping development teams implement that technical direction, and engages the broader technical community via speaking and open-source contribution.
Prior to joining Capital One, Bobby was Director of Product Engineering at B23 LLC, a startup working on enabling big data solutions in cloud environments. Before B23, Bobby worked on the Product Team at Cognitect building, testing, and helping customers win with Datomic.
Bobby's been writing web applications and distributed systems with Clojure and ClojureScript since 2010.
"Some errors, however, are sufficiently obscure to escape detection for a surprisingly long time." -Brooker and Wheeler, 1952
Clojure does not come with a Condition system as powerful as Common Lisp's. Instead, we have Exceptions, which start unwinding the stack the moment they're thrown, destroying information as they go. The values of locals disappear, and there is no ability to continue from the location of the error. Several libraries solve this problem, but they do not compose well with each other. We will discuss these libraries, how they work, and why they don't compose. We will consider alternatives that may compose better, and the tradeoffs and amongst all of these.
About the speaker: Chris, a.k.a. Chouser, co-authored "The Joy of Clojure" and enjoys using Clojure regularly with the LonoCloud team at ViaSat.
One of the most frequent complaints from new users of Clojure is the error messages. But many of the error messages that users are faced with are not actually errors from the core language at all but instead surface from macro parsing code. This parsing code is often brittle, difficult to write and can produce truly awful errors.
Cursive is a Clojure IDE which works from unexpanded source. It uses Parsing Expression Grammars to parse macro forms, which makes the parsing code much quicker to write and also dramatically increases its composability and reusability. Additionally this allows much better error reporting. Syntax errors can be identified at the point the error occurs with much friendlier messages. Achieving better error reporting requires little extra work by the developer. Cursive can use this information to mark syntax errors in the editor and provide information about what was expected at the error point.
I'll show a lot of examples of the grammars that Cursive uses and also the code that uses them. I'll also discuss the benefits from using this technique for more general macro parsing - I now believe we should parse all macros this way.
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.
This talk will discuss the many reasons why ClojureScript is in fact a very pragmatic language to consider for web development. It will discuss recent improvements, some of the not-so-obvious benefits, and use cases where ClojureScript shines.
About the speaker: Derek Slager is a Director of Engineering for platform systems at IMS Health. He's been building web-based applications since the dot com era, and enjoys building and speaking about large scale systems, browser-based or otherwise.
Quil is a very popular Clojure graphical library that is used in a variety of projects and is often introduced to beginner Clojure programmers. A recently developed functional mode ("fun-mode") middleware by Nikita Beloglazov introduces MVC approach that allows for a purely functional state manipulation. However, even in the fun-mode Quil drawing functions draw shapes (rectangles, ellipses, etc) directly on the canvas in an imperative programming style. Our "super-fun" addition to Quil allows shapes to be used as first-class entities in a program: a user defines a shape without drawing it (or even without specifying a position at which it would be drawn). Simple shapes and user-imported images can be combined into complex shapes using "above", "beside", and similar functions. A "draw-shape" function draws the entire shape on the canvas at a specified location. Together with the fun-mode, this approach simplifies working with graphics and provides abstraction over the majority of imperative features of Quil. This is especially important for beginner programmers since they can concentrate on functional approaches, and yet enjoy creating complex dynamic interactive graphics without getting stuck on tedious low-level details. The project has been modeled after beginner-friendly graphical library in Racket.
About the speakers: Elena Machkasova has been teaching computer science at University of Minnesota, Morris, an undergraduate public liberal arts college, since 2003. Her Ph.D. is from Boston University. For the last couple of years she has been working with students on a project ClojureEd that focuses on putting together a CS1 course (a first course that students would take in a CS major or a minor) that incorporates Clojure.
Thomas Hagen is a third year undergraduate at U of M Morris and a relatively new Clojure user. In-between managing Computer Science Club, Magic: The Gathering Club, and Super Smash Bros Club, as well as co-hosting the schools “Coding Dojos”, he likes to take a break with a cup of tea and a guitar.
Ryan McArthur currently attends University of Minnesota, Morris for an undergraduate degree in computer science. He only recently started using Clojure, primarily the graphical libraries, and is enjoying the experience.
The controversial nature of climate data demonstrates that scientific data sets can be challenging to communicate about. Traditional visualization approaches often fail to effectively illustrate the implications and limitations of this kind of data. This is especially true when the target audience are not domain experts.
This talk provides an overview of some key differences that scientific data sets have from more common data sets, such as business analytics. These differences impact correctness of results and add complexity to handling, processing, visualization and even understandability of these kinds of data. Using climate data as a touchstone, we will explore these differences with AWS/Clojurescript examples to illustrate what makes visualizing large scientific data sets challenging while demonstrating promising alternative approaches.
About the speaker: Ms. George Kierstein has a deep interest in data visualization and a long professional history building high-performance computing systems on a variety of platforms. She is a recent functional programming convert and is excited about what functional programming and Clojure in particular can bring to the scientific community. She has over 16 years experience in industry and a Masters in Computational Neuroscience from Boston University.
The latest generation of big data tools such as Apache Spark routinely handle petabytes of data while also addressing real-world realities like node and network failures. Spark's (http://spark.apache.org) transformations and operations on data sets are a natural fit with Clojure's everyday use of transformations and reductions. Spark MLlib's excellent implementations of distributed machine learning algorithms puts the power of large-scale analytics in the hands of Clojure developers. At Zalando's Dublin Fashion Insights Centre, we're using the Clojure bindings to Spark and MLlib to answer fashion-related questions that until recently have been nearly impossible to answer quantitatively.
At the Dublin Fashion Insights Centre, we are exploring methods of categorising the web into a set of known fashion related topics. This raises questions such as: How many fashion related topics are there? How closely are they related to each other, or to other non-fashion topics? Furthermore, what topic hierarchies exist in this landscape? Using Clojure and MLlib to harness the data available from crowd-sourced websites such as DMOZ (http://www.dmoz.org, a categorisation of millions of websites) and Common Crawl (http://commoncrawl.org, a monthly crawl of billions of websites), we are answering these questions to understand fashion in a quantitative manner.
About the speaker: Hunter Kelly is a software engineer at Zalando's Fashion Insights Centre in Dublin, Ireland, where he works on an interesting mix of big data and machine learning projects. He's a graduate of the University of California at Berkeley, where he pretty much lived in Emacs and spent too much time hacking in elisp. Ever since, he has yearned for a language with the expressive power of Lisp that could actually be used in the real world. Since learning about Clojure in its early days, he has enjoyed exploring how to think about and express problems in it. Before joining Zalando in 2015, he spent years in the trenches working at companies such as Pixar, Google, a few dot booms, and a few dot flops.
About the speaker: Jearvon Dharrie is a software engineer at Comcast. Jearvon spends his day working with Ruby, and the JVM. In his free time he enjoys toying with programming languages. He is currently interested in Clojure and ClojureScript.
Scientific computing has generally been restricted to procedural and object-oriented programming languages, such as C/C++, Java, Python, etc.. We have developed Clojure-based projects to support not only analysis of scientific data, but also scientific simulations. Our analysis tools are applied to biomedical data, in particular biological imaging of clinical human samples and high-resolution subcellular microscopy images. Our simulations are used for modeling ecological and evolutionary dynamics, as well as multi-cellular biological systems. The use of Clojure has facilitated the growth of our software ecosystem due to the power of Clojure to manage code complexity. Furthermore, the ability to rapidly prototype compact yet complex code has allowed us to advance on many fronts of scientific computing simultaneously.
About the speaker: Kyle Harrington is a postdoctoral fellow at Harvard Medical School in the Center for Vascular Biology Research of Beth Israel Deaconess Medical Center. With 20+ years of programming experience, the last 5 being focused on Clojure, and PhD in Computer Science, he is applying functional programming techniques to scientific computing and image processing problems. This involves simulations on high-performance computing clusters, and analysis of multi-gigabyte biomedical images. Thanks to the vivacious and clever Clojure community the application of Clojure to scientific problems has been a productive way of tackling new computational problems.
Genetic programming harnesses the mechanisms of natural evolution, including mutation, recombination, and natural selection, to automatically synthesize computer programs. It has been applied to a wide range of problems spanning several areas of science, engineering, and the arts, in many cases equaling or exceeding human performance.
Genetic programming's roots are in Lisp, making Clojure a natural choice for modern genetic programming research and development. In this talk I will show how a simple genetic programming system can be written in about 100 lines of Clojure code, how a mature genetic programming system (PushGP) implemented in Clojure can improve the state of the art in automatic programming, and how genetic programming can be incorporated into an artificial life environment implemented in Clojure and Quil.
About the speaker: Lee Spector is a Professor of Computer Science in the School of Cognitive Science at Hampshire College in Amherst, Massachusetts, and an adjunct professor of Computer Science at the University of Massachusetts, Amherst. His areas of teaching and research include genetic and evolutionary computation, quantum computation, and a variety of intersections between computer science, cognitive science, evolutionary biology, and the arts. He is the Editor-in-Chief of the journal Genetic Programming and Evolvable Machines (published by Springer) and a member of the editorial board of Evolutionary Computation (published by MIT Press). He is also a member of the SIGEVO executive committee and he was named a Fellow of the International Society for Genetic and Evolutionary Computation.
More details: http://hampshire.edu/lspector Resume: http://hampshire.edu/lspector/spector-resume.pdf
Over the past years, development for the ClojureScript compiler has moved at a fast pace and its community is growing continuously. It's a fun community which I enjoyed to be a part of over the past months through my Google Summer of Code project. In this talk I will give an overview of the moving parts of the ClojureScript compiler, dive into some details about the compilation process itself with a hands-on example and will provide you with some pointers on how you could start contributing to the compiler.
About the speaker: Maria is a Clojure/ClojureScript developer working at LiveOps. She is also currently an online student at Georgia Tech studying towards her master's degree in Computer Science. Other than programming, she enjoys running, spending time with her husband and growing the programming community in Auckland by organizing workshops, such as RailsGirls and ClojureBridge.
Many of us have hazy memories of finite state machines from computer science theory classes in college. But finite state machines (FSMs) have real, practical value, and it is useful to know how to build and apply them in Clojure. For example, FSMs have long been popular to model game AIs and workflow rules, and FSMs provide the behind-the-scenes magic that powers Java's regexes and core.async's go blocks. In this talk, we'll look at two programming puzzles that, suprisingly, have very elegant solutions when looked at through the lens of FSMs, with code demonstrations using two different Clojure libraries for automata (automat and reduce-fsm), as well as loco, a Clojure constraint solver.
About the speakers: Mark Engelberg has been an active member of the Clojure community ever since Clojure turned 1.0, and is the primary developer of math.combinatorics, math.numeric-tower, data.priority-map, ubergraph, and a co-developer of instaparse. By day, he teaches Scheme and Clojure to talented kids in the Seattle area; by night, he creates logic puzzles and games, using Clojure as his "secret weapon". His latest game is Code Master, a programming-themed puzzle game for kids, available exclusively at Target (and created with Clojure, of course!)
Alex Engelberg was indoctrinated by his father in the ways of functional programming at a young age, and Clojure rapidly became his language of choice. He is happy to be using Clojure professionally as a software engineer at SecureOne in Seattle. Alex also enjoys contributing to open source; he is the primary developer of loco, and co-developer of instaparse.
Development tooling for Clojure is impressive. Leiningen, and more recently Boot, are fantastic products that provide library and Clojure version isolation that is often far better than what can be found in other languages.
However, a development environment for a project includes more than just lein or boot. A project often include development workflow plugins, external binaries that are specific to your project, specific Java versions and potentially more. This can be difficult and cumbersome to initially set up correctly on a local machine, and more importantly, can be even more difficult to share with your team in a reproducible way.
In this talk, we'll explore wrapping your Clojure development tooling in a container to take advantage of Docker's resource isolation to create a portable, shareable and most importantly - immutable development environment for you and your team.
While this can be a bit of extra work, encapsulating your development tools in a container can drastically reduce the amount of time it takes for team members get on board a project, cut down those "but it works for me" moments, and can also be a handy way to manage those resources you may only need occasionally.
About the speaker: Mark Mandel is a Developer Advocate for the Google Cloud Platform. Hailing from Australia, Mark built his career developing backend web applications which included several widely adopted open source projects, and running an international conference in Melbourne for several years. Since then he has focused on becoming a polyglot developer, building systems in Clojure, Go, and JRuby on a variety of infrastructures. In his spare time he plays with his dog, trains martial arts and reads too much fantasy literature.
The standard approach to developing a program or API in Object Oriented Programming is to take a "Top Down" approach in which the modeler starts with the domain at large and decomposes this domain into smaller pieces, generally in the form of classes. This often results in complex, interconnected type hierarchies. In Clojure, the standard approach is to design "Bottom Up," in which the developer first models an actual domain instance using Clojure data structures and then writes simple functions for manipulating the domain data. These functions can then be recombined and composed into more powerful functions. Ultimately, a program emerges. This approach has several advantages including: 1) bottom up functions have more reuse, 2) bottom up design allows for immediate domain modeling using actual data, 3) it is easier to reason about what is going on in bottom up design. This talk will first describe the two approaches, then it will walk through the development of a program using bottom up design in Clojure, culminating in a live demonstration of the program. Attendees will gain an appreciation for this technique and see it in action. In particular, they will see how Clojure is especially well suited to this approach.
About the speaker: Mark Bastian has been developing applications in the Java ecosystem for over 10 years. He started doing Scala and Functional Programming over 5 years ago and has been programming in Clojure personally and professionally for over a year. He is a programming languages and paradigms enthusiast and loves finding and evangelizing the best practices from all the languages and paradigms he encounters. In his spare time he blogs about Clojure and Functional Programming at http://fn-code.blogspot.com.
Over the past three years Clojure has become Damballa's secret weapon in the fight against botnet malware. It's now our language of choice for all production data-processing, including ETL, modeling, and access microservices. Three properties of the language make it particularly suited to pragmatic data-processing applications: JVM hostedness, interactivity, and value-orientation. This experience report will describe how leveraging these properties has allowed us to rapidly develop malware-detection machine-learning pipelines which operate on literally Internet-scale data.
About the speaker: Marshall Bockrath-Vandegrift is Principal Software Engineer for Damballa's Research and Development team. At Damballa, Marshall currently focuses on original malware-detection research and the infrastructure necessary to support that work. He is concurrently pursuing a Masters in Statistics at Georgia Tech, and lives in Atlanta, GA with his wife and two cats.
Although Clojure programmers should be spending most of their time thinking, we occasionally need to type to get our ideas into computers. We'll talk a bit about this history of keyboards and how Clojure (and lasers!) can be used to design and manufacture the next generation of keyboards.
About the speaker: Matt Adereth builds tools and infrastructure for quantitative research at Two Sigma using Clojure. His first love is Mathematica, but he's happy to have found a homoiconic refuge on the JVM in Clojure. In his spare time, he obsesses over keyboards and trains his kids to sort the ridiculous collection of keyboard components he's amassed.
On the Netflix search team we had many data pipelines, patched together using different technologies, which made it difficult to integrate and monitor system health. This inspired us to build Dagobah, a new take on data pipelines with a focus on data provenance.
Dagobah is a cross-platform, meta-scheduler that's different from your typical workflow engine. With Dagobah you describe each node as an independent, addressable computation.
A node can specify its data dependencies and Dagobah will compute them prior to running the node. You then ask Dagobah for data you need and it figures out how to build it and any dependencies, enabling data sharing and versioning in a unique and flexible way.
Users can optionally specify that a node in the graph must come from a specific build, git branch, or commit. Because each computation is memoized and all data is immutable, multiple users can all rely on the same data without duplicating work.
Dagobah is capable of running jobs on many platforms and can be extended to utilize many others. At Netflix, we use Dagobah to build data pipelines that run PigPen jobs on Hadoop, Spark jobs on various platforms, and Docker containers on Titan.
About the speaker: Matt Bossenbroek works at Netflix on the Personalization & Search team. He helps to manage the data pipelines that deliver the Netflix you know & love. He is a Clojure enthusiast, writing Dagobah, PigPen, and other internal Netflix libraries in Clojure, working to spread the language throughout the company. Previously he worked at Microsoft, doing basically the same thing in c# (sans OSS).
Does your application need to manipulate more data than a single machine can handle? Have you tried Hadoop, Storm, or Spark but felt it didn't quite fit your problem?
Onyx is a new distributed, masterless, fault tolerant computation platform written specifically with Clojure developers in mind. It gracefully composes many concerns that other frameworks complect: computational structure, data flow, stateful lifecycles, deployment, and more. Its superpower is its ability to create distributed workflows at runtime in an ad-hoc fashion. In effect, Onyx allows you to bridge the gap across programming languages, execution environments, machines, and time. Since its release, Onyx has become one of the highest performing open source streaming platforms, burning in on official benchmarks at over millions of messages per second.
About the speaker: Michael Drogalis is the inventor of Onyx and founder of Distributed Masonry. He specializes in designing high-throughput analytics products.
Clojure for a desktop GUI application. With JavaFX. For game development. And it's all built on top of an in-memory, transactional graph database.
One of the biggest game developers in the world needed a new IDE to build games for their engine. Eclipse just wasn't cutting it any more.
It may sound a bit nuts to use Clojure for desktop GUIs, but this architecture delivers incredible benefits to the tool developers.
About the speakers: You can find Michael Nygard coding, writing, speaking, or thinking about how the Universe works. He has lived with systems in production and learned hard lessons about the importance of operations. Highly-available, highly-scalable commerce systems are his forte.
Ragnar Svensson has worked as a game developer for many years, starting out with player mechanics for AAA console games and transitioning into game engine programming, primarily for the mobile and web platforms. He co-founded the game engine Defold, which was acquired by King in 2014. He currently works for King as lead engine developer of the Defold engine.
So you wrote a nice new clojure library and are about to release it as open source to the public? What could go wrong? I learned some lessons the hard way and will show what mistakes I made designing the API of the library, what I learned and which part macros played in that game.
About the speaker: Self-Employed web developer since the beginning of the web. Migrated from Java/J2EE to clojure in 2012 and not regretted it once. Author of liberator. Father of Four.
Currently, many of the data analytics tools for business users are either severely feature constrained in the name of ease-of-use, or are too complex as thinly wrapped abstractions atop the underlying programming languages. They don't address the needs of savvy business experts who need something more expressive than Excel without having to become software engineers.
Software professionals, on the other hand, are seeking ways to publish their algorithmic and process abstractions in a manner where they can be composed and leveraged further by their users.
Juxt builds upon ideas from past programming systems like Yahoo Pipes and Scratch, to create an interactive and graphical tool for Data Analytics and Web APIs, using Clojure as the extension language.
Applying the best practices from Functional Programming and Data Flow Programming, Juxt enables non-coders to rapidly build sophisticated data driven apps. And our APIs enable Clojure devs to easily publish their libraries as composable and reusable platform components.
In this talk, I'll present the challenges and learning from our experience using Clojure and Clojurescript to build a powerful, performant and highly UX driven app.
About the speaker: Ram Krishnan is Founder and Chief Technologist of Juxt.io, where he is building easy to use and expressive Big Data Analytics tools for business users.
With over 20 years experience developing software, Ram started his career working in C, Lisp, Smalltalk, Java and Erlang before discovering Clojure. He has been using Clojure professionally since 2009 and continues to be surprised and delighted by the language and community.
We had a month till the industry conference. It had to run on JVM. We are a .NET shop. We tallied the team's skills other than C#: Ruby, Java, Python, PHP, Scala, Perl, and Clojure. Not a single overlapping language between us.
"Who would feel comfortable having to train everyone else?"
I put myself forward for Clojure. A month later we shipped.
Here's the report of how I became confident enough to suggest Clojure as an option and then train the rest of the team. I'll cover the skills and attitudes that I believe made the project a success. I'll also make suggestions for what can reduce the friction of introducing Clojure at your company.
About the speaker: I am a software engineer, writer, and dev manager. I co-organize Clojadelphia, the Philadelphia Clojure meetup. I author the development blog Deliberate Software, where I write about Clojure, F#, and skills for new developers.
I have a passion for training and learning. I previously worked as a middle school teacher, then later as a developer trainer. I've found Clojure to be the tool that gives me the longest lever between my skill and the problem, so it is the tool I grab for first. Therefore, most of my teaching these days is around Clojure.