sporto

class DoSomething
	def self.build(dep:)
		->(user:) {
			self.new(dep: dep, user: user).call
		}
	end

	def initialize(dep:, user:)
		@dep = dep
		@user = user

sporto

{"lastUpload":"2017-09-22T09:48:44.528Z","extensionVersion":"v2.8.3"}

sporto

This is an example reusable element I made for our application https://github.com/sporto/elm-select

My current API is not great as it requires a lot of boilerplate to hook init, state, update and view.

But in summary this library requires:

• Some configuration
• App state: Some state that the application manages e.g. currently selected thing
• Hidden state: Some state that the component cares about, that can be hidden from the app

sporto

This is an example reusable element I made for our application https://github.com/sporto/elm-select

It is an input field with auto suggestions.

This element needs three pieces of state:

• List of things to search for
• Current selected thing
• And the query the user is typing (At the moment this is in "hidden" state)

sporto

https://twitter.com/markdalgleish/status/830557687779700736

Extreme is very vague. I assume you are comparing JS vs Elm / PureScipt.

You get a lot more than purity i.e. robust, speed of development, confidence.

You give up less than you say.

Convenience: Depends on what are you used to, Haskell, PS can be have a lot of 'convenience' after you learn them. Is just different type.

sporto

http://reasonablypolymorphic.com/blog/elm-is-wrong

Haskell dev writes some Elm, concludes that the language should be avoided. Writes an article about it.

JS developer then reads and thinks, oh Elm is bad, I better stick to JS then.

We just made a huge disservice to the programming community. That article might be right in several things (how the lack of Typeclasses hurts expressiveness), but it totally missed the point of Elm.

As an industry we want to move to more robust languages. Haskell has been around for many year, but we are still mostly using mediocre programming languages. Haskell is great but it has a huge learning curve, so people don't adopt it.

sporto

A common way is to chain operations using method calls:

collection
    .map(f1)
    .filter(f2)

However this only works if collection has the methods we want e.g map, filter. There is no way to chain something that doesn't exist in collection in the first place.

sporto

import Html exposing (text)

multBy x =
  (*) x

biggerThan x =
  (<) x

nums =
  [1,2,3]

sporto

We have two components, parent and child. When user hovers over the parent we want to change an attribute on the child. We achieve this we are using a global class in the child so the parent can select it. But this breaks the modularity of css modules.

Is there a way to solve this in a nicer way without using global?

sporto

I think we need to adopt a more robust programming language in the future than ruby. Ruby has been great in terms of letting us build things fast up to now. But Ruby falls shorts in speed and robutness.

At the moment we do thinks like:

• Guard for the type of an argument functions, we raise if incorrect
• Use Json.schema to validate hashes
• Check for nils and return nils if nil
• Create unit test that check what would happen when an input is nil