Blog » Conference: PolyConf 2014

Conference: PolyConf 2014

2014-10-31

I just finished PolyConf, a two-day "polyglot programing conference", and I'm really excited. There were a lot of really interesting talks so I want to share it all with you. Here are some of the things I saw:

• A guy from Wunderlist team talked about using 10+ different programming languages on production. Apparently they have a lot of microservices. Some interesting takeaways: if you write it, you run it (and that includes convincing other people to learn your language!); and a service should be simple enough so that (as a last resort) you will be able to recreate it in one day.

• Interesting talk about teaching programming to people with completely different backgrounds (e.g. humanities). Apparently you will struggle with lack of mathematical rigor and basics (such as computational complexity). On the other hand, you get a lot of "domain knowledge" when cooperating with them, and (not sure if that's a plus) they are much more willing to do repetitive tasks than us lazy programmers :)

• Very nice lightning talk about Commodore 64. The guy showed us a program in assembly: look, here is this program, it runs in a loop and does this animation. But then I take the address of this loop, and put it in an interrupt handler, and look! It still executes but I can type text at the same time! So we get asynchronous programming on an 80s machine.

• Translating stuff to JavaScript seems to be a hot topic. There was a talk by Haskell enthusiast about two projects: Fay, a Haskell-like functional language, and ghcjs (you can imagine what it does). The benefits are type-checking (including remote operations), same language on client and server, and being able to write async code in a monadic style (including combinators like "do these two things in parallel").

• Good insight from Elasticsearch guys that decided to make their HTTP API more accessible - they said that "clients are part of the distributed system" and decided to write the clients for their API in various languages as well, to ensure that the users will have a good experience with Elasticsearch. Then they were able to adapt one test suite to all these languages.

• A demo of immutable data structures in Clojure. You can have an immutable "vector" (internally a tree) that you can modify with a (small) logarithmic overhead, and keep both versions around, sharing the common parts. Sort of like Git. So for instance you can have an editor storing all versions of a file and effortlessly add undo-redo functionality. I really want to use all this to make a time-travel game sometime.

• An interesting but quite frightening talk from a manager in an "agile company" - a large Poznań-based Python software house (STX Next). Highlights: whole team in one room (nice!), there has to be a woman in every room (ok…), everyone uses time-tracking (uhh….), there are huge screens everywhere and every employee is on camera (get me out of there).

• A talk about NoSQL and domain-driven design. I think I undestand more about what the fuss is all about - it's not about being able to store amorphous, complicated JSONs, but the fact that value objects (e.g. price+currency pair) don't really make sense as database tables; and relational joins don't have to be the only way of representing relationships. (Well, also scaling.)

• Awesome coding session with a guy making snake game in ClojureScript (another language compiled for the browser). He was really excited about being able to hot-swap the code in browser without having to reload (and keeping the state), enthusiastic about Paredit mode in Emacs, and got everyone fired up about the technology. "Can I have two more minutes? I can make it eat berries in two minutes!"

• A talk about cross-platform Ruby being translated to all different technologies including Arduino and Objective-C on iOS. Also with a healthy serving of "hexagonal architecture" thrown in (write platform-agnostic code and write "adapters" for absolutely everything external). Sounded like too much of a good thing, to be honest…

• At the end, a great presentation of automated test generation by John Hughes of QuickCheck fame. He told us "don't write tests - generate them!" and presented the approach on several examples, ranging from a toy circular-buffer program in C to verifying huge amounts of code in automobile software based on a 3,000-page standard. We have a rudimentary tool here at Codility for challenges, maybe it's time to resurrect it?

And that's not even mentioning everything (there was also F#, some Rails Girls and PyLadies, a few more philosophical talks…) So all in all, a great conference that I'll definitely attend again next year.

I hope you enjoyed this write-up and feel encouraged to attend more events like that!