344 karma · joined July 19, 2011
In other words, how much of those numbers is explained by said lower probability, and how much by parents' willingness to trust their kids?
I think you're wrong on this one. A large number of devs care about dev experience at the expense of other important things like platform maturity, reliability, and security.
I don't agree with many of Steve's points in his post, but I do agree on this point. Both factors - x-platform development and instant redeploy - have contributed significantly to React Native's success so far. Indeed, if it weren't so important, I wouldn't expect Google to invest as much time and money as it did in getting Instant Run to work correctly (like others said, it was buggy as all hell when it first landed in Studio's stable channel and only became usable after many months). The fact that Flutter advertises "stateful hot reloading" prominently is just more evidence that it's important for attracting devs.
This discussion is about blogging, so IMO it's a valid comparison. While WP can be used for a whole bunch of other stuff, that doesn't change the fact that it's one of the most popular blogging platforms.
> It sounds like you didn't know how to secure your server with at least chroot jail, selective port filtering, and njinx injection filtering or apache fail2ban.
Well, I shouldn't need to know those things if all I really care about is blogging.
Also, it's going to be a lot more difficult for a street-side vendor to cheat you compared to a behemoth like Whole Foods with deep pockets, the latest and greatest preservatives etc at its disposal to make meat look healthy, and a large, existing customer base that implicitly trusts its products.
This is a classic Tragedy of the Commons. No single individual is incentivized to sacrifice for the good of the group as a whole.
But it's not correct to say that "it's not going to happen" - there are many counter-examples. The most notable is the ozone layer depletion problem that has been largely mitigated over the last 3 decades through concerted action among govts, NGOs and with public education. From https://en.m.wikipedia.org/wiki/Ozone_depletion:
"The Montreal Protocol is considered the most successful international environmental agreement to date. ... The ozone hole was seen as a "hot issue" and imminent risk as lay people feared severe personal consequences such as skin cancer, cataracts, damage to plants, and reduction of plankton populations. ... Americans voluntarily switched away from aerosol sprays, resulting in a 50 percent sales loss even before legislation was enforced."
So yes, at some future point, if govts/NGOs do their part and the average human comes to believe they face imminent personal danger (which we already do but it's hidden), meat production may well become heavily regulated and large numbers of people may switch to vegetarianism.
Sorry, but yes :)
The commit is immutable because when you "amend" a commit, git actually creates a new commit object, assigning it a new SHA1 hash. This means that the original contents from before the amend (i.e., the "old" commit) are still accessible via the old SHA1 hash - proving that an "amended" commit is actually a copy of the old one, not an in-place mutation.
Think of it like this - if I copy a text file and edit the copy, would you say that I've "mutated" the original file? No, right? That's what git does - it never actually mutates a commit :)
EDIT: to clarify further, git identifies each commit with a unique SHA1 hash which is assigned when the commit is created, and that hash depends on the contents of the files + the current timestamp + the SHA1 of its parent commit + some other things. Which means, if you try to edit the contents of the commit in any way at all (or even if you create another commit with the same exact files at a different time, or as a child of a different commit), its SHA1 hash will be different, i.e., it is a new commit by definition.
Let me preface this by revealing that I'm neither a functional programmer, nor am I convinced that functional programming or immutability is any sort of silver bullet.
Your original thesis was that "a data structure cannot be functional," which you later defended by saying "git is only immutable on the meta level, its implementation uses mutable files", which, while being 100% true, is also true of the category of programming languages we call "functional" as they rely on mutable RAM. That is what the GP has been trying to explain to you, but your obvious hate for anything labelled "functional" makes you blind to all this.
Sorry mate, you just have to concede the point here. This is not a discussion about whether functional programming is any good, which is what you seem to be treating it as.
I think I can offer something to the discussion here, as I'm straddling the 2 camps - having a fairly intricate understanding of git (I've held training seminars at my company about it), and basic familiarity with functional (technically "persistent") data structures thanks to a long-standing interest in Clojure.
What the functional camp is talking about, when they refer to git as a "purely functional data structure", is the core of git's implementation - commits are immutable snapshots of the repository arranged in a directed acyclic graph (or a tree, if there are no merge commits), and branches are "just" movable pointers to some commit. In this view, everything other than this core model of history as a graph is extra details layered on top.
The other camp (let's call them the "git camp") looks at git in its entirety, including branches, tags, the index, the working tree, stashes, and so on, and they can't help but come to the conclusion you mentioned - "Branches are mutable references! The index is mutable! The working tree is mutable! How can git possibly be called a functional data structure?"
While this 2nd perspective is understandable and technically correct, I think it misses the point the other camp is trying to make: that the immutable commit is the "fundamental unit of git" so to speak, that we interact with everyday, and that most of git's history-manipulating commands (git commit, git commit --amend, git rebase, git merge, git cherry-pick) can be described in terms of purely-functional operations on the commit graph. Once you understand this, many complex git scenarios become easier to understand (rebase, and filter-branch, for example), so this view does have practical value. Then branches, tags, the index, stashes, etc can indeed be understood separately.
In fact, this perspective of git as a data structure is so useful, that I rarely use "git log" as it is, preferring these additional flags to view the entire graph instead:
git log --graph --all --decorate --oneline
I hope that helps, cheers!
Basically what I'm saying is that the differences are very minor compared to differences vs, for example, other languages (Java, Scala, C++, etc). So from that perspective there's not much to complain about. I just have a slight bias towards Ruby, I find it a little more readable (in a small way).
What I do see is that Python is somewhat less consistent and readable (list comprehensions beyond the simplest ones are unreadable, Ruby's blocks allow cleaner DSLs, len(a) vs a.size, little things like "3.times", allowing "?" and "!" in identifiers). But Python has a bigger and more diverse ecosystem. So although I would prefer Ruby over Python, the ecosystem aspect makes the point moot.
I think you could add some space on the left side of the toggle and maybe show the "Orange" label there, or at least just add the space so it looks separated from the "Now UI kit" brand label.
I actually checked (using [1]) the contrast ratio of some of these widgets, and they work out to very low numbers:
- Form placeholders - #ddd on #fff - contrast ratio 1.4:1
- Labels of disabled checkboxes - #9a9a9a on #fff - ratio 2.8:1
- Tab labels - #b8b8b8 on #fff - 2.0:1
This is far lower than the W3C's recommended minimum ratio of 4.5:1 [2] for text smaller than 24px. And since the font weight is often lower than normal, the perceived contrast ratio is even lower than the figures above suggest. I think the contrast needs major improvements for decent UX.
PS: http://contrastrebellion.com/
[1]: http://leaverou.github.io/contrast-ratio/#%23dddddd-on-white
I agree with many of your points, but that casual dig at semver is unwarranted and reveals a misunderstanding of the motivation behind it [1]. Semver defines a contract between library authors and their clients, and is not meant for deployed applications of the kind being discussed here. Indeed, the semver spec [2] begins by stating:
> 1. Software using Semantic Versioning MUST declare a public API.
It has become fashionable to criticize semver at every turn. We as a community should be more mindful about off-the-cuff criticism in general, as this is exactly what perpetuates misconceptions over time.
[1]: https://news.ycombinator.com/item?id=13378637
[2]: http://semver.org/
Kotlin on the other hand has a tiny runtime (< 1 MB before dead-code elimination etc with Proguard) and negligible startup cost - in fact several popular Android libraries have a bigger startup cost impact than Kotlin.
I don't think the GP meant replacing JS with Kotlin, rather they're referring to implementing React Native modules in Kotlin instead of Java, keeping the JS part untouched. (As you may know, React Native modules/components require native implementations before they can be used in JS).
I hope that clears things up a bit!
Source: I closely follow all developments in the Android ecosystem, and have been doing so for over 2 years.
Source: I've been developing Android apps for 2 years and closely follow all developments in the community.
Cities on Mars - it's not productive debating this at such an early stage, though it makes for an interesting discussion.
Direct manipulation is great at discoverability, when I'm exploring the choices available to me, but it sucks if I'm looking for something specific (for software with a minimum level of complexity, like Photoshop or Excel). Interface agents have the opposite characteristics, as the article explains. So, they're complementary techniques.
To provide a simpler example, not involving AI: if the user is a domain expert (say, a graphic designer), the ability to search for and perform a specific action quickly is far more important than discoverability. For example, the user may already know that GIMP provides a feature for drawing a path but have only used Photoshop in the past and now they just can't find that action.
Aside: it is telling that established design software like Photoshop / GIMP has such a bewildering maze of menus even today. But if you take Google Chrome, for instance, it provides a stellar searchable user interface [1].
[1]: http://vickychijwani.me/searchable-user-interfaces-are-the-f...