but on the other hand, it’s got to be grating to deal with the same entitled, uninformed or complaining comments all the time.

Over the years, I have come to believe this is a vital part of building a community. Using draconian tactics to stomp out annoying comments is using power unwisely and worse yet – cripples your community in multiple ways.

The first thing to remember is that when a comment (entitled, uninformed or otherwise) comes up repeatedly – that is a failure of the community to provide a resource to answer/counter/assist with that comment. That resource can be a meme, a link, an image, a FAQ, a full on detailed spec document, whatever. This type of thing is part of how a community gets a personality. I think a lot of the reason there are a bunch of dead discourse servers for projects is too stringent policing. You should have a place for people to goof off and you have to let the community self police and become a real community. Not entirely, obviously, but on relevant topics.

This constant repetition of questions/comments is healthy, normal, it is the entrance of new people to the community. More importantly, if gives people who are just slightly deeper in the community someone to help, someone to police, someone to create resources for, even to a degree someone to mock (reminding them they aren’t THAT green anymore) – a way to be useful! This is a way to encourage growth, each “generation” of people helps the one that comes after them – and it is VITAL for building up a healthy community. In a healthy community the elders will only wade in occasionally and sporadically to set the tone and will focus on the more high minded, reusable solutions that move the project forward. Leave the minor stuff be done by the minor players, let them shine!

Beyond being vital to build the community – it is a signal of where newcomers are hurting. Now if documentation fixes the problem, or a meme… terrific! But if it doesn’t, and if it persists … that is a pain point to look at – that is a metric – that is worth knowing.

I’ll add the perspective of someone who loved Elm and will never touch it again. We’re rewriting in PureScript right now :) I’m happy I learned Elm, it was a nice way of doing things while it lasted.

In Elm you may eventually hit a case where you can’t easily wrap your functionality in ports, the alternative to native modules. We did, many times. The response on the forum and other places is often to shut down your message, to give you a partial version of that functionality that isn’t quite what you need, to tell you to wait until that functionality is ready in Elm (a schedule that might be years!), or until recently to point you at native modules. This isn’t very nice. It’s actually very curious how nice the Elm community is unless you’re talking about this feature, in which case it feels pretty hostile. But that’s how open source rolls.

Look at the response to message linked in the story: “We recently used a custom element to replace a native modules dealing with inputs in production at NoRedInk. I can’t link to it because it’s in a proprietary code base but I’ll be writing an speaking about it over the next couple months.”

This is great! But I can’t wait months in the hope that someone will talk about a solution to a problem I have today. Never mind releasing one.

