This month's topic: Clojure: Functional Programming for the JVM (Howard Lewis Ship)

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.

(description from http://calagator.org/events/1250456403)

----------

PJUG meetings start with eat+meet+greet time (pizza and beverages are provided), followed by the featured speaker, then some time for Q&A, discussion, and sometimes a drawing to give away swag. :)

It is not necessary to RSVP, on Upcoming or otherwise; go ahead and just show up!

Many people also go for drinks afterward, at a location decided on the fly (more often than not, Jax on 2nd).

Twitter: @pjug
Web: pjug.org
(feel free to join our mailing list, linked from the website!)

         

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.

We have two talks scheduled for this meeting:

• SocketStream, a phenomenally fast real-time web framework for Node.js, presented by Eric Redmond
• ClojureScript, the Clojure to JS compiler, presented by Kevin Lynagh

Feel free to join our mailing list at http://groups.google.com/group/pdxjs if you too are a JavaScript admirer. Or visit our web site for more information at http://pdxjs.com/.

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.

Recommended reading:

C2: http://keminglabs.com/c2/
Knockout.js: http://knockoutjs.com/
Rich Hickey's talk on the benefits of immutability: http://www.infoq.com/presentations/Are-We-There-Yet-Rich-Hickey

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 conference is $350. Register now!

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/blog http://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.

Dan Herrera will be discussing the use of Trident and Kafka to implement realtime distributed streaming computations. Please see his recent blog post for more information: http://whoahbot.com/2013/07/10/writing-trident-topologies-in-clojure.html. Dan is a Data Engineer at Simple where he builds scalable distributed data processing platforms.

If we have any energy left, let's have a group discussion about core.async at the end of the meetup.

Ben Kaplin is a Systems and Automation Engineer at Copious (http://www.copio.us). Come learn about the Datomic architecture and query language.

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.

Clojure hack night at Puppet!

Show up at 5.30 if you want to form a team for a focused Dojo session, or later if you want to hack on your .emacs.

Closed: Puppet is reportedly closing at 3pm today due to snow.

Kevin sez:

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:

• designing an application around Stuart Sierra's "Reloaded" workflow: http://thinkrelevance.com/blog/2013/06/04/clojure-workflow-reloaded

• basics (and not-so-basics) of the Ring HTTP model

• using Chas Emerick's Friend library to handle web user and API authentication

• deploying/monitoring a Clojure application in (low-stakes) production

• structuring an application around protocols so that service backends (e.g., S3) can be easily swapped between development, staging, and production

If there's anything that seems particularly interesting to you (in the above list or otherwise), please reply to this thread so I can prepare a bit of material.

I'm planning on giving a 20 minute high-level overview of the application, and then opening it up to questions and focussing on whatever topics folks are interested in.

per #clojure-pdx on irc.freenode.net on 5/12:

waynr: howdy folks

waynr: i might try to make the clojerks meetup on thursday

benkay: sweet!

benkay: i don't know what we're doing yet

benkay: do you want to talk about a thing waynr ?

waynr: maybe, i think i am going to try to help get lein-release into leiningen this week in the afterwork hours, not sure if there is much to say about that

waynr: maybe the thing at this meetup could be collaborating on getting lein-release into leiningen...technomancy mentioned in #clojure that this is a pretty big blocker for 2.4.0

waynr: i haven't delved too deeply into it but it seems like the existing plugin really does most of what technomancy mentions here:http://librelist.com/browser//leiningen/2014/5/1\release-task/

benkay: sounds great, waynr

benkay: would this be an active hacking session or...

waynr: yeah that sounds like a good use of the time

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.

See you at Puppet!

Soren Macbeth, chief data scientist at yieldbot, will discuss machine learning techniques using cascalog, storm, and spark.

The session will begin with one or more lightning talks at 6:45pm followed by Soren's presentation at 7:00pm.

Learn the basics of computer programming by making games!

This 2 hour workshop will give you an introduction and overview to programming, programming with Clojure and developing simple games.

We will start with an existing game template and then make changes and see the effects in real time.

Then we will talk about how simple 2D games are structured and introduce more technical game and programming concepts and aspects.

And then work on making more changes and customizations.

Please check the link for more info and get a free ticket at EventBrite so we know you are coming.

Thanks!

Come talk and ask/answer questions about Clojure ClojureScript and related topics.

Successful strategies for the self-organizing Clojure meetup:

http://blog.factual.com/clojure-office-hours

Please also review the Puppet Code of Conduct. As we reside in their space, we abide by their rules.

https://docs.puppetlabs.com/community/community_guidelines.html#event-code-of-conduct

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.

This month we have duelling Howards! Two Howards enter, one Howard leaves.

First Howard Abrams will give us a short talk on

1) How to Host a Mini Workshop

and then

2) A Mini workshop on Yesql

Then Howard M. Lewis Ship will present 3) Exceptional Feedback in Clojure

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.

Follow @clojurewest for updates.

Let's discuss the latest in Clojure and what we've learned and experienced at ClojureWest.

We'll have a series of short presentations from members so be sure to think about what you'd like to share and let me know.

