Ashamed to work in Silicon Valley: how techies became the new bankers - beauzero
https://www.theguardian.com/technology/2017/nov/08/ashamed-to-work-in-silicon-valley-how-techies-became-the-new-bankers
======
malvosenior
> is perceived: as under-regulated, overly powerful companies filled with
> wealthy tech bros and “brilliant assholes”

I’m not so sure the industry is “perceived” like this, it’s more like old
media outlets (especially The Guardian and NYT) relentlessly push this message
and this piece is no different.

I get that technology has destroyed their ability to gatekeep messaging, their
business model and their prestige but at some point old media attacks become
too transparent and probably have the opposite effect as intended. I think
technologists have reached that point. I don’t know if the general audience
has yet but I’ve never heard anyone complain about “tech bros” in real life
(probably because they don’t really exist).

~~~
slivym
It's perceived like that by me, and I work in the industry. You can take
Levandowski, Kalanick, Jobs, Zuckerberg, or many others.

If there's no problem with Brilliant Assholes in technology then why are there
such a clear pattern of them?

Paul Graham has got a no-asshole rule for a reason- and it's not because he
finds it difficult to find assholes to fund.

~~~
Bartweiss
It still feels like this approach runs on anecdote, and on equivocation
between "techies" and "billionaire tech CEOs".

People with enormous power and wealth are frequently terrible across all
industries. I'm still fairly convinced Kalanick has more in common with
Weinstein and Miki Agrawal than your average trenches-level programmer, simply
because power corrupts. (If tech has a singular problem, it's that startup
culture means some people are in power for their whole careers.)

And at the trenches level: yeah, brilliant assholes are a thing in software.
And classical music, and physics, and law, and... They're all specialized
fields with noninterchangeable work, power-law payouts, and room to minimize
human interaction in daily work.

I don't disagree with you that this happens in the field, and I definitely
appreciate hearing from people in the field who might agree with this article.
But it still feels like there's a pattern of comparing Silicon Valley to
Wallstreet, while ignoring the myriad other fields with similar dynamics.
That, not the existence of assholes, is the part that feels agenda-driven to
me.

~~~
mcguire
A few points:

1\. The median household income in the US is something like 1/3 to 1/2 of what
I understand the starting salaries are in SV. For most outside the tech
bubble, economically, there is little visible difference between "techies" and
"billionaire CEOs".

2\. Much of Kalanick's behavior is mirrored by lesser techies, albeit on a
smaller scale.

3\. Anyone have any hard numbers on the size of the "techies and billionaire
CEOs" class versus the total professional classical musicians and physicists
in the world? Certainly, the former seems to have more actual impact.

4\. Do you really want to live on the pointy end of lawyer and wall street
banker jokes?

("What's the difference between a lawyer and a catfish?" "One is a bottom
feeding scum-sucker; the other is a fish.")

~~~
tj-teej
What and a kid who just graduated from college with 80K of debt and is writing
test automation for Google is a scum-sucker? Give me a break...

------
PeekPoke
I've been in the computer industry for 30 years now. Back when I started we
were all looked down on as underachieving losers who couldn't talk to 'normal'
people, couldn't get laid and would never amount to anything in 'the real
world'. Look at the world now, look at programs like The Big Bang Theory - the
world has change and the geeks have truly inherited the earth. How they are
behaving is as clear an example as you can possibly get when the originally
downtrodden get power, wealth and influence - they use it and say 'F*ck you'
to those who laughed at them and are now no longer at the top of the pile. Go
figure.

~~~
skizm
I agree with this for the most part, but The Big Bang Theory is a bad example
imo. It is still laughing _at_ geeks, not with them. I think that's why it
rubs a lot of people (myself included) the wrong way.

~~~
Bartweiss
There's certainly a reason _Silicon Valley_ got away with duplicating the
components of _Big Bang_ exactly.

Like, they've both got the stereotypical awkward Indian engineer who can't
talk to women, but SV took a novel approach by not hating him. SV's weird-by-
engineering-standards characters are weird for reasons outside of their
nerdiness (e.g. Jared's German-language night terrors), BBT just turned
Sheldon's nerdiness up to 11. (And created a _really_ nasty autism stereotype
in the process.) And so on.

(Can anyone imaging BBT finding a stereotype as obscure as Gilfoyle's
occultist thing? Because that's definitely a 'thing', but it's some serious
inside baseball.)

If anything, you might argue that the transition from _Big Bang_ to _Silicon
Valley_ is a display of the changing position of nerds. More realistically,
though, I think they're just aiming at different demographics.

~~~
internetman55
I thought the Indian guy on BBT was one of the more sympathetic characters. He
is a bit sheltered, but seems to do significantly fewer stupid things than the
rest of the cast. Also seems to be a good friend. But I've only seen a few
episodes.

------
VicVee
"“You wake up, get the shuttle bus, go to the bubble of campus and order food
via an app when you get home. You are not a citizen, just a bizarre leach who
makes money,” he explained."

I'm not sure I understand. The whole article is just describing literally
anyone in any industry.

What people can't seem to grasp is that tech in SF/SV simply created a massive
insular culture that doesn't contribute to the culture that was previously
there. It just took over ruthlessly. All previous artistic beauty that was in
SF is just gone now and replaced with tech kids that get paid a ton and would
rather spend it on cryptocurrencies and music festivals than participating in
the city's artistic scene.

Its no wonder at all why people don't like tech people. Its not because they
get paid a ton. Its just because they get paid a ton and have no care for
anything that was previously there.

But I mean, its a tiny city and the city's building regulations don't do much
in the way in helping with gentrification at all. Not sure what else could
have possibly happened.

~~~
neilk
> I'm not sure I understand. > The whole article is just describing literally
> anyone in any industry.

Teachers. Surgeons. Physiotherapists. Soldiers. Artists. Grocers. Cleaners.
Miners. Forestry. Farmers. Elder care. The people who drive your shuttle bus.

Most industries require contact with other humans, and implicate you in their
happiness. In techland, we are already a step removed from our customers
(because we create autonomous artifacts.) But beyond that, now we’re powered
by overwhelming amounts of capital. And the whole point of that capital is to
create vast power imbalances between you and the people you’re allegedly
serving.

In a previous decade, computer programmers could have counted themselves as
citizens. Connecting and empowering people. Maybe a lot us still are. But
lately, a lot of what we’re doing is finding new ways to yank Jenga pieces out
of society, in hopes that all the pieces will fall into our bosses’ laps.

~~~
Bartweiss
> _Most industries require contact with other humans, and don’t rely on
> overwhelming amounts of capital to try to create vast power imbalances
> between you and the people you’re allegedly serving._

I agree with the statement, but I'm not sure it squares with your list? Tech
and banking aren't unique in offering the chance to sit alone in an office and
turn early advantages into ludicrous excess.

Broadly, we're talking about jobs that have power-law payouts among their
practitioners, require highly skilled (and hard to interchange) labor, and
don't intrinsically punish jerks (meaning limited interaction with coworkers
or customers). Not all of them make billions, but they get something
exponential that encourages them to compete - fame or professional power or
job security.

That's a lot of careers. Orchestral musicians fit, lawyers fit, surgeons fit
in spades, artists and mathematicians and philosophers all fit.

Obviously tech and banking are not equivalent to those things - heart surgeons
have never destroyed the economy. But I think it's a catastrophic mistake to
try and understand why tech and banking cause these problems by acting like
the professional demeanor is unique. That is at best a starting point, a way
of acknowledging that if yanking pieces out of society is easy and rewarding
it will happen. The question from there is "how do we stop that from
happening?"

(I'm not sure how much we honestly disagree, I just think the distinction is
important. That Jenga metaphor is fantastic.)

~~~
falcolas
Something of an aide from the main thrust of your argument:

> Orchestral musicians fit

My friend who was in the Boston Pops disagrees - the pay was crap (he had to
provide music lessons on the side to maintain a reasonable income), the
pressure was humongous, and their off-hours practice to keep at the top of
their game puts our own hobby programming efforts to shame. Like video games,
all musicians want to perform in the big orchestras, creating a highly
competitive supply glut.

I'm also fairly certain that most mathematicians and philosophers come nowhere
near to our power distribution curve.

That leaves us in the company of bankers, lawyers, and surgeons. Not the
highest prestige group of people to exist alongside. Especially since, while
well off, we're making nowhere near their "Fuck You" levels of money.

~~~
Bartweiss
From the responses here, I think I was unclear with the power law part.

I don't just mean "the pay distribution is exponential". I mean any system
where the rewards of the work (as judged by the people doing it) accrue
primarily to a small fraction of the workers. This isn't about the size of the
payout, it's about a system where competition and potentially ruthlessness
within the labor force have substantial benefits. (Contrasted with careers
like factory labor where getting 'ahead' of coworkers doesn't have much to
offer.)

So for orchestras, "all musicians want to perform in the big orchestras,
creating a highly competitive supply glut" aligns nicely with what I mean,
even if that supply keeps salaries down. Most talented musicians don't make it
into a career, most career musicians teach in schools or play weddings or
otherwise don't make it to the Pops. Video game design is another power-law
return - most people don't get to lead teams, most team leads don't make hit
games. The same for mathematicians - the payouts are largely status, tenure,
and prestigious institutions, but they're still exponentially distributed.

A decent definition would be any profession where the stereotypical example
and the prototypical example are completely out of sync. The prototypical
truck driver is basically what we imagine them to be. The prototypical
software engineer works on an inventory system for a non-tech company
someplace outside the Valley, and has nothing much in common with the 'techie'
stereotype.

------
sverige
The video of Dropbox employees trying to kick local kids off the soccer field
is exactly how I picture most of the failed social interactions in Silicon
Valley. Utterly clueless, then they wonder why people say they dislike them.

~~~
counterpoint1
Ya, how dare some people want to use a field they had reserved ahead of time!

Sometimes I wonder what bizarro world other people are living in. Every city
in America has public spaces which can be reserved - playing fields, gazebos,
park areas, picnic spaces, museums, art spaces. Only because it was tech
workers in SF does anyone suddenly pretend like first-come first-served
laissez faire is the only acceptable use of shared resources.

~~~
sverige
Obviously the kids that were there had no idea that it could be reserved. See
another comment here about that reservation being available only on an app,
not the website.

The cluelessness is in the aggressive assertion of their "rights" and their
complete failure to listen to what the local kids were saying. Hell, they
couldn't even be bothered to play a pickup game with them.

The frightened / annoyed looks of the two Dropboxers when they realized they
were on video adds to the hilarity. I was pretty sure they wanted to be cops
asserting some bogus right not to be filmed in a public space at that moment.

~~~
red75prime
One party paid the money for reservation, other party is ignorant of the
rules. Situation is pretty clear to me, but I'm programmer and have trouble
noticing subtle unwritten social rules.

