Our April meeting will be a roughly 1-hour talk by local Rust expert Jim Blandy on Rust's ownership system. If you're newer to Rust, skim through the first sections of http://rust-from-a-scripting-background.readthedocs.org/en/latest/ and http://doc.rust-lang.org/stable/book/ before the talk to get your bearings.

We meet on the first Wednesday of every month, from 6-8pm, at Mozilla's Portland space.

Join us in #pdxrust on irc.freenode.net (http://webchat.freenode.net/) with any feedback about what you'd like to see!

Remember that Rust's Code of Conduct applies to this event.

This month's talk will cover some of the cool stuff you can do with Rust's type system. If you're totally new to Rust, skim the initial sections of http://doc.rust-lang.org/stable/book/ and http://rust-from-a-scripting-background.readthedocs.org/en/latest/ to get acquainted with Rust's basic purpose and syntax.

Are you a Rust expert? Have you played with Rust a bit and told yourself you really should write more code in it, but never made the time? Do you just like learning about cool new programming languages? If any of these apply to you, come to the PDXRust meetup to learn more and meet others with similar interests!

We meet on the first Wednesday of every month, from 6-8pm, at Mozilla's Portland space. The first hour is either lightning talks from group members or a more in-depth tutorial from a Rust expert, and the second hour is hacking and social time.

Join us in #pdxrust on irc.freenode.net (http://webchat.freenode.net/) with any feedback about what you'd like to see!

Remember that Rust's Code of Conduct defines the Rust community's expectations for participation.

Linux has powerful block device mapping capabilities that are used by tools such as LVM. Froyo is a new tool that uses these capabilities in a dynamic way to create a hassle-free, redundant storage volume that grows with your data. In this talk, Froyo's creator Andy Grover will discuss its implementation, with special emphasis on the Rust language features and libraries that it builds upon.

This talk will cover a lot about libraries (serde, dbus-rs, nix, clap), how Froyo uses lang & std features (BTreeMap, Rc, RefCell, filter_map), and Froyo's internal data structures & representation.

There will be 2 talks this month!

Rustdoc for Everyone:

You don't have to be a great writer to create great documentation. There are simple techniques and rules you can follow to build documentation for your users. Rust ships with documentation tools, but not all crates take advantage of them. Documentation is the first way that developers interact with your code - great documentation sets your crates apart, helps users skip easy questions, and cuts down on bug reports. In this talk, we will explore techniques for writing great documentation.

Speaker Jeremiah Peschka has been breaking software since 2000 - he's been told this sounds impressive, but he thinks it might just make him feel old. He blogs over at http://facility9.com and can be found on twitter and IRC as peschkaj. When Jeremiah isn't working with databases and Rust, he can be found playing video games, hanging out at food trucks, or napping at home.

Bridging Ruby and Rust:

Ruby is not the fastest language in the world, there is no doubt about it. This doesn't turn out to matter all that much – Ruby and its ecosystem has so much to offer, making it a worthwhile tradeoff a lot of the times.

However, you might occasionally encounter workloads that are simply not suitable for Ruby. This is especially true for frameworks like Rails, where the overhead wants to be as little as possible.

In this talk, we will explore building a native Ruby extension with Rust to speed up parts of Rails. What does Rust have to offer here over plain-old C? What kind of challenges would you run into when briding a dynamic langauge like Ruby with Rust? Let's find out!

Speaker Godfrey Chan is a member of the Rails core team and a co-author of Helix, a toolkit for implementing Ruby classes in Rust. He works at Tilde Inc, splitting his time between building Skylight and open-source consulting.

Other Information:

PDXRust meets on the first Wednesday of every month, from 6-8pm, at Mozilla's Portland space. The first hour is either lightning talks from group members or a more in-depth tutorial from a Rust expert, and the second hour is hacking and social time.

Join us in #pdxrust on irc.freenode.net (http://webchat.freenode.net/) with any feedback about what you'd like to see!

