yokohummer7

Just curious, is Atom's UI considerate about modifying the content of a configuration file? I'm tired of programs changing the structure of it willy-nilly without even notifying the user (e.g. a click in the toolbar implicitly loads the configuration file and saves it with a different layout). Is Atom OK with this?

Yeah, like many others I maintain my configuration files in Git, so having to use files to configure is a pro, not a con, at least for me! I haven't been using VS Code but this sole factor might be the reason I will reconsider using it in the future.

Some might say having both manual configuration and automated dialog would be better, but many such interfaces ruin the structures of my intentionally organized setting files. I will take no GUI than misbehaving GUI at any time.

Great, I didn't know the terminal portion if VS Code exists as a separate project. Was it made to fuel VS Code? Or did it already exist before launching VS Code?

I also liked the name of the project, xterm.js. :)

This is an off topic, but I just learned from the article that PowerShell will soon be the default in place of cmd.exe in Windows 10. I welcome this change as I found the experience of using PS was superior to that of bash/zsh in general cases.

But I hope they figured out the performance problem. As of writing, in the stable version of Windows 10, PS is perceptually slower than cmd, so I was forced to use PS only when needed. Funnily it was even slower in Windows 8, so the current affair is better than ever. But to be truly a default I think the performance of PS should at least match that of cmd.exe.

The slowness shown in the pre-1.9 terminal is a bit ridiculous. Was it really the case? I've never seen such a strangely-behaving emulator! Really good that they resolved the issue.

> To be clear, it isn't that I find the code difficult to grok: if you don't understand how switch works, please stop using C.

Oh please. C is perfectly usable without knowing switch is actually a bunch of gotos. The idea that one has to know all the hidden edges of a language to use it is pointless, because every language has something like that. Even Python can be a minefield if one tries hard abusing metaclasses, and I'm pretty sure 95% of the Python users don't know how to use them.

If you pursue the idea of knowing every deep place to the extreme, the only language left for general developers to use is Go. A language so concerned at removing hidden features that almost no features are left.

IMO the success of Windows 7 was an exception, not the norm. Comparing the adoption rate of Windows 10 to that of Windows 7 might be a little harsh. 24% isn't actually that bad, considering Windows 7 is still good enough.

> if you’ve got a Mac with a fan and that fan is currently spinning loudly, triggering Siri will slow it down so that the fan noise doesn’t interfere as much with your speech.

These kinds of small details make me happy. Nice touch as usual, Apple.

  > Well, in an actual functional programming language like PureScript or Haskell we can:
  >
  > sum :: [Int] -> Int
  > sum = foldl (+) 0
  >
  > The list cannot be undefined, cannot be null.

Yes it can?

  main = putStr "The result is: " >> print (sum undefined)
  
  The result is: 
  Program error: Prelude.undefined

So by the same logic Haskell doesn't have pure functions, either?

It doesn't have the same semantics, because even after introducing the new variable, it is still immutable. So you cannot accidentally modify the new variable. e.g.,

  let x = 1;
  let x = x + 1;
  x = 99; // Error: you can't accidentally modify the immutable variable `x`

  let mut x = 1;
  x = x + 1;
  x = 99; // Ok

You can even turn back a mutable varaible into an immutable variable, like this:

  let mut x = 1;
  x = x + 1;
  let x = x;
  x = 99; // Error: `x` became immutable

This can be useful to "pin" the variable after a large number of calculations done to it.

What's the reason? Were the method names needed to be aligned somehow?

It might be useful to have an option to turn all the "non-obvious" Unicode characters into the form of <U+XXXX> in programming editors. One concern is that some legitimate text will break, but it would be worth it considering most code is written in English anyways.

There are many things that are present in assembly but lacking in C. For example, how do you detect integer overflow in C without resorting to compiler extensions?

That is almost true, but there's one exception in those GC'ed languages due to the dichotomy of value types and reference types. The confusing behavior on capturing the iteration variable is one example.

> It looks like a really well thought out language

Well, I think it could have been more cleanly designed if it was able to abandon the burden of Objective-C interoperability. (But Apple can't do this, obviously.) The standard libraries could have also been much cleaner if it didn't rely on NextStep. Also, I don't personally like the dichotomy of value types and reference types, but YMMV.

> The big advantage that RISC has these days is that fixed width instructions are easy on the decoder.

One thing that I've wondered is how much more efforts are needed to decode variable-width instructions. Decoding itself sounds fairly easy (but frankly I don't know any details), to the point that the amount of time needed for loading/storing/calculating overwhelms that of decoding. But decoding should happen extremely fast to fill the pipeline, so the speed might still matter. Can decoding instructions be an actual bottleneck?

Any hope that humans can eventually beat robots?

A release cycle of two weeks looks miracle to an outsider like me. Good to see what's going on internally. I loved the video showing automated champion moves, show me more! Also,