~~~
gyom
Sure, the rules are simple, but if you listen to the guy who says that he grew
up here, he explains that field has NEVER been reserved. It’s easy to imagine
how some bureaucrat updated the rules and accidentally destroyed a nice social
space by turning it into a field that people pay for, use, and leave (opposed
to a more spontaneous meeting place for young people who aren’t that
organized).

You can’t fault the Dropbox people there for making a reservation and
expecting that it would be valid. They’re a bit clueless in how they respond,
though, not realizing that those rules are clashing with the unofficial social
dynamics happening there.

(Semi-related : That’s why we might feel that banks are assholes for
foreclosing houses that belong to deployed soldiers. Legally they can do it,
but it sounds like it’s the shittiest application of the law.)

------
NiklasMort
Let's be honest here, lot of people should be, there are too many jobs in tech
that are morally questionable and people just do it because they get a 6+
figure salary. I had a personal experience with that in a new company and
within the first hour some upper head stated "we don't like opensource,
opensource is a problem" (silicon valley company). Lot of other related
issues, see the threads on the homelessness issue that was posted today.
Silicon Valley is living in a bubble

~~~
thisisit
I don't get it. How is stating "we don't like opensource, opensource is a
problem" considered morally questionable or bad? There are lot of companies
out there, outside SV, which don't really care for open source for various
reasons. Whether they are correct or not, is a separate matter.

~~~
spacelizard
You can tell a lot about a company by their attitude on this. The fact that
"you should let your users have freedom" is still a controversial statement in
those type of companies should tip you off as to how they treat their
customers.

Also, the fact that we still often have to use "open source" as a euphemism
for "free software" in these type of situations illustrates the point even
further. Freedom or liberty does not matter to these companies. It's not even
about money or greed to them as they often give away their software/services
without charging. All they care about is establishing complete control and
dominance of the market.

~~~
thisisit
I think you are conflating two different things here. I am not debating the
first paragraph on how companies treat users but I really doubt the 2nd para.

Not using "open source" doesn't mean what you are implying. There are a lot of
considerations companies go through on selecting to work on OSS or not.

That said, the quoted example is confusing at best. Companies are made of
people and people have biases. You never know what kind of bias or
consideration the hiring manager had in mind. Normally, for me if someone
makes a statement which I don't agree with - I do make an effort to ask
"Why?". I don't simply walk off because someone has a different opinion. But
maybe, that is my idea of getting hired - understanding what and why of things
I might end up doing.

~~~
spacelizard
This is exactly what I mean though. The term "open source" has become so
incredibly politicized that it doesn't mean anything any more. I used to use
the term in business contexts but I don't anymore because of this. The real
issue is how they treat others. For me a good metric has been if a company is
willing to focus on empowering the customer and giving them freedom and
liberty.

I've noticed that hammering "why" only seems to work at mid-sized companies --
in the case of a fortune 500, then the whys are usually significantly
disconnected from what most employees are doing, unless you're talking to the
board or senior management, in which case you are probably being paid to
determine the why. In the case of a startup, everyone seems to be running
around like chickens with their heads cut off frantically trying to determine
the "why" but no one is really sure of what it is.

------
KKKKkkkk1
I personally don't know anyone who works in finance, but I doubt that many of
them are ashamed of what they do. And I know plenty of people in tech, and
most of them are actually proud and well respected by their peers for it. So I
guess it's just wishful thinking from the Guardian.

~~~
taternuts
Anecdotal, but I actually work with someone who was in finance making 10x what
the average programmer makes who gave it all up in his late 20's to code
because he felt at the end of the day he was just ripping people off and
morally hated it. Probably not the usual case, though (I'd like to think I'd
do the same, but man, that was a lot of money to give up)

------
guiomie
"Some of these folks aren’t the most socially gifted people and therefore
suddenly having a culture encouraging this experience for them bleeds into
everything, giving them a sense of self importance and entitlement." ... ahah,
there are socially awkward people in every industry, this is just blatant
generalization.

But yah, Silicon Valley is becoming the next Wall Street, I can't count the
number of MBA's at work anymore. I doubt things will get better with tech and
cypto potentially getting bigger.