Remember that Rust's Code of Conduct defines the Rust community's expectations for participation.

We'll have 2 talks again this month!

Design Patterns in Rust:

Nick Cameron is a core contributor on the Rust language's language design, tools, and compiler teams. He's in town for RustConf, and will be sharing his talk on Design Patterns in Rust with us! Here's the abstract:

This talk will cover some of the common idioms and design patterns encountered when programming in Rust.We’ll work through simple idioms used in everyday programming for tasks such as object creation and customisation, resource management, and destruction. We’ll then cover more complex patterns often used in generic data structures and libraries. We’ll also discuss some of the underlying themes and why these idioms and patterns occur in Rust.

The talk will not assume previous experience with Rust. The audience will gain an understanding of programming with Rust and its strengths and weaknesses. For those learning (or intending to learn) Rust, the talk should provide a short-cut to intermediate and advanced programming skills.

Corrode: Automatically Translating C to Rust

C has been the de facto systems programming language for 44 years, which means an awful lot of useful software is written in that language. As excellent as Rust is, it doesn't have that inertia behind it. (Yet!) Rust has good FFI support for calling C functions, plus tools for automatically generating FFI bindings, which make much of that existing software usable for new Rust projects. Still, gaining Rust's full safety advantages requires rewriting existing C software in Rust, which is currently a manual, time-consuming, and error-prone process.

Corrode is a tool that aims to bridge this gap by automatically translating C source code to equivalent Rust. A Corrode-translated program is no safer than the original C was, but it gets the most tedious translation work out of the way so a programmer can focus on taking advantage of Rust's more advanced features.

In this talk we'll explore what Corrode does, and does not, do. We'll discuss interesting examples that will surprise most C programmers, while staying accessible to programmers in any language. We'll look at how Corrode has been tested: the most effective ways are methods not widely used with other software. And we'll evaluate Corrode's documentation and community-building efforts, to both show how you can contribute and suggest steps you might consider for your own projects.

Speaker Jamey Sharp is Corrode's initial author and a programmer experienced in a variety of languages including C, Java, Python, Haskell, and x86 assembly. He is new to Rust, compared to those languages, and Corrode grew out of his learning experiments. (The exercise has been very effective at finding odd corners of both C and Rust...) He recently completed a session as a Recurse Center resident, teaching advanced topics to diverse audiences of programming enthusiasts spanning every skill level, which he enjoyed tremendously.

Other information:

PDXRust meets on the first Wednesday of every month, from 6-8pm, at Mozilla's Portland space. The first hour is either lightning talks from group members or a more in-depth tutorial from a Rust expert, and the second hour is hacking and social time.

Join us in #pdxrust on irc.freenode.net (http://webchat.freenode.net/) with any feedback about what you'd like to see!

Remember that Rust's Code of Conduct defines the Rust community's expectations for participation.

We'll be offering three Rust training sessions, targeting different skill levels: Beginner, Intermediate and Advanced. You may take the morning Beginner session followed by the afternoon Intermediate session, but it is not appropriate to pair the Beginner and Advanced sessions.

Registration costs $199 per training.

Interested in learning about a new Rust network application?

Want to take a crack at hacking on the middleware?

Join us as we hack on Tokio!

Github: https://github.com/tokio-rs/tokio

We'll start promptly with a quick tutorial of Tokio.

Afterwards, we'll be working on Tokio clients, severs, and docs.

Food and drinks will be provided.

RSVP at https://tokiohacknight.splashthat.com/#rsvp

The first ever RustConf will be a gathering of both Rust's established community and its newcomers. We're excited to all get to spend time together, deep-diving into all things Rust.

Registration is required and costs $219.

This month we'll have teams of PSU students telling us how they used Rust in their senior capstone projects.

One is a flight controller, and the other is a formal verification system. If you'd like to know more about robots, proving software correctness, or just real-world applications of Rust, this is the meetup for you!

