First ever meeting for the PDX Erlang user group. We will cover some basic getting-started stuff, then dive in to what I am tentatively calling ErlangGames. This meetup is for people of all experience levels, from no programming experience to curmudgeony basement-dwellers. Our format will be slightly different from what you are use to in a user group, optimized for fun.

CANCELLED due to geolocation

This meetup is for people of all experience levels, from no programming experience to curmudgeony basement-dwellers. Our format will be slightly different from what you are use to in a user group, optimized for fun. Learn you some Erlang.

This meetup is for people of all experience levels, from no programming experience to curmudgeony basement-dwellers. Our format will be slightly different from what you are use to in a user group, optimized for fun.

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.

Hello Portland!

Let's talk Erlang, Elixir, OTP, scalability, uptime, web apps, beer and all things computer industry.

Got something to share? Looking to learn? Drop in and join us!

The next PDX Erlang and Elixir Meetup is this Wednesday from 6:30pm to 8:30pm at CrowdCompass.  Mexican food from Los Gorditos will be provided. Vegan and gluten free options available.  Email [email protected] if there is something specific you'd like to try from their menu (links at bottom).

There's still room on the agenda if you have something to discuss, otherwise we'll open it up for general discussion.  The agenda so far:

Stephen Peters will give a recap of his time at Erlang Factory in San Francisco earlier this month and possibly demo a new monitoring tool for the Erlang VM.

Daniel Hedlund will be giving a brief overview of erlank.mk, rebar and relx and how they fit into the Erlang app development ecosystem.  He will also present a bare bones cowboy app and go over each of its components, and how to pull in other dependencies like redis and json libraries.  The app will be made available on GitHub so you can clone and experiment after the meeting.

Hope to see everyone there!

Los Gorditos Taqueria Menus:

• Vegan: http://www.losgorditospdx.com/menu/vegan-menu/taqueria-vegan-menu/
• Vegetarian: http://www.losgorditospdx.com/menu/vegetarian-menu/taqueria-vegetarian-menu/
• Meat: http://www.losgorditospdx.com/menu/meat-menu/taqueria-meat-menu/

If you have trouble finding us, please call Stephen at 503.575.0815 or Daniel at 503.453.7535.

We are the Portland Erlang and Elixir meetup.

Matthew Lyon will give an “Intro to Elixir” presentation from and for the perspective of people coming from scripting languages such as Ruby, Python, and Javascript.

Elixir is a functional, meta-programming aware language built on top of the Erlang VM. It is a dynamic language with flexible syntax and macro support that leverages Erlang's abilities to build concurrent, distributed and fault-tolerant applications with hot code upgrades.

José Valim is the creator of the Elixir programming language. His goals were to enable higher extensibility and productivity in the Erlang VM while keeping compatibility with Erlang's tools and ecosystem.

We've also secured a free month subscription to Elixir Sips (http://elixirsips.com/) for everyone. Elixir Sips releases two videos every week to help you get started learning Elixir and keeping up with new tools and libraries. Feel free to pass the link along to anyone you know who might be interested.

Offer expires May 16th: https://elixirsips.dpdcart.com/subscriber/add?plan_id=176&plan_term_id=376

Mexican food from Los Gorditos will be provided. Vegan and gluten free options available. Email [email protected] if there is something specific you'd like to try from their menu: http://www.losgorditospdx.com

We look forward to seeing you!

• Steve Peters

The next PDX Erlang and Elixir Meetup is this Wednesday from 6:30pm to 8:30pm at CrowdCompass.  

There's still room on the agenda if you have something to discuss, otherwise we'll open it up for general discussion.  The agenda so far:

Show what you're working on, point and laugh at what others are working on, or be more polite and offer constructive criticism.

Either way, join us this week and let's talk Erlang!

If you have trouble finding us, please call Stephen at 503.575.0815 or Daniel at 503.453.7535.

The next PDX Erlang and Elixir Meetup is Wednesday 6/18 from 6:30pm to 8:30pm at CrowdCompass.  

Matthew Heizenroder from Orchestrate will show us how to go from idea -> web app in no time flat using Webmachine, Heroku and Orchestrate.

Webmachine is a web framework written in Erlang - https://github.com/basho/webmachine/wiki/Overview Heroku is a cloud platform as a service - https://www.heroku.com Orchestrate provides NoSQL databases as a service - http://orchestrate.io

