Talk about strange bedfellows: what happens when you mix one part Lisp (one of the oldest computer languages), one part Java (so young, yet so well adopted), a healthy serving of functional programming, and a state-of-the-art concurrency layer on top? That's Clojure, which "feels like a general-purpose language beamed back from the near future." Clojure embraces functional programming with immutable data types and first class functions. It is fully interoperable with Java. Clojure's approach to concurrency includes asynchonous Agents, and Software Transactional Memory. Clojure is fast, elegant, dynamic, and scalable: a language for the future, today.

ABOUT THE GROUP: Join programmers, researchers and enthusiasts to discuss functional programming. pdxfunc is a study/user group exploring the world of functional programming based in Portland, Oregon. The group welcomes programmers interested in all functional languages, including Haskell, Erlang, OCaml, Scala, and others. The group meets regularly and provides presentations, demos and discussions applicable to all skill levels, from newbies and experts. The meetings are usually on the second Monday of the month.

ABOUT THE VENUE: The group will meet in the Events Room, the large glassed-in room by the main entrance on Hawthorne. There will a "pdxfunc" sign on the door. Feel free to show up early to eat and socialize, we have the room reserved from 6pm on.

The monthly meeting of Portland's first JavaScript and ECMAscript users' group. We discuss topics ranging from client-side and server-side web frameworks, to functional and prototypal programming theory.

Kevin Lynagh will talk to us about data-driven web applications with ClojureScript:

A web page or application is, at its core, just a visual representation of data that people can read, look at, and manipulate.Typically the mapping between the abstract data and elements on the screen is implicit in the code: take some piece of the data, do X here, do Y there; when the user clicks on that thing, modify the page here, and so on.

Reasoning about such code is difficult: either control is inverted across many different callbacks with complected concerns, or one must endure a great deal of ceremony with models, controllers, view models, and views/templates to structure an application.Ideally when we build a web application all we should have to do is describe how our application's data should be represented on the DOM.We shouldn't need to worry about callbacks, twiddling the attributes of particular elements, or updating cached state.

As it turns out, ClojureScript's rich data structures and semantics allows us to easily write such simple, declarative code.I will discuss these ideas using examples from visualization-rich dashboard applications.

Clojure/West is a three day conference about the Clojure and ClojureScript programming languages at the Gerding Theater. There will be keynotes by Rich Hickey (Clojure) and Matthew Flatt (Racket) as well as about 35 talks. View the full sessions list.

The miniKanren Confo is a special 4 hour conference about logic programming (in particular miniKanren). Dan Friedman and Will Byrd (co-authors of the Reasoned Schemer) will provide a keynote. The list of sessions can be found on the Clojure/West site.

Registration ($50) is required and can be done either standalone or as part of registration with the Clojure/West conference (Mar 18-20th).

Clojure is a modern functional programming language. It's ecosystem is packed to the brim with tools that help you
achieve more with less typing, less moving parts, and less (or no) mutable state.

Come learn about functional programming, tips to getting started and being effective with Clojure, software transactional memory, and persistent data structures.
Clojure is language built to tackle the complexity of the systems we face today, and this talk will take you on tour through
its features, opinions, and approach.

About the speaker:

Paul deGrandis lives for magnificent engineering. Elegant, well-founded, useful solutions to problems that say something about engineering's beauty.
Currently he is a scientist and co-founder at NDensity - an innovation lab. Previously he worked at Tutorspree (YC), PushButton Labs, Etsy.com, OurShelf (DreamIt), and SilverCloud Software as well as working in advanced research. He's also contributed, time, money, and effort to Code for America, PyPy, and Clojure.
He is often speaking on Clojure, distributed systems, and dependable systems.
http://www.pauldee.org/bloghttp://ndensity.com

With OSCON in town this week, bringing to town many from the functional programming community among others, we thought it would be a good idea to hold a casual functional programming meetup. There's no agenda and no talks, but there will be beer and good conversation.