Many people did not see native modules as a shortcut or a secret internal API. They were an escape valve. You would hit something that was impossible without large efforts that would make you give up on Elm as not being viable. Then you would overcome the issues using native modules which many people in the community made clear was the only alternative. Now, after you invest effort you’re told that there’s actually no way to work around any of these issues without “doing them the right way” which turns out to be so complicated that companies keep them proprietary. :(

I feel like many people are negative about this change because it was part of how Elm was sold to people. “We’re not there yet, but here, if we’re falling short in any way you can rely on this thing. So keep using Elm.”

That being said, it feels like people are treating this like an apocalypse, probably because they got emotionally invested in something they like and they feel like it’s being changed in a way that excludes them.

You’re right though. Maybe in the long term this will help the language. Maybe it will not. Some people will enjoy the change because it does lead to a cleaner ecosystem and it will push people to develop libraries to round out missing functionality. In the short term, I have to get things done. The two perspectives often aren’t compatible.

I’m personally more worried about what will happen with the next major change where Elm decides to jettison part of its community. I don’t want to be around for that.

I would prefer that the discussions weren’t removed or locked, but on the other hand, it’s got to be grating to deal with the same entitled, uninformed or complaining comments all the time. I’ve read most of these discussions, and other than people venting, nothing is ever achieved in them. My reflexive reaction is to be uncomfortable (like a lot of other people) but then, there is also a certain clarity when people just say that they will not engage in a discussion.

I’ll go one further and say I’m quite glad those discussions get locked. Once the core team has made a decision, there’s no point in having angry developers fill the communication channels the community uses with unproductive venting. I like the decisions the core team is making, and if those threads didn’t get locked, I’d feel semi-obligated to respond and say that I’m in favor of the decision, or I’d feel guilty not supporting the core devs because I have other obligations. I’m glad I don’t have to wade through that stuff. FWIW, it seems like the community is really good at saying “We’re not going to re-hash this decision a million times, but if you create a thread about a specific problem you’re trying to solve, we’ll help you find an approach that works” and they follow through on that.

I don’t have a lot of sympathy for folks who are unhappy with the removal of the ability to compile packages that include direct JS bindings to the Elm runtime. For as long as I’ve been using Elm the messaging around that has consistently been that it’s not supported, it’s just an accidental side effect of how things are built, and you shouldn’t do it or you’re going to have a bad time. Now it’s broken and they’re having a bad time. This should not be a surprise. I also think it’s good decision to actively prohibit it. If people started using that approach widely, it would cause a lot of headaches for both the community and hamstring the core team’s ability to evolve the language.

I think what bothers me the most about the core team’s approach to features is not that they keep removing them, but that for some they do not provide a valid alternative.

They’ll take away the current implementation of native modules, but coming up with a replacement is too hard, so even though the core libraries can use native code, us peasants will have to do without.

They won’t add a mechanism for higher rank polymorphism because coming up with a good way to do it is hard, so even though the base library has a few magic typeclasses for its convenience, us peasants will have to make do with mountains of almost duplicated code and maybe some code generation tool.

So where does that leave Elm right now? Should it be considered a production-ready tool just by virtue of not having very frequent releases? Or should it be regarded as an incomplete toy language, because of all the breaking changes between releases, all the things that haven’t been figured out yet, and how the response to requests for ways to do things that are necessary in real code is either “you don’t need that”, which I can live with most of the time, or “deal with it for the moment”, which is unacceptable.

I think Elm should make it more clear that it’s ostensibly an unfinished project.

I was hoping to read other points of view on that matter, thanks for taking the time writing down yours!

It seems like you haven’t read the article very carefully.

1. You completely forgot to mention the operator behind the wheel - If anyone, that person will most likely be charged and, regardless of the verdict, carry it for the rest of their life.

2. From https://www.sfchronicle.com/business/article/Exclusive-Tempe-police-chief-says-early-probe-12765481.php:

… it’s very clear it would have been difficult to avoid this collision in any kind of mode (autonomous or human-driven) based on how she came from the shadows right into the roadway, …

… I suspect preliminarily it appears that the Uber would likely not be at fault in this accident, either, …

Sylvia Moir, police chief in Tempe, Arizona

The fault is actually in the driver, who was instructed to be alert and keep both hands at the wheel at all times. Uber should not have released this obviously and they should get shit for it but I think until there’s nobody behind the wheel the responsibility of any accident falls on the driver, just as it does with planes presently.

EEVblog #1066 - Uber Autonomous Car Accident - LIDAR Failed?

In reality, both the pedestrian and the car (and Uber) share some responsibility. You shouldn’t cross a four lane road at night wearing black outside of a crosswalk. A human driver is very unlikely to see you and stop. Not blaming the victim here, just saying it’s easier to stay safe if you don’t do that. However, the promise of autonomous cars with IR and LIDAR and fancy sensors is that they can see better than humans. In this case, they failed. Not to mention the human backup was very distracted, which is really bad.

From the video I don’t think a human would have stopped in time either, but Uber’s car isn’t human. It should be better, it should see better, it should react better. Automatic collision avoidance is a solved problem already in mass-market cars today, and Uber failed it big time. Darkness is an excuse for humans, but not for autonomous cars, not in the slightest.

She should still be alive right now. Shame on Uber.

And every single thing you listed is mitigated by just slowing down.

Camera feed getting fuzzy ? Slow down. Now you can get more images of what’s around you, combine them for denoising, and re-run your ML classifiers to figure out what the situation is.

ML don’t just classify what’s in your sensor feeds. They also give you numerical measures for how close your feed is to the data they previously trained on. When those measures decline,, it could be because the sensors are malfunctioning. It could be rain’/dust/etc. It could be a novel untrained situation. Every single one of those things can be mitigated by just slowing down. In the worst case, you come to a full stop and tell the rider he needs to drive.

FWIW, this is all caused by a Foldable ((,) a) instance that is already quite controversial in the Haskell community1. It isn’t the only controversial Foldable instance either - did you know there is a Foldable (Either a)2?

The main friction is that removing instances that were previously there may cause code that currently compiles to stop compiling. One suggestion I personally like is to have a compiler warning for the pathological cases3.

<interactive>:6:1: error:
    • No instance for (Foldable ((,,) t0 t1))
        arising from a use of ‘length’

— what’s incomprehensible about this?

it’s more like reflexes. Completely unconscious but potentially very skilled

You’re making a good point but I stumbled on this bit. Intelligence and consciousness are potentially two very different things, so that’s an entirely different line of enquiry. It might be worth framing this as “very skilled, but in a very small set of tasks” instead.

Thanks for your advice!
I get your point, but I do not think that AI is like a reflex, since a reflex needs way less data to train.

While it’s true we know near to nothing about how our brain actually work, it seems not a statistical tool given how few attempts we need to learn something.

However we are doing some progress in our understandings.
Here an interesting article about the topic. I strongly suggest you to follow the links there: the article is nice, but the linked sources are great!

Yes, I knew something was up with the certainty level the author had with the evidence they were proposing. Obviously I’m a novice, but I have some degree of intuition about the things we don’t or can’t know yet. Saying with certainty that neural nets will never accomplish intelligence reeks of anthropocentric bias even if it were true.

Huh! Thanks for your answer and sorry if I you feel somehow sad about this!

I think that most of your objections come from a shallow read of the slides. But I can ensure you that other colleagues, that also work with ANN in particular, find them pretty well founded and clear.

Here I pick and answer only to those of your objections that are actually connected to what is meant there.

There are many NN approaches that are not deterministic. Actually, there are NN approaches that rely on noise.

False. Computers are deterministic.

When you add true entropy to an algorithm that run on a computer, you randomize the input, not the algorithm.

The random contribution to the computation can be recorded so that the computation can replicated.
And you will always get the same outputs.

Obviously, to do that, you must have a clear understanding of what your input is.
Obviously, if you forget a piece (the random part) you cannot reproduce your own results!
But if so… are you sure you are working in the field?

I’m also not sure what “statistically approximate” means.

Nothing exotic: “statistically approximate” means to approximate through the use of statistics.

An ANN is a statistical algorithm. Just like a K-mean is.
It’s obvious that it’s statistics: you can only use it if you have tons of data.

Had you read all the slides you had see that I explain how the fancy names we are using are good for literature (and business) but not for science. They fool the experts too!

we need a big data set to filter out unwanted functions with each sample we feed to it. … We can not really know which function a complex ANN will approximate.

I don’t even know what to make of this. Is this a statement that you don’t know what your network will learn? Well.. ok. I mean, that’s the point of training something isn’t it?

You have been fooled by the language you use: ANNs do not learn anything. They approximate.

I mean that underfit and overfit are two faces of the same medal: you do not know which one, of the infinitely many functions that fit your dataset, your ANN will approximate.

If you are lucky it start to approximate a function that is similar to the one you actually desire.

Otherwise it start to approximate a function that works well in the region of your training dataset but not outside (overfit) or it does not even fit the whole training dataset well enough (underfit).

AI is not accountable, so it cannot take decisions over humans

Maybe shouldn’t? But it certainly can.

How? We put it in jail? We turn it off? How?

Are you sure you work in the field? Oh… yes I can see… you are! ;-)

