Rust core developer & Mozilla Research Engineer Tim Chevalier is giving an early preview of his OSBridge presentation "Rust: A Friendly Introduction". Come listen to Tim's talk & chow down on some pizza!

Full details on the Google Group:

https://groups.google.com/forum/?#!topic/pdx-rust/MCyuQDfB-F4

More about Tim's talk:

http://opensourcebridge.org/sessions/970

(RSVPs appreciated!)

Mozilla Research Engineers Jack Moffitt & Patrick Walton (possibly Brian Anderson too) are in town for OSCON & will be making an appearance to talk Rust!

Patrick will be giving us a talk & demo RE: his NES emulator sprocketnes, and Jack will be discussing the ways in which the Rust type system helps keep Servo developers safe from the pitfalls of parallelism.

Oh, and free beer & pizza for all :)

A Portland Oregon users group primarily for languages that compile to machine native format such as C, C++, and Assembly.

5:30pm Doors open, unstructured time.

6:30pm The MOS 6502 might be the most historically significant processor for one reason: It fueled the PC revolution. You have probably used a device with a 6502, and maybe even programmed one, but do you know the historical context for it and what made it successful? This talk briefly covers the following aspects of the 6502: the events that lead to its creation, the elegance of the design, and the lessons we can learn from its success.

Speaker Bio: Jason Dagit is a research engineer at Galois. He received a M.S. in Computer Science from Oregon State University in 2009. He has been active in the Haskell community since 2005 and he is currently a member of the Haskell.org committee. His areas of interest include functional programming, computer graphics, and most recently hardware design. He enjoys working in the space between pure research and industrial practice.

7:30pm Popcount as an Example Of Microbenchmarking in C

Quickly determining the number of 1 bits in a binary machine word, the so-called "popcount", has always been an interesting problem for developers. Popcount is useful in applications ranging from cryptography to games, so it is worth trying to optimize. In this talk, I will report on a number of different popcount algorithms and their C implementation performance, in the context of a "microbenchmarking" framework custom-built in C for this purpose. I will also explore the pitfalls of C in microbenchmarking and the issues, problems and relevance of microbenchmarking in general.

Speaker Bio: Bart Massey got his B.A. in Physics from Reed in 1987, having learned C while he was there. After a couple of years writing C code at Tektronix, Inc. Bart attended University of Oregon, where he received his MSCS in 1992 and his Ph.D. in 1999. For the past 14 years, he has been a Computer Science Professor at Portland State University. He still writes more C than he cares to admit.

8:30ish pm Head to an elevator. People might go someplace to continue chatting.

ARRIVING BY BIKE?

Cyclists are welcome to park their bikes in the New Relic office. Bikes are not allowed in the building lobby, however, and must use the freight elevator. To get your bike up to the 28th floor, enter the building's parking lot by going down the ramp at 5th and Pine. Go past the booth -- no need to pick up a ticket -- and turn right. Go straight until you almost run into the elevator lobby, then go right again. On the back side of the elevator block you'll see a beat up pair of double doors marked "freight elevator." You can get up by buzzing in with the intercom, and saying you're here for New Relic. Ride on up to the 28th floor, you'll easily find the bike parking.

A Huge thanks to New Relic for providing the venue and food.

Thanks to O'Reilly for sending books.

Come and listen to some guy ramble about the innards of the Rust compiler. Free beer & pizza for all!

First talk at 7PM, come early to hack, or network

• 7pm Title: Restoration of a simulator of one great machine on another.

Abstract: Gordon Bell described Seymour Cray as the greatest computer builder that he knew of as demonstrated by his designs and their successors that operated at the highest performance for over 30 years. Bell was from DEC, Cray from CDC, two routine producers of beautiful architectures. I programmed both. In this talk I will review the restoration of my work based on the patterns widely used in assembler of the time. This itself is an innovation in restoration and well suited to the modern web.