Looking forward to seeing you here!

• Steve

Matthew Heizenroder from Orchestrate will show us how to go from idea -> web app in no time flat using Webmachine, Heroku and Orchestrate.

Webmachine is a web framework written in Erlang - https://github.com/basho/webmachine/wiki/Overview

Heroku is a cloud platform as a service - https://www.heroku.com

Orchestrate provides NoSQL databases as a service - http://orchestrate.io

It's going to be a great meeting. Looking forward to seeing you here!

(NOTE: OSCON Birds of a Feather sessions are open to all in the community. You do not need to be registered for the conference to attend.)

As part of OSCON Francesco Cesarini will be leading an Erlang Birds of a Feather gathering at the Oregon Convention Center.

It's an opportunity to meet and greet other functional programming people and discuss how to get things done in the real world that demands highly available, fault tolerant, never-stop systems in heterogeneous environments.

Come prepared to talk and learn!

Also in attendance will be Erlang co-creator Robert Virding and other notable Erlang experts.

http://www.oscon.com/oscon2014/public/schedule/detail/37674

Nathan Aschbacher throws down on his favorite Erlang topic:

Learning Erlang made me a better engineer and architect.

Even if you don't think you have a use-case for Erlang, don't have an interest in functional programming, and find reading Prolog inspired syntax directly proportional to your increased consumption of Excedrin... according to Nathan Aschbacher (currently Chief Architect at Snapflow and previously Principal Consulting Architect at Basho) you should learn Erlang anyway.

Nathan will be presenting on his path to Erlang and functional programming, his initial disdain, his later begrudging respect, and finally his eventual love and nostalgia for all things Erlang-y.

Join us and share in the conversation.

This month Casey Rosenthal will lead us through the first session of his Erlang Games. Both beginners and experts alike will have a chance to match brains against seemingly easy problems and learn new and surprising approaches.

Join us and expand your knowledge of Erlang and computing in general!

We will be putting hands-on-keyboards for coding.

If you don't already have Erlang installed on your favorite geekbox, quick instructions can be found here: http://learnyousomeerlang.com/introduction#what-you-need

Learn more about Casey and his wisdom here: www.linkedin.com/pub/casey-rosenthal/84/24b/163

Here's the relevant page on Meetup: http://www.meetup.com/Portland-Erlang-User-Group/events/219563465/

• Steve

The Erlang Games continue!

Nathan Aschbacher will lead us through a series of hands-on programming problems that will get your hands dirty in code.

Designed to be instructive and entertaining for both the n00b and experienced erlangutang, join us and expand your skills!

• Steve

"Let's get functional... functional." -Olambdia Newton-John

We'll be kicking off the first in a series of Elixir Games meetups. The "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drink will be provided. There will also be small desk fodder prizes for the winning teams.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

"And the winner for Best Actor is..." -Pid Spawnington

Well, we managed to kick things off with solid attendance, some competition that came down to the wire, and valuable lessons learned all around. Let's see if we can build some momentum as we take a dip into how Elixir handles concurrency and how we might solve problems with those tools and patterns.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drink will be provided. There will also be small desk fodder prizes for the winning teams.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

If you'd like to take a look at the previous session's exercise feel free to check it out here: https://github.com/elixir-pdx/prime , some submitted solutions are available on non-master branches.

Special thanks to Daniel Hedlund and CrowdCompass, ‘The leading mobile app provider for conferences and meetings’, for hosting us.

Daniel Hedland of CrowdCompass will be leading April's meeting.

Learn more about how Unix shells compose simple programs to solve complex tasks and how these processes interact with each other under the hood. We will discuss how Unix processes behave compared with standard Erlang and Elixir processes and how the Erlang VM could be used to emulate common patterns found in the Unix shell.

A very basic REPL will be provided to play around with some of these ideas. After the discussion, we will break out into groups to try to re-implement some common Unix commands in your favorite ErlangVM-based language and then use shell composition to solve a set of everyday problems.

Questions?

[email protected] 503-575-0815

Can you build a data processing pipeline that might one day help save humanity? For this next meetup we'll be looking at one of Elixir's features that sets it distinctly apart from its older Erlang sibling.... the Pipeline Operator.