------
pjs_
This video is pretty strong:
[https://www.youtube.com/watch?v=tYNuR1oaQts](https://www.youtube.com/watch?v=tYNuR1oaQts)

~~~
fragsworth
I don't mean to disparage him but I can't relate to the guy. Maybe I'm cold or
detached, but I feel little to no attachment to the places I grew up in as a
kid, so I personally don't feel like they need to be preserved.

I see it not as a loss, but more like a change.

Also no-fault evicting is not a terrible travesty. It sucks, but usually
there's compensation to help with moving expenses. If the land owners don't
have the ability to do this, renters can hold them by the balls (preventing a
sale) and it would drive rent prices through the roof to compensate for this.

------
mnm1
'“Being in tech puts a badge on you. Things are going bad for a large section
of the economy in this area and here’s a shiny beacon of people getting paid
far too much for what they do."'

While I agree that the execs are paid way too much, this isn't exclusive to
tech. And if they're talking about your run of the mill software engineer
(like me) then I disagree completely. There are multiple logical reasons why
tech salaries are "high" (though really they're not that much higher than many
other engineering disciplines' salaries). Another way to see it is that all
other salaries are too low, but that's beside the point. As someone with tech
skills, I can leave tomorrow and start my own business. If the salaries
weren't high enough, I would either do that or work in a completely different
career. Why would I do software if I could work an easier, less-stressful job
for the same amount of money? And finally, let's face it, most people cannot
write software and will never be able to write software no matter how many
coding camps or classes they attend. Writing software isn't like making
coffee, a process anyone can learn. So people who have never written software,
and probably don't have the capacity to do so if they wanted to, complaining
that run of the mill tech engineers like me are making too much money have no
idea what they're talking about. I challenge them to learn tech, get into the
industry, do real-world work, and then do that for 1/2 or 1/3 of your typical
salary, if that's what they think the jobs are worth. Either that or shut up
and stop being jealous, judgmental children.

------
brad0
> referencing his time at Dropbox when people would “fly around the office on
> these stupid scooters and skateboards”

Why are techies being shamed because they’ve worked hard and spent it on
something they like?

This is why tech has a diversity problem. It’s not the inner culture. It’s the
outer culture and the shame attached to it.

EDIT

I don’t own one of those skateboards/scooters but I do appreciate working in a
culture where people similar to me finally feel comfortable to be themselves
without judgement.

I feel that the people quoted in this article are a bit too manipulated by
other’s opinions.

In the end you have to ask yourself: are _you_ happy doing the work here? If
not, then change. But if you yourself are happy and you leave because of the
media’s opinion then you’re setting yourself up for a miserable life.

~~~
tomjen3
Why are techies being shamed because they’ve worked hard and spent it on
something they like?

Cause the powers that used to be (newspapers, the established parties) are
scared. More and more power is in the hands of the tech industry and it is
reasonably popular (last numbers I read was that google had 88% approval,
whereas the approval of congress compared disfavourably with AIDS). Tech was
the wunderkind and underdog in the 90ies, mostly harmless and a producer of
shiny toys.

Tech now has some amount of power, but because we are still outsiders we get
stupid articles like that. My hope is that google figures out how to run an AI
newspaper (so the articles can be made free) and use it to remove the rest of
the power from the incumbents because they do too much damage to us.

------
jstewartmobile
Until Google joins Goldman Sachs as yet another unelected branch of the
government, I think they're overstating it a bit.

I'm sure Google's working hard on it though!

~~~
lovich
Google and Facebook have already taken a good chunk of the fourth estate

~~~
jstewartmobile
When they get their $1T+ bailout at a moment's notice, I'll agree with
"became". For now, they're just evil Jr.--still in the process of becoming.

~~~
lovich
I get your point about government intervention, but you spoke about an
unelected branch of the government. They are the new media and the media has
traditionally been considered an unofficial branch of the government

~~~
jstewartmobile
Still a long climb up evil mtn. if they want to push the bankers off their
spot.

Most poor people I know are only poor because of finance--title loans, student
loans, rent-a-center, medical debt, credit cards, etc., and it's a race to the
bottom for everyone since the banking system diminishes the value of cash
faster than most people can accumulate it.

At least Google is providing some kind of benefit to mankind alongside their
fuckery.

------
mcgarnagle
From one poison to the other.

------
lin_lin
The Guardian has a clear anti-tech/SV bias, I'll take the lot with a desert
spoon of salt.

~~~
ionised
And once upon a time it had an almost sycophantic pro-tech/SV bias.

Think about what has changed instead of just dismissing an argument outright
without addressing any of its points.

~~~
lin_lin
I honestly don't remember that. I could easily have predicated what would come
up in the article, the G have a bizarre fascination with that mini-shuttle
protesting story. It comes up in pretty much every tech/SV story. Throw in a
bunch of anecdotes, a few jabs at gentrification (because it's only tech
people who are responsible for it, not planning etc), the hilarious
implication that most techies work for the big companies listed when you and I
both know that bs, a video of a few morons from Dropbox and somehow that all
equates to techies being the new bankers? Really? That's got past an editor?

------
alphonsegaston
It didn’t have to be this way and it still isn’t the only path we have. It’s
possible to build technologies that are fundamentally more socialist and
redistribute wealth back to their users. Social media is disruptible in this
fashion and so is gathering data for training AIs.

San Francisco’s poverty and squalor is already a concrete example of where
this Wall St 2.0 mentality leads. Let’s work on escaping this path.

~~~
stevenwoo
Your argument would hold more water if the homelessness issue were not a
problem all across coastal cities in California. I don't know what the cause
is, but it isn't the technology industry, and I'm not a huge technology
induestry booster.

~~~
alphonsegaston
Extreme wealth inequality is the source of the problem everywhere. In SF, that
inequality is driven by tech.


Cloaking a 3-D object from all angles demonstrated - chunkyslink
http://www.bbc.co.uk/news/science-environment-16726609

======
blcArmadillo
Kinda reminds me of [http://www.eecs.umich.edu/eecs/about/articles/2011/guo-
camou...](http://www.eecs.umich.edu/eecs/about/articles/2011/guo-
camouflage.html).


Elm in Production: 25K Lines Later - Albert_Camus
https://charukiewi.cz/posts/elm/
======
ToJans
First:

> Elm has an incredibly powerful type system

Near the end of the article:

>Want to decode some JSON? Hard, especially if the JSON is heavily nested and
it must be decoded to custom types defined in your application.

IMHO the lack of typeclasses/traits is really hurting Elm. Take haskell f.e.

      {-# LANGUAGE DeriveGeneric #-}

      import GHC.Generics

      data Person = Person {
            name :: Text
          , age  :: Int
          } deriving (Generic, Show)

      instance ToJSON Person
      instance FromJSON Person

While I understand Evan's aversion against complexity, it makes me a bit wary
about using ElmLang in production. I am currently using TypeScript, but if I
would need a more powerful type system, I would probably switch to
Haskell/PureScript or OCaml/BuckleScript instead.

~~~
fbonetti
I really wish people would stop spreading the meme that decoding JSON in Elm
is "hard". Yes, Haskell allows you to automatically decode/encode datatypes,
but this only works in the simplest of cases. For example, if your backend
returns a JSON object with snake-cased fields, but your model has camel-cased
fields, `instance ToJSON Person` won't work; you'll have to write a custom
decoder. The automatic decoders/encoders in Haskell only work if the shape of
your JSON perfectly matches your record definition.

Writing decoders in Elm is not hard. It's manual. It's explicit. It forces you
to specify what should happen if the JSON object has missing fields, incorrect
types, or is otherwise malformed. There's a slight learning curve and it can
be time consuming at first, but it guarantees that your application won't blow
up at runtime because of some bad data. Because of this, JSON decoding is
frankly one of my favorite parts about Elm.

Typescript, on the other hand, offers no such guarantee. If you write a
function that takes an Int and you accidentally pass it a String from a JSON
response, your app will blow up and there's the nothing the compiler can do to
help you. Personally, I'd rather write JSON decoders than have my app blow up
because of a silly mistake.

~~~
somenewacc
You don't need to write the decoder boilerplate manually to get all those
benefits.

For example, here's how you rename a JSON field while
serializing/deserializing a data type in Rust:

[https://play.rust-
lang.org/?gist=1b382bc1572858841d5e392435d...](https://play.rust-
lang.org/?gist=1b382bc1572858841d5e392435de73f4&version=stable)

You just annotate the field with #[serde(rename = "..")]. Here is a list of
such annotations

[https://serde.rs/field-attrs.html](https://serde.rs/field-attrs.html)

Serde is also generic in the serialization format; the example I linked uses
serde_json, and was adapted from its README here [https://github.com/serde-
rs/json](https://github.com/serde-rs/json)

~~~
MaxGabriel
Same for Haskell. This package provides common translations like snake_case to
CamelCase:

[https://www.stackage.org/haddock/lts-9.0/aeson-
casing-0.1.0....](https://www.stackage.org/haddock/lts-9.0/aeson-
casing-0.1.0.5/Data-Aeson-Casing.html)

Giving you automatic encoders/decoders like so:

instance ToJSON Person where toJSON = genericToJSON $ aesonPrefix snakeCase
instance FromJSON Person where parseJSON = genericParseJSON $ aesonPrefix
snakeCase

And the implementation of that package is like 4 simple lines for snake case;
it's totally doable on your own for whatever you need
[https://github.com/AndrewRademacher/aeson-
casing/blob/260d18...](https://github.com/AndrewRademacher/aeson-
casing/blob/260d18d62bbb57240b0b7b1e908c8a896ffd8d77/src/Data/Aeson/Casing/Internal.hs#L34-L40)

I haven't had to do snake_case to CamelCase with Aeson before, but I have
dropped a prefix before, like "userName" -> "name", "userAge" -> "age", and it
was pretty easy and well supported.

Also I would note that this isn't as big of a deal for Haskell and Rust,
because they're primarily backend languages, so they're more often sending out
JSON in whatever form they please, rather than consuming it. In my experience
the main consumers (Javascript on the web, Objective-C on iOS and Java on
Android) use CamelCase anyway, so there's a natural compatibility.

------
antouank
After doing a couple of contracts on Elm projects for several months, and
returning now back to a React-Redux stack project, I cannot emphasize enough
how much better working with Elm is.

In every single aspect. I just wish that it will get mainstream as soon as
possible.

His article is spot on, and agrees with what I've seen, and most others that
used Elm. Just look it up.

~~~
StreamBright
I am more interested in the details that just this blank statement that
everything is better. After trying Elm several times we failed to implement
even basic things in it that we could do in React/Redux easily. For an average
JS developer Elm is totally alien tech compare to React or Angular. For
Haskell programmers Elm is pretty appealing because of the familiar syntax and
type system, but the intersection of Haskell programmers and frontend
developers are pretty small.

~~~
antouank

         For an average JS developer Elm is totally alien tech compare to React or Angular

To turn your argument the other way. The JS landscape, where "trendy"
libraries change every few months, is also alien to anyone that doesn't keep
with the latest libraries every few months. Is that not worse? I don't have to
explain "JS fatigue", it's a fact.

For example, I just got into a new team, and I have to now use what they use.
I've been doing JS for 4+ years, and that stack I'm facing now, is alien and
confusing to me. I have to invest time and learn what the hell those redux-
sagas are, or what "magic" create-react-app tools hide, and in general, it's
very confusing so far.

With Elm, I spent a few weeks 1 year ago to learn the language, and that was
it. All the libraries are very simple to use because of the language. I doubt
that learning "redux-sagas" will help me a year from now.

Also, Elm, gives a very coherent package. You don't have to transpile or add a
linter, or a type checker, or stitch new libraries every few months because
the trend changed. No webpack or babel or eslint or immutable.js or typescript
or flow or any of those.

Not to go into the part of the safety and confidence the compiler gives you.
Typescript or flow are not even close to that quality and guarantee level.
_Note that again you have to learn their syntax and configure them, so that 's
again a cost on top of learning JS. And they are as much alien as Elm._

FWIW, I start now side-projects in Elm, and I get things done way faster than
with JS. And that's also what I see from other people as well, regardless of
whether they come from JS or another language.

~~~
StreamBright
Well sure, but as an architect/CTO I do not care about trendy, I care only
about properly working, easy to develop and maintain and wildly used so I can
hire for. Elm is none of these at the moment, but React is.

~~~
rtfeldman
Properly working, check.

Easy to develop and maintain, big check.

Widely used so you can hire - it's usually easier to hire Elm developers
because there are more people who want to use it than jobs hiring for it. The
opposite is true for JS. So...better than check, at least for right now! :)

Here is a CTO giving a talk about his company's experiences with Elm:

"Elm from a business perspective" \-
[https://www.youtube.com/watch?v=DvQI1KntMhk](https://www.youtube.com/watch?v=DvQI1KntMhk)

------
dmjio
If decoding json in Elm is considered hard, I'd recommend checking out _miso_
([https://github.com/dmjio/miso](https://github.com/dmjio/miso)), a Haskell
re-implementation of the Elm arch. It has access to mature json libraries like
_aeson_ for that sort of thing, along with mature lens libraries for updating
your model. Here's an example of decoding json with GHC.Generics using
typeclasses.
[https://github.com/dmjio/miso/blob/master/examples/xhr/Main....](https://github.com/dmjio/miso/blob/master/examples/xhr/Main.hs#L130-L131)

~~~
enalicho
You don't need to switch a whole language because of JSON decoding. There are
many tools that exist to aid you write JSON decoders in Elm. The language is
not just about the architecture -- you can implement the architecture in any
language, as Redux has proven. What people like about Elm is the compiler and
design philosophy that radiates through the entire community. Switching to
Haskell won't give you that, as the Haskell community has different
priorities.

Here are some JSON tools for Elm:

\- json-to-elm [http://json2elm.com](http://json2elm.com)

\- swagger-elm [https://github.com/ahultgren/swagger-
elm/](https://github.com/ahultgren/swagger-elm/)

\- elm-graphql [https://github.com/jahewson/elm-
graphql](https://github.com/jahewson/elm-graphql),
[https://github.com/jamesmacaulay/elm-
graphql](https://github.com/jamesmacaulay/elm-graphql)

\- elm-export [https://hackage.haskell.org/package/elm-
export](https://hackage.haskell.org/package/elm-export)

~~~
desireco42
Oh, this is awesome, json2elm really helps :) thanks, didn't know about it.

~~~
enalicho
No problem! Glad you found it useful :) It's not perfect by any means, but
it's not meant to be.

~~~
desireco42
Yeah right, just to jumpstart the effort, especially when there are a lot of
entities.

------
endgame
I'm really looking forward to the day when all these new-to-Elm people start
hitting the complexity ceiling of their language and convince the maintainers
to add just a little more power. Example: Haskell's typeclasses have a high
power-to-weight ratio, and Elm has to work around their absence (e.g., writing
a fresh map function for each data type). Once there's a critical mass of
frontend types who understand the power of FP, convincing people to try FP
won't be the difficult step any more, and Elm won't need to try so hard to be
un-intimidating.

~~~
dmitriid
Can't for the life of me figure out why people equate FP with the abomination
that Haskell is.

Erlang is FP. Javascript is FP. Ocaml is FP.

Type classes, or anything else that has "types" in them such as dependent, or
liquid, are not FP, they are types. Types that found their way into a couple
of FP languages.

~~~
ykler
I don't think many people (and not the parent) "equate" FP with Haskell, but
Haskell is in a way the most functional mainstream language because it is the
only lazy one. You can have a purely functional language without laziness in
principle, but, as Simon Peyton-Jones points has said, laziness, despite
having serious costs, keeps a language designer honest by making it impossible
to add side effects. The non-lazy languages all have side effects. A language
like OCaml can still be relatively functional because of the way it is
typically used. While JavaScript is not traditionally used in a functional way
but can be.

[http://www.cs.nott.ac.uk/~gmh/appsem-
slides/peytonjones.ppt](http://www.cs.nott.ac.uk/~gmh/appsem-
slides/peytonjones.ppt)

~~~
dmitriid
> Haskell is in a way the most functional mainstream language

1\. Is it the most functional language because it's lazy? No

2\. Is it the most mainstream language because it's lazy? No

3\. Is it the most functional mainstream language because it's lazy? No + no =
no

Laziness does not a functional language make.

> You can have a purely functional language

What would be the purpose of a pure FP? Oh. There would be no purpose.

> laziness ... keeps a language designer honest by making it impossible to add
> side effects

wat

Laziness is delayed execution. That's it. There's _nothing_ stopping you from
delaying a side effect.

~~~
chriswarbo
> Laziness is delayed execution. That's it. There's _nothing_ stopping you
> from delaying a side effect.

Laziness is about more than just side effects.

I think "evaluation" or "reduction" would be better words than "execution"
here. Laziness (call by need) is an evaluation strategy for (beta-)reducing
expressions, which has two nice properties:

\- If an expression can be reduced without diverging by _some_ evaluation
strategy, then it can be reduced without diverging using call by need.

\- Efficiency, in the sense that no duplicated work is performed.

The other common evaluation strategies are call by name and call by value.
Call by name has the first property, but not the second; so there are cases
when it's exponentially slower than call by need. Call by value has the second
property, but not the first, so there are cases when it diverges
unnecessarily.

This 'unnecessary divergence' is a major reason why most programming languages
end up overly complicated to understand (at least, mathematically). For
example, consider something like a pair `(cons x y)`, and its projection
functions `car` and `cdr`. We might want to describe their behaviour like
this:

        ∀x. ∀y. (car (cons x y)) = x
        ∀x. ∀y. (cdr (cons x y)) = y

This is perfectly correct if we're using call by name or call by need, but
it's wrong if we're using call by value. Why? Because under call by value
`(car (cons x y))` and `(cdr (cons x y))` will diverge if either `x` or `y`
diverges. Since the right-hand-sides only contain one variable each, they
don't care whether or not the other diverges.

This is why Haskell programs can focus on constructing and destructing data,
whilst most other languages must concern themselves with control flow at every
point (branching, looping, divergence, delaying, forcing, etc.).

~~~
dmitriid
Thank you! I clean forgot about call-by-need vs. call-by-value

------
advanderveer
What an excellent article: from tech to business, from the human aspect to
practical code examples. Worth a read, even if you're not considering Elm.

~~~
akuji1993
Not into Elm at all right now and also kind of not convinced about functional
programming, yet. But the article was definitely worth a read. I need to
slowly open up for FP, I guess.

~~~
moomin
I'll make an observation: I write C# for a living. The great thing about that
is that it has a truly great debugger. But, as you rapidly discover, it's
easier to debug some code than others. For one thing, you want to be able to
go back to the start of the function and re-run it. That means that methods
that mutate internal state are hard to debug. Also, it's even better if you
can follow the chain of reasoning without rerunning the code. This means
having a variable for each assignment, rather than overwriting an existing
one. Finally, when processing large data lists, it's easier to debug if you
have separate variables for logical steps. e.g. Get the employees of Company X
(variable) that are managers (variable) and sum their salaries (variable).
Trying to debug round a for loop is an exercise in frustration.

What all these things have in common is: it's easier to reason about the
values in a program than the program counter, and that destroying information
makes it harder too. And that, to a great extent, is why FP is useful. Even
really basic FP in C# or Java.

~~~
moogly
Dumb question: Have you tried IntelliTrace in VS Enterprise (sadly only
available there)? It tries to solve many of the issues you're mentioning. You
can even start a remote IntelliTrace debugging session in production.

~~~
moomin
Not a VS enterprise shop, sadly. Don't think I've ever worked for anyone
prepared to pay for it! It does sound enormously cool. Does it also handle one
of my favourite problems: when a method fails because a constructor parameter
was wrong, it's pretty hard to rewind.

With that said, VS Pro still has one of the best debuggers on any platform. To
the extent that I think C# developers sometimes cut corners because the
debugger helps so much.

------
dmitriid
> making very heavy use of Ajax calls to a JSON-based RESTful API

and then

> Want to decode some JSON? Hard, especially if the JSON is heavily nested and
> it must be decoded to custom types defined in your application. Doing this
> will require an understanding of how JSON decoding works in Elm and will
> usually result in quite a bit of code (our application contains over 900
> lines of JSON decoders alone).

What a great pragmatic language

~~~
Albert_Camus
Author here. As I posted in a different reply:

JSON decoding is hard relative to what it is like in JavaScript. In your JS
code you can just call JSON.parse() and get the corresponding JavaScript
object.

In Elm, decoding is not nearly as easy as it is in JS because every field must
be explicitly converted to an Elm value. Depending on the complexity of your
conversion from JSON to Elm value (e.g. whether you are just decoding to
primitive values or to custom types defined in your program), there may also
be a bit of a learning curve.

As I stated in the post, there is a benefit in doing all of this: your Elm
application will effectively type-check your JSON and reject it if it is
malformed.

~~~
maxiepoo
Can you not do the same thing as JSON.parse() in Elm by parsing into an
unstructured JSON type?

~~~
mjaniczek
Parsing into Json.Encode.Value gives you that Value but no way to work with it
except, at later time, using Json.Decode.decodeValue on it. And you're back to
specifying decoders...

~~~
maxiepoo
Seems like you could easily make a library that just parses into some Union
type that represents JSON values.

It's likely a design decision to force people that otherwise wouldn't to
represent their data in a more structured way.

------
iamwil
Having started using Elm for side projects over 3 years ago, the article is
pretty much spot on.

Programming in Elm had been a delight, especially when you let go of OOP and
embrace functional concepts and practices. On one hand, you lose mental tools
that you've relied on, but you gain the other tools you didn't even know
existed before.

Where I really disliked about Elm is when I had to encode or decode JSON. It's
a giant royal pain in the ass. Also, when you find you have to break out to JS
often for libraries you don't want to write yourself, it's not a good fit--as
I found out when write a toy interactive notebook to render markdown in Elm.

But for most SPA that just manipulate form data and communicate with the
server, it's a pretty great fit.

~~~
kristianp
Isn't decoding JSON a big part of an SPA though? How do you deal with data
from the server?

~~~
enalicho
There exist multiple tools to aid you with writing decoders:

\- json-to-elm [http://json2elm.com](http://json2elm.com)

\- swagger-elm [https://github.com/ahultgren/swagger-
elm/](https://github.com/ahultgren/swagger-elm/)

\- elm-graphql [https://github.com/jahewson/elm-
graphql](https://github.com/jahewson/elm-graphql),
[https://github.com/jamesmacaulay/elm-
graphql](https://github.com/jamesmacaulay/elm-graphql)

\- elm-export [https://hackage.haskell.org/package/elm-
export](https://hackage.haskell.org/package/elm-export)

Once you've got the hang of it, it's not that hard either. Just time
consuming. That's where json2elm comes in :)

------
noshbrinken
Something I find incredibly off-putting about Elm is the evangelical and
generally unbalanced tone taken by many prominent members of the Elm
community. I almost never come across Elm advocates accepting a valid
criticism of the language. The response almost always amounts to "you don't
understand" or "yes, but". They spend a lot of time celebrating the compiler's
humanistic virtues but seem less clearly humanist in their relation to
original thinking or diversity of thought. So much of Elm community dialogue
(in talks, in articles, in the Elm slack which I follow daily) is simply those
with more experience initiating those with lesser experience into the "Elm
way" of doing things. For this reason, Elm feels more like a framework with a
domain specific language than a fully qualified programming language. And
while it might seem like a gentle introduction to functional programming
techniques, I'm not confidant that it really teaches people the concepts
themselves nor gives them enough room to think critically about how to apply
them. Instead, the task is to internalize and apply the "Elm way". The
inability to even acknowledge the unprecedented labor required simply to parse
a JSON response is a perfect example of the cultish mentality emerging in this
community.

~~~
KirinDave
> less clearly humanist in their relation to original thinking or diversity of
> thought

So what you're frustrated with is that a group of likeminded individuals
celebrates their common point of interest and doesn't make room for you to
nay-say them?

> So much of Elm community dialogue (in talks, in articles, in the Elm slack
> which I follow daily) is simply those with more experience initiating those
> with lesser experience into the "Elm way" of doing things

This could be said of a lot of PL environments. How many Python tutorials stop
midstride to browbeat you about how great Python's way of doing things is?
Sure feels like a lot to me.

> The inability to even acknowledge the unprecedented labor required simply to
> parse a JSON response is a perfect example of the cultish mentality emerging
> in this community.

Right but... what do you want? Acknowledgement? My friend, literally everyone
here is agreeing it's harder than JSON.parse. No one argues it is "easier." I
can't find a handy example in this thread of anyone saying, "Yeah this is
great." There are tools to ease this pain, and there are ways to call external
JS code that does this.

At the end of the day though, validating data structures on the wire both
structurally and for content is a lot of work. Most Javascript projects don't
do it. Hell, most _typescript_ projects just say, 'Well if it breaks it
breaks.'.

By pure coincidence this redacted typescript snippet is up on my other screen:

        function validateTaskArgs(cdata: any, ldata: any): [boolean, IDomainObject1, IDomainObject2] {
            if (cdata === null || ldata === null) {
                return [false, null, null]
            }

            const cdkeys = ["key1", "key2", "key3"]
            const ldkeys = ["key1", "key2", "key3", "key4"]

            const checkKeys = (keyset: string[], obj: any) => {
                const result = keyset.reduce(
                    (p, c) => { return p && !!obj[c]},
                    true)
                return result
            }

            return [
                checkKeys(cdkeys, cdata) && checkKeys(ldkeys, ldata),
                cdata as IDomainObject1,
                ldata as IDomainObject2
            ]
        }

This ugly bit of custom logic just to validate a pair of objects in a larger
json datastructure, and even that has bugs. This can't deal with a bunch of
problems, but it's just too much pain to actually string together the logic in
a composable way in typescript, so I accept this kind of drudgery.

But earlier I actually linked a much more sophisticated piece of purescript
that's about the same size and not only is easier to read and is self-
describing (the code to build the objects IS the spec), but it uses those
properties to report console errors. You can see it here:

[https://gist.github.com/KirinDave/9af0fc90d005164743198692f3...](https://gist.github.com/KirinDave/9af0fc90d005164743198692f380d4d9)

If you want to make Elm better at JSON, that's the sort of stuff you wanna ask
for. And folks will rightly be resistant. Because the programming concepts
that make that work (free applicative, in this case) are not things the elm
target audience has learned about, yet. Elm's leadership is acutely aware of
how big a stack of new concepts they're putting on everyone's plate, and
they're cautious about offering more.

~~~
noshbrinken
Thanks for the code snippets. That actually helps me to understand quite a bit
how Elm's JSON parsing situation can be improved within the FP paradigm.

> So what you're frustrated with is that a group of likeminded individuals
> celebrates their common point of interest and doesn't make room for you to
> nay-say them?

I'm not frustrated with responses to criticisms I've made. In fact, I haven't
made any criticisms (except of course, the ones in the last comment :P). So I
don't have any experience of anyone not making room for _me_. But I have
observed some smart people with well-articulated suggestions get shut down.
It's not that their suggestions weren't accepted but it was the way that their
ideas were received. I haven't actually seen someone who isn't Evan C.
contribute something significant that isn't "doing X like Evan would do it."
In the entire world of this language, there seems to be 1 architect and a
community of implementers. Now, there's nothing wrong with being an
implementer. I am an implementer. But it seems easy to see that cultures are
healthier when there are a diversity of ideas.

I think that your characterization of the Elm community as a "group of
likeminded individuals celebrat(ing) their common point of interest" is
actually close to what I'm talking about. It's great when a programming
language community is passionate about the language. If people enjoy using
that language, it's certainly a good sign. But I wouldn't trust the judgment
of a group of people who can't critique what they love and are unwelcoming to
those who do.

The counterpoint here is Dan Abramov and the Redux community. Dan is
continually pushing people to understand why they are using Redux and _not_ to
see it as a solution for everything. That kind of transparency, and the
continual acknowledgement by Redux maintainers that there is more than one
good way to do something, is the kind of intellectual honesty that I'm using
as a standard in my assessment of Elm.

> How many Python tutorials stop midstride to browbeat you about how great
> Python's way of doing things is?

I couldn't say and it wouldn't change my opinion of Elm.

------
delegate
Anyone familiar with both Elm and Clojurescript ?

Clojurescript's 're-frame' lib implements something similar to the Elm
architecture and is quite pleasant to work with.

How does the Elm experience compare to the Clojurescript experience ?

~~~
hellofunk
Similarities:

1) Re-frame and Elm are both backed by a virtual dom (Re-frame leverages React
behind the scenes, Elm uses virtual-dom)

2) Both impose a single app state

3) Both require user events and outgoing state mutation to be explicitly
defined somewhere outside of the context of a view

4) Both operate on a sort of "game loop" style of processing events and
calling view functions

5) All data is immutable in both languages (though Clojurescript provides
explicit mutable structures if desired, which require special syntax so any
mutation is evident)

Differences:

1) Elm's model is pure FP -- data is passed to a function, and then it calls
other functions. An individual view function in Elm cannot independently
subscribe to any kind of data event, either a state change or a socket
message, etc; it must receive the data it needs as an argument to the function
only. Depending on who you talk to, this is either limiting or properly
restrictive. It does mean that a branch of your Elm user interface should
generally correspond to a single branch of your app state, or that view
functions in complex interfaces must take quite a lot of arguments; this is a
pattern for which re-frame explicitly offers a workaround (though you can also
do it the Elm way in re-frame if you want). In general, these differences lead
to more re-usable components in re-frame than in Elm.

2) Elm has no real asynchronous library for high-level concurrency. Most
Clojurescript projects (at least large SPAs) often leverage core.async as an
abstraction for large UIs that handle many independent processes
simultaneously. Core.async makes clojurescript particularly versatile for
accomplishing things in a single-threaded environment as if it were modelled
with multiple threads.

3) Elm has its own compilation story that is separate from the JS ecosystem.
The Elm devs are working on dead code elimination. Clojurescript projects are
all built on Closure, which provides DCE, compression, and global inlining
which can provide some projects notable speedups. The Closure libraries also
give Clojurescript cross-browser abstractions for hundreds of common tasks in
front-end development that have been battle-tested by Google in all of their
web services, so it can greatly reduce development and debugging time for
complex apps that run everywhere.

4) Elm controls JS interop much differently than Clojurescript. The tradeoff
is that in Clojurescript you will inevitably spend more time debugging runtime
errors, while in Elm you will spend more time developing your JS interop code
and testing cross-browser compatibility.

5) There are many UI libraries available for re-frame because it can wrap
existing JS tools (including wrapping UI libraries built for React). There are
fewer for Elm, and it's more common to roll your own UI in Elm. There are pros
and cons here. I've worked on two large projects in Clojurescript, one which
was all custom UI components and another that leveraged polished libraries in
the wild. The former took much much longer to make but looked more unique.
Having the choice to go either way is a big benefit since project goals widely
vary. If you are primarily a developer/coder and not a web/graphic designer,
you may be frustrated at UI design in Elm. If you work with a designer, this
is not a problem. But if you work alone, having access to a lot of UI tools
can free up your time and efforts quite a bit, and Clojurescript has an edge
here.

6) Types: Elm has static types, while Clojurescript offers clojure.spec (which
is optional though widely used). Spec is a runtime contract system so you can
guarantee that all args passed to functions or setup in data structures meet
specified criteria; not just types of the args, but also any other predicates,
such as a valid range for an integer, etc. For example, an Elm union type
would be a Clojure set, where each element could be a specific data structure
with other specs attached to it. However, Elm has proper static types, which
are caught at compile time, not runtime. There are benefits of both styles. If
you want to tightly catch very specific data aberrations that flow through an
app, clojure.spec is easy to use for that purpose; but if you want more
general checks before the program runs, Elm would be preferable.

7) Performance: All of Clojurescript libraries that wrap React (including Re-
frame, vanilla Reagent, and Om) offer an interesting runtime optimization that
I've not seen in other languages, and is not available in React itself. If the
data that a view function requires (either via its arguments or subscription)
has not changed from the prior render frame, then the entire view function is
skipped without running, since its output would not be any different. What
this means is vast sections of your app's code don't even need to run on each
render frame, and this is not trivial. In a small app, it would make no
difference, but in complex SPAs this can be very significant. Elm offers a
library, Html.Lazy, that attempts something similar, though my impression is
that most Elm projects do not use it since it can be tricky to explicitly add
this behavior; in Clojurescript, it is built in automatically. In Re-frame,
they go an extra step by de-duplicating any queries or subscriptions so that
multiple views which use the same data context do not query, fetch or
calculate the required data more than once, which is then passed to all
requested functions. If you are working on an app that processes lots of data
frequently, this can be the single selling point of using Clojurescript, as it
frees up the CPU to deal with only those things that are guaranteed to require
processing.

Clojure's syntax is very tight and concise, while Elm's language is elegant
but more verbose. I have found that there is approximately a 2.5X increase in
code size in Elm when trying the same ideas out in both languages.

All other things being equal, you can probably get a re-frame app going very
quickly; if you need to prototype something or get to an MVP as soon as
possible, it is really hard to beat Clojurescript compared to any other
compile-to-JS language. If however you are going for application purity and a
reduction in runtime debugging, Elm (or Purescript or some other statically-
typed languages) would be a better fit.

Ultimately, Clojurescript is a general purpose language, while Elm has a very
specific use-case; if you fit into the Elm model, it can be nice. If you need
to reach outside that model, it is a challenge.

~~~
Nekorosu
Worth mentioning that Clojure(Script) comes from a different school of thought
(Lisps) and has its own approach to development called REPL driven
development. It allows you to experiment a lot and fail fast.

Large projects are absolutely doable but require more discipline and
experience with the language from developer. For example you can start with a
crude prototype and introduce clojure.spec later. When you do this is entirely
your choice while in Elm you just have to write function signatures and
types/structures definitions from the beginning.

ClojureScript has a very easy interop with JavaScript. Actually this is one of
design goals. Consuming JavaScript library is super easy. For example most of
virtual DOM libraries are built upon React. This is good because writing
performant virtual DOM with older browsers support isn't an easy task.

The toolchain has code splitting and dead code elimination. It had it long
before Webpack and can even optimize imported JS libraries code. As far as I
know Elm still can't do it.

Another good thing is you can use Clojure(Script) both on the client and the
server. This allows you to nearly skip data serialization/deserialization
using powerful "transit" library. Actually you can use transit on server with
several other languages. So it's not a lock in but it's much smoother with
Clojure.

The libraries ecosystem is rich. For example Clojure(Script) has a mature
WebSockets library (it's both server-side and front-end) with any kind of
fallback you can imagine.

~~~
hellofunk
I agree with much of your points but a few things to add clarification:

While lisps do traditionally provide repl-driven development and you can do
this in Clojure, most Clojure devs I know are not actively working right at
the repl. If you do like some aspects of repl-like interactivity, Elm does
have elm-reactor which has some similarities to Clojurescript's figwheel,
though not quite as mature or comprehensive.

Aside from the repl, you are right that you can get a proof-of-concept going
in Clojurescript extremely fast so if you want to see if an idea succeeds or
fails before investing lots of time, you can't beat Clojurescript.

The Elm toolchain is slowly evolving to include things like dead code
elimination (which it doesn't have yet but probably will in the near future).
However, I think it will be a long time (if ever) that Elm will support global
inlining, automatic variable renaming and some other optimizations that come
for free with the Google Closure compiler support. The other important
difference is that as the Google Closure compiler adds features or further
improves its optimizations, these are mature and widely used and immediately
available for free without much (if any) extra work on the Clojurescript team.
It's a philosophical difference that the Elm devs prefer to solve these
problems on their own rather than leverage existing tools in the industry, but
since the Elm dev community is small (much of it is only one person), this
means that lots of time must be spent on these solutions at the expense of
features more specific to the Elm language.

Also I think you are right that Elm as a language is a little easier to learn
than Clojurescript (though to someone new to FP, both Elm/Haskell style syntax
and Lisp syntax might be equally bizarre). But I think that ease is made up
for by some of the concepts in Elm that can be difficult to learn (decoding,
Tasks, ports, etc), so it's probably a net flat difference on the learning
curves between the two systems.

~~~
mjaniczek
I believe you can use Google Closure Compiler on Elm JS files with great
effect the same as Leiningen uses it on ClojureScript JS files. (Although most
people probably use uglifyjs instead.)

But of course ClojureScript's JS is generated carefully so as to be better
optimizable by Google Closure Compiler, and that's not the case with Elm.
IIRC, in version 0.19 Elm will change it's JS so that it's better optimizable
by uglifyjs.

~~~
hellofunk
> I believe you can use Google Closure Compiler on Elm JS files with great
> effect

No, you can't use the advanced optimizations from Closure compiler in Elm.
This is unlikely to change any time soon because Elm's compiler emits JS that
directly violates one of the restrictions that Closure requires for advanced
optimizations, namely the referencing of field names as a string.

~~~
mjaniczek
Good to know, thanks!

------
steinuil
I've used Elm for a while and I don't really see what's the problem about JSON
decoders/encoders. Sure, they're verbose and annoying to write if you have a
particularly intricate JSON structure, but I don't really see a better
alternative for decoding and encoding JSON in a type-safe way, and with Elm's
constraints on ease of learning.

More freedom on type-level programming would help, but that would certainly
complicate the type system, and the only language I know that lets you fold
over arbitrary record types is Ur/Web, which has a richer type system than
even Haskell, and I don't see Elm adding things to its type system (other than
type classes, hopefully), given that other interesting features were already
removed because very few people used them.

------
unabst
Quick question.

> Want to measure the height of an element on the page at the moment a user
> clicks on it? Hard, in order to do this we had to make heavy use of event
> bubbling and writing JSON decoders for the native event.target object that
> is produced by an onclick event.

What would be considered best practice?

Is it best practice to re-implement this sort of thing? Seems one could easily
find vanilla JS code and encapsulate it, or add a helper lib?

------
fiatjaf
I think JSON decoding is great in Elm. Actually, that may be the best part of
that language.

------
therealmarv
When JSON decoding is hard this is not a minor thing when looking at my
RESTful APIs. This is a major trade off. How to deal with it ideally?

~~~
Albert_Camus
Author here. JSON decoding is hard relative to what it is like in JavaScript.
In your JS code you can just call JSON.parse() and get the corresponding
JavaScript object.

In Elm, decoding is not nearly as easy as it is in JS because every field must
be explicitly converted to an Elm value. Depending on the complexity of your
conversion from JSON to Elm value (e.g. whether you are just decoding to
primitive values or to custom types defined in your program), there may also
be a bit of a learning curve.

As I stated in the post, there is a benefit in doing all of this: your Elm
application will effectively type-check your JSON and reject it if it is
malformed.

~~~
Existenceblinks
> JSON decoding is hard relative to what it is like in JavaScript

I'm not making a joke but this is a valid point. And if it had ELMON (Elm
object notation), things would be more straight forward.

~~~
mavelikara
No, that is not a joke. If one tried to convert an Applet to HTML5 and came
across a server backend that returned serialized Java objects, parsing that
into JS would have been significantly harder than the two lines with
ObjectInputStream it would take in Java.

------
acobster
Great article! I have no experience with Elm but I'm much more likely to try
it out now. I'm curious to hear your thoughts on this though:

[http://reasonablypolymorphic.com/blog/elm-is-
wrong](http://reasonablypolymorphic.com/blog/elm-is-wrong)

~~~
walrus
The core complaint is the lack of typeclasses. If your coding style relies
heavily on generics, maybe Elm isn't for you.

~~~
Skinney
Why? Elm has generics.

------
niels
When I last tried Elm, I didn't find any really good UI libraries. Also there
weren't any good solutions for i18n. Has the situation changed?

~~~
hellofunk
Depends on your needs. If you are targeting desktop, there are a couple of UI
libraries for Elm. However, they are buggy when you try to test them out on a
mobile tablet. I have found that most Elm developers create their own UIs
since wider access to JS UI toolkits is not easy. That does mean that you need
to enjoy general web design or work with a designer, or be willing to put in
extra time when working in Elm.

~~~
niels
Yep, Agree. I specifically used elm-mdl and elm-ui. Elm-mdl were not well
maintained and elm-ui, while nice, is desktop only.

------
anon335dtzbvc
"JSON-based RESTful API as its back end" what language do you use for the
backend, Haskell?

~~~
iamwil
You can use anything that can expose an HTTP port. It doesn't have to be
Haskell.

------
bandrami
I wonder if its successor framework will be called pine.

~~~
mLuby
2019: JSON decoding in Mahogany-lang is hard…


A years-old, one-letter typo led to Aliens: Colonial Marines‘ weird AI - xoa
https://arstechnica.com/gaming/2018/07/a-years-old-one-letter-typo-led-to-aliens-colonial-marines-awful-ai/
======
SerLava
Even with the huge number of other issues plaguing that game, it's staggering
to imagine the amount of dollars that they lost specifically because of that
single "a" keystroke.


From bootcamp student to bootcamp instructor - Pete-Codes
https://www.nocsdegree.com/ex-bootcamp-developer-now-teaches-the-course/
======
Pete-Codes
Author here.

I was chatting to Matt Studdert from Frontend Mentor and I found out that he
now teaches at General Assembly in London where he went to learn to code.
Pretty cool example of the self-taught/no degree route so thought I would
interview him.


Strengthening HTTP: A Personal View - tkorotkikh
https://www.mnot.net/blog/2014/01/04/strengthening_http_a_personal_view
======
rx4g
It's disappointing to hear that the idea of requiring TLS with HTTP/2 has lost
traction. For me, TLS-everywhere _was_ the carrot on the stick.

I recognize that getting consensus is hard work, but I don't think creating
another encryption-optional protocol and letting vendors duke it over security
is going to end well for the users.

      HTTP is a deployed protocol with lots of existing
      stakeholders, like proxy vendors, network operators,
      corporate firewalls and so on. Requiring encryption
      with HTTP/2 means that these stakeholders get
      disenfranchised.

I'd like to hear the arguments of the potentially-disenfranchised stakeholders
first hand. Is it mainly because it makes it harder to sell or use products
that allow traffic snooping?

~~~
matthewmacleod
One obvious change here is that it would make CA-signed certificates mandatory
for all HTTP2 web servers - is that really a situation we want?

~~~
quicksilfer
That doesn't have to be the case. You could still allow self-signage, with all
of the security caveats that presents.

Who knows. Maybe that arrangement could even spur a sorely needed push for a
free certificate trust network and get rid of CA's entirely.

~~~
rx4g
Self-signed certs are much harder to get browsers to accept these days. The "I
know what I'm doing" button and process are becoming ever more complex, and I
wouldn't be surprised if they just start going away in favor of a list of
trusted root CAs, which you may or may not be able to control as a user,
depending on your browser. Which sucks. But anyway.

StartSSL is one place where you can get a free cert for your website today
(and yes, they charge for revocation, but revocation is pretty ineffective
anyway). I got a free cert from them, but my mobile browser doesn't trust it,
so I decided to shell out $10 for a cert that's more widely auto-trusted by
browsers. Not a huge cost, IMO.

------
jbb555
I hate this new HTTP. They seem to have taken a beautifully simple concept and
added so much complexity it's ugly and horrible and awful.

~~~
matthewmacleod
I hear this a lot, but without a consistent argument as to why that's the
case. Do you have anything more than that to offer?

HTTP 1.1 is relatively simple, but it's also a bottleneck.

~~~
protonfish
Don't shift the burden of proof-It is up to HTTP/2 proponents to demonstrate
that the benefits are greater than the costs and from everything I've seen the
benefits are meager and the costs are large.

~~~
matthewmacleod
I'm not trying to shift the burden here, but the point made was along the
lines of "HTTP2 is rubbish" \- I've seen this a lot, with little to back it
up.

But I'd say some of the benefits were:

\- Server push support \- Multiplexed requests/header compression/other
performance improvements \- Mandatory encryption support

Downsides are (from what I understand):

\- Not a plaintext protocol

There may be more downsides, which I'm happy to hear about.

~~~
jimktrains2
> \- Server push support

Couldn't a multi-part document already do this?

> \- Mandatory encryption support

Couldn't they just have said "OK, HTTP 1.2 MUST be done over a TLS
connection?" Also, didn't the TLS-always idea go away recently?

The downsides also include reïmplementing much of level 4 (congestion
management, flow control, &c) and all of the complexity that goes with it.

------
jessaustin
_For example, in the current design of HTTP the decision as to whether to use
encryption is completely up to the server; the only thing the user can do is
observe whether a URL is “HTTP” or “HTTPS” (or maybe watch a lock icon) and
decide whether they can continue surfing._

This seems a strange characterization. As in any other network protocol, if
the client and server don't agree then nothing happens. If either insists on
something the other finds unacceptable (e.g. a 404 response to "GET /your-
secret-plans HTTP/1.1") then the transaction doesn't take place. Perhaps this
could be made more explicit via a header, but what would that really gain?

~~~
rx4g
I think he's saying that clients could decide beforehand whether they want to
go into HTTPS-only mode, for example.

But this is something clients can actually do today, without the need for a
new protocol or any awareness on the server side. URL isn't HTTPS? Don't load
it. I actually did a Firefox plugin that implements this, called http-nowhere.

~~~
matthewmacleod
_But this is something clients can actually do today, without the need for a
new protocol or any awareness on the server side. URL isn 't HTTPS? Don't load
it. I actually did a Firefox plugin that implements this, called http-
nowhere._

Yes - and my understanding is that the browser developers are going to require
all HTTP2 connections to be over TLS anyway.

------
jimktrains2
Beyond everything else, someone should have stopped and said "Wait, this is
level 4 stuff we're implementing in level 7. There has to be a saner way"

I also find the naming very disingenuous. This is not even an HTTP-style
protocol, it should not be named HTTP2.

As for people who want to require CA certs everywhere: Are all the free certs
out there accepted by all browsers? (Honest question).

------
higherpurpose
There goes HTTP2's most exciting feature. I guess IETF will remain as useless
as ever. Strong encryption on the Internet will need to arrive organically
from certain projects catching momentum, and then Internet stakeholders can
adopt them _as they are_ , or risk being left behind. IETF standards will
always have a multitude of compromises to please all the _top_ Internet
stakeholders (even if that's detrimental to the Internet ecosystem and its
security).

Also are those 1 or 2 (from what we know of) NSA employees still shaping
crypto policy at IETF?

------
bkeroack
Forget the hand-waving and excuses, TLS needs to be mandatory, period.

This alone would make me forgive just about any other problem with HTTP/2.

~~~
Touche
Disagree, purely informational websites have no need for TLS.

~~~
rakoo
On the other hand, what's the problem in using TLS for cases you don't think
it useful ? I can see a few reasons here, but I don't see any of them being
enough not to use TLS everywhere:

\- TLS is expensive: my gut says it's wrong, but I'd love to see some numbers.
Ilya Grigorik [0] has done some experiments here, and I don't see TLS as
really bad

\- TLS is complicated: true, and we have to rely on tried and tested
implementations. I'd say you'd need to do it whatever security we use (and we
want security, right?)

\- TLS requires certificates from the flawed CA infrastructure we have: wrong,
public-key authentication isn't even the only authentication scheme possible
with TLS, it's just the first one we think about (and also the most tested
one).

Do you have other counter-arguments ?

[0] [https://www.igvita.com/2013/12/16/optimizing-nginx-tls-
time-...](https://www.igvita.com/2013/12/16/optimizing-nginx-tls-time-to-
first-byte)

~~~
Touche
Those two reasons are enough to me. The web is supposed to be for everyone. A
small restaurant that just has directions and a menu on their website
shouldn't have to deal with the headache of setting up HTTPS.

~~~
x1798DE
If all HTTP connections enforced TLS, how would there be any extra burden?

------
TazeTSchnitzel
Myself, I like the idea of opportunistic encryption. Why not require TLS for
HTTP/2 but don't require authentication for [http://](http://) URLs?

~~~
matthewmacleod
It's hard to see what benefit that would offer. Non-authenticated TLS is
trivially vulnerable to MITM attacks. This is especially the case because I
can't foresee a situation in which a website would put the effort in to
implement opportunistic TLS, but not implement straightforward authenticated
HTTPS…

~~~
TazeTSchnitzel
It completely prevents passive surveillance, however. Sure, you can MITM, but
the point is now to look at _anything_ you _have to_ do an MITM attack, unlike
now, where most traffic is unencrypted and you can do surveillance passively.
This makes surveillance more difficult. Net gain for everyone.

~~~
matthewmacleod
I'll concede that passive surveillance would not be possible. However, I think
that benefit is marginal - AFAIK, unencrypted support in HTTP2 is optional and
won't be supported by browsers in any case.


Focus on Results Not time - zemariamm
http://www.behancemag.com/Tip-Focus-on-Results-Not-Time/5718

======
dangrover
A lot of the time, keeping track of the time I spend on non-billable projects
is the only way to keep myself going. But I don't use it as the sole metric
for gauging my productivity.


Trump issues executive orders with effective bans of TikTok, WeChat - lvturner
https://www.cnet.com/news/trump-issues-executive-orders-with-effective-bans-of-tiktok-wechat/
======
Traster
I would imagine this is going to be struck down by a court not because he
doesn't have the power to do this, but because he'll have failed to adhere to
a fair process in coming up with this - the same reason that his DACA decision
was over-turned by the supreme court.

------
tellarin
This also potentially has many ramifications in different industries. Tencent
(owner of WeChat) is a big investor in media and entertainment companies. One
side effect, for example, is blocking financial payments to Riot Games, Epic
Games, Fortnite, and half the gaming industry.

~~~
jimmygrapes
The current wording seems to apply only to transactions involving WeChat,
leaving Tencent's other holdings alone... for now.

------
nicbou
> The concern stems from the data that TikTok and WeChat collects on their US
> users, as well as the perceived inability of Chinese companies like
> ByteDance and TenCent to reject requests from China's ruling Communist Party
> (CCP) access that data

Isn't this exactly what US companies have been doing to their users? Isn't it
also what the US government has been trying to achieve for years?

As a European user, it looks as if the pot is calling the kettle black.

~~~
aeternum
Yes, but hasn't China also forced US companies (and probably European
companies as well) to sell parts of themselves in order to continue operating
in China?

This can also be interpreted as a way to even the playing field.


Passwordless authentication is here: new Yubico FIDO2 key - rdslw
https://www.yubico.com/2018/04/yubico-and-microsoft-introduce-passwordless-login/?source=me
======
rconti
Can someone help me understand how this is different from the existing YubiKey
products, which I've used?

* Passwordless single factor with AD integration (couldn't this already be done by storing your password on the key?)

* 2factor auth with the token as one of the factors.

From the article:

\-----------

Single Factor: This only requires possession of the Security Key to log in,
allowing for a passwordless tap-and-go experience.

Second-Factor: In a two-factor authentication scenario, such as the current
Google and Facebook FIDO U2F implementations, the Security Key by Yubico is
used as a strong second factor along with a username and password.

Multi-Factor: This allows the use of the Security Key by Yubico with an
additional factor such as a PIN (instead of a password), to meet the high-
assurance requirements of operations like financial transactions, or
submitting a prescription.

~~~
freeone3000
"Passwordless" single factor done by storing your password on the key isn't
passwordless. You have a password. U2F replaces the password with a "bearer"
authentication token - it's two-factor auth without the password, instead of a
password-manager based approach.

The actual announcement in this blog post is Azure AD and Windows 10
integration, not anything new by Yubico.

~~~
bonestamp2
In the "passwordless" scenario... if someone stole your yubikey, could they
access anything you had authenticated it for?

~~~
rconti
and/or could they press the button in a terminal and get your token printed
out in plaintext, in a way that could be reused?

~~~
LammyL
In single factor mode (passwordless), your token is your password. So if you
lose it, someone could access your accounts if they know your username.

The USB tokens don’t store a password, they store a master key pair, and then
derives a site-specific key pair based on the URL you are connecting to. The
site issues a challenge and the token signs it. This prevents replay attacks,
and there is no way to export the secrets from the token. There is also no way
to authenticate to a site by just having the key plugged in - you have to
press the button on it. There is no way through software, even low level usb-
hid commands, to trigger the button press.

Overall it’s really well designed and more secure than passwords, even in
single factor mode.

The major downsides are that it requires browser support, and doesn’t work
with iOS.

------
cmurf
This is what I want for family members: the end to passwords and the end to
using Facebook (or even Google for that matter) to authenticate logins. I
continue to lament the end of Mozilla Persona.

------
eganist
Legal wonks:

I know biometric identification isn't afforded the same protection by law on
the basis that biometrics are public (e.g. fingerprints are left everywhere),
but what about physical keys? FIDO2 is entirely analogous to a physical key,
and it's not exactly public the way biomtrics are.

I'd still prefer a password for that added 5th amendment layer of protection,
but I'm looking for what legal minds think about this right now.


Sinclair's script for stations [video] - fahd777
https://www.youtube.com/watch?v=hWLjYJ4BzvI
======
lstamour
As background:
[https://m.youtube.com/watch?v=GvtNyOzGogc](https://m.youtube.com/watch?v=GvtNyOzGogc)
(Last Week Tonight)

------
smoll
Hmm... I wonder if this is extremely dangerous to our democracy.

------
hidenotslide
Reminds me of the old Conan segment that highlighted this behavior. Here are
some clips from 2012-2014.

Twinkie Trouble
[https://www.youtube.com/watch?v=OzdV0Imti3s&ab_channel=TeamC...](https://www.youtube.com/watch?v=OzdV0Imti3s&ab_channel=TeamCoco)

Could this be the end of email overload?
[https://www.youtube.com/watch?v=8p7RnDQwFRw&ab_channel=TeamC...](https://www.youtube.com/watch?v=8p7RnDQwFRw&ab_channel=TeamCoco)

I scream, you scream, you know the rest.
[https://www.youtube.com/watch?v=46-fI18pJyw&ab_channel=TeamC...](https://www.youtube.com/watch?v=46-fI18pJyw&ab_channel=TeamCoco)

Enjoyed from a desk or the couch.
[https://www.youtube.com/watch?v=QZnoSy7NHgI&ab_channel=TeamC...](https://www.youtube.com/watch?v=QZnoSy7NHgI&ab_channel=TeamCoco)

You don't need us to tell you that gas prices are back on the rise.
[https://www.youtube.com/watch?v=dAkxR9T01pw&ab_channel=TeamC...](https://www.youtube.com/watch?v=dAkxR9T01pw&ab_channel=TeamCoco)

Economic factors may take some spring out of the Easter Bunny's step this
year.
[https://www.youtube.com/watch?v=dguiAWrUGMM&ab_channel=TeamC...](https://www.youtube.com/watch?v=dguiAWrUGMM&ab_channel=TeamCoco)

A child's happiness is priceless, especially on a birthday.
[https://www.youtube.com/watch?v=dFsDnn9FjOQ&ab_channel=TeamC...](https://www.youtube.com/watch?v=dFsDnn9FjOQ&ab_channel=TeamCoco)

Mike Myers says "Yeah, Baby."
[https://www.youtube.com/watch?v=RIevazPIPzU&ab_channel=TeamC...](https://www.youtube.com/watch?v=RIevazPIPzU&ab_channel=TeamCoco)

It's okay, you can admit it if you've bought an item, or two, or ten for
yourself.
[https://www.youtube.com/watch?v=TM8L7bdwVaA&ab_channel=TeamC...](https://www.youtube.com/watch?v=TM8L7bdwVaA&ab_channel=TeamCoco)

Don't worry, be happy.
[https://www.youtube.com/watch?v=KZ1mA1NeUmU&ab_channel=TeamC...](https://www.youtube.com/watch?v=KZ1mA1NeUmU&ab_channel=TeamCoco)

Those with a special someone may look to their mobile device to help them say
"I love you."
[https://www.youtube.com/watch?v=44ojS4UNn8I&ab_channel=TeamC...](https://www.youtube.com/watch?v=44ojS4UNn8I&ab_channel=TeamCoco)

Frank Ocean tells a major fast food chain to buzz off, and which celeb peed in
a glass jar?
[https://www.youtube.com/watch?v=u41bQG_Ll7E&ab_channel=TeamC...](https://www.youtube.com/watch?v=u41bQG_Ll7E&ab_channel=TeamCoco)

Is it time for dogs to have a social network of their own?
[https://www.youtube.com/watch?v=dZElSajQdOo&index=13&list=RD...](https://www.youtube.com/watch?v=dZElSajQdOo&index=13&list=RDu41bQG_Ll7E&ab_channel=TeamCoco)

The final days of the campaign can get a little salty.
[https://www.youtube.com/watch?v=hKziIEXT6MU&index=18&list=RD...](https://www.youtube.com/watch?v=hKziIEXT6MU&index=18&list=RDu41bQG_Ll7E&ab_channel=TeamCoco)

------
anonytrary
This reminds me heavily of Gail Wynand in The Fountainhead, by Ayn Rand. That
said, this video probably suffers from some sort of selection bias. However, I
do not doubt that a centralized group of individuals can pull the rights
strings in the right places in order to achieve a desired outcome. There exist
people who stand to gain from the destruction of Facebook.

If the incumbents of mainstream media could somehow get rid of Facebook by
encouraging legislation to be passed which prevents unqualified individuals
from disseminating news, it would not be a win for society at all, even if
it's a loss for Facebook. There is a fine line between regulating Facebook and
destroying freedom of speech on the internet. It would seem that the very
notion that Facebook is a tool for democracy destruction is more dangerous
than Facebook itself.

It seems crazy to think this is even possible, but I don't put anything past
anti-terrorism efforts. I am quite afraid to consider such an outcome. I find
myself conflicted; if Facebook goes down, I really hope it's for the right
reasons. I really hope freedom is not taken away in this ordeal. We are
already starting to see freedoms being taken away from the people. YouTube,
Craigslist, etc. have already banned certain types of content in the past 2
weeks because of new legislation.


A Professor Tried to End a Sit-In with Bolt Cutters. Now He’s Been Fired - gok
https://www.nytimes.com/2019/08/11/us/johns-hopkins-povey.html
======
deogeo
I watched the video linked in the article. When the professor grabs someone's
arm (someone trying to obstruct him), this is labeled (by the video) an
'assault'. When he is dragged out of the building, being restrained by
multiple protesters, this is not an assault - but the person punching one of
the protesters, I assume to try and get them to let go of the professor - that
_is_ labeled an assault.

And the professor's plan to enter the building is labeled a 'premeditated
attack'. The six people he had with him (far outnumbered by the protesters)
are labeled a 'mob'.

Oh, and the video (in which the worst thing is a punch seen from afar) starts
with a scary content warning for "physical assault and violence, abusive
language, swearing".

Protests have been reduced to victimhood competitions, but rarely have I seen
them become _this_ pathetic.

------
exabrial
I feel bad for the guy; had to be horrible watching your life's work being
destroyed.

Chaining buildings shut is a fire hazard at the minimum, but felony
trespassing + breaking & entering in reality. I understand the university
officials desire to not make a scene, but not doing anything is just as bad.

~~~
toomuchtodo
As opposed to not having students arrested for trespassing in Garland Hall for
34 days? The disparity in consequences is striking. Why would you not expel
the students who participated? Why did Baltimore's prosecutor drop all charges
against the sit in participants who refused to leave after being offered
immunity? You have the right to protest, but not for your protest to be
consequence-free.

~~~
cvla
> You have the right to protest, but not for your protest to be consequence-
> free.

I don't understand what you mean here. Do you mean that you have the right to
protest, but then you can be punished for protesting? That doesn't sound
right.

~~~
toomuchtodo
The constitution protects your rights with the government, not your college.

------
gok
To those that don't know, Povey is something of a giant in Speech Recognition.
It's hard to find a recent ASR paper that doesn't cite him. So while his
behavior is reprehensible he's probably not wrong that someone will hire him
anyway.

------
scohesc
I hope these protesters realize that the building they're holding hostage from
the university costs money to run and maintain - which will probably be a
factor in tuition costs getting even higher when they go to pay their bill
next year.

If I was the university - I'd start by cutting power and water to the
building. They're being too nice by giving them an out by granting immunity if
they leave.

~~~
deogeo
I wouldn't be so sure - at the more desirable schools, tuition is mostly a
function of what people are willing to pay. That is why it increased so
quickly.

------
AcerbicZero
"He said he had tried to take the building back from the students in part
because a computer server that hosted his research was inside and
malfunctioning."

If he had been successful this would have been a nearly perfect xkcd -
[https://xkcd.com/705/](https://xkcd.com/705/)

I realize that's a little glib, but there isn't much of substance to say about
something like this. If a university wants to abandon one of its buildings to
students (or squatters, etc) going rouge and trying to take the building back
isn't likely to end well for a university employee, regardless of the politics
in play.

------
eridius
> _Povey, 43, also wrote a 1,600-word essay about what happened, along with a
> treatise about how he believes white males are discriminated against in
> “this environment” and how he is expected to act like a “neutered puppy-dog.
> "_

If I had any inclination to feel sorry for the guy, it just evaporated.

(quote comes from a Baltimore Sun version of the article since I'm hitting the
NYT paywall)

~~~
masonic
Note that neither paper gave the full quite in context.

------
musicale
This is bizarre. What was wrong with:

"Hey guys, I'm professor so-and-so, I need to get inside to fix the computer
which I use for my research."

"Oh, professor so-and-so, nice to see you. Sure, come inside and we'll unchain
the door to your lab so you can get in."


Feedback Ladders: How We Encode Code Reviews - swyx
https://www.netlify.com/blog/2020/03/05/feedback-ladders-how-we-encode-code-reviews-at-netlify/
======
aizatto
Just stumbled on this, an interesting convention to use. Thanks for the
thoughts.

~~~
swyx
thanks for reading!


Begginer in C. Critique my code and give ideas? - zeved
https://github.com/zeved/znote

======
zeved
Hello HN. I'm trying to learn / relearn C (for real this time). Wrote this
little tool for linux and I would like some feedback. Also, if you could give
me some ideas for future small projects that would give me more experience in
C... thanks!

~~~
plikan13

      int get_number(char buffer[])
      {
        long int i = 0;
        char *p;
        if(fgets(buffer, sizeof(buffer), stdin) != NULL)
      {

sizeof(buffer) will always be 4 (or 8 if you compile 64 bit) because
sizeof(pointer to char) is 4 (or 8). It will NOT be the size of the buffer
that you pass as an argument. To fix this problem you need to change the
function to

      int get_number(char buffer[], int buffer_size)

Also the buffers that you pass to this function seem to be too small.

~~~
zeved
thank you very much. i appreciate it!


TIOBE Index for January 2016 - ryandvm
http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html
======
dzdt
The Redmonk rankings are much better. As opposed to TIOBE, who look at counts
of internet search results, Redmonk looks at code in Github and questions on
Stack Overflow. There should be an update out in the next couple weeks; here
is the latest from half a year ago :
[https://redmonk.com/sogrady/2015/07/01/language-
rankings-6-1...](https://redmonk.com/sogrady/2015/07/01/language-
rankings-6-15/)

~~~
unexpand
+1 for the redmonk.com link. This data looks more inline with what I see
everyday.

------
vruiz
I know it's based on some empirical data, but every time I've looked at a
TIOBE index has made absolutely no sense to me.

~~~
mkozlows
Delphi/ObjectPascal above both Swift AND ObjC? Sure, that makes sense. If it's
1997.

~~~
mamcx
Delphi is very alive (I'm moderator in a Delphi forum). Think this way:
Delphi/FreePascal have almost all the market for a Pascal-alike syntax for
them alone.

With the C-family you have a lot of options.

Also: Nothing beat Delphi at doing RAD apps today.

------
claystu
Tiobe can't be right. It has Assembly ahead of Ruby and right behind
JavaScript. What???

Redmonk looks flawed too. I would expect GitHub to create a major sampling
bias in favor of smaller, throwaway projects, and in fact, a quick search(1)
on GitHub appears to show 2.2 million projects smaller than a kilobyte that
have never gotten a single star. Should those be counted? Do they really
reflect anything meaningful about the language's _rank_?

In my opinion, the only meaningful measure of a programming language worth
_quantifying_ from the net are StackOverFlow tags: they can be counted and
read and provide a real reflection of the language's community without giving
any special preference to language, license, or context.

Everything else is hopelessly subjective: whether or not the language maps
well to a particular problem, whether it maps well to the way you like to
program, and whether it fits into the ecosystem in which you plan to deploy
it. You can't measure those with google searches.

(1)
[https://github.com/search?utf8=%E2%9C%93&q=size%3A%3C1+stars...](https://github.com/search?utf8=%E2%9C%93&q=size%3A%3C1+stars%3A%3C1&type=Repositories&ref=searchresults)

~~~
ad-hominem
Just curious, but are there proper heuristics that are easily implementable to
improve the ranking a language receives from github usage?

For example, only count repositories that have more than 2 stars.

I don't like cutting repos because they are under a certain size, because even
a few bytes may be genuinely useful and widely used, but a repository nobody
is looking at or really using is most likely a pet project.

Maybe count only projects with > 2 stars (or forks?) OR projects with over a
kilobyte of code? Perhaps such a project with no forks, no stars, but a lot of
code might be a reference implementation or used in a talk or blog post or
something but isn't useful other than to reference.

I agree counting all github repos is a silly way to do it.

------
pier25
Poor Objective C, nobody likes you.

[http://www.tiobe.com/index.php/content/paperinfo/tpci/Object...](http://www.tiobe.com/index.php/content/paperinfo/tpci/Objective_C.html)

------
vorg
Notable is the search-engine-optimized rise of Groovy from #82 to #17 in a
mere 12 months. The subsequent TIOBE comment "Scala might gain a permanent top
20 position soon" is probably a back-handed dig by TIOBE at the likely
impermanence of Groovy's top 20 position.

The last time Groovy made the top 20, it hit #18 in Oct 2013, but 3 months
later (Jan 2014), had dropped back out of the top 50 (#32 in Nov, #46 in Dec).
TIOBE said the following month "The data is produced by one of the Chinese
sites that we track is interpreted incorrectly by our algorithms. After we
fixed this bug, Groovy lost much of its ratings." But before that fix
happened, interviews with the current Apache spokesperson for Groovy
(Guillaume Laforge) promoting Groovy's top 20 position were published in 5
online rags (www.infoworld.com, www.eweek.com, cacm.acm.org, jaxenter.com, and
glaforge.appspot.com), and all of them quickly appeared in Google's top 30
search results for "groovy programming" and remained there for 6 to 12 months
afterwards.

It's a good bet that same feedback effect will be engineered before Groovy
starts losing its new top 20 ranking, perhaps before next month.

In fact, this sort of thing also happened with Groovy in December 2010. Groovy
began a sudden rise from outside the top 50 when Groovy tech lead Jochen
Theodorou "volunteered" his services to Tiobe in late 2010 to help them
improve their algorithms. In April 2011, however, Groovy fell from #25 to #65
on Tiobe in a single month after they increased the number of search engines
they monitor.

These fleeting peaks for Groovy in the TIOBE rankings (#25 in Apr 2011, #18 in
Oct 2013, #17 in Jan 2016) between its usual ranking of somewhere between #51
and #100 (e.g. #82 only 12 months ago) are a bad thing for Groovy because of
damage to its reputation as a solid language suitable for long-term IT
solutions. Such ranking volatility gives off the stench of smoke-and-mirrors
marketing intended to benefit a single stake-holder, probably the person who
the groovy-lang.org DNS domain is the personal property of.

[1] [http://www.infoworld.com/t/application-
development/c-pulls-a...](http://www.infoworld.com/t/application-
development/c-pulls-away-java-among-top-programming-languages-230603)

------
brightball
How in the world did Go drop out of the top 50 based on everything in the news
this past year.

~~~
mkozlows
Look, Go might be gaining in popularity, but there's just no way it could
compete with behemoths like Apex, Ladder Logic, and ABAP.

~~~
w8rbt
This is the epitome of sarcasm.

------
anc84
I highly enjoyed the article:
[http://i.imgur.com/qGEjNVL.png](http://i.imgur.com/qGEjNVL.png)

------
mrfusion
It's pretty amazing that Python is basically mainstream at this point. Right?

It's also odd that they're aren't more Python jobs.

------
xhrpost
I always am perplexed with how C and C++ are so high on this list. Given that
some (all?) of the measure is based on search engine results. When I had some
C/C++ back when I was in college, I was very underwhelmed at the number of
resources available online. I had taught myself web development just by
Googling everything I had an issue with. Tried the same with C/C++ and felt
there was an couple orders of magnitude less available information.

~~~
koja86
C++ developer here. IMHO the easiest access to quality information are books
(usually not for free) but apart from that I was always able to find
everything on-line -standard draft, language changes proposals, references, SO
questions, blogs, talks, OSS projects, OS/hw specifications - you name it. Do
you mean anything in particular you were not able to find?

~~~
xhrpost
Yea, I can't remember as it's been many years but I do remember finding maybe
one or two sites talking about what I needed (somewhat), and what I was
working with was probably pretty entry-level stuff.

------
stefek99
How do you explain JavaScript going down?

Is it because of the rise of languages that compile to JavaScript?

------
bdcravens
Interesting the VB.net doesn't even show up until 2010.


Developers – here is the best WHY to quit your 9–5 job - millisecond
https://medium.com/swlh/developers-here-is-the-most-convincing-reason-for-quitting-your-9-5-job-111801b7bd8
======
millisecond
I've been thinking a lot about the compression in salaries lately. More from
the stance that if senior developer salaries are incrementally higher than
junior that it seems like building an all-senior team would have business
value. Maybe that's all obviated by the new tech/learning, but in my
experience seniors greatly outperform juniors when you're dealing with hard
problems.

Not sure about the "oh it's so easy to start your thing, just do it" part of
the article though.