No equality relation in the Codomain

shrug Who cares?

The child killed by a self driving car that turned left by 3 cm.

It turned 3 cm to the left just like every other time. Just in the wrong place at the wrong time.

I’m not even going to touch the whole knowledge section. It’s not even wrong. It’s naive.

Oh this is a good objection! Can you back it with some papers or even book we can read?

The question is not rhetorical. I would really appreciate such links.

(to prove) to be general, an Artificial Intelligence should be able to discover and explain us new abstractions and functions over them

Eh.. Kittens have general intelligence. Good luck getting them to do any of this!

Ehm… funny you talk about kittens… :-)

Did you see the cat in the slides. Did you understand what it means?

You are so good at pattern matching that you see a cat even if you know that there is no cat there.

The same happens when we see a neural network at work: we see an intelligence, but there is no intelligence there.

It’s also what happened with the first train films of the Lumiere’s brothers.
People saw a train coming towards them, but there was no train.

And it’s the same with kittens.
You see an intelligence because you project your own experience to explain his behavior.

But there is no intelligence there.

The idea that AI is automatically superintelligent is pop science.

First I was not talking about Artificial Intelligence, but Artificial General Intelligence.

But, had you read more carefully you would have understood that saying that AGI is ASI is an obvious effect of the definition of AGI that I propose.

In particular, to be general it must be able to abstract. That means to be able to identify concepts and functions on its own.

Now, we as human, first react to perceptions then learn from them. Sometimes days later.
This is an effect of our biological evolution. But it also means that our reactions are always suboptimal when we face an event that we cannot explain because it contradicts our knowledge and predictions.

A machine would not have this limit. It can integrate the new perception in its knowledge first and use the new knowledge to react. This give it an edge over humans.

So when we will create an artificial general intelligence, we will create an intelligence with an edge over us.

No equality relation in the Codomain

shrug Who cares?

Re-reading the slide I realized that it might not be clear why this is relevant.

It’s related to the “complex” slide on Function.

Two functions are equal, if and only if

• they have the same domain
• they have the same codomain
• they follow the same rule

The rule part is what make the equality relation relevant.

If we state the equality as f(x) = g(x), we are assuming an equality relation in the codomain.

Instead stating that f(x) = y <=> g(x) = y, does not assume such relation.

But to avoid the need of equality in the Codomain, you need the co-implication.

