Has anyone seen this? (talk by Richard Feldman on integrating Web Components with Elm) https://www.youtube.com/watch?v=ar3TakwE8o0&t=1180s

Looks pretty awesome ❤️

While I understand that these two files serve different purposes, I wonder if we need both and/or if we could infer one from the other?

A "sign" of "health" for a project I always look at is their "Continuous Integration" ...
At the time of writing, the elm-lang compiler: https://github.com/elm-lang/elm-compiler has
https://travis-ci.org/elm-lang/elm-compiler/builds/172483668

And having master in a failing state is not an isolated event:

Granted, the last release v0.17.1 was in June and there is no "Rule" stating that the master branch of a project has to always be but in general we prefer the idea of having a "Golden Master" branch to "Last Known Good" ... see: http://www.smaclellan.com/posts/shippable-at-all-times/ only merge your feature branch into master when it's passing ...

We understand that Evan does not want/need continuous deployment for the elm-compiler.
working on an incremental release with a bunch of new features arguably makes life easier for developers because they don't have to be constantly distracted by new features or braking changes.

What other "costs" are there?

relates to #1

This seems like quite the process. I'm wondering if:

1. I am missing something and there's a smoother way to install

2. If the process I'm following is correct, then what is the best way to include the instructions for installing on Ubuntu in the repo

I am mostly following this but with some minor tweaks. It seems rather long to include all of that directly in the readme, so perhaps I can make an updated version in another repo and it can be linked to? Ideally there is a quicker install process but doesn't seem so.

P.S. I tried npm install -g elm and that doesn't work 😢

asked by @stevepeak in chat ...

relevant to @Kumjami, @jruts & @Talento90 who are all .ts aficionados. 😉

I saw this deal https://www.manning.com/books/elm-in-action and I thought I should share it with you. Enjoy it

@nelsonic I know you said there are really good stack traces, but I'm also curious: how are the source maps? Is it easy to put a breakpoint in the Elm code and step through it in Chrome dev tools? I guess this would be my main concern with a non-JS based language. I've found it easy enough to read and set breakpoints in Babel-transpiled ES6 at least (since using full sourcemaps for production-scale apps is really slow on each recompile).

For the Quick-Start, is there any reason we don't use elm-reactor instead of elm-make?

I found Elm-reactor relatively faster, more informative and it shows some of the cool factors with Elm. But I might be missing something about elm-make so I wanted to ask.

http://blog.jenkster.com/2016/11/type-bombs-in-elm.html

should this go in the How? section of the readme? 🤔

Elm Format

elm-format formats your code so that it is consistent with the community standard format.
Let go of your preconceptions of how code should look in other languages, elm is your chance to embrace a new paradigm so don't waste time discussing spaces vs. tabs? or one statement per line? or newline after code block? Simply use the community standard and focus on your feature.

See: https://github.com/avh4/elm-format
Editor integrations: https://github.com/avh4/elm-format#editor-integration

There is one example in the Elm-Specific Articles section

How Elm made our work better (success story): http://futurice.com/blog/elm-in-the-real-world

I'd love to see more success stories or case studies of where Elm is used over traditional JavaScript Web Applications

Can we use WebSockets (or even Socket.io) in Elm?
There is: http://package.elm-lang.org/packages/elm-lang/websocket/latest
But I don't see a good example anywhere ...

https://www.manning.com/books/elm-in-action

@rtfeldman's book is "40% Complete" and only expected (estimated) for release in "Summer 2017" ...

Question:

Should we pre-order it to show our support/commitment for/to his superb content...?
Or "wait and see" ...?

Wondering if anyone has looked through this and thinks it would be relevant:

https://github.com/sporto/elm-tutorial
https://www.elm-tutorial.org

Sometimes you are going to need interoperate with javascript, maybe because you need access to some native APIs and there isn't any elm library to interop with that native api yet. Or maybe because you already have javascript code and you want Elm to be able to communicate with it.

For those cases, Elm comes with Elm ports, and they will allow us do that communication.

People is raising their interest about progressive web apps.

Other technologies have tools for code splitting, so service workers can cache chunks of that code to load faster. Does anybody knows if there is any tool to do something similar in elm? maybe there is a way to split the runtime from the rest of your application and also split your app by routes.

## Reading

• Sign-up form example: http://tech.noredink.com/post/129641182738/building-a-live-validated-signup-form-in-elm
• Master Elm pt. 1 - Why Elm? https://ohanhi.github.io/master-elm-1-why-elm.html
• Faithful Elm and the Amazing Router: http://www.gizra.com/content/faithful-elm-amazing-router/