In the previous two Elixir Games PDX meetups we've looked at how to solve some simple problems in a functional programming style, and we've also taken a look at Elixir's concurrency and parallelism paradigm. We'll be partially combining some of those principles and practices to mine some critical data.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided. There will also be small desk fodder prizes for the winning team.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Special thanks to my friends Russell Mull, Jeff Weiss and Puppet Labs, ‘the leader in IT automation’, for hosting us.

Until now we haven't focused much at all on a huge part of what makes Elixir great... seamless access to Erlang OTP. OTP, or Open Telecom Platform, is a set of frameworks and tools that make it relatively easy to build robust, fault-tolerant, and scalable applications. In this Elixir Games we're going to focus specifically on the Supervisor. Well-defined supervision strategies are the bedrock of all exceptional Elixir software (Erlang and LFE too).

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided. There will also be small desk fodder prizes for the winning team.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Special thanks to my friends Russell Mull, Jeff Weiss and Puppet Labs, ‘the leader in IT automation’, for hosting us.

10 Billion a Day, 100 Milliseconds Per: Monitoring Real Time Bidding at AdRoll

Brian Troutwine of Adroll will be joining us tonight. Adroll uses Erlang to power their high-speed, never-stop online advertising services. That's right, 10 billion transactions a day.

Brian's talk will provide motivation for the extensive instrumentation of complex computer systems and make the argument that such systems are essential. This talk will provide practical starting points in Erlang projects and maintain a perspective on the human organization around the computer system. Brian will focus on getting started with instrumentation in a systematic way and follow up with the challenge of interpreting and acting on metrics emitted from a production system in a way which does not overwhelm operators’ ability to effectively control or prioritize faults in the system. He’ll use historical examples and case studies from my work to keep the talk anchored in the practical.

Talk objectives:

Brian hopes to convince the audience of two things:

• monitoring and instrumentation is an essential component of any long-lived system and

• it's not so hard to get started, after all.

He’ll keep a clear-eyed view of what works and is difficult in practice so that the audience can make a reasoned decision after the talk.

Last time we looked at Supervisor hierarchies, and unintentionally on my part almost everyone picked up the GenServer behavior as a component of their solution. Damnable misleading documentation! However that prompted a further conversation about GenServers and other components of OTP (the Open Telecom Platform). In the spirit of learning and disambiguating things we'll take a deeper look at some of these architectural patterns in Elixir and how they can help us better organize our projects and design better systems.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided. There will also be small desk fodder prizes for the winning team.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Special thanks to my friends Jeff Weiss and Puppet Labs, ‘the leader in IT automation’, for hosting us.

It's summertime in Portland! Rather than work our brains too hard in the heat, let's just get together, socialize, chat and show off anything we happen to be working on.

Meetup with us at the Lucky Lab on SE Hawethorne. Look for the Erlang laptop stickers!

We'll get back to having speakers in September.

Stay tuned for news about Erlang at OSCON.

If you've heard of Erlang, perhaps you've also seen the acronym "OTP". What the heck is "OTP" and why do the Jedi refer to it as the "magic" that gives Erlang it's reputation for scalability and fault tolerance?

Why is it called Erlang/OTP? What gives? How does this relate to Elixir? What should I know about it?

Nathan Aschbacher of Visa and Elixir Games PDX has kindly agreed to join us and share his wisdom, give us an overview and also, to levitate R2D2.

Our generous hosts this month are HouseHappy.

October we followup on this deep topic with Jeff Weiss showing self-healing application magic in Elixir and OTP. Hope to see you there!

• Steve

If you've heard of Erlang, perhaps you've also seen the acronym "OTP". What the heck is "OTP" and why do the Jedi refer to it as the "magic" that gives Erlang it's reputation for scalability and fault tolerance?

Why is it called Erlang/OTP? What gives? How does this relate to Elixir? What should I know about it?

Nathan Aschbacher of Visa and Elixir Games PDX has kindly agreed to join us and share his wisdom, give us an overview and also, to levitate R2D2.

Our generous hosts this month are HouseHappy.

October we followup on this deep topic with Jeff Weiss showing self-healing application magic in Elixir and OTP. Hope to see you there!

• Steve

Jeff Wiess will share his presentation from ElixirConf EU and give us a live demo:

Chat Bot: A Practical Walkthrough of the powerful Features Elixir/Erlang/OTP

Bring your laptop and be ready to help us try and crash Jeff's chat server service.

Written in Elixir, a "Ruby-like" flavor of Erlang this demo will show supervision trees, clustering and live code updating.