We'll be meeting up on the patio at Green Dragon. If you're just visiting and are worried you won't recognize the geeks when you get there (we're usually easy enough to spot), feel free to ping people on the PDXFunc mailing list (https://groups.google.com/forum/#!forum/pdxfunc) or on IRC at #pdxfunc.

Mastering Time With Clojure and core.async

We all know that the most challenging programming problems we're likely to face involve threading. Lots and lots of threads,
coordinating and communicating in complex and non-deterministic ways. Clojure by itself gets us part of the way there with immutable data-structures and threading primitives (such as atoms and agents), but coordinating many threads in the ways demanded by real applications increases complexity and reduces performance.

core.async is a new library for Clojure that rationalizes and simplifies coordination of large numbers of threads using communicating sequential processes; the end result is manageable code that looks and feels synchronous ... easy to read, easy to maintain. As is often the case in Clojure, a few simple primitives work together to open up a rich world of possibilities.

We'll be talking about high-level goals for 2014, and coming up with a list of:
- topics on which we can present to each other
- topics/technologies around which to build hack nights/days
- speakers we'd like to raise funds to invite to Portland

If you're a Clojure/Lisp vet, it'd be great to have your insight on expert topics. If you're new to the ecosystem, we want to hear about what areas your interests revolve around to best cater to the local community.

The domain problem is conceptually simple: you provide sets of images and are notified with visual diffs of changes. The motivating use case was regression testing a web data visualization product---taking screenshots is far easier and more comprehensive than unit testing JavaScript + DOM + CSS styling.

The application is about 1300 lines of code, which includes all of the (Clojure-generated) markup and styling.It's built with Clojure, ClojureScript, and Datomic.
I'll touch on:

Leiningen is a very important component of the Clojurian toolchain, responsible for compilation, en-jar-ificaation, REPLs, running applications in production, many other things, and soon package release automation as well!

Please join us to hack on Leiningen this Thursday at Puppet Labs. Please also join us if you're dabbling in Clojure, want to engage in hifalutin' discourse about editors, or just want to hang out with other lispy programmery folk.

We also tend to go for food/drinks afterwards, where conversation ranges more broadly into war stories, philosophy and idle industry trend speculation.

Zach Tellman wrote an interesting piece on successful strategies for the self-organizing Clojure meetup:

http://blog.factual.com/clojure-office-hours
Let's try this model! There will be a whiteboard, Puppet will graciously host and those who want to learn can come to learn, those who want to hack can come and hack, and those who are willing to share their wisdom are welcome to do so.

We will be discussing some different graph and network algorithms and exploring how best to implement them in Clojure. Focus will be on functionality, efficiency and generalizability. And joy.

Bio: Ryan Spangler is currently Lead Developer at Little Bird, a social network analysis software startup in Portland OR. He has been contributing to open source Clojure for going on 4 years now, and he has been a lisp enthusiast in some form or another since he saw his first parenthesis.

You're in the flow: writing code, experimenting in the REPL, running tests ... and then it happens: an exception. Clojure approaches a kind of ideal coding environment, right up until something goes wrong. Clojure stack traces are notoriously challenging: hard to read, lots of noise, and limited in context. Fortunately, we have the tools to fix this! We'll describe Pretty: a library that presents exceptions ordered and formatted for readability, and Tracker: a library to provide context to exceptions that goes beyond the stack trace.

4) Sane, smart, fast, Clojure web services with Rook
Rook (the name is a play on Bishop) is a library that fits into Ring as a straight-forward, easy way to build web services. In essence, Rook is a mapping between web resources and specific Clojure namespaces.Rook leverages conventions, metadata, and a few strong opinions to make it fast and easy to build well structured web services, following the REST pattern ... and goes beyond just request dispatching, providing some much needed infrastructure that helps you build code that is concise, efficient, testable, and maintainable..

This free workshop will be hosted by Puppet Labs and Simple in Portland, Oregon. This workshop is open to anyone who identifies as a woman, genderqueer, genderfluid, or genderfree regardless of gender presentation or assigned sex at birth. It is suitable for complete beginner to intermediate programmers who have no previous experience of the Clojure programming language.

In this workshop, we'll take you through building a sample app using Clojure. We'll meet up Friday night at the Simple offices in the Pearl to install all of the software you need, and then spend Saturday at the Puppet Labs offices in SW learning and writing code. There will be dinner provided at the Friday installfest, and breakfast and lunch provided at the Saturday workshop. Each participant needs to bring their own computer with fairly recent Mac, Linux or Windows installation. If you have questions about your hardware, email one of the organizers before the event!

One of the two largest Clojure conferences held each year in the US, Clojure/West offers two days of training workshops followed by three days of talks. Also there are unsessions happening in the evenings.

We're going to have two talks this month. First Russell Mull will present:

Logic Programming from the Inside Out

Description: Learn about the guts of miniKanren and core.logic, obtaining a deeper understanding of the fundamental truths of logic programming. (And also some neat functional programming tricks)

Then I'll lead a workshop on:

Single Page Apps with ClojureScript, Figwheel, Reagent, etc.

Description: We'll do a quick high-level workshop to introduce using ClojureScript with Reagent to create a very simple web app. I'll show a work flow using Figwheel and we'll discuss some architectural decisions as time allows.

If you've been meaning to look into ClojureScript this is a great way to start and if you're experienced come and share your thoughts and help others.

Bring your laptop with leinengen installed or team up with others at the meeting.

Clojure's test.check library for generative testing is something that a lot of people talk about, but relatively few actually use. Lots of people, myself included, find that test.check's Haskell origins make it more than a bit alienating at first, and dealing with that unfamiliarity while adopting a new testing paradigm is a lot to ask.

In this short talk, I'll discuss ways of approaching generative testing in Clojure and show how generators are composed of small, simple parts. I'll also demonstrate my own library based on test.check, jen, which makes it even easier to write generators for typical Clojure data types.

Bio: Justin Holguín is a full-time Clojure developer at Puppet Labs who enjoys experimenting with new ways to write, find, and fix bugs.

Office hours are a great place to chat with other developers and help or get help with any questions that come up.

Everyone is always welcomed regardless of skill or experience. If you curious come on out.

This month we'll have a special newcomers focus where we'll start with introductions, have lighting talks, discuss somethings we like about clojure and some things we find confusing and help each other install a dev environment.

Curious about Clojure? Have questions about Emacs or Cursive or Vim or Spacemacs or anything else? Come on out and we'll help.

Recently we at Little Bird had a series of issues trying to get another Clojure distributed computation library working in production. Learning from the frustrations involved in that process clarified exactly what we wanted out of a distributed computation system, and soon after Ibis was born. The goal was to simplify everything and leave the hard problems of synchronization to battle tested libraries that already do it well, namely Zookeeper and Kafka. Built on this solid foundation, Ibis was a natural expression of our intent when designing a distributed system. Providing seamless distribution in the face of adding and removing nodes on the fly, streaming, scheduling and unique tasks, Ibis is already serving us well in production and we consider it a great success.

Clojure on AWS Lambda is like the Reese's Peanut Butter Cup of the functional programming world. Lambda gives you an easy way to run your functions in the cloud without needing to provision or manage any servers. It's also really cheap and extremely scalable. In this short presentation we'll walk through building and deploying a Clojure microservice using only AWS Lambda and API Gateway. We'll also discuss ways that your Lambda functions could support larger applications in an AWS environment.

Bio:

Dan Anolik has been doing a mix of software development and solutions architecture in the Portland area for over 19 years. He has worked as a consultant for building cloud native applications and is a fairly recent convert to Clojure. Away from the keyboard Dan plays mandolin in a bluegrass band and has been a long-time wilderness search and rescue volunteer.

ClojureScript has the best client side work flow available. Beating out JS (even with modern tooling), and other compile to JS languages. With ClojureScript and figwheel we have hot code reloading, stable application state across reloads, & an interactive browser connected REPL. You can develop your client side app as if you where inside the browser. In this short presentation we will go over what figwheel does, how to set it up, and demo what it is like to build an SPA in ClojureScript + Om.

Jordan Schatz is a polyglot software engineer, working in Clojure, ClojureScript, Python, Javascript, Racket, PHP among other languages to build and scale systems for the last 10 years. He has a particular love of functional programming, dev ops & NoSQL/new data stores. Outside of computer science he pursues interests in alternative energy systems, alternative architecture and the life sciences.

The Untangled web framework is a ClojureScript web framework that blends various web development libraries together with a good bit of glue code to make single-page webapps a breeze.

Untangled leverages a lot of things that were pioneered in Om 1.0 by David Nolen, and adds it's own layers of simplification and opinion.

It is a full-stack environment, but you can pick and choose the pieces you wish to use.

We'll discuss the basic idea of the bits you need to develop an Om.Next app and cover how Untangled provides a lot of that for you.

You may want to checkout this overview, companion video as well as the Om.Next quick start and the Untangled tutorial.

Bio: Tony Kay works at NAVIS in Bend. He's been doing software development since the mid-80s in most of the common suspects: C, C++, Java, Scala, Clojure, Javascript. Tony is currently the technical lead on new software development, where he's driven the adoption of Clojure/Clojurescript and worked as the lead on the Untangled Web Framework project, which they use to develop our production software. His interests include fermenting random things for gluten-free sourdough bread, cooking, making software engineering better as a profession, and barefoot hiking.