## Videos

• "Code is the Easy Part" by Evan Czaplicki: https://www.youtube.com/watch?v=DSjbTC-hvqQ

Once we have a decent intro to elm-lang we should respond to this thread (with a back-link):
https://www.quora.com/What-do-you-think-is-the-future-of-the-Elm-programming-language

Seen on HN today -> https://www.humblespark.com/ellie-announcement

I saw this deal https://www.manning.com/books/elm-in-action and I thought I should share it with you. Enjoy it

We should add CONTRIBUTING.md file a with a link to: https://github.com/dwyl/contributing to make it clearer to the various lovely people contributing to this repo.

Need validated in: #58 (comment)

In our Anonymous Public Twitter Poll: https://twitter.com/nelsonic/status/795164336834617344
There was an almost perfect Pareto distribution which I totally did not expect:

The beauty of using a Twitter Poll is that it's:

• low friction (one-click to vote)
• true anonymity (twitter gives us no ability to see who voted or how people voted!)

The downside of using the Twitter Poll is that:

• We have no idea who the people that don't like elm-lang are And given the final result they are unlikely to speak up... 😞

I did not expect the result to be this positive (in favour of).
I'm excited about the future again! (even if half of Americans aren't!!)

Because of the ordering on the how section

How?

The best place to start is with the "Official Guide": http://guide.elm-lang.org/get_started.html

we have condensed the steps into the 5-minute instructions below:

I think people are quite likely to click on the link and start working through the installation guide, before even reading "we have condensed the steps below" - something I see really often when people are going through online tutorials.

If you think it is better/easier for people to follow DWYL's condensed version (which I definitely do), I would suggest you change the order, so that you reference the official guide at the end

Dwyl's learn-elm tutorial instructs you to clone the repo and fire up elm reactor after changing one piece of text in one file, and then pause to reflect on the experience. The next step is to begin An Introduction to Elm, which starts with some playing around in the repl and then swiftly moves into quite complex tasks. I am concerned that the curve is too steep and that some may be discouraged and give up.

I would suggest that people do the following:

1. Core language: https://guide.elm-lang.org/core_language.html
2. Elm architecture: https://guide.elm-lang.org/architecture/
3. Elm for Beginners: http://courses.knowthen.com/p/elm-for-beginners
4. Elm architecture tutorial: https://guide.elm-lang.org/architecture/user_input/

https://youtu.be/DX28Hyn8gQw

see: http://www.meetup.com/Elm-London-Meetup/events/235176818/
10 South Place, London, EC2M 2RB

http://reasonablypolymorphic.com/blog/elm-is-wrong post by @isovector
discussed at: https://news.ycombinator.com/item?id=12906119
thanks @katpas for pointing us to the HN thread!

Jessica Kerr, aka @jessitron [blog], is working on a really neat usage of Rug called Atomist which is sort of like Rails or Yeoman, for an Elm project. 🤷‍♂️

Rug files are usually called "editors", you can see some here.

However, Atomist will act like a pair-programming bot, you can tell it to add new features, make code amendments and automate a lot of tasks, all from Slack.

It's still in the early stages, but she's just started working on it full-time. Atomist/Rug could give us a way to build out Elm projects much faster. It aims to alleviate some of the repetitive tasks like having to update multiple files when adding a new feature. From the looks of it, I would postpone adding much of anything about it to the guide, at least until they have a stable runway, but it looks very promising! 👀

Atomist: website || twitter

Video: "The Clockwork Gardener: Growing an Elm App With Templates" by Jessica Kerr

Write-up

Elm-Rugs

Rug Language

Why and What is Rug?

TL;DR :: Rails for Elm, yo!

Examples: http://elm-lang.org/examples

The (online) GitBook seems to be the best place to start: http://guide.elm-lang.org/get_started.html

• Richard Feldman - Introduction to Elm (March 22, 2016): https://youtu.be/zBHB9i8e3Kc

Adventures in Elm • Jessica Kerr @jessitron -> https://youtu.be/cgXhMc8M4X4

• "As a maintenance developer, I really, really, really appreciate elm because of it's focus because it's not JavaScript and it really focusses on my feelings as a person both right now while I'm writing the code and also later when I'm reading the code and when I'm changing the code."
• "Elm is a language of compassion..."
• "My fingers work. And I would rather do a little more work with my fingers a less work with my brain so I can use my decision power for actual business logic" 9:10

