tinyspacewizard

Start-ups should strongly consider F#.

It's a force multiplier when you have a small team of strong developers.

What should we use instead?

> Why two cloud providers? Initially we used only DigitalOcean, but a data intensive SaaS like tap needs a lot of cloud resources and AWS have a generous $1,000 credit package for self-funded startups.

So some Kubernetes experts migrated to AWS for $1k in credits. This is madness. That's weeks of migration work to save the equivalent of a day of contracting.

> Of course you can inspect it: open the source code you wrote and read it. Also, don't write the code you don't want to be executed?

This is not what they meant by inspection.

What they mean is that you can write a function, in Haskell, that given a value in the DSL, it returns the list of all requests it will perform on execution.

This can be useful for tests, security, caching, performance, debugging...

This seems like a cool article, but it isn't readable without Haskell background knowledge.

> For an intuition why this is true, consider that the constant functor Const r has an Applicative instance whenever r is a monoid, because pure stores a mempty value and (<*>) combines the held values with (<>). For a fun exercise, implement runAp_ in terms of runAp and Const.

Really?

Weird feeling knowing that an ecommerce / wallet store has employees with more advanced programming knowledge than most financial institutions.

1. Wrapping is more code than using a built-in pipe operator

2. There is a run-time overhead to wrapping

IMO a design goal of programming langauges should be for the most readable code to also be the most performant.

Language features tend to be controversial until they are mainstream.

There is more than one proposal; the F#-style one doesn't have the (weird) placeholder syntax.

> You can still make it work by adding it to the prototype

This is exactly what we want to avoid!

Pipes are great where you want to chain several operations together. Piping is very common in statically typed functional langauges, where there are lots of different types in play.

Sequences are a common example.

So this:

    xs.map(x => x * 2).filter(x => x > 4).sorted().take(5)

In pipes this might look like:

    xs |> map(x => x * 2) |> filter(x => x > 4) |> sorted() |> take(5)

In functional languages (of the ML variety), convention is to put each operation on its own line:

    xs 
    |> map(x => x * 2) 
    |> filter(x => x > 4) 
    |> sorted() 
    |> take(5)

Note this makes for really nice diffs with the standard Git diff tool!

But why is this better?

Well, suppose the operation you want is not implemented as a method on `xs`. For a long time JavaScript did not offer `flatMap` on arrays.

You'll need to add it somehow, such as on the prototype (nasty) or by wrapping `xs` in another type (overhead, verbose).

With the pipe operator, each operation is just a plain-ol function.

This:

    xs |> f

Is syntactic sugar for:

    f(xs)

This allows us to "extend" `xs` in a manner that can be compiled with zero run-time overhead.

Sad that the pipe operator proposal seems to have stalled.

The F# version of the proposal was probably the simplest choice.

Brexit made this far less likely - but perhaps people in France, Germany, Spain, etc. could do this.

Functional Programming hasn't even been tried for game development, really. There is a lack of overlap between the game dev industry and academia. The studios are (rightly) risk averse and try to use the same broad strategies to build games - OOP, maybe ECS for large swarms, etc.

Personally, I think that FP could be a great fit, but we first need to come up with architectures that solve real game development problems. We have to do this with small scale experiments first (game jams are perfect for this) and then scale up only if they succeed.

This project is exactly that - kudos to the author.

You should put this online somewhere!

Expect a wave of artists moving into education to make ends meet.

Also a bit scary to have a system without a scaling mechnism built-in in the path of customer traffic. At some point you may be racing to upgrade it.

Python is really bad at recursion (part of why it's not appropriate for functional programming), so perhaps an unfair benchmark?

A Pythonic implementation would use loops and mutation.

I think what Meta is doing is really smart.

We don't really know where AI will be useful in a business sense yet (the apps with users are losing money) but a good bet is that incumbent platforms stand to benefit the most once these uses are discovered. What Meta is doing is making it easier for other orgs to find those use-cases (and take on the risk) whilst keeping the ability to jump in and capitalize on it when it materializes.

As for X-Risk? I don't think any of the big tech leadsership actually beleive in that. I also think that deep down a lot of the AI safety crowd love solving hard problems and collecting stock options.

On cost, the AI hype raises Met's valuation by more than the cost of engineers and server farms.

Terraform is not really a competitor. Maybe Nomad is? I expect most K8s shops use a bit of Terraform, maybe Vault, etc.

Could easily be leverage in the negotiation.

Google support Kubernetes, so there's precedent there.

I could see Microsoft keeping things open too. So far they have done OK with GitHub and NPM.

There should be a way to exclude seasons (e.g. Simpsons)

Like most public policy issues, a balance needs to be struck. Typical SUV trips could easily be done in a lighter vehicle or even no vehicle at all.

Article implies that free public transport lead to increases in car traffic. But we have to wonder, would it have been even worse without free public transport?

Excel single-handedly keeps VB alive; it has a huge amount of sway over what langauges people use and learn - so why settle for Python?

Sonic Youth apologized that their release wasn't as good as Atomizer.

This is a press release masquerading as news.

Kubernetes is a tool that makes portability between clouds easier - and it was released by a challenger brand in cloud.

Not a conspiracy at all. See also IE, Android, Kubernetes...

Suave is really cool for this too.

Here is a hello world server that fetches all of its own dependencies - just 3 lines!

    #r "nuget: Suave, 2.6.2"

    open Suave

    startWebServer defaultConfig (Successful.OK "Hello World!")

Ehhh a large company would much prefer:

    $$$$$$ income on $$$ costs

to

    $$$ income on $ costs