But the only way to prove the co-implication without an equality relation in the codomain is to prove that each of the rules followed by the two functions can be logically deduced by the other one.

That is: the two rules are the same one expressed in different ways.

I don’t understand the argument. I don’t think Gabriel is over-complicating anything here. Quite the opposite:

He started out by just creating a directory with a Main.hs file and explicitly mentioning that for very simple programs and scripts, you can get away without creating an actual package and just use ghc directly to build it. He then shows how you can turn your directory into a simple package by adding a minimal *.cabal file, and now you can specify dependencies and use cabal build to build your package. Finally, he introduces stack, and explains the conveniences it would give you.

IMHO giving this step-by-step explanation is more helpful to a beginner, than diving right into stack new my_proj. I personally would’ve been more intimidated by the amount of “unnecessary” boilerplate stack new generates, than manually creating 2 files and typing out a few lines myself; when all I want to do (as a starter) is start writing my Hello World.

I could keep going as everything in this article is totally unfounded in reality.

Indeed explicitly so - I chuckled at presenting Back to the Future as some sort of scientific evidence.

Heh. I spoke to an astrophysicist not long ago who was deeply upset at computer scientists repeating the notion of 2⁸⁰ as “the number of atoms in the universe”.

Not all particles are part of atoms, and in the case of dark matter, we can’t reasonably estimate the number of particles, since we don’t know the mass of each. Also, the only number we can even begin to consider is for the observable universe, which is substantially smaller than the entire universe. And no, the interesting stuff is not solely in the observable part. We do have a good number for the mass of the observable universe, but no way right now to guess what portion of it is in supermassive black holes, where it is not useful for computation.

I volunteered that this specific value probably got repeated so much because it’s the accepted number for cryptographic infinity. “Which is thought of as the amount of computation you could do if you converted the entire universe into a computer and ran it until the end of time, because that’s apparently a thing cryptographers fantasize about.” Executive summary: If that’s really what it’s an estimate of, it’s quite low.

Anyway, yeah, this “AI singularity” stuff is coming from the same people who put “first multicellular life” and “transistor” on the same chart. Just for your amusement value.

The idea that we’re going to copy the brain in any meaningful way is also nonsense. There is no mechanism to image a brain at the level of detail required. And even if the brain is simply a neural network (in the CS sense of neural network; which it is not) recovering the weights even if we have the connections is going to be impossible.

What is your opinion of Blue Brain Project? They use biological neurons and their strategy to model neurons and recover weights seems eminently sound.

I wish people would lay off some of this nonsense.

I feel you. The problem is no one can demonstrate, with exactness, which part is (or is not) nonsense and should be laid off. There are impressive tools, an obviously impressive goal, progress in some areas but no overall perspective on what’s happening. Sure, most sober minds will say whole brain simulation is a crock, that’s what I believe but there are a lot of ideas out there and the problem of which approach to “prospect” is very hard. Full brain simulation in overall ignorance of the brains' function may be a fool’s errand but trying to simulate the brain may give insights that wind-up usable elsewhere. The idea of a single dimension to intelligence also seems to me fatally flawed, seems like the basic mistake that AIG boosters (or worriers) like Nick Bostrom, Eliezer Yudkowsky and the author of this article make. But it’s hard for me to say that with certainly unless I can demonstrate what intelligence actually is.

As you say, we don’t know how the brain works and we don’t know what full intelligence is. That might mean the problem is unsolvable and the AIG folks are wasting their time. That might mean the problem is easier than we imagine and a few breakthroughs can prove the naysayers wrong. Extreme ignorance creates these paradoxes. If the problem was colonizing a continent of known size or visiting a planet of known distance, the difficulties would have quantities attached. Without that, we’re have “unknown unknowns” but the provision that since human intelligence has a material structure and software breakthroughs have happened, the prospects aren’t purely speculative. The situation might be comparable to the earlier European conquest of the Americas - the explorers were ignorant of the land and uncertain what the payoff would be - yet all this ignorance didn’t mean that found nothing or the quest wasn’t worth it.

Even if only for ideas, you might want to take a look at the Memory Pool System. Definitely my favorite GC implementation to work with, great people and great docs.

Would you consider changing the name of your project?

Scheme->C (also styled scheme2c; https://github.com/barak/scheme2c) is a pretty well-known Scheme implementation (at least in circles that care about these things) by Joel Bartlett with a 20 year history. I fear there’s going to be a lot of confusion out there. It has a few users that use it for research (most of the code I wrote for my PhD was in Scheme->C and it’s pretty capable. I ran it on robots, to run fMRI experiments, on a supercomputer, etc; it still works quite well and has gotten quite a few upgrades to make it feel more modern). There’s some hope that one day it might get more mindshare again as it’s quite fast (we ran live computer vision demos with it) and capable compared to most schemes out there.