Bio: Ward Cunningham has worked for and consulted to daring startups and huge corporations. He has served as CTO, Director, Fellow, Principle Engineer and Inventor. He is best known for creating wiki. He leads an open-source project rebuilding wiki to solve more complex sharing situations addressing some of societies toughest problems. Ward founded movements in object-oriented, agile software, extreme programming and pattern languages. Ward lives in Portland, Oregon and works for New Relic, Inc.

• 7:30pm Title: Building Things With SDL" (Simple DirectMedia Layer) http://www.libsdl.org/

Abstract: An overview of the Simple DirectMedia Layer and some of the things you can do with it and basic howto bits.

Bio: Jason ChampionJason Champion, Software Mad Scientist.

First talk at 7PM, come early for networking, or hacking.

Introduction to Splay Trees

What, why and how they can be used. I'll go over how splaying works, how we use it in OlegDB, why it can be a better choice than binary trees for certain situations and how the splaying algorithm can/can't be applied to other kinds of trees.

Quinlan Pfiffer: OlegDB coauthor

x86 machine language programming in the bash shell

Compilers, and assemblers are seemingly magical programs that turn text into something the CPU can process directly. I decided the best way to demystify things was to implement my own solution.

Daniel Johnson: pdxbyte founder, and full stack technology generalist

PDX Rust is a local user group for Rust developers as well as those curious about it. We are welcome to all skill levels, whether you've hacked on core or you haven't even installed rustc yet, come along, learn and share knowledge!

Yehuda Katz will likely be speaking about Rust 1.0. Remaining time will be used for group discussion or for folks to break off a bit and work on projects.

PDX Rust is a local user group for Rust developers as well as those curious about it. We are welcome to all skill levels, whether you've hacked on core or you haven't even installed rustc yet, come along, learn and share knowledge!

Speaker is Zack Pierce on "Rust for Java devs": https://github.com/ZackPierce/rust_for_java_devs

abstract: Jesse has been using Rust to write a PAM module. He will tell us about what he has learned about working with Rust, and about getting Rust’s lifetime-checking to mesh with external C functions.

bio: Jesse Hallett is a research engineer at Galois. He has extensive experience in web and high-level programming; but has only recently ventured into system programming. It has been said that Rust makes system programming accessible to people who wouldn’t touch C++ with a 12-foot pole. Jesse is one of those people. And he is interested in talking about how Rust helps him to access a wider world of programming.

Come celebrate the launch of Rust 1.0!

Whether you are a new Rustacean, or have been around long enough to fondly remember the ~ sigil, come on out and celebrate!

We will be having 5 minute lightning talks, so feel free to come with one prepared! The talks will explain the power of Rust, how to work in a rustic style, point out common libraries, and current projects and more.

Thanks to Mozilla for the food and refreshments!

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've tentatively scheduled the meetup for the first Wednesday of every month, from 6-7pm. September's meeting will be at Mozilla's Portland space.

What will happen at the meetup? Good question! That's largely up to attendees: What do you think would help you level up your Rust skills most effectively? Current ideas include talks from crate and product authors explaining how and why they implemented their projects in Rust, lightning talks about whatever interesting Rust-related things you've learned since the last meeting, peer code review time, and of course plain old hacking sessions to sit down and work on your Rust project in a room full of people who can help you make sense of the compiler errors that it generates.

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

Alternately, drop your questions and ideas into https://etherpad.mozilla.org/pdxrust-September2015ideas .

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

Logistics:

Parking near the building can be scarce. The Mozilla office is close to the 11th&Couch stop and 10th&Couch stop on the NS streetcar line, and within walking distance of several bus lines. Covered bike parking is available in the courtyard that you cross to get to Mozilla's building, across from the Peet's Coffee and Tea seating area.

The building is mostly wheelchair-accessible, in that there are no unavoidable stairs and the outside door has an automatic opening switch. Restroom doors on the 3rd floor and Mozilla office door are not automatic.

Food is not yet planned for the event. If your company would like to sponsor food for the meeting, let edunham know ([email protected], or IRC).

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!

This meetup occurs on the first Wednesday of every month, from 6-8pm.

October's meeting will be at Mozilla's Portland space.

What will happen at the meetup? Good question! That's largely up to attendees!

We start with 30-50 minutes of lightning talks from anyone who:

• Has built something in Rust that they want to share,

• Wants to build something in Rust and is seeking feedback and collaborators, or

• Has learned something cool about Rust that they think would be useful to others.

After the lightning talks, we have about an hour of hack time so you can sit down and work on your Rust project in a room full of others who enjoy the language.

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.

Logistics:

Parking near the building can be scarce. The Mozilla office is close to the 11th&Couch stop and 10th&Couch stop on the NS streetcar line, and within walking distance of several bus lines. Covered bike parking is available in the courtyard that you cross to get to Mozilla's building, across from the Peet's Coffee and Tea seating area.

The building is mostly wheelchair-accessible, in that there are no unavoidable stairs and the outside door has an automatic opening switch. Restroom doors on the 3rd floor and Mozilla office door are not automatic.

Food is not yet planned for the event. If your company would like to sponsor food for the meeting, let edunham know ([email protected], or IRC).

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.

Join us for the June meeting of PdxDevOps.

Agenda:

Speaker: Chris Roberts

Topic: SparkleFormation and orchestration APIs

Summary: SparkleFormation is a Ruby based DSL to programmatically build templates for cloud orchestration APIs. It even has a companion CLI tool for interacting with remote providers. This talk will give a brief history on how SparkleFormation came into existence, its evolution to becoming the library and application it is today, and an overview of the things possible with SparkleFormation. Once a common foundation has been laid, we'll dive in a bit deeper to examine some non-trivial use cases touching on nesting, graphing, planning, cross provider support/interactions (AWS CFN isn't the only rodeo in town), integrating Serverspec via callbacks, and how sparkle packs can delegate infrastructure composition across teams. If there's still time and interest after all this, we can touch on why CFN is currently the best orchestration API, why CFN sucks, what's great and horrible about other orchestration APIs, why you should have an "infrastructure repository", the absurdity of humans composing documents in serialization formats, and anything else people want to talk about.

Speaker: Eric Maxwell

Summary: Eric will take us through chef's new offering: Habitat. Habitat is written in rust. Habitat is a new approach to automation that focuses on the application instead of the infrastructure it runs on. With Habitat, the apps you build, deploy, and manage behave consistently in any runtime — metal, VMs, containers, and PaaS. You'll spend less time on the environment and more time building features.

pdxdevops is a Portland, Oregon user group that explores the glorious intersection of software development and systems operations, and shares practical advice on working effectively in an era of agile infrastructure, server automation and cloud computing. The group welcomes participants interested in any related products, technologies and methodologies. The group has been meeting regularly since August 2010 for presentations, demos and discussions applicable to all skill levels, from newbies and experts. Every month 15-35 people come together to share their knowledge, projects and enthusiasm for devops – join us!

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.

Join us for the July meeting of PdxDevOps.

Agenda:

Speaker: Jason Yee

Topic: Data-driven Post-mortems

Henry Ford once said, “The only real mistake is the one from which we learn nothing.” So how can we learn the most from system failures? This session will move beyond “blameless” post-mortems & show how we can use data to avoid & mitigate future failures.

pdxdevops is a Portland, Oregon user group that explores the glorious intersection of software development and systems operations, and shares practical advice on working effectively in an era of agile infrastructure, server automation and cloud computing. The group welcomes participants interested in any related products, technologies and methodologies. The group has been meeting regularly since August 2010 for presentations, demos and discussions applicable to all skill levels, from newbies and experts. Every month 15-35 people come together to share their knowledge, projects and enthusiasm for devops – join us!

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.

abstract: In 2015, a language based fundamentally on substructural typing–Rust–hit its 1.0 release, and less than a year later it has been put into production use in a number of tech companies, including some household names. The language has started a trend, with several other mainstream languages, including C++ and Swift, in the early stages of incorporating ideas about ownership. How did this come about?

Rust’s core focus is safe systems programming. It does not require a runtime system or garbage collector, but guarantees memory safety. It does not stipulate any particular style of concurrent programming, but instead provides the tools needed to guarantee data race freedom even when doing low-level shared-state concurrency. It allows you to build up high-level abstractions without paying a tax; its compilation model ensures that the abstractions boil away.

These benefits derive from two core aspects of Rust: its ownership system (based on substructural typing) and its trait system (a descendant of Haskell’s typeclasses). The talk will cover these two pillars of Rust design, with particular attention to the key innovations that make the language usable at scale. It will highlight the implications for concurrency, where Rust provides a unique perspective. It will close out with a discussion of Rust’s development process and design considerations around language and library evolution.

bio: Aaron Turon is Research Engineering Manager for the Rust team at Mozilla. He received his PhD from Northeastern University, where he studied programming language design, program verification, and low-level concurrency. His dissertation was awarded the SIGPLAN John C. Reynolds Doctoral Dissertation Award in 2014. After his PhD studies, he continued his research in concurrency verification and programming techniques as a postdoc at MPI-SWS. He joined Mozilla in 2014, and has played an active role in Rust’s development since then.

Join us for the Feb meeting of PdxDevOps.

Agenda:

Speakers:

Name: E. Dunham (https://twitter.com/QEDunham) Topic: Automating more of the things

One aspect of DevOps is that one person can accomplish multiple peoples' worth of work by delegating tasks to other people or systems. I'll introduce you to some of the systems that the Rust and Servo developers delegate community management tasks to, and show you how they can be useful in more conventional settings.

edunham is the "DevOps Engineer" for Mozilla Research.

Jesse Dearing (https://twitter.com/JesseDearing)

Topic: Failure and RCAs: A Love Story
I love failure! I don't love to bathe in the tears of engineers but I love understanding how the systems that run our world fail. Everything from a failed hardware component to a human mistake. I love reading RCAs like murder mysteries. I will cover failure, how to learn from it, and preventing it. I will cover tools, processes, and techniques for reviewing and learning from failure without making people cry.

Jesse Dearing is a Lead Site Reliability Engineer at InVisionApp where he wrangles databases and builds tools to manage them. Jesse likes to learn how languages connect to other systems. Jesse likes making everything a Bash one-liner and is his own chaos monkey as a result. When he's not picking apart systems and automating them, he enjoys riding bikes, reading, and spending time with family.

pdxdevops is a Portland, Oregon user group that explores the glorious intersection of software development and systems operations, and shares practical advice on working effectively in an era of agile infrastructure, server automation and cloud computing. The group welcomes participants interested in any related products, technologies and methodologies. The group has been meeting regularly since August 2010 for presentations, demos and discussions applicable to all skill levels, from newbies and experts. Every month 15-35 people come together to share their knowledge, projects and enthusiasm for devops – join us!

For the first PDXRust of 2017, Rust Bindgen [1] hacker Nick Fitzgerald will explain how to get the rest of the world talking to Rust!

There'll be plenty of time for questions and meeting other local Rustaceans, as well.b

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.

[1] https://github.com/servo/rust-bindgen

No main talk today, so we'll have some opportunities to share neat Rust things and then time to work on your code, get help, and help others.

Rustaceans of all levels of experience are welcome to attend!

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

Abstract: Rust is a new systems programming language that promises to overcome the seemingly fundamental tradeoff between high-level safety guarantees and low-level control over resource management. Unfortunately, none of Rust’s safety claims have been formally proven, and there is good reason to question whether they actually hold. Specifically, Rust employs a strong, ownership-based type system, but then extends the expressive power of this core type system through libraries that internally use unsafe features. In this work, we present RustBelt, the first formal (and machine-checked) safety proof for a language representing a realistic subset of Rust. Our proof is extensible in the sense that, for each new Rust library that uses unsafe features, we can say what verification condition it must satisfy in order for it to be deemed a safe extension to the language. We have carried out this verification for some of the most important libraries that are used throughout the Rust ecosystem. In the talk, I will first review some of the essential features of Rust, and then explain some of the key ideas behind the RustBelt verification.

Bio: Derek Dreyer is a professor of computer science at the Max Planck Institute for Software Systems (MPI-SWS), and recipient of the 2017 ACM SIGPLAN Robin Milner Young Researcher Award. His research runs the gamut from the type theory of high-level functional languages, down to the verification of compilers and low-level concurrent programs under relaxed memory models. He is currently leading the RustBelt project, which focuses on building the first formal foundations for the Rust programming language. He also knows a thing or two about Scotch whisky.

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.

"Office hours"-style project night with focus on Rust beginners, no experience necessary.

Bring your own project, help someone else with theirs, or start with compiling your first "Hello World!".

Entrance is on North Interstate across from the Lombard MAX station. Street-side parking available. Doors will be open 6-8pm.

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

Bring a laptop, bring a project, and let's hack on something at the Lucky Lab!

Join your comrade Rustaceans at the Portland Rust Hack Night!

An evening of Rust hacking and unstructured discussion at Mozilla's Portland office. All welcome, from beginners to experts.

This month's speaker: Josh Stone (@cuviper)

Rayon is a Rust crate for writing parallel computations beautifully and safely. If you've got a computation written as an iteration, just change .into_iter() to .into_par_iter(), and Rayon will take care of distributing and balancing the load across your machine's processors automatically. But wait! There's more! Rayon covers other patterns of parallel computation as well.

Josh is one of the main contributors to Rayon, and it's a privilege to have him present for us.

Join your comrade Rustaceans at the Portland Rust Hack Night!

An evening of Rust hacking and unstructured discussion at Mozilla's Portland office. All welcome, from beginners to experts.

Among other things, we'll have a show of hands for people looking for help on Rust projects, and people interested in volunteering on a project, to see if we can't pair some folks up. If you've got a project, now's the time to get it into shape for collaboration!

This month’s speaker: Erik Nordin (@ObliqueMotion)

Tonight we'll take a look into Rust’s most straightforward smart pointer, Box, examining some practical scenarios in which Box is extremely useful and often necessary. Though the overall focus will be on Box, we will touch on other subjects like generics, trait bounds, iterators, enums, structs, and more. Bring a laptop and join us for this beginner-friendly follow-along-style presentation with live coding. All are welcome. It will be “heaps” of fun!

Erik Nordin is a CS student at Portland State University (PSU). He is finishing his last two school terms and graduating with a B.S. in Computer Science this December. Erik first started programming in Rust exactly one year ago when he took Bart Massey’s summer Rust course at PSU.

Join your comrade Rustaceans at the Portland Rust Hack Night!

An evening of Rust hacking and unstructured discussion at Mozilla's Portland office. All welcome, from beginners to experts.

Among other things, we'll have a show of hands for people looking for help on Rust projects, and people interested in volunteering on a project, to see if we can't pair some folks up. If you've got a project, now's the time to get it into shape for collaboration!

There will be food! Let us know beforehand if you have any dietary restrictions.

[Note unusual date: this is the second Monday of September, not the usual first Wednesday!]

Sometimes programming Rust can feel like serious business. Let's reject the absurdity of the real world and slip into solipsism with generative art. How does Rust hold up as a paint brush? And what can we learn when our fantasy worlds bleed back into reality?

Nick Fitzgerald will lead us on a tour of his explorations of the world of generative art. There may even be some live art improv with audience participation, and a live plotter demo!

Join your comrade Rustaceans at the Portland Rust Hack Night!

An evening of Rust hacking and unstructured discussion at Mozilla's Portland office. All welcome, from beginners to experts.

Among other things, we'll have a show of hands for people looking for help on Rust projects, and people interested in volunteering on a project, to see if we can't pair some folks up. If you've got a project, now's the time to get it into shape for collaboration!

There will be food! Let us know beforehand if you have any dietary restrictions.

Join your comrade Rustaceans at the Portland Rust Hack Night!

An evening of Rust hacking and unstructured discussion at Mozilla's Portland office. All welcome, from beginners to experts.

Among other things, we'll have a show of hands for people looking for help on Rust projects, and people interested in volunteering on a project, to see if we can't pair some folks up. If you've got a project, now's the time to get it into shape for collaboration!

There will be food! Let us know beforehand if you have any dietary restrictions.

Join your comrade Rustaceans at the Portland Rust Hack Night!

An evening of Rust hacking and unstructured discussion at Mozilla's Portland office. All welcome, from beginners to experts.

Among other things, we'll have a show of hands for people looking for help on Rust projects, and people interested in volunteering on a project, to see if we can't pair some folks up. If you've got a project, now's the time to get it into shape for collaboration!

There will be food! Let us know beforehand if you have any dietary restrictions.

This month's speaker: Russell Cousineau (@rcousineau on GitLab)

Learn about Rust macros by example. We'll learn what kinds of macros exist in Rust and how they work. Then we'll build a really simple declarative macro, followed by a really simple procedural macro. To wrap up, we'll dissect some macros in the wild!

Join your comrade Rustaceans at the Portland Rust Hack Night!

An evening of Rust hacking and unstructured discussion at Mozilla's Portland office. All welcome, from beginners to experts.

Among other things, we'll have a show of hands for people looking for help on Rust projects, and people interested in volunteering on a project, to see if we can't pair some folks up. If you've got a project, now's the time to get it into shape for collaboration!

There will be food! Let us know beforehand if you have any dietary restrictions.

There's a wild world of C software out there just waiting to serve a Rustacean's needs, but the terrain can be rocky and unfamiliar. Even if you're already comfortable with Rust, C, or both, wrapping C libraries with FFI can be tricky to navigate.

This month, Owen Nelson (@theomn) will recall some of the sights he saw on his recent visits to the C-Side. Hopefully, once you've seen some snapshots of the local landmarks, you'll be encouraged to take a trip of your own!

Join your comrade Rustaceans at the Portland Rust Hack Night!

An evening of Rust hacking and unstructured discussion at Mozilla's Portland office. All welcome, from beginners to experts.

Among other things, we'll have a show of hands for people looking for help on Rust projects, and people interested in volunteering on a project, to see if we can't pair some folks up. If you've got a project, now's the time to get it into shape for collaboration!

There will be food! Let us know beforehand if you have any dietary restrictions.

WASM (Web Assembly) is a web standard that run in almost every browser. Shaun Savage will show a project that integrates wasm-pack with VuejJS. He will explain what WASM is, how to use wasm-pack to compile Rust into WASM, how to interface WASM to JavaScript, and finally some tricks in to how to speed up Rust/JS communication.

Join your comrade Rustaceans at the Portland Rust Hack Night!

An evening of Rust hacking and unstructured discussion at Mozilla's Portland office. All welcome, from beginners to experts.

Among other things, we'll have a show of hands for people looking for help on Rust projects, and people interested in volunteering on a project, to see if we can't pair some folks up. If you've got a project, now's the time to get it into shape for collaboration!

There will be food! Let us know beforehand if you have any dietary restrictions.

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."

Meet up with fellow Portland-area Rust programmers, give a lightning talk on your own project, find something interesting to collaborate on, or just enjoy talking shop with your fellow Rustaceans!

This is our first meeting since the pandemic! (Remember the pandemic?) We don't have any big topics planned to present, so this will just be a hack night. Brainstorming talk ideas for future meetups is definitely on topic.

Kindly hosted by Portland State University, we'll be meeting in Computer Science Conference Room FAB 086-01. Calagator has an entry for this venue: https://calagator.org/venues/202394217

(I'm a bit unclear on the security details; we may have someone at the door to let people in, in which case arriving late might be difficult, since we'd of course like that person to come down and join the group eventually. When I have more details I'll update this. -JimB)