> In Wood 5 we don't use wards anyway, so I see no problem with this critical failure

100% agreed. There's no point in changing to lens because nobody buys a ward!

The problem is that the brand new Haskell Programming book, which seems to be recommended nowadays among Haskellers, is being written by bitemyapp (the one described in the first link). He's been bitching other languages, especially Go. He even stated Haskell is simpler than Go, which just shows his twisted reality. It is very unfortunate that such a toxic person is influential to the community.

Unfortunately they also had to narrow down the scope of type inference recently. IIRC type annotations are now mandatory for class-level variables (member variables). This hindered the "Ruby-like" feeling, but they had to give up global type inference because it costed too much memory in some cases. I got an impression that global type inference is difficult (or, costly) in general.

I don't know much about this drama, but here's my perception from the outside.

There has been a long-standing fight between the Haskell.org committee and the developers of Stack, regarding what should be the "default" option to install Haskell to be displayed on the homepage. Many Haskellers think Stack is a strictly better tool, but the Haskell.org committee thinks that the Haskell Platform is still worth mentioning on the homepage. The Stack team could not convince the committee for months.

In the end, the Stack team decided to create a new Haskell community, haskell-lang.org. One of the Stack developers who had contributed to the original haskell.org even said "I don't approve of the current haskell.org, nor your use of my design".[1] It seems that they are trying to replace the Haskell community in the same way how Stack replaced Cabal. This also includes a GitHub organization, an IRC channel, and even a subreddit (/r/haskell_lang).

[1] https://mail.haskell.org/pipermail/haskell-community/2016-Ap...

I think this is just a reflection of the proportion of the female contributors in overall open source communities. There's really no reason for the Rust project to do anything "anti-female". Actually I think it is a bit too concerned with diversity.

Then the problem now becomes why there aren't that many female contributors out there. This is just a theory, but I think it is because males' nature make them do free labor to obtain fame. I admit this is purely my experience, but females are more likely to refrain from such labor that does not pay off.

> while(something) a[x] = b[x++];

Wait, isn't this an undefined behavior? Is the order of evaluations of `x` in the left side and `x++` in the right side defined? I'm always confused at things like this!

What you said is purely anecdotal. Here's another anecdote I think worth mentioning (it is from a Haskeller who has spent years teaching Haskell to kids):

https://www.reddit.com/r/haskell/comments/3pfg7x/either_and_...

> this experience has taught me that whenever functional programmers claim that certain things are only unintuitive because programmers have had their minds polluted by non-Haskell programming languages... they are usually wrong.

> the more common claims you see about how purely functional programming is easier and more intuitive for students without previous imperative programming languages. Surprisingly, that's not the case. Even in situations where I don't expect it, I'm constantly fighting everyone's urge to think about situations first and foremost in imperative terms.

I think it's safer to assume that functional approaches have inherent complexity compared to imperative approaches. YMMV, of course.

> Implicit numeric casts that lose bits are not allowed anymore.

That's good to hear, but I want implicit conversion to be forbidden unconditionally (even int * float -> float). I've been bitten by even widening conversions, so I just want to let them go away. It might be great if such an option could be applied to module level.

> ??

Sorry if my understandings or my words were wrong, but I got the impression that D also suffers from destructors that throw. (double-throw) Is this not the case in D? If so, could you elaborate how it achieves that?

I'm personally rather fond of purging exceptions from the language level completely, like Go did(Of course panics are technically exceptions, but their usage is culturally discouraged). Of course, this is just my personal opinion, but I would be happy if D had a story on this problem.

To me, while D fixes many warts of C++, D is still too similar to C++ to justify the change. It still has implicit numeric cast, exception unsafety and strange behaviors.[1]

In addition, the D authors are generally opposed to disciplined approaches, e.g. type classes, region-based memory management, which are being added to C++. Especially regarding the former, while "design by introspection" may have its merits (Andrei Alexandrescu's presentation on allocator is worth watching[2]), I think many still prefer explicit interfaces over implicit ones, so I don't see D take off in the near future, at least until the wanted features are added to the language.

[1] http://forum.dlang.org/thread/htmkdnmlqyvkidkrsmri@forum.dla...

[2] https://www.youtube.com/watch?v=mCrVYYlFTrA

If deleting some rows is not feasible, I would even suggest special-casing the page and making it redirect to the 404 page, even though the user data would be still there. I mean, do somethimg. Seeing the issue not resolved even after the founder recognized the problem is utterly painful.

I wonder why they didn't fix the plus sign.

It seems that the author is following his own lesson faithfully:

https://www.reddit.com/r/programming/comments/3r3m6q/please_...

But... but... they are YC-funded. People with such a childish attitude should have been filtered earlier. :(

Anyways, I don't think I would sign in to their site anymore. It is unfortunate that one of the YC companies doesn't feel "cool" anymore.