Our generous hosts this month are HouseHappy.

We've struggled a bit for the last couple months to fully tackle supervision and GenServer patterns, but we're going to stick with it until we emerge victorious, or until we reach our retry limit and permanently timeout. So, this month we'll be at it again. In fact we'll use the same premise as last month. Take a look here https://github.com/elixir-pdx/pang if you want a refresher if you were with us last month, or to get up to speed if you weren't able to make it.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided. There will also be small desk fodder prizes for the winning team.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Special thanks to my friends Jeff Weiss, Russell Mull and Puppet Labs, ‘the leader in IT automation’, for hosting us.

Considering it's the day before Thanksgiving I'm not expecting a huge turnout, but despite that I want to make sure we do something useful. In the spirit of people distributing themselves all over the place for the holidays I thought it would be appropriate to dig into the core distribution functionality in Elixir provided on the back of Distributed Erlang.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided. There will also be small desk fodder prizes for the winning team.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Special thanks to my friends Jeff Weiss, Russell Mull and Puppet Labs, ‘the leader in IT automation’, for hosting us.

Have you heard of Phoenix? Phoenix is a framework for building HTML5 apps, API backends and distributed systems. Written in Elixir.

http://www.phoenixframework.org/

Seve Salazar of HouseHappy.org will walk us through creating a simple but real(wish)-world JSON API using Phoenix and deploying it to production as an OTP application. It will cover usage of Ecto, rendering JSON from a controller, integrating with StatsD using Exometer, and finally using edeliver to ship it to production.

We'll try to keep our table manners civil, but food encoded in Erlang External Term Format is going to sail through the air at nearly the speed of light.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided. There will also be small desk fodder prizes for the winning team.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Special thanks to my friends Jeff Weiss, Russell Mull and Puppet Labs, ‘the leader in IT automation’, for hosting us.

Magnus Feuer, Head System Architect at Jaguar Land Rover's Open Software Technology Center (JLR OSTC) will be leading the Erlang & Elixir Meetup tonight.

Magnus will describe how his team is building the next generation of connected vehicles and the role that Erlang plays in making that possible.

Learn more about the technology project that's driving this here: https://github.com/PDXostc/rvi_core

We will also get a tour of the incubator.

Watch this space! More details to come!

About The Open Software Technology Center: https://www.jlrtechincubator.com/content/about-ostc

Jaguar Land Rover (JLR) is more than a car company. In Portland, Oregon we operate the Open Software Technology Center (OSTC), where JLR Engineers take ideas and put them into the next generation of Jaguars and Land Rovers.

A unique state-of-the-art facility, the OSTC focuses on In-Vehicle Infotainment (IVI). Technology is a major driver of cars and the User Experience (UX), and the OSTC strengthens JLR’s technology focus through software development. Staffed by world-class technology innovators, connected and collaborating with the best minds worldwide, we strive to be the place where innovative consumer electronics become automotive grade.

We’re an important contributor to the Portland community, positively impacting local economic growth, bringing tech jobs to Portland and the automotive/transportation sector in Oregon. A good corporate neighbor in the Pearl District/Downtown, the OSTC supports local events and outreach programs to local education.

We also oversee the Tech Incubator, giving entrepreneurs the opportunity to develop their innovative new products and services with seed funding, space to work, and the support of JLR engineers and industry professionals.

• Steve Peters
• [email protected]

We parted ways from the normal format of this meetup last time, and instead of working on the problem stated, we ended up working on trying to get a relatively complex Erlang project (erl-dns) to build using only Elixir's build chain as well as added an Elixir module to the project to ensure that we could attempt to extend the project using only Elixir code.

This month we'll continue the games format, but instead of a contrived problem we'll continue down this path of modifying and contributing to an open source project.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided. There will also be small desk fodder prizes for the winning team.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Special thanks to my friend Jeff Weiss and Puppet Labs, ‘the leader in IT automation’, for hosting us.

James Aimonetti of 2600hz.com will be joining us tonight to talk about how Erlang powers the Kazoo project and Voice-over-IP products all around the world.

Kazoo is a scalable, distributed, cloud-based telephony platform that allows you to build powerful telephony applications with a rich set of APIs.

Designed to handle anything from large carrier to small countries, the Kazoo infrastructure can do it all. There are no lock-ins and the software is open-source to give you complete freedom.

