Greg Ziegan gregziegan

Lightning Talk proposal for ReactiveConf 2017 http://www.reactiveconf.com #ReactiveConf

Porting Prezi to Elm in 99 lines of code

Elm is a statically-typed functional programming language. Its compiler produces safe JavaScript which is guaranteed to be free of runtime exceptions. Moreover Elm is packed with a bunch of powerful abstractions which let us build visual and reactive Web applications in a few lines of code.

As an example, I show the implementation of a simple framework for building Prezi-like presentations. It's just 99 lines of code!

The Why and When of Choosing Elm

What is Elm?

Language (and "framework") for building web frontend applications
Can be used in place of HTML, CSS and JavaScript
Compiles into the above

Star this gist to see the talk at ReactiveConf 2016.
Retweet to spread the word.
Have a look at this blog post to see other proposals.
Try elm-search to see what this is all about.

An API search engine in Elm for Elm

Elm is a statically typed functional language that compiles to JavaScript. It's well-known for its developer experience: the compiler provides nice error messages, the package system enforces semantic versioning for all published packages and makes sure every exposed value or type has some documentation and type annotations.

In this gist I would like to describe an idea for GraphQL subscriptions. It was inspired by conversations about subscriptions in the GraphQL slack channel and different GH issues, like #89 and #411.

Conceptual Model

At the moment GraphQL allows 2 types of queries:

query
mutation

Reference implementation also adds the third type: subscription. It does not have any semantics yet, so here I would like to propose one possible semantics interpretation and the reasoning behind it.

Architecture in Elm

This document is a collection of concepts and strategies to make large Elm projects modular and extensible.

We will start by thinking about the structure of signals in our program. Broadly speaking, your application state should live in one big foldp. You will probably merge a bunch of input signals into a single stream of updates. This sounds a bit crazy at first, but it is in the same ballpark as Om or Facebook's Flux. There are a couple major benefits to having a centralized home for your application state:

There is a single source of truth. Traditional approaches force you to write a decent amount of custom and error prone code to synchronize state between many different stateful components. (The state of this widget needs to be synced with the application state, which needs to be synced with some other widget, etc.) By placing all of your state in one location, you eliminate an entire class of bugs in which two components get into inconsistent states. We also think yo

The introduction to Reactive Programming you've been missing

(by @andrestaltz)

This tutorial as a series of videos

If you prefer to watch video tutorials with live-coding, then check out this series I recorded with the same contents as in this article: Egghead.io - Introduction to Reactive Programming.

ANNOUNCEMENT

I have moved this over to the Tech Interview Cheat Sheet Repo and has been expanded and even has code challenges you can run and practice against!

\


	import React from 'react'
	import Portal from 'react-portal'
	import getOffsets from 'positions'
	import { findDOMNode } from 'slate'

	/**
	* No-op.
	*
	* @type {Function}

	module TimeApp ( start, Config, App ) where
	{-\| This module helps you start your application in a typical Elm workflow.
	It assumes you are following [the Elm Architecture][arch] and using
	[elm-effects][]. From there it will wire everything up for you!

	**Be sure to [read the Elm Architecture tutorial][arch] to learn how this all
	works!**

	[arch]: https://github.com/evancz/elm-architecture-tutorial
	[elm-effects]: http://package.elm-lang.org/packages/evancz/elm-effects/latest

	import android.content.Context;
	import android.os.Debug;
	import java.io.File;

	public class OomExceptionHandler implements Thread.UncaughtExceptionHandler {

	private static final String FILENAME = "out-of-memory.hprof";

	public static void install(Context context) {
	Thread.UncaughtExceptionHandler defaultHandler = Thread.getDefaultUncaughtExceptionHandler();