ElixirConf 2015

2014: 99 attendees

2015: 257 attendees

Keynote: Bruce Tate

Chris McCord:

Phoenix vNext

  • gettext i8n
  • Channel Presence
  • GraphQL experiments

@bitwalker:

Elixir Deployments

  • github.com/bitwalker/exrm
  • github.com/bitwalker/conform

Erlang "Release"

  • Compiled application
  • With config
  • In a single tarball
  • Including the Erlang runtime (erts)
  • Confusion about 12-factor suppprt

@asange: CRDTs

(or, the data structure for the apocalypse)

CRDTs

  • Eventually consistent, distributed data structures
  • Not good library support yet
  • Theoretically awesome for CZ

https://github.com/pfraze/crdt_notes

@mr_urf: Elm + Phoenix

  • github.com/cultivatehq/seat_saver
  • (less than ideal)
  • I'm getting involved!

Elixir in Production

  • Open ports 4369, 9100-9600
  • Don't use registered processes
  • One-for-one supervision
  • One Erlang VM per server
  • Use the observer
  • "low reds and empty queue"
  • "+K true +A 60"

@jessitron: Elixir is all of us

What comes next?

  • Stateless
  • MVC
  • Microservices
  • REST
  • Agile
  • No Estimates
  • Stateful
  • The Elm Architecture
  • "Better" Microservices
  • GraphQL*
  • Lean
  • "How to Measure Anything"

Call to Action

  • Code
  • Blog
  • Teach
  • Organize
  • Evangelize

@josevalim: Elixir vNext

  • Erlang 18 only
  • HashDict -> Map
  • GenRouter
  • Extremely efficient data pipelines

Braintree guy: Ecto

  • ORM for Phoenix
  • DataMapper pattern (not ActiveRecord)
  • No lazy queries
  • Queries are just data
  • No AR callbacks (and there never will be)
defmodule MyApp.Post do  
  use Ecto.Model
  import Ecto.Query

  schema "posts" do
    field :body, :string
    field :published, :boolean
    field :published_at, :datetime
    field :title, :string

    has_many :comments, MyApp.Comment
  end
end 

MyApp.Comment  
|> join(:left, [c], p in assoc(c, :post))
|> where([_, p], p.id == 1)
|> select([c, _], c)
|> MyApp.Repo.all
  def published(query) do
    from p in query,
    where: p.published == true
  end

  def sorted(query) do
    from p in query,
    order_by: [desc: p.published_at]
  end  

  def for_post(query, post) do
    from c in query,
     join: p in assoc(c, :post)
    where: p.id == ^post.id
  end

  def popular(query) do
    query |> where([c], c.votes > 10)
  end
alias MyApp.Post  
alias MyApp.Comment

published_posts = Post  
|> Post.published
|> MyApp.Repo.all

last_post = Post  
|> Post.published
|> Post.sorted
|> MyApp.Repo.one

recent_popular_comments = Comment  
|> Comment.for_post(last_post)
|> Comment.popular
|> MyApp.Repo.all

Other talks

  • BEAM Internals (x2)
  • Erlang Interop

Takeaways

  • 25% of the conference is using it in production.
  • Jose Valim is the anti-DHH.
  • We have to be careful not to reimplement Rails.
  • Apps are getting more interactive.
  • Sources -> Transformations -> Sinks
  • Not every conference should be polyglot
  • Emacs++ :(

Opportunities

  • Devise for Phoenix
  • Tighten up the deployment story
  • Integrate Phoenix with JS frameworks
  • GraphQL experiment
  • Better vim/atom/sublime/TM support

Code!

Made with Slides.com