Other information:

PDXRust meets on the first Wednesday of [almost] every month, from 6-8pm, at Mozilla's Portland space. The first hour is either lightning talks from group members or a more in-depth tutorial from a Rust expert, and the second hour is hacking and social time.

Join us in #pdxrust on irc.freenode.net (http://webchat.freenode.net/) with any feedback about what you'd like to see!

Remember that Rust's Code of Conduct defines the Rust community's expectations for participation.

This is the last PDXRust meetup of 2016!

We'll be having lightning talks: Share anything about Rust that you've:

• Done recently

• Learned about and found interesting, or

• Want to learn about or get help with!

Remember, we follow the Rust Code of Conduct. No food is provided at the meetup, though you're welcome to bring food with you or head for dinner afterward with a group of new friends.

Tokio, backed by the Rust futures library, has a unique execution model. The talk will do a deep dive, explaining the context, rational, and how it is implemented

Tokio author Carl Lerche will  explain how the tokio-core reactor is implemented. Attendees will have an easier time following along if they've read Rust's beginner documentation, but no prior knowledge of Tokio or futures is required.

PDXRust does not provide food, though you're welcome to bring food with you or head to dinner with other Rustaceans afterwards. 

We follow the Rust Code of Conduct.

Come hack on Rust projects with us! Write your first Rust crate, contribute to an open source Rust project, team up with someone else on a cool new Rust tool, or even hack on rustc itself!

Lucky Lab has food and drinks and lots of open seating.

We follow the Rust Code of Conduct.

See you there!

PSU Computer Science professor Bart Massey has mentored a variety of capstone projects using Rust, as well as writing a variety of projects in the language. He'll tell us about some chess playing code that he wrote in Rust.

Food is not provided at the meetup, thoguh carts are nearby if you'd like to grab a bite before and many Rustaceans are in the habit of going to dinner together afterwards. Expectations for the meetup are set forth in the Rust Code of Conduct; contact any of the organizers if you have a concern.

Sorry for the late notice on this one -- Nick will be hosting a hack night with optional lightning talks for our September meeting.

Bart is back, this time to tell us stories and answer questions about 25 bite-sized pieces of Rust! 

Check out the code at https://github.com/BartMassey/advent-of-code-2016 if you'd like to put him on the spot with questions.

Bart also organizes some Portland State University Capstone projects, so if you're pondering where to find a team of eager Rustaceans who'll write open source code for university credit, he's the person to talk to.

As always, remember that you can request future meetup topics or volunteer to speak in the issue tracker: https://github.com/pdxrust/meetups/issues

Matthew will be sharing his journey with Rusoto, Rust's unofficial AWS SDK. He'll cover how Rusoto came about, what it's like working on it, and how it works as well as examples of how it can be used.

This month, Shea Newton will be presenting "Writing Software That's Safe Enough To Drive A Car!"

Autonomous cars run on software, and most of the microcontrollers in today's cars are programmed using C. We have found that even the best code checking for C does not protect against system-crippling errors - the kind of errors that could endanger the lives of future drivers. C is simply not the right language for safety-critical software, but what about Rust?

## Target audience

I'd like to try and keep this talk relatively high level. Examples of self-corrupting code may resonate more with developers who have written C but ideally the talk will apply to anyone interested in Rust and curious about the state of self-driving car technology.

------------------------------------------------------------------

We may also have time for lightning talks and socializing as well.

------------------------------------------------------------------

As always, we'll be following the Rust Code of Conduct: https://www.rust-lang.org/en-US/conduct.html

For our second online brown-bag, we will learn about Krustlet from Taylor Thomas!

"Come join me as I show you how to run WebAssembly on Kubernetes using the newly released Krustlet project. We’ll go over how it works, why it is important, and what its limitations are. As a bonus, we’ll go over why we used Rust and the ups and downs of using it with Kubernetes."