Have you ever wanted to extend your Clojure talents to the desktop?
Turned off at the thought of digging into Swing or building native
shims around your beautiful functional code? Then look no further than Github's
Electron, a cross-platform toolkit for desktop
apps using familiar Javascript techniques, which of course we can make
much more fun and powerful with Clojurescript. Learn how to build
desktop apps with all the custom menus, system notifications, and badges
you've come to expect, right from your REPL.

About Josh Miller

Josh Miller has been building software professionally
for over a decade, in fields ranging from Erlang-backed Twitter crawlers
to Objective-C iOS apps, but his heart belongs to Clojure. Josh is a
software consultant living in Portland, OR.

If you've ever had to interrupt a series of operations with ugly nested branching logic and thought, "there should be a better way", you're not alone. I'll show you how to use some basic category theory abstractions from funcool's cats library to write declarative code that's easier to read and reason about, and how to integrate it with their promesa library for declarative asynchronous programming.

Using Clojure greenfield project is great but what about legacy projects full of toxic decay and code zombies lurking the repo?

Clojure is your post apocalyptic weapon. You don't have to re-write the whole monolith; by switching key parts of the infrastructure we can reduced the number of servers and costs.

Get bragging rights with your managers and higher ups by introducing Clojure and Clojure community practices in large legacy apps. In this installment we’ll explore how to reduce the high IO costs of large scale email processing with Clojure.

In this talk, Austin Haas will discuss why games are difficult to make and how DEVS, a popular simulation modeling formalism, can help. This talk may be relevant to anyone interested in game development, systems theory, actors, agents, or FRP.

Regex derivatives: the functional pearl inside core.spec

The new spec library in Clojure 1.9 uses an old but elegant method for recognizing sequences. We'll develop an implementation of this algorithm in Clojure.

Bio: Russell writes Clojure at Puppet. He's into guitars and separating his functions from his data.

This talk will show you how to use Clojure and the new spec library to write programs that behave as expected, meet operational requirements, and have the flexibility to accommodate change. We will also discuss how developing with spec is declarative, predicative, layered and robust.

This is a live remote, interactive presentation where we will have time for questions.

GraphQL is a way to expose your services and data to your clients in a uniform, efficient, and client-driven way.It sidesteps much of the confusion and clutter of a REST solution, and provides clear solutionsto scalability, documentation, and updates to your data and services. We've been having great successwith GraphQL at Walmart, and are soon to release an open-source Clojure implementation.

This is the first month of our new format, based on discussion following the survey: The first half will be geared toward beginners, and the second half will be geared toward more advanced material.

For the next several months the beginner material will be a series of lessons in the Haskell programming language. We will be following Brent Yorgey's CIS 194 syllabus (http://www.seas.upenn.edu/~cis194/spring13/lectures.html). So bring a laptop, or just follow along. Between months you are encouraged to work on the assignments and we will review them. Lyle will be leading the lecture this month.

This month's advanced talk will be delivered by Leif, who will be following up his discussion of data parallelism in Spark (Scala) and Haskell.

A key innovation in Clojure (versus earlier Lisps) is the abstraction of sequence processing functions away from the list type, to the more general sequence interface. This polymorphic abstraction lets what would otherwise be a large library of functions operating on a single collection type (list), grow in power to operate over more collection types, including maps, sets, vectors, and many others.

The clojure.core sequence processing facilities borrow great ideas from earlier Lisps and Haskell too. Conversely, ClojureScript’s collections library can be viewed as a successor to Clojure’s own. By exploring a little bit of this surrounding terrain, we gain a much clearer understanding of Clojure’s elegant and powerful collection processing.

In this first 45-minute presentation, we’ll introduce a toy problem and we’ll solve it a few different ways at the REPL. From very basic beginnings, we’ll introduce sequence processing and collection-sequence duality. We’ll progress smoothly to higher-order functions and beyond (I don’t want to ruin the surprise mkay?) Along the way we’ll meet a number of foundational Clojure functions and forms.

If you’ve read a Clojure book (mainly the first few chapters) and you’ve written some code, you have everything you need to understand this talk. Intermediate Clojurists, may also come away with some new insights.

Bio:

Bill Burcham has earned his living for almost three decades now, making software. He’s liked Lisp best for even longer than that. As many have pointed out: Lisp feels like something discovered—not something invented. There is something essential in Lisp.

When he’s not engaged in a media fast, Bill can be reached @billburcham

There are 6 difficult problems frameworks and libraries try to solve in JavaScript, but never quite get there. Learn how these problems (and more!) are solved by ClojureScript and how it can provide a platform for new solutions.