James will be giving us a high level view of the architecture behind Kazoo, both from a platform perspective and from an Erlang perspective. We'll survey some of the code that is of interest, such as the gen_listener behaviour (for AMQP message consumption), the PropEr tests in various modules, the wh_json module for working with Erlang-encoded JSON objects), and more. No telecom experience required!

This month we'll be continuing down the path of analyzing and modifying a production-grade open source project. Last month many people who attended were able to discover where in erl-dns our custom zone-file handling code should go. This month we'll drive toward a real replacement implementation to take the next step toward being able to make incremental zone updates and pave the way toward DNS-SD functionality.

This month we'll continue the games format, but instead of a contrived problem we'll continue down this path of modifying and contributing to an open source project.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided. There will also be small desk fodder prizes for the winning team.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Special thanks to my friend Jeff Weiss and Puppet Labs, ‘the leader in IT automation’, for hosting us.

NOTE: Please RSVP via the meetup.com website, it helps for food and beverage planning.

Last month we had a really varied mix of experience levels in attendance, and so this month we'll cover a subject that will be useful to audiences and participants of all shapes and sizes... Dialyzer & TypeSpecs. Elixir isn't a statically typed language, but thanks to TypeSpecs and Dialyzer we can do static type analysis and avoid whole horrible classes of runtime errors by checking our code at compile-time.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Special thanks to my friend Jeff Weiss and Puppet Labs, ‘the leader in IT automation’, for hosting us.

Erlang On NixOS - Managing And Releasing Erlang Systems In The Cloud With A Fully Declarative Package Manager

In this talk we will discuss how to manage Erlang dependencies with the Nix package manager and how to use the Nix system to deliver declaratively described images containing an Erlang Release to cloud platforms.

Talk objectives:

To educate the audiance about the value of using a functional, declarative package management system to deliver functional, declarative systems.

Target audience:

Developers actively deploying Erlang systems and those interested in deploying Erlang System.

About Eric Merritt

Co-author of Erlang and OTP in Action, open source contributor, Erlang Engineer.

Elixir inherits a tremendous suite of debugging, tracing, and monitoring facilities from its Erlang pedigree, where the use case was something shaped like, "Be able to attach to, live trace, muck with, and live zero-down-time upgrade this service running on a thing dangling from a 10m pole in the backwoods of Siberia." In this month's meetup we'll take a look at some of these tools and use them to poke around some running services.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Special thanks to my friend Jeff Weiss and Puppet, ‘the leader in IT automation’, for hosting us.

The Elixir language and standard library is always in a state of diligent improvement, and in accordance with that trend GenStage was recently added. GenStage is a core generic behavior designed to provide a way of coordinating communication between processes with built-in back-pressure. This month we'll take a closer look at what this is, what problems its intended to solve, and exercise the functionality a bit to see how to use it for real-world-shaped problems.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Special thanks to my friend Jeff Weiss and Puppet, ‘the leader in IT automation’, for hosting us.

We've looked at Supervision trees in the past, but we've often glossed over how to best use them to your advantage. It's quite easy to accidentally use these fault-tolerance primitives to, somewhat ironically, make your applications less fault-tolerant. This month we'll take a look at design and implementation practices to help make sure you're using these incredible tools to your best advantage.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Special thanks to my friend Jeff Weiss and Puppet, ‘the leader in IT automation’, for hosting us.

This month we're going to take a look at the architecture of a couple open source Elixir libraries, talk about them, how they fit with OTP principles that Elixir inherits from the Erlang ecosystem, and devise a strategy for how to bring the existing design into line with a more OTP-y way of doing things. We'll also discuss why that's valuable or desirable and start to iterate on making those changes together.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Special thanks to my friend Jeff Weiss and Puppet, ‘the leader in IT automation’, for hosting us.

You’ve heard about Elixir’s and Phoenix’s scalabililty, performance and simplicity and how it can be used for websites, micro services, APIs and embedded IoT devices. But you may not be sure how to get started or if you’d enjoy it.

This is an informal hands on workshop to get people familiar with the basics of Elixir and Phoenix.

There is no charge to attend and all are welcome but space is limited so please register so that we plan accordingly.

Thanks.

This month Moxley Stratton from Househappy will present on some of the things they're doing at HouseHappy. In particular how they are using Elixir to synchronize PostgreSQL to Elasticsearch.

He'll include a discussion on a tool I wrote that lets you write totally dynamic queries for Ecto.

