The Wayback Machine - https://web-wp.archive.org/web/20161214012757/http://making.meetup.com:80/tagged/scala
Making Meetup • Posts Tagged ‘scala’

Scaladays NYC 2016

This year, Meetup had the honor of sponsoring Scaladays NYC as well as hosting the official conference afterparty. For those unfamiliar with Scaladays, it is one of the largest yearly Scala conferences, often held in multiple cities around the world. This year’s conference in New York City had over six hundred attendees and almost sixty talks spread across four tracks over the course of two and a half days. Needless to say, myself and four other Meetup engineers had blast attending the conf.

(Opening keynote by Martin Odersky)

Some of our favorite talks in no particular order include (but are not limited to):

  • Data Structures of the Dark Side by Shimi Bandiel (@shimib)

  • Roll Your Own Shapeless by Daniel Spiewak (@djspiewak)

  • Implicits Inspected and Explained by Tim Soethout (@TimSoethout)

  • DDD and Onion Architecture in Scala by Wade Waldron (@wdwaldron)

  • Scala Goes Native by Denys Shabalin (@den_sh)

Two personal favorites of mine were Domain Driven Design and Onion Architecture by Wade Waldron and Being Creative with Genetic Algorithms and Typeclasses by Noel Markham (@noelmarkham). In his DDD talk, Wade illustrated DDD concepts via ‘the domain of cooking an egg,’ and even shared some sample code (https://github.com/WadeWaldron/scaladays2016). Noel’s talk was more Scala-centric, and was focused on explaining typeclasses by implementing a fun genetic algorithm which attempted to recreate the Mona Lisa.

(Side note: If anyone is interested in genetic algorithms, there’s a fun race car simulation that can be found here: http://rednuht.org/genetic_cars_2/)

We also got to hear directly from some folks at Lightbend (formerly TypeSafe) and the École polytechnique fédérale de Lausanne (EPFL) who are helping push the boundaries of Scala development. I would highly recommend checking out EPFL’s Dotty project, which “is a platform to try out new language concepts and compiler technologies for Scala” (https://github.com/lampepfl/dotty). Other exciting projects that were presented at the conference included enhancements to Scala.js, a registry for Scala libraries, and also taking Scala native by providing memory management features to Scala developers (https://github.com/densh/scala-offheap). The EPFL also announced the launch of the Scala Center, a new initiative that will act as the open source foundation for Scala with representatives from both the community as well as industry.

And of course, no conference is complete without a popping afterparty, hosted at your’s truly: Meetup HQ. We were pleasantly surprised at the turnout and had a great time mingling and hearing about all the exciting things (Scala and non-Scala related) our peers in the tech community are pursuing.

(Yay party!)

We were even blessed by the attendance of Scala’s creator Martin Odersky, along with many other luminaries of the Scala community.

(Meetup + Martin Odersky + Friends)

If any of the above post was remotely interesting to you and you’d like to find out more about what we’re all about here at Meetup, check out these interviews with our engineers (http://making.meetup.com/tagged/hiring)!

NE Scala 2016

Towards the end of the first week of March, on March 4th and March 5th, Meetup put together a small team of engineers who volunteered to attend the 6th annual Northeast Scala Symposium in Philadelphia.

I am an engineer on Meetup’s Member Engagement team, building a system that delivers smart and personalized notifications to members on our platform. I am also a part of Meetup’s Core Engineering team, where we are using Scala a lot in order to build out our platform. Given my work and interest in Scala, I was one of the engineers who participated in the trip, and I’d love to share some of the things I learned during Day 2 of the event!

This was the first language conference I have ever attended and it was even more exciting to me, given that I only started working in Scala since I joined Meetup, almost 2 years ago, straight out of college!

Day 2

Day 2 was the unconference day and it started with a casual meeting, in which every participant who had something to present would take a timeslot on a spreadsheet, such that at the end of the meeting we had a relative schedule for the day. After this, everyone was free to go to whichever presentation was most appealing to them.

And off I went!

Early Morning Category Theory with (Rúnar Bjarnason)

Eager to learn more about Scala and the theoretical background behind it (and being a math nerd), I picked Category Theory as my first presentation to attend. I did not know much about what Categories are in Scala and what kind of rules govern these entities, but I went in excited to learn something new.

The talk started with an abstract definition of Categories as collections of objects and arrows (or maps/morphisms) that define relationships between the objects. These concepts seemed very familiar to me from those of Set Theory.

Rúnar went on into describing Functors (maps between Categories, that preserve their structure) and then explained what Monads, Monoids and Comonads were, while also doing some whiteboard Scala examples of all of this. These topics were necessary background needed in order to answer a question posed by someone in the audience:

Prove that List is a comonad in the monoid category of List

Using the information absorbed up to that point, we were able to follow a simple proof of the statement.

This was my first ever exposure to Category Theory and I loved it! Rúnar’s explanations made me dig more into it after the conference!

Scalaz-Stream Workshop with (Rúnar Bjarnason)

The second presentation I went to was also led by Rúnar Bjarnason, but this time it was very hands-on. He introduced us to a small IRC client & server built using scalaz-stream and everyone in the room had to implement a feature of their preference to add to it.

I went on trying to implement the ability to change nicknames while in a chatroom. The process of working with scalaz-stream and, implicitly, with scalaz was relatively new to me since I haven’t written pure functional code using scalaz before, but it was a really good experience to be exposed to both of these Scala libraries.

By the end of the workshop, my implementation ended up being somewhat functional :)

Living with SI-2712 with Daniel Spiewak

After a couple of other presentations, I got to my last presentation of the day. It was about a known Scala compiler bug and it involved a lot of live coding, type-level programming, category theory (d'oh) and just pure amazement.

The gist of the presentation was a proof of concept of the compiler bug and ways to get around it. It was very well explained and, even though the material got pretty intense towards the end, I enjoyed the deep dive!

Conclusions

I really enjoyed my time at NE Scala and learned a lot of new things, from theoretical aspects of Category Theory, to more applied concepts using pure functional scalaz. I am very excited for the next conference I’m going to attend (or even unconference, since Scala Days 2016 is approaching and will be in NYC :) )!

Plugging a leak

One of our trusty backend services developed a file descriptor leak a few months back. Every few days it would hit the process’s generous limit and fall over.

We looked and searched and searched for the bug. Part of the difficulty is that we didn’t have the best process monitoring (+ recording!) set up beforehand, so it wasn’t as easy as it should have been to identify exactly when the bug was introduced. So we read and re-read all the code changes to the affected service. And tried changing lots of stuff. None of it helped!

One thing that did happen around the time the problem started is we upgraded to Scala 2.10 – there’s a post about that! The older Scala actors library that we were still using was now deprecated, but we saw no immediate problems and left that migration as a future project.

But lacking any better ideas for fixing the file descriptor leak we decided to go ahead and migrate to the newer actors library – then we realized we didn’t need actors for this service at all. So instead we just removed the deprecated actors library. And then this happened.

Leak plugged

Bliss.

Measuring Scala 2.10

We upgraded from Scala 2.9.1-1 to 2.10.0 and it made some stuff faster.

Upper bound of response times

@softprops did the 2.10 upgrade in a branch a few weeks back with the minimal code changes it required. We were surprised at the time to see some improvements in our benchmarks. I was eager to see if those translated into measurable gains in actual performance.

The chart shows 24 hours of worst response times for one of Meetup’s backend services that uses Scala. Mostly, it operates on huge immutable collections. Last week’s timings under the Scala 2.9 regime are in purple, and this week’s timings under Scala 2.10 are in green. Week to week the request volume is basically the same.

So we’re seeing some nice improvements in performance from a painless upgrade. (In fact, a very pain-reducing upgrade, for Unfiltered routing.)

Thanks to all involved for the solid Scala 2.10 release.

Making Meetup Smaller For Bigger Meetup Events

Sometimes when you want to have a bigger impact you need less, not more. Meetup is full of lots of nice features to help make organizers’ lives easier. You may not realize this, but we roll them out all the time. Since most of these features apply to all events, every event page is full of ways for people to connect and organize. The downside to having many features is that it gets harder to make some content stand out from the rest.

Recently the Boston, Philly, and New York Scala enthusiasts broke from a huddle and decided to organize an East Coast Scala event. The event itself is organized through the New York Scala Enthusiasts meetup group but its attendees come from various affiliations. Many of potential attendees who might add great value to the event wouldn’t frequent the group’s calendar as often as I do, so I realized I needed a better way get the word out. I wanted to somehow make the event more visible.

Traditional Meetup event calendar pages tend to look the same for every event, making bigger events harder to stand out from the rest. Meetup everywhere event pages are a little less so, but everywhere events are about an event happening, well, everywhere. In my case, the event was only happening in one place.

Thankfully, we live in a wonderful world of APIs and free hosting solutions! Meetup has no shortage of APIs so I decided to use them to make a simpler event site and increase the event’s visibility.

The result was taking something fully featured like

Northeast Scala Symposium inside Meetup

and turning it into something fluffy like

Northeast Scala Symposium outside Meetup

With Meetup’s API this was pretty straightforeword via our rsvps and events methods. Even better, I got to use one of my favorite languages to do so. It’s worth mentioning the use of a great http client library called Dispatch that comes with a Meetup interface right out of the box. I was even able to give something back. Hosting was a given, Google App Engine makes versioned deployment effortless, and free :). After some spit shining all it needed was a name. Fortunately, a hero was able to step up and call its name.

The result of a weekend’s work was well worth it. nescala.org may actually turn into something bigger than just a single event, but for now, the size feels right. It’s hard to go wrong with minimal. There’s lots of areas for more integration with Meetup but for now I wanted to keep it simple.

In the future, I may integrate a polling feature. We actually used a service called doodle but I think we can do this better and with tighter Meetup integration.