grndn

"Understandably, there has been much speculation as to [leader]’s mental fitness. It has been marked that [leader] possessed a perpetual immaturity. He had great difficulty in taking matters seriously, and tended to fixate on surface level details that caught his fancy to the neglect of the heart of the matter. He spoke without preparation or consideration, seemingly unaware of the consequences this brought about.

However, the influence of the [leader] on [country] politics made [country]’s isolation inevitable. A byzantine system where promotions were based on the favor of a man who did not have the character to set a consistent policy made for a state that was not a credible partner."

Two separate Sherlock Holmes stories have a "stranger at a public wedding ceremony" as a plot point!

Personal anecdote: I had a subscription to the Philly Inquirer. They made it very easy to sign up online, but there was no way to cancel online. The website only said "call the sales team to cancel".

I changed my home address to California, and shortly after, a new "Cancel Subscription" button appeared on the PI website, which worked great.

Fellow Branestawm enthusiast here. That is the first time anyone has ever mentioned Professor Branestawm on HN, as far as I can tell! It's triggering deep memories.

As another comment said, you can write client side code in F# which gets transpiled to JS, just like Typescript or CoffeeScript. This approach allows you to use JSX components directly from your F# code. It's very cool. Other FP languages have something similar.

https://www.compositional-it.com/news-blog/fsharp-react-seri...

Elixir took the pipe symbol from F# (See Jose's comment at [1]). For more details see my other comment below.

[1] https://elixirforum.com/t/which-language-first-introduced-th...

OCaml took the '|>' pipe symbol from F#. And F# was the language that made the '|>' pipe symbol popular in mainstream programming (as opposed to the unix '|' pipe symbol), afaik. According to Don Syme, it was used in F# in 2003 (see "Early History of F#", section 9.1, [1] which references [2]).

Here's his full comment:

/quote

Despite being heavily associated with F#, the use of the pipeline symbol in ML dialects actually originates from Tobias Nipkow, in May 1994 (with obvious semiotic inspiration from UNIX pipes) [archives 1994; Syme 2011].

... I promised to dig into my old mail folders to uncover the true story behind |> in Isabelle/ML, which also turned out popular in F#...

In the attachment you find the original mail thread of the three of us [ Larry Paulson; Tobias Nipkow; Marius Wenzel], coming up with this now indispensable piece of ML art in April/May 1994. The mail exchange starts as a response of Larry to my changes.

...Tobias ...came up with the actual name |> in the end...

/endquote

Haskell has had "$" or "backwards pipe" for ages, but that is just another way of doing function application and it does not feel the same as (and is not used the same way as) the unix-style piping paradigm.

[1] https://fsharp.org/history/hopl-final/hopl-fsharp.pdf

[2] https://web.archive.org/web/20190217164203/https://blogs.msd...

Peter Norvig does his own research: "When faced with a controversy like this, the great thing is that you can do your own research. If you suspect Oreskes or Peiser (or both) might be biased, you can look at the data yourself."

Also, AFAIK, one of the first uses of "do your own research" in the modern sense. Google hits before 2009 do not use it in this way. [0] https://www.google.com/search?q=%22do+your+own+research%22&t...

As one of the comments pointed out, it's even funnier if you turn on the automatic captions :)

Agreed about the TLA docs, but it is worth persisting, as TLA is very useful in some situations. These slides cover the basic syntax enough to get started.

https://www.slideshare.net/ScottWlaschin/tla-for-programmers...

The original title is "Write your own Excel in 100 lines of F#." I don't know why the F# part was removed either. HN guidelines say "please use the original title, unless it is misleading or linkbait; don't editorialize.". Having read the article, I don't think the "in 100 lines of F#" part is misleading, nor is it Buzzfeed-style clickbait.

C# Light (from 2014) - https://www.slideshare.net/ScottWlaschin/c-light

+100 "The Logic Of Failure" is a great starting point, and everything by Gerald Weinberg is worth reading.

I came here to say the same thing. :)

The fundamental problem is that you want one piece of (semantic) content to be presented on many different platforms with very different design approaches.

The current approach uses if-then-else conditions in CSS, and when that fails, if-then-else conditions in JS, and when that fails, complex JS to transform the DOM. The XML/XSLT approach, although clunky, might actually be better in many cases.

Here is the history of the |> symbol as best as I can tell:

1994: Isabelle/ML (part of Isabelle proof assistant tooling) (https://blogs.msdn.microsoft.com/dsyme/2011/05/17/archeologi...)

2005 and earlier: F#

2012: Elm

2013: Elixir (https://github.com/elixir-lang/elixir/pull/751)

2013: OCaml (https://ocaml.org/releases/4.01.0.html)

For a counterpoint, see the "Victorian Bakers" doc from the BBC: http://www.dailymotion.com/video/x4h8mty. See 11 min mark for bakery conditions and 23:30 for flour adulteration. The free market at its finest with no regulation.

You are on the right track (no pun intended). Your second and third function signatures are actually the same thing in F# (and any other language with curried functions by default). Similar functions such as "map" and "filter" can be thought of the same way.

A big benefit of currying by default is that all functions can be treated as one parameter functions -- a very powerful tool for function composition.

Also, providing only some of the parameters (e.g. the first) and leaving some to be provided later is the technique known as "partial application" -- another key tool in functional programming.

If you think these things look interesting, you should for sure look into F#/OCaml/Haskell/Elm/etc.

And for those interested in a FP-oriented (rather than OO) approach to cap-based security, here's a post on using it as a tool to enforce good design: http://fsharpforfunandprofit.com/posts/capability-based-secu...

How about F#? It feels like Python and has a Pandas equivalent in Deedle (https://bluemountaincapital.github.io/Deedle/), but fits well in the .NET ecosystem, including using SqlServer effortlessly. This report is a good starting point: http://fslab.org/report/

Thanks for these -- the aether one is hilarious.

Couldn't this just be a form of the "Sports Illustrated cover jinx", that is, regression to the mean?

Many FP-ers believe that you need to use understand the math or at least use the "right" terminology before using monads.

There is an obvious counter-example. Millions of C# developers are using monads already under the name of "LINQ". I don't think it would have been as popular if Microsoft called things by their "right" names.

Too late, I'm afraid. That horse has literally* bolted. The world has decided on what "steep" means now.

* http://www.salon.com/2013/08/22/according_to_the_dictionary_...

Zawinski's Law

"Every program attempts to expand until it can read mail. Those programs which cannot so expand are replaced by ones which can."

http://www.catb.org/jargon/html/Z/Zawinskis-Law.html

Did you notice the date on that C#6 post?

Like this (in F#) http://blogs.msdn.com/b/andrewkennedy/archive/2008/08/29/uni...

The problems that XML and XSLT address have not gone away. It saddens me when the XML-hating JSON community starts reinventing solutions that have all the same issues of bloat and complexity (see JSON schema, Collection+JSON, Siren, etc).

I would not be surprised if someone soon announces a "JSON Transformation" tool that can convert one JSON schema to another. Followed shortly by a standard for JSON namespaces so you can mix different schemas, a standard for binary JSON, a standard for JSON-encryption, and so on.

"Those who cannot remember the past are condemned to repeat it."

+1 for mentioning Lene Lovich!

Elm is worth checking out: http://elm-lang.org/

The VsVim plugin for Visual Studio gives you the best of both worlds! https://github.com/jaredpar/VsVim/