Thanks.

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.

Intersted in learning more about Clojure? Have questions or need help with a set up, library or Clojure/Functional Programming concept?

Come by the Office Hours meeting this month.

Bring any questions you may have or topics on your mind and we'll see how others can help.

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.

Our scheduled speaker had to cancel unexpectedly so we'll have lighting talks and office hours.

The talks don't need to be formal at all. Just take 5-15 minutes sharing something you've learned or are working on.

To get the ball rolling I'll do:

"What I've learned about React Native and ClojureScript"

So what have you been working on? Don't be shy. Your group needs you.

And as for the office hours ... just come with your questions, problems and challenges and we'll try to help.

Thanks.

Julio

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.

Cats:

http://funcool.github.io/cats/latest

Promesa:

http://funcool.github.io/promesa/latest/

Bio: Matthew Lyon helps humans and computers communicate.

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.

Bio: Paco is a developer in Portland Oregon and can be found on twitter at https://twitter.com/kidpollo

We'll have two talks this month.

Making Games in Clojure(script) with the DEVS Modeling Formalism

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.

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

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 are curious come on out.

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.

Potluck and game night for Portland Coders of all flavors. Register at eventbrite: https://www.eventbrite.com/e/10th-annual-winter-coders-social-and-potluck-tickets-31309764348

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.

Part I: Eager to Process

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

This month, Echo will be leading us through Haskell Lesson 2 (Week 2 at http://www.seas.upenn.edu/~cis194/spring13/lectures.html)! The category theory talk has been rescheduled for April.

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

This meeting continues our Haskell lesson series with Echo delivering Lesson 3 on Recursion Patterns, Polymorphism, and the Prelude from Brent Yorgey's CIS194 course (http://www.seas.upenn.edu/~cis194/spring13/lectures.html).

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.

website

Join us for another fun-filled evening of learning and discussion!

Tonight, Lyle will present Lesson 5 from Brent Yorgey's CIS 194 lectures: http://www.seas.upenn.edu/~cis194/spring13/lectures/05-type-classes.html, as well as reviewing the homework from Lesson 4.

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.

This month, Leif will present Lesson 6 on Lazy Evaluation from Brent Yorgey's CIS 194 lectures.

Then, Rob Norris will talk about free things.

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. 

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 are curious come on out.

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

This month, we'll be meeting in a new location! Collective Agency has moved to 511 SW 10th Ave. We'll be meeting in the main area.

First, we'll cover Lesson 7 on Folds and Monoids from Brent Yorgey's CIS 194 Haskell lectures.

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.

Lyle will present Brent Yorgey's CIS 194 Lesson 8 on IO in Haskell.

Then Lyle will present Vintage BASIC, a BASIC interpreter he wrote in Haskell some years ago but has recently revised.

Facebook's Javascript-based cross-platform mobile solution React Native has been rapidly gaining mindshare recently, and for good reason: it's a tasteful, flexible, understandable way to build performant mobile applications by repurposing your web stack knowledge.

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.

Echo will present Brent Yorgey's CIS 194 Lesson 9 on functors in Haskell.

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.

Zach is the author of Elements of Clojure https://leanpub.com/elementsofclojure , and a number of open source libraries.

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.

Justin Smith will present his library, poirot, and explain why it was needed and demonstrate how it is used to simplify debugging and writing regression tests.

Bio:

Justin is a full time Clojure programmer and maker of weird music. He's remarkably active on #clojure IRC and the clojurians slack channel.

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.

• What we'll do
Please note: this is a Thursday meetup and we will be meeting on the **27th** floor!

-=== Proposed Schedule ===-

David Wells: React + Serverless

Developer @ https://serverless.com/
https://twitter.com/DavidWells

Come learn how to build a robust multi-stage React application backed by a Serverless API, complete with user authentication & protected routes. 💸
He will walk through using React, AWS Lambda, custom authorizers, and Auth0 JWTs to create an infinitely scalable, pay per execution full stack app.
Open Source Repo: https://github.com/serverless/forms-service

Live Stream: https://www.youtube.com/watch?v=UGrGce6-cX4

-=== Event Details ===-

New Relic (http://newrelic.com/) has graciously offered their event space to host our meeting this month. If you are new to the group, welcome! We hope that you find this community a friendly and open one. To new and existing members, please take a look at the code of conduct (https://github.com/portland-react-js/meetup/blob/master/code-of-conduct.md) for our group.

-=== Other ===-

As a reminder, we're on Slack! You can join us here http://portlandreactjs.herokuapp.com to chat with other Reactivists all talking and helping each other with React!

• What to bring

• Important to know

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.

Apache Beam is a data processing library that runs on Google Dataflow, a serverless distributed computing service.

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.

Beyond consulting, Ryan organizes Clojure Remote (http://clojureremote.com )–an online conference focussed on remote Clojure & ClojureScript developers. Keep an eye out for ClojureScript Days coming Summer of 2018.

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 are curious come on out.

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

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.

Presenters:

Jesse Sherlock Startup veteran, incredibly broad and deep. https://github.com/infracanophile

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_