Pizza and beverages generously provided by our friends at HouseHappy!

• Steve

Elixir and Erlang make tremendous tools for integrating between different kinds of interfaces. In fact there's arguably no better system for quickly constructing reliable and fault-tolerant control planes available today. However, in order to do that in a rich ecosystem of technologies it is a requirement that we be able to interact with and orchestrate various kinds of external processes. So for this meetup session we're going to learn about exactly how to do that.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Special thanks to our friends at Puppet, ‘the leader in IT automation’, for hosting us.

Many developers are probably familiar with unit-testing, and probably a few even rigorously utilize it, but software validation exists on a spectrum ranging from formal verification to nothing at all. Unit-testing tends to reside a lot closer to the empty abyss side of that spectrum in-practice, so what methods and tools can we use to start inching (centimetering, for the internationally inclined) closer to the other side? To get to a point where we're brimming with confidence about our design and implementation? Property-Based Testing can be the next step on that journey, and this month we'll take a look at one of Elixir's PBT frameworks and use it to validate a bit of code.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Special thanks to our friends at Puppet, ‘the leader in IT automation’, for hosting us.

Bridging the gap between higher-level application development and embedded device deployments is all the rage these days. As is the case with the much of the rest of the Elixir ecosystem, there's a project to help make such ambitions a lot more friendly and inviting to work with (http://nerves-project.org/). This month we'll be taking a look at this project, explore a handful of similar alternative approaches to the same problem, and see if we can get some simple distributed Elixir applications running and communicating as Nerves apps.

If you have any of the supported hardware (referenced below), then by all means bring it with you and we'll see if we can get things working on real hardware. All the organizer's embedded SBCs are Odroid C2's, which aren't Nerves-compatible, so we won't be able to supply hardware for the whole group, but for those that don't have hardware to deploy to we can still build QEMU ARM images and run them in an emulated VM environment.

Supported Hardware:

https://hexdocs.pm/nerves/targets.html

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Special thanks to our friends at Puppet, ‘the leader in IT automation’, for hosting us.

Similar to traits in other languages, Elixir Protocols are contracts that modules can implement for enabling collections (both sinks and sources) and inspection. We'll take a look at Protocols, how to adhere to them and how to create them.

For the newcomers, the "Games" format is designed to create a bit of friendly competition and is accessible for all ranges of experience; beginners and pros alike.

If you'd like to take a look at the previous sessions' exercises feel free to check them out here: https://github.com/elixir-pdx/, some submitted solutions are available on non-master branches.

Early in this series we'll be focusing mostly on solving problems in a functional paradigm, and as the series continues over time we'll move more and more toward Elixir's differentiators; Erlang interop, hygienic macros, & OTP patterns.

If all that read like gibberish to you, don't worry you don't have to know any of that jargon, and by the time you do everything will already make sense. Because we'll introduce ideas and concepts in a way that will help you understand those things conceptually before you ever need a weird name for them.

Food and drinks will be provided.

Please make sure you come with a computer to work on and have Elixir pre-installed locally or in a VM and ready to go.

http://elixir-lang.org/install.html

Venue Change: Now at PolySync.

Jesse Cook will lead our exploration tonight.

Jesse: A beginner Alchemist who's really enjoying the functional nature of Elixir and the design of the language.

Description: Moving complexity around - What's the best way to provide a unified API in front of some of the worst APIs out there? The tools I reached for are Phoenix, Absinthe for GraphQL and a series of adapters. These adapters utilize both polymorphism and metaprogramming, but was this the right way to do it in Elixir? Let's discuss the overall architecture and the nitty gritty details.

The Portland Erlang and Elixir User Group's March meeting

The age-old trope of developers being lazy and never writing docs has some basis in reality. What can we do to use the code developers write to create documentation and other assets? I'm not talking about annotations or "special" code comments either - the actual code (well, the AST the compiler creates from the code).

With Kazoo, we have a growing userbase wanting to build their own functionality on top of the platform; yet our docs were lagging, out of date, all over the place, or simply non-existent. Come learn how we are taking docs seriously, jump-started the effort by exploiting patterns in our codebase to auto-generate docs and JSON schemas, and built controls into our CI to hopefully ensure the docs are maintained and up to date.

Bio: Having worked on Kazoo for 7+ years now, James Aimonetti has made it his mission to bring better docs to Kazoo's open-source and commercial users. He wants to spread the gospel to other developers and hopefully provide some ideas for how you can bring docs into your development culture too!