We are constantly on the lookout for a "(less but) better" way to build web applications.

elm-lang first came to our attention in 2014 when Seven More Languages in Seven Weeks: Languages That Are Shaping the Future showed how to build a game "without callbacks" ...
Then last year when @gaearon mentioned it in his "Hot Reloading with Time Travel" talk we were reminded that elm was a source of inspiration for Redux ...
When @rjmk mentioned it in dwyl/technology-stack#12 we looked at it at the time with some excitement but decided it was not going to be suitable for our project(s) because it was front-end only ("Single Page App focused") and the "bundle" size for the compiled app was quite large and there was no support for server-side rendering (so we could not build apps progressively...).

Some people have reached "JavaScript Fatigue" (as exemplified in this post by @jjperezaguinaga https://hackernoon.com/how-it-feels-to-learn-javascript-in-2016-d3a717dd577f ... yes, the post is "satire" but it has roots in reality!) and are considering other options...

The question we want to answer with this investigation is: can we use elm-lang to build "Full Stack Progressive Web Apps" ?

Which Programming Language (Warning: Rabbit Hole)

• Should we focus on one language? http://martinfowler.com/bliki/OneLanguage.html
• Revenge of the nerds: http://paulgraham.com/icad.html
• The Python Paradox: http://paulgraham.com/pypar.html
• Beating the Averages: http://paulgraham.com/avg.html
• http://readwrite.com/2014/09/01/programming-language-coding-lifetime/

While attending the elm-lang meetup #13 @jackfranklin demoed http://doyouevenelm.com

He also showed us https://www.npmjs.com/package/create-elm-app
https://medium.com/@eduardkyvenko/how-to-create-elm-app-cf052629a11a

then http://surge.sh/ for quickly publishing static elm apps.

The Elm Playground: https://github.com/jackfranklin/elmplayground is sweet! 🍭

One of the points in his Elm elevator pitch was that there are no runtime exceptions:
https://quanttype.net/posts/2016-03-22-runtime-exceptions-in-elm.html

We need to clarify this for "selling point" for new people.

ironic that when I attempted to load: http://elm-lang.org/examples/buttons I got:

Do we have a Gitter channel for this repo? would love to ask a couple of setup questions in it. 😄

help-wanted question 👍

As we discussed here #58, Should we set those examples as submodules or they should be folders inside this repo?

I'd love to see a resource on how to explain in laymans terms to clients why Elm should be used

The Elm Compiler version 0.18 was published last Friday. https://github.com/elm-lang/elm-compiler/releases/tag/0.18.0

But there was no mention of the release on twitter: https://twitter.com/elmlang
or on the elm blog: http://elm-lang.org/blog

So, the question is: is it "ready" to be used? or should we still be using v0.17.1 for the code in this tutorial?

What is like to write tests for Elm code?
Is there way to collect coverage info?
How fast can we run a suite? (e.g. for a large project with 10k+ tests ... seconds or minutes?)

This looks like a good place to start: http://package.elm-lang.org/packages/elm-community/elm-test/2.1.0
and the fact that someone is working on a Book is a really good sign: http://elm-test.com

Wikipedia has a decent intro: https://en.wikipedia.org/wiki/Elm_(programming_language) (always a good sign when there's a wikipedia page...):

Elm is a domain-specific programming language for declaratively creating web browser-based graphical user interfaces. Elm is purely functional, and is developed with emphasis on usability, performance, and robustness. It advertises "no runtime exceptions in practice,"[3] made possible by the Elm compiler's static type checking.

so far, so good...

Salient Features

• no side effects, all functions are stateless, and all data is immutable
• Much smaller language than ES2015, so technically people could go from basic JS straight into elm and skip ES6/React/Redux/WebPack/Babel/etc ...
• Apparently it's "fast" too: http://elm-lang.org/blog/blazing-fast-html
• The debugger is probably my most 😍 feature: http://debug.elm-lang.org/

Further Reading:

• https://www.quora.com/What-do-you-think-is-the-future-of-the-Elm-programming-language
• https://red-badger.com/blog/2015/10/21/elm-what-is-it-good-for/

https://youtu.be/_wTaKRnO9yo

https://youtu.be/tN5UmM2yZPY

The London Elm Meetup has just been announced and spaces will be taken fast! 💨

https://www.meetup.com/Elm-London-Meetup/events/236845874/ 📝

CC: @katbow @sofiapoh @jsms90 @iteles @NataliaLKB @tsop14 @Cleop @andrewMacmurray @ivanmauricio @Shouston3 @sohilpandya @eliascodes
the last one was really good ... ask @SimonLab and @jackfranklin ... if you can make it, go! 📆

Rather than re-invent and duplicate effort, we should recommend that people do @rtfeldman's Workshop!

• https://frontendmasters.com/workshops/elm/
• https://github.com/rtfeldman/elm-workshop

He's got way more experience than any of us and his workshop is thorough!

I've seen this package https://github.com/avh4/elm-beautiful-example/. You can use it to wrap your examples and make them beautiful and self-explanatory adding a small description, title and github url.

There is a command in node for creating a new node package (npm init), but I couldn't easily find how to do something similar for Elm, but at the end is just elm-package install or elm-package install -y if you want to avoid the interactive mode.

Playlist: https://www.youtube.com/playlist?list=PLglJM3BYAMPH2zuz1nbKHQyeawE4SN0Cd

At the time of writing https://repl.it/languages has no support for elm-lang

Asked for clarification/help on Twitter: https://twitter.com/nelsonic/status/796307294346743808

@SimonLab / @andrewMacmurray / @Shouston3 / @ivanmauricio are you chaps aware of an alternative that will allow us us to link to a specific snapshot of code and run it in the browser the way repl.it does? (thanks!)

localStorage acces: https://github.com/elm-lang/persistent-cache
anyone got experience using it yet...? 🤔

A few reasons why we might NOT want to use Elm: (feel free to add to this list!)

• additional learning curve for people who have only just learned JavaScript
• functional/immutable paradigm is not everyone's cup-of-tea. it can be perceived as "too mathematical" and not very beginner-friendly...
• it's virtually impossible to find/hire a person with Elm experience on their "CV" (which means our clients will have to train up anyone they hire to maintain/extend any code we write for them...)
• encourages more front-end-heavy apps as opposed to progressive web apps
• no server-side rendering (yet) ... see: https://github.com/elm-lang/virtual-dom/issues/29
• may be "difficult to sell" to organisations who have not heard of it. (i.e. all orgs that don't have a tech-focus or at least a tech-curious person in a decision making capacity!!)
• (I might be mistaken, but...) at the time of writing, it appears that there are Zero Female Contributors to the Elm Compiler: https://github.com/elm-lang/elm-compiler/graphs/contributors this could be a coincidence or it could be that the Elm community is not very welcoming...? @jessitron might be able to enlighten on this... https://youtu.be/cgXhMc8M4X4?t=5m11s
• There is no published book on Elm or the Elm Architecture which can suggest immaturity... the online resources are good and there's "Elm in Action" which is due Summer 2017 ... but that won't be enough to "convince" some clients.
• What else...?

Note: some of these "reasons" are not specific to elm but are applicable to all compile-to-JS languages e.g. clojurescript because by deciding to use them you are forcing all the people on your team and client(s) team(s) to learn a whole other language just so they can update a line of code in the codebase...

It might be worth adding something to the tutorial about the reactor in case anyone isn't clear why you're running a server to view your Elm output. There's a pretty reasonable explanation here: http://elmprogramming.com/elm-reactor.html

Elm

Pros
There are lots of very positive blog posts about Elm e.g. here

• Beginner friendly
• Quicker debugging due to very clear error messages
  e.g.

• No null or undefined
• Total immutability -> makes it easier to keep track of state
• Purely functional -> code can be more easily refactored
• No runtime exceptions
• Reactive

In this blog post, the author explains

The strictness of the type system eliminates an enormous amount — if not the vast majority of — mundane errors. Furthermore, refactoring is incredibly nice. Daniel Bachler had a relatable talk in BerlinJS not long ago: Fearless refactoring with Elm. The refactoring experience most of the time is:
Make changes, any changes.
The compiler tells what you missed.
Go to 1.
When the code compiles, it will work. There will not be any crashes. The only things that can go wrong are application logic. Application logic is what we should be focused on at all times, but many languages don’t let us do that. And since Elm enforces immutability and functional style, it is in fact very hard to cause regressions that you don’t know about.
I find that when coding Elm, I get to spend most of my time thinking about the actual problem that I am solving. Whereas when coding JavaScript, I spend my time debugging and only every once in a while get to think about the actual problem.

Cons

• Relatively new so potentially less of a community when we run into problems

React/Redux

Pros

• Ability to keep track of state
• Lots of existing components already
• Javascript so potentially easier for us to get started at first
• Bigger community

Cons

@dwyl/ateam Please add your thoughts 👍