Are you tired of constantly chasing after the next framework? Do you ever feel like frameworks don't solve the hard problems, like callback hell, state management, and correctness checking? Are you looking for something that could make your software radically simpler and let you code better features? ClojureScript could be the answer. In this talk, you'll learn how ClojureScript solves really some tough problems in JavaScript and how it provides a platform for new solutions.

Note: This is a special edition meeting at a different time and place than normal

Lyle will give an introduction to category theory, a theory about mathematical structures and their relationships, which has applications in functional programming.

The meeting will be at Collective Agency in the Tiffany Center - the same place as the February meeting. The elevator is expected to be restored to operation by then. (UPDATE: Elevator service to the 8th floor has not yet been restored, so you will have to walk from the 4th floor.) Someone will wait in the lobby to let you in as the front doors are locked after 6. The meeting is on the 8th floor.

Deep learning (DL) has become an important topic in the AI and machine learning world. New advances in algorithms, hardware and software have made it a critical part of self driving cars, language translation, image understanding, medical analysis, and many other fields. Though DL systems are commonly written in Python (wrapping C/C++ libraries) we want to explore options available to Clojure developers.

We'll have a 2 part meeting with myself (Julio) and JR leading extended lightning-talk style presentations.

First, Julio will guide us through a discussion on:

• the basics of deep learning and the common tools and libraries
• Java and Clojure options (DeepLearning4J and Cortex) and when they may be applicable.

In the second part JR will discuss his experiences while taking a deep learning for self driving cars course.

JR Says: Neural networks are just plain spooky. In just the past few years, they've gotten so good at classifying images (is this a cat or a dog? is this tissue cancerous or non-cancerous?) that they're often better at their task than humans are. In this talk, you'll see how to use a neural network - the same one used by comma.ai, a real-life self-driving car company - to drive a simulated car better than JR can.

Then, Matt Rice will talk about the 1ML language, a variant of ML which unifies the main expression/type language with the language of the module system (signatures, structures and functors). He's also been creating his own language derived from it.

Meeting is on the 8th floor of the Tiffany Center. If you arrive before the meeting starts, there will be someone in the lobby to open the front door for you. If not, there will be a sign posted with a phone number for you to call, and someone will come down to let you in. Take the elevator on the right to the 8th floor, and exit to your right. The sign next to the space says Forge Portland. We meet in the large open area there.

Then, Jamon Holmgren will explain his implementation of the A pathfinding algorithm in Elm. A is used in games to calculate the least-cost path for a computer character to move from one spot to another. Elm is a language similar to Haskell (but simpler) that compiles down to JavaScript, used for apps that run in web browsers.

ClojureScript's React.JS wrappers have been around a while, and fighweel has really made the development experience shine. When I first started playing around with ClojureScript I really wanted to make browser games more than web apps and this got me thinking. Can a library exist which allows for creating and manipulating any object model similarly to how React interacts with the DOM? This talk is about a pair of libraries I've began writing which makes an attempt at proving this out.

And since it's Javascript-based, Clojurescript is an ideal functional language to equip your mobile development environment with space-age benefits like immutable data, pure functions, and best-of-all, REPL-driven UIs.

Come learn how to bootstrap a mobile environment with React Native, Clojurescript, and re-frame, and how to incorporate native code for functionality not yet handled by React Native.

About Josh Miller

Josh Miller has been building software professionally for over a decade, in fields ranging from Erlang-backed Twitter crawlers to Objective-C iOS apps, but his heart belongs to Clojure. Josh is a software consultant living in Portland, OR.

Brian Ginsburg will give a short presentation on Minima (https://brianginsburg.com/minima/), a playground for experimenting with minimalist musical patterns, which he wrote in Elm.

We will have extra time in this meeting for hands-on learning. You are encouraged to bring a laptop or work together with someone else. You can practice working with functors, hack on Minima, or ask any other questions you might have.

This month I am happy to announce we will have a remote presentation from Zach Tellman. I've heard Zach speak several times and every time have learned a lot and been impressed by the breadth and depth of his knowledge and thinking.

He will share with us a discussion of what an abstractions are, what makes them fail, and how to make them better.

Come celebrate the 10th anniversary of PDX Func! The first meeting was on 11/15/07. There'll be food and drink and cake! We'll also discuss the new format for meetings based on the survey results. We will also go over the Applicative Functor lesson from CIS 193, which will be our final lesson from that track.

We've had a few presentations on using re-frame and continue to get many questions on this fantastic tool. There is a lot to learn but you will be rewarded when building single page apps. So this month our own Matthew Lyon will present:

Constructing Interfaces with re-frame

I’ve talked to many clojurists who are curious about front-end programming but don’t know where to start. They haven’t done front-end work before, they’re unfamiliar with JavaScript or React, and they don’t understand how those pieces fit together. I’ll walk through what a ClojureScript development environment looks like; what makes front-end programming different and how React, reagent, and re-frame fit into this; how to create views with Reagent; how to manage state and the outside world with re-frame; and how to effectively debug your front-end code.

Matthew Lyon has been building the front- and back-ends for web applications for over twelve years, and with Clojure for three years. He enjoys creating interfaces for helping people work through complex interactions.

This month we'll have member provided lighting talks. We have two scheduled so far and room for more. Get in touch if you want to do one also.

First we have John Skilbeck talking about converting a traditional Clojure project meant to be run on a server or on docker into a AWS Lambda runtime, while leaving the original project's source code intact. He'll provide a brief background on AWS Lambda and how that works, and then a walkthrough of the project.

Then we'll have JR Heard's talk: An Introduction to Specter

Specter is a library that allows you to elegantly and performantly manipulate Clojure/Script data structures. In this sure-to-be-compelling lightning talk, we'll learn why Specter exists, how to use it, and how to write our own Specter "navigators".

Datalog is a powerful recursive query language that can be implemented in a few hundred lines of Clojure. It's a great introduction to logic programming and it can be used to solve real problems. It is also the basis for Datomic's query language.

In this presentation, I will explain Datalog, how it is used in Datomic, and how my team is using Datalog (in Clojure) to build flexible programs that transform large amounts of interdependent data in minutes with Apache Beam.

Bio: Austin is a senior engineer at Healthsparq, where he uses Clojure to transform healthcare data. He has been programming in Clojure for about 7 years. His interests include Logic Programming, Automated Planning, and Game Development.

Much has been said about building re-frame applications in the small, but how well do these same techniques perform building large applications? In practice, our team found traditional approaches to events and state management led to highly-coupled code that was difficult to maintain and test.

In this talk we'll explore why this happens and some simple techniques you can use to create more re-usable re-frame code without boilerplate or any 3rd party libraries.

Biography
Ryan is a Clojure developer, author, and founder of Homegrown Labs (http://homegrownlabs.ca ), a consultancy and education company based in Winnipeg, Canada.

Since April 2017, Ryan & Homegrown have been working with Funding Circle building rich admin applications using ClojureScript & re-frame.

Portland has a fairly lively Clojure ecosystem -- how can we leverage that base and become a hub of Clojure culture?

The biggest opportunity appears to be in helping newcomers connect the dots. The language was designed to be clear, consistent, practical, and empowering -- this talk will explore how we can apply those principles to support the local scene and create an onboarding model other groups can use.

Bring your gripes and ideas.

Bio:
New to the language and somewhat obsessed, Tom has worked as a writer, editor, and programmer. He hosts the Tuesday night Clojure Study Crew, and is currently building what he hopes will be the next best Clojure documentation tool.

Come join us in an evening of stimulating discussion where we explore an approach in developing an event-sourced, CQRS-based real time system. We’ll look at the reframe inspired events system on the server side, as well as how the interceptor pattern can be used to achieve a clean implementation.

Fenton Travers
Organizer of the Vancouver Clojure meetup. 10 years experience at Oracle before drinking the Clojure kool-aid.
https://github.com/ftravers

Paul Lucas
Deeply involved at the intersection of music and functional programming. Has been booked for live coding gigs in UK and Japan. Front-end focus.
https://github.com/paullucas

Gargoyle Software specializes in Clojure software development for the cannabis industry. We believe in mutualism, questioning assumptions, and honoring craftsmanship. We're located in Vancouver, BC and have a median of 9 years experience. We offer full-service project management or staff augmentation and in-house design. We are about to release our first Clojure open source contribution.

Vars are at the heart of how Clojure code is evaluated, but their primary features are subtle and their secondary features are many and obscure. Understanding Clojure's vars not only clarifies how the language works, but also opens up new ways of making the language do what you want, especially when building development tools.

BIO

Gary Fredericks is a software engineer who has been making Clojure-themed jokes for nearly ten years. He lives in Chicago and does programming things for DRW. He is writing these words from a playground swing and it is windy and cold. https://twitter.com/gfredericks_