The Secure Remote Password Cryptor (SRPC) addresses mobile app security in a post web-app world. SRPC provides HTTPS quality security without the explicit transfer of trust inherent in using HTTPS with PKI. SRPC is immune to HTTPS Man-in-the-Middle issues and also provides many features out-of-scope for HTTPS.

SRPC requires a pair of libraries, one on the client device and one on the server. To create an easy way for mobile app developers to try SRPC, I've built a Erlang OTP system that acts as an SRPC tunnel to an "unaltered" HTTP server. The system is comprised of:

• srpc_lib: Low-level functionality
• srpc_srv: The SRPC protocol
• srpc_elli: An Elli layer to expose srpc_srv to an elli app

There are two optional pieces:

• srpc_elli_proxy: Proxies request to the "unaltered" HTTP server
• srpc_elli_lager: Lager module

Finally, I have a test system for testing the iOS framework (Android is underway):

• srpc_elli_test: Test implementation

Presented by Paul Rogers, an independent software engineer with many years of development experience across multiple platforms using a number of different computer languages. He has a Master of Science in Mathematics, which helps him dig into the internals of cryptography, and a Master of Science in Physical Oceanography.

This will likely be a small talk, with room for additional mini talks.

For the longest time, content management systems have been dominated by PHP projects like WordPress, Drupal, and the like. But for those of us who want to build a Phoenix website, our only recourse has been to build some sort of admin and implement content management from scratch.

Thesis provides an easily bolted on content editing system to your Phoenix website and provides a great developer and user experience. It works with your existing authentication system and database and is only a few lines of code to implement on your site.

Jamon Holmgren created Thesis originally for Rails and then recreated it for Phoenix along with Yulian Glukhenko. He’ll talk about what Thesis is and give a demo of implementing it onto an existing Phoenix website.

Doors open at 6:30, and the talk starts around 7. Pizza and drinks provided by Househappy

Doors open at 6:30. Talks start at 7:00.

Pizza, soda and beer provided by Weedmaps.

October's meeting will host a set of mini talks, up to 20 minutes each.

Talks:

• Paul Rogers:

EntropyString

• Zach:

Elixir Bot Server Frog and Toad

• Moxley Stratton:

Test mocks

Talks start at 7:00pm. Doors open at 6:30pm.

October will host a set of mini talks, up to 20 minutes each. We are requesting proposals for this now. Please send a direct message to Moxley if you're interested.

Pizza, soda and beers sponsored by Weedmaps.

Talks:

• Connor Clay: Testing strategies in Elixir

• Daniel Hedlund: DevDocs

• Andrew Vy: Elixir + Headless Chrome

• Moxley Stratton: Test mocks with "Mox"

Doors open at 6. Talk starts at 6:30.

This month, Connor Lay will talk about setting up a basic Continuous Integration pipeline for a new Elixir project. Let me know if that overlaps too much with any of the other topics and I can find something else :)

Moxley Stratton will talk about working with Elixir macros, specifically around building a wrapper around Ecto.Schema.

Pizza, sodas and beer provided by Weedmaps.

This month, Jesse Cooke (@jc00ke) will give his initial impressions of LiveView and an experience report of replacing a typical JS widget with LiveView.

Location: Yeon Building, 522 SW 5th Avenue, Suite 900 9th Floor at the end of the hall.

Note: Doors open at 5:30pm. Social time is 5:30-6:00. Lobby Doors lock at 6:00pm so please attempt to make it before then. The talks start at 6:00pm.

• What we'll do The monthly meeting is the primary event offered by Elixir PDX. It includes presentations given by local and remote Elixir and Erlang presenters.

• What to bring Yourself! A laptop sometimes comes in handy.

• Important to know Pizza and drinks are typically provided by one of our sponsors.

This month: Moxley Stratton and Mike Wilding will give a talk on using the Ecto.Changeset module to save associations along with their parent records.

Note: the talks start at 6:30pm. Doors open at 6pm. Social time is 6pm-6:30pm.

• What we'll do The monthly meeting is the primary event offered by Elixir PDX. It includes presentations given by local and remote Elixir and Erlang presenters.

• What to bring Yourself! A laptop sometimes comes in handy.

• Important to know Pizza and drinks are typically provided by Weedmaps.