Hacker News new | past | comments | ask | show | jobs | submit | davidgl's comments login


Also see https://www.fshade.org/, a F# dsl for shaders

From the tool itself:

SSH to a Tailscale machine

USAGE tailscale ssh [user@]<host> [args...]

The 'tailscale ssh' command is an optional wrapper around the system 'ssh' command that's useful in some cases. Tailscale SSH does not require its use; most users running the Tailscale SSH server will prefer to just use the normal 'ssh' command or their normal SSH client.

The 'tailscale ssh' wrapper adds a few things:

* It resolves the destination server name in its arguments using MagicDNS, even if --accept-dns=false.

* It works in userspace-networking mode, by supplying a ProxyCommand to the system 'ssh' command that connects via a pipe through tailscaled.

* It automatically checks the destination server's SSH host key against the node's SSH host key as advertised via the Tailscale coordination server.

Examples being the PS3 cell architecture and HP's Itanium chips

Haskell and COM, hilarious

My experience is good, small but very active and engaged community, interop with C# is seemless, I architect a large healthcare care system, 5% F# and 95% C# and very happy

Or https://fable.io in the F# world, which is production ready and excellent

> It’s easy to over-index on reuse as a primary goal of APIs (I believe taming complexity is a more important goal)

So true !

Is it more complicated though ? I've been developing for over 30 years, and I don't feel like its got any worse, I think it's the nature of the medium.

These days I fight with npm or nuget dependencies problems, 20 years ago I was trying to write Delphi code to do simple REST requests, the complexity moves around but is still there.

Out of the Tar Pit (http://curtclifton.net/papers/MoseleyMarks06a.pdf) was written 15 years ago, and it's all about curbing complexity

I think this is an example of simple vs easy. Writing request code 20 years ago was harder, because you needed to read docs and write a lot by hand. But it was simpler because it didn't add any additional hidden complexity from libraries or whatnot. At least in most languages it got better: we only need something simple and easy, like Javascript's fetch. Does complexity we don't have to maintain count?

About Out of the Tar Pit, complexity manifests itself in various shapes. The essay itself lists some that have gotten better: state is one, with people using more functional code. The "Power corrupts" part has also gotten better, IMO, with languages becoming simpler (Go) or more restrictive (Rust).

I think the "Code Volume" part is still a big one. One thing I'd like to see curbed to avoid code volume are the proliferation of code for handling edge cases. Having libraries and code able to handle tens of edge cases is both a blessing a curse. However most developers and business people can only see the blessing part.

Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact