PolyConf is a three-day, single track, multi-disciplinary conference on advanced technologies for programmers interested in polyglot approach to software development.
Code of Conduct
Contact Organizers
Contact Organizers
About
PolyConf is a three-day, single track, multi-disciplinary conference on advanced technologies for programmers interested in polyglot approach to software development
Important dates:
CFP closes: Mar 13, 2016
Community voting: Mar 20 - Mar 31th, 2016
Speaker notification: Apr 3, 2016
Conference: June 30 - July 2, 2016
Speaker benefits:
Free admission to the conference
Up to 3 nights at the conference hotel
We cover the travel cost up to 256 EUR in Europe / up to 1024 EUR outside Europe
If your company or employer covers your travel and accommodation costs then it will be added as a Bronze sponsor on the website
Sessions are 30 minutes long (including Q&A). Workshops are 4 hours long.
The hypothesis of linguistic relativity says that the languages we speak influence the way we think. I argue this applies to programming languages too. However, key differences between spoken languages and programming languages enable us to adapt and shift our ways of thinking more fluidly as we learn programming languages than as we learn spoken languages. We can and should leverage these differences to grow individually as programmers and further advance our favorite programming languages.
They bridge your application and your database. They're object-relational mappers, and no two are alike. Join us as we compare ActiveRecord from Rails with Ecto from Phoenix, a web framework for Elixir. Comparing the same app implemented in both, we'll see why even with two different frameworks in two different languages, it's the ORM designs that most affect the result. This tale will teach you how to pick the right ORM for your next project, and how to make the best of the one you already use.
Owning Ownership: How Thinking About Ownership Prevents Bugs
Sean Griffin,Committer to Ruby on Rails, Maintainer of Active Record, Creator of Diesel
Every function or method we write in any language has some hidden semantics. Who owns the values passed in? What am I allowed to do with the values returned? In 2015, Mozilla released the Rust programming language, which brought to the table ways to represent these "ownership" semantics in programs. In this talk, we'll take a deep dive into how thinking about ownership can help keep defects out of our programs, regardless of language.
Workshop on how to prototype static front end page (with some bonuses) using ClojureScript and React.js combined in the package of Reagent/Re-frame ClojureScript libraries. I would like to show, that for fast and loose prototypes, ClojureScript ecosystem could be easy win.
Prerequisites: computer with Leiningen installed, urge to have fun and learn something new.
Elm is a functional, statically typed language where all values are immutable.This provides a much more robust system that's also much easier to work with than the JavaScript equivalent. Elm encourages separation of code into modules and protects you from runtime errors with a smart compiler that's able to catch most errors before they happen. In this talk I'll introduce the Elm and demonstrate why I think Elm is something all JS developers should be paying attention to.
This talk will explore languages, programming, tools, and complicated connections between all of them. We will try to look at expanding possibilities that current technology gives us, with focus on new areas and uses for programming. We'll approach language not only as a tool for creative expression, but also constraint on the way we think.
Andreas Rumpf,Senior Software Engineer at Metatexx GmbH
Nim is a quite unique programming language that focusses on meta programming by giving you one of the most powerful macro systems. In this talk we will look at how Nim's macro system gives us a high performance asynchronous IO framework. In other words what is usually built into a language core can be an ordinary library extension in Nim.
This talk is dedicated to lessons we’ve learned while designing, developing, and deploying to production our very first Erlang project. Erlang and, even more importantly, its underlying virtual machine have challenged our methods of building systems in our primary language at stylefruits, Clojure. I’ll use our new Erlang-based project as a source of concrete examples and differences. Join me and discover how the rock-solid Erlang platform can affect the way you structure your systems.
We're a development team working on B2B healthcare applications written in Clojure. As an experiment, we put started to use the Datomic database for some small-scale production applications in early 2015. Over the course of a year, we've gathered more experience with using Datomic, learned to appreciate its features and hate its weaknesses. In the talk, I will show some usage patterns and techniques that are enabled (or enforced) by Datomic's architecture and feature set.
When software grows in complexity due to complex requirements, managing concurrent modifications between modules becomes an important challenge. Two general strategies are applicable: passive and reactive. In this talk we will see when each strategy is advantageous, and how the reactive strategy is a sensible default.
Max Stoiber,Developer Advocate for OSS at Thinkmill
React is great to build applications with, but hard to build big applications with. Making sure your setup is top notch from the very beginning is essential to avoid a lot of technical debt later on.
Utilizing the amazing tools at our disposal, the best architectural foundation possible and leveraging current best practices, we'll showcase how to start and finish your next project the right way.
Elm is a new programming language based on the idea of Functional Reactive Programming (FRP). Elm lets you create highly interactive web applications without all the messy callbacks tangling around shared states.
In this talk Yan Cui will give a gentle introduction to Elm and share his experience learning Elm and creating a game of Snake in under 15 mins!
In this session, I will demonstrate the same thing in Ruby, Perl, Python and Node - a simple backend API with a javascript front end. I will use appropriate libraries and idioms in each of the languages, with the goal of teaching attendees how to parse what's happening in code they are seeing, regardless of language.
codebeat.co is a hosted static analysis tool for multiple languages. We've come a long way in terms of how we analyse source code - from wrapping open-source libraries to writing our own language-specific analysers to writing language-agnostic analysers. In this talk we will cover the idea behind abstract ASTs and how they allow us to quickly add support for new languages.
With libraries like Mirage, `js_of_ocaml`, & ARM compiler output OCaml apps can operate at such a low level we don't even need operating systems on the backend anymore (removing 15 *million* lines of memory-unsafe code) - while at the same time, writing UI's is easier & more reliable than ever before, with lightweight type-checked code sharing between server, browser clients, & native mobile apps.
We'll look at what's enabled by new tech like Unikernels, efficient JS/ARM output, & easy host interop.
When developing a new product, developers are naturally attracted to using the newest technology: Node! Go! Clojure! React! Elixir! Mongo! Dynamo! But is that really a wise choice? This talk will share experiences from building products with the latest and greatest technology stacks and the risks it brings to the project.
We just released our iOS app built with Clojurescript on top of React Native in the App Store. YOLO tech or solid like a rock!? An experience report on building for iOS with Clojurescript.
This talk will introduce Oden, an experimental, statically typed, functional programming language built for the Go ecosystem. We will look at how Oden aims to leverage the great features of Go — static linking, cross-compilation, goroutines, channels and the great set of libraries and tools — and enable higher-level abstractions, generics and a safer yet more flexible type system.
Skynet, er, frameworks have taken over the world. With the help of the Terminator you will learn how to stabilise humanity again. Or at least to stabilise your understanding of object-oriented JavaScript.
Learn the difference between class-based OO languages and prototypal languages. Understand why it is worth learning the prototypal way of doing OO and how it can help you write cleaner and simpler code.
Clojure 1.9 will ship with a new standard library: clojure.spec. It provides an extensible syntax for specifying the shape and domain of data. It allows instrumenting functions and macros, so user errors are spotted earlier, and result in better error messages. The real kicker is that specs can form the basis for generative testing.
A lot of us got introduced to object-oriented programming when we first learned how to program, and some (if not all) of us kept using object-oriented languages for school/work. Functional programming paradigm produces more readable and reliable code, and Julia will introduce some of the ways to make learning functional programming easy.
Functional programming didn't enter our homes with full power, although, you could tell it's trying. We'll look at simple functional concepts, which can be used as fresh method of looking at old problems, e.g., code duplication, error handling and control over side-effects. I hope to convince you, that with functional thinking it's easier to handle the code complexity and you won't have to sacrifice your effectiveness. Examples in Java, Scala and Haskell.
HTTP server software can be seen as commodities today; it's not often one has to go deep down the stack and fully understand and appreciate what makes up the Web protocol. This session will present the Lwan project, an experimental HTTP server project that has gained some notoriety after serving over 2.2M JSON objects/second in the TechEmpower Web Framework Benchmark. In this highly technical talk, the author will go through the project's history and how a request goes through it.
