skysight-inc/HackerNews huggingface dataset:
You could also argue that relying on "total functions" is an antipattern because it doesn't account for "undefined behavior / exceptions / crashes / memory corruption" and leads programmers to overreliance on the compiler. We can throw race conditions and deadlocks in there too, since very often it will be difficult for a compiler to detect those at compile time. A PL that gracefully handles programming errors as well as exceptions, memory corruptions, etc, emitting a logged problem and continue to chug along will let the programmer decide how bad an error is, with high uptime, and make a business decision about whether or not it's worth fixing at the time.
ggg.gg?
A substantial fraction of books have been digitized, even if not publicly available.

Perhaps a more interesting question would be that of all significant/important knowledge in human history. Some information is more important than other; the name of a childless bachelor who lived in a small town 200 years ago is still knowledge, but it isn't helpful for very much.
I've reorganized it a bit.
Quantum Computing Needs You to Help Solve Its Core Mystery
How This Supercolony of 1.5M Penguins Stayed Hidden for Nearly 3,000 Years
When it comes to the military, top gun wins. A specialized gun will top a non-specialized one in a given combat situation, all else being equal. Of course, the F-35 will be a great general purpose weapon against far less advanced targets, but if they are pitted against their Russian and Chinese counterparts, I don't believe they will fare all that great.
Duck isn't much of an improvement, the word doesn't sound serious in business.
The production of "stuff" is not inherently good.
>Boston residents literally had no voice in the city's negotiations with Verizon about FiOS and didn't even hear about it until they jointly announced their deal.

Boston residents got a taste of what it's like for the rest of the state when the Boston/Cambridge area runs the show.
> // no curly braces, semicolons or parentheses

Is this a good thing? It feels like saying "It's English without the periods or line breaks or capital letters."
I'm looking at Ocaml again because of the existence (and quality) of the Bucklescript backend for Javscript.

That makes Ocaml sound pretty attractive on the portability front.

A question for anybody here regarding portability: Is it viable to maintain a portable core using a subset of Ocaml (something like Standard ML maybe - no objects) and compile that in F# using Ocaml portability mode?

For context, I've read this question on SO from 2010 [0] but I'm looking for some more 2018 perspectives from HN people.

[0] https://stackoverflow.com/questions/4239121/code-compatibili...
Having used and enjoyed F#, I ended up programming in Scala which is almost the same language, despite the huge superficial differences:

- Indentation delimited blocks vs curlies

- CLR vs JVM

- Whitespace vs Parenthesis for function calls

- Currying by default vs currying optional

Despite all this, when you actually start coding, it's remarkably the same:

- Immutability by default, transformations rather than mutation

- Less classes with embedded implementation logic, more "dumb" records with external functions

- Structural pattern matching

- Tagged unions

- Type inference

- Convenient definition of record/struct-like data types with free copy-constructor

- Operator overloading

- Easy FFI to external libraries in a different paradigm

- Easy "dropping down" to mutable, imperative code (e.g. for performance, or interop)

- Both have lots of syntactic and semantic warts and corner cases, though few enough you can live with them

- Garbage collected, multithreaded, JITed runtime

- Both compile to Javascript

While every single feature looks totally different on the surface, starting with a totally different syntax, the two languages are more the same than different. If you look at the tutorials linked from that page, all of them can be translated almost line-for-line from F# to Scala (and vice versa: take any random Scala tutorial, and you can trivially translate it line-for-line into F#)

Scala brings with it a bigger ecosystem, both in Scala and from the JVM, and better tooling support in general (Both Scala-specific, as well as general JVM tooling which all works with Scala: profilers, debuggers, package managers, ...), and slightly more seamless platform interop (Scala <-> JVM is less jarring than F# <-> C#), which is why I ended up sticking around.
With a sole proprietorship, certainly.

With a partnership, maybe.

Anything bigger, unfortunately not.
The first two comment snippets read like someone who woke up with a horse's head in their bed after refusing the proposal from the React Family.
you might want to look into parser combinators https://fsharpforfunandprofit.com/posts/understanding-parser...
depending on what kind of "text proccessing" you want to do.
Rust's Result type is isomorphic with checked exceptions, FWIW, just a bit more explicit in its use.
And that's a poor design decision. Why should it matter.
From what I can tell you're talking about processing logs to device metrics, but this project is specifically about storing the raw logs themselves. Two different (albeit potentially related) problems.

What you are proposing for deriving metrics from logs exists in plenty of forms. Check out https://github.com/google/mtail , for example. Of course, you still have to store them somewhere, visualize them somehow, etc. That won't simply be part of your shell pipeline.
Shuttle flew on autopilot. The crew was largely there to supervise, at least in terms of the flying up and back down to landing. Automated systems actually flew the craft. The pilot was the emergency backup plan. So Buran wasn't all that much of a leap.

Shuttle's crew did the things the autopilot could not, all the docking, all the satellite grabbing, and certainly all the science. Buran's one flight was just an up-and-back proof of concept. So a crew wasn't needed.

Without a crew, the pilots' only job would have been to save themselves in various emergency scenarios should the systems fail. Take the pilots out and you don't have to train/study/prepare for those scenarios, at least not before the first flight. By removing the pilots, Russia reduced early program costs. It was a form of technical debt. They would eventually have to prep for humans, but at least they could get the craft flying first.
Can we at least have a more intelligent conversation about how google designs its algorithms than "It's entirely automated".

Everyone here knows that google didn't just plug a bunch of servers together and it just magically came up with a search engine.

The idea that google has completely washed its hands of any untoward tweaking of search results to favour one party or another is just ignoring the reality of the claims being targeted at google.

It didn't help either that when questioned about things like the plan to "improve hispanic voter outreach in key states" that google just pretends like it never happened.
Use emacs or vim. They work right out of the box.
> If it's still compiling to an IR, and getting JITted at runtime, that seems kind of inefficient in a world where Go exists.

It really depends on your use case. If you're writing programs with very short run times, for example, then the time spent on spinning up the run-time and JITing the bytecode can amount to a significant portion of the program's execution time.

If you're writing a program that's going to run for several seconds or minutes (let alone hours, days or weeks), then the milliseconds spent JITing the bytecode just don't matter.

It's also true that, since JIT compilation happens just in time, it doesn't really have the luxury of being able to spend a whole lot of time on optimization. Depending on the kind of problem you're working on, that can make a meaningful difference. Fortran or C would still be my languages of choice for serious number crunching. .NET tends to be used more for I/O-bound or non-performance-critical applications, though, where that doesn't really matter, either.
That requires 1 bit of information, and there is often a way of embedding that bit in the value itself; but the general technique of representing alternatives is called “a tagged union.” (You can also hear the fancy terms “the product type” for the struct and “the sum type” for the union.)
>The researchers lost touch with 13 people, while 57 people died and 332 declined to take part."

This is one of the major downsides to longitudinal studies— people are unpredictable.
Dieter Rams — As Little Design As Possible [0]

Also, if you like Dieter Rams, the film “Rams” by Gary Hustwit [1] is digitally available on Dec 14th.

[0] https://www.phaidon.com/store/design/as-little-design-as-pos...

[1] https://www.hustwit.com/rams/
I really want a .fox domain but the whole tld is reserved for Fox news which doesn't seem to use it.
I'd push back if a public library refused to do ILL. (Though I can be fairly stubborn.) If cost is a concern, offer to pay. If a librarian says that they don't offer that service due to low demand, ask if they could make an exception. Maybe ask another librarian who might be more open to the idea. I don't know what to do about a lack of trust.

Lacking the right software is not a valid excuse. UT will send "ALA requests" every once in a while if the lending library isn't in their software. As far as I can tell an ALA request is just this form mailed or emailed: http://www.ala.org/rusa/sites/ala.org.rusa/files/content/sec...

I might suggest contacting various universities about getting copies of theses from them. It's possible that they'd be perfectly willing to scan them for you, even for free. On this note, I've been surprised by the extent some corporations have gone to provide me with copies of proprietary technical reports they produced. One time I called the number on the website of a large corporation and my call was forwarded to their staff librarian, as I recall. A few weeks later I got the requested report. It had to go through some release process, but they were happy to share their work. Another time I emailed a generic address at a Shell research lab, and a few weeks later I got a copy of the report I wanted. There have been failures as well, but I was surprised by how frequent the successes were.
1. Yes, you can. We initially targeted Kubernetes because that's what we use and packaging for it is simple. We'll soon release packages for all distros, support syslog/journald etc.

2. Hmm, please open an issue regarding this with the use-case that prompted this? This is not a use-case we have but if this is important for more people, we'd be happy to support it!

3. You can only select based on the metadata, the metadata is just a set of kv pairs. Like {app=cassandra, namespace=prod, instance=cassandra-minion-0}

4. Yes, we used gzip. Please see the sheet referenced at the end of the design doc [0] to see what we compared with.

5. It's mainly protobufs right now [1] over HTTP, but we'll be adding more docs soon. Mind opening an issue for this so that we don't forget?

[0] https://docs.google.com/document/d/11tjK_lvp1-SVsFZjgOTr1vV3...
[1] https://github.com/grafana/loki/tree/master/pkg/logproto
Every Ubuntu user should be well aware of compiz by now, mostly because of having to switch to a new terminal screen and restart it at least once a day whenever it crashes.
Interesting fact is that CEO of Nvidia Jensen Huang is a cousin of AMD CEO, Lisa Su.

https://en.wikipedia.org/wiki/Jensen_Huang#Personal_life
Calling the New York state government “conservative” is laughable. Democrats have controlled the governor’s seat for 32 of the last 43 years. They have controlled the Assembly (which has primary responsibility for tax and spending bills) for all of the last 43 years. New York state has one of the highest levels of taxes and public expenditures in the whole country.
Καθαρή νίκη επί της Μίλαν ο Ολυμπιακός
Boy Scouts Considering Chapter 11 Bankruptcy
Only 20% of Bitcoin addresses have more than $100 worth of BTC
The 2018 XPS 13 Developer’s Edition–Have it your way on a “just works” Linux
it's actually a great success when you consider the true goal of the program, which is to spend taxpayer money
They ought to have a study on whether playing fast paced video game shows down mental decline.
Proving 1&gt;0
> I disagree with your case, this is clearly an error because it should never get to dividing by 0.

> No you misread my refutation, I make no claims of the errorness or exceptionness of dividing by 0,

Hmmm.
Or people with less decline are more busy, have less motivation to stay in touch with a study that doesn't feel relevant since they're healthy?
Is Electron maintained separately from the Atom team?
Remember Lavabit... https://en.wikipedia.org/wiki/Lavabit
For text processing in F# there is a library called FParsec, which is really powerful: http://www.quanttec.com/fparsec/

Regarding JIT and Go, I've built identical programs in both and while Go is faster, its not by as much as you would think (in my example, 60ms vs 40ms). Go is much more verbose to write, but its output exe is all by itself without the hundreds of dlls .NET likes to lug around.

F# works with CoreRT just fine, with some small caveats (its sprintf/printfn functions don't work I think). I've modded one of my games to use it: https://github.com/ChrisPritchard/Tetris
Maybe, but given the huge dropout rate I don't see how we can conclude anything from this study.
Of course, that would also be true if it had reached the opposite conclusion.
Sorry, misunderstood. Yes, VT100 is rather archaic. Is there a more modern alternative?
I've heard many economists echo this argument.

People who have the opportunity to attend an elite university and decline it would be doing so because their opportunity cost is better.

But the question is still open: why should credentials not be open to fair competition? Shouldn't a poor woman in Africa be able to compete for the same computer science credentials, bar exams, medical exams (this would require further vetting of practical lab skills) as a Harvard student, through the same exams and projects? Of course, Harvard could still give its students its own stamp of approval, but the education and credentials should be open to competition, not behind walled gardens.
At NeurIPS Nvidia said they were working on adding an RTX api to CUDA
Big Auto Drives Full Speed in the Blockchain Race
> constant alert for a Russian attack. Norway is very oil rich

Ridiculous scaremongering. Implying that Russia would invade Norway for it's oil, when Russia has 13 times more proven oil reserves than Norway [1]

Rather than highjacking a thread about Norwegian naval accident, in order to disparage Russia, perhaps you'd simply like to claim that Russians hacked Helge Ingstad ?

[1] https://en.wikipedia.org/wiki/List_of_countries_by_proven_oi...
What are you using to run the regex? ripgrep could make up for some of the loss from not having it indexed.
Curly braces - F# is a whitespace-significant language, so contexts are still plenty visible.

Semicolons - If that's the main thing telling you where an expression ends, it's time to start taking your code formatting more seriously.

Parentheses - Still exist, but only for expression grouping and tuples. It's just that they aren't used as a function application operator. This admittedly takes some getting used to, but starts feeling easy and natural surprisingly quickly.

Importantly, function application without parens feels a lot nicer in F# than it does in Scala or Nim. I think the difference is that, in F#, adding parens around a function's argument list would actually change the meaning of the expression, and likely cause a compiler error.† In Scala or Nim, they're (sometimes) optional, which just creates this unnecessarily confusing situation, not entirely unlike optional semicolons in JavaScript.

† - If it's a 1-ary function, you'd be fine, because it would interpret the parens as grouping operators around the argument. If it's a 2-ary function, then it would probably cause a compile error, because parens around a space-delimited list are (I'm pretty sure - it's been a while since I last worked in F#) not valid syntax. If you add commas, so that it looks like a C# method call, it would then interpret it as a tuple, which would probably mean a compile error, unless the function has an overload that accepts a tuple of that arity as its first argument, and, even then, only if applying that version of the function doesn't somehow lead to a type error.

(Edited for clarity and extra babbling.)
Why shouldn't I do that?

I don't work for Microsoft, I'm not locked in, and I'm just trying to get my own work done. I am equally productive with Vim, and it doesn't lag, so I switch over.
Test as many immunomodulatory hormones, glandular extracts, and bioactive plants as you can figure out. It might help humans you know someday.
Interesting, I always thought that spec-first and rigorous testing methodologies came from limitations in technology. For example without the capacity for constant updates software had to be as close to perfect and bug free as practical before distribution. I cannot imagine doing agile on a widely distributed software project as it is done today with games and their day-one patches.

EDIT: rephrasing for clarity
Probably off-topic, but I've always wondered how malware authors register domains that are generated by Domain Generation Algorithms, without it being trackable back to them.
I think I actually agree with you. That said, I would recommend it _because_ it actually has something to back it up–that's worth a lot imo.
That's a really good question. I generally end up building these tools for personal use or to see if some design space is worth exploring, and so don't bother cleaning up the code/making it easy for other people to run. In addition, people now have the expectation that people releasing open source code owe them some manner of improvements/support/maintenance, something I'm not interested in doing. I like David Beazley's recent tweet about releasing his code asis - https://twitter.com/dabeaz/status/1069236767029633024

I've got a number of tools like this - a basic SQL GUI for doing analytics (https://news.ycombinator.com/item?id=14050833), a Tableau like clone with interactive graphics for visual analytics (https://pbs.twimg.com/media/Cyji3jRWIAA2LRY.jpg:large) - your comment is making me reconsider that people might find them useful without any expectation of support/warrantee of fitness.
There are two obvious errors here.

1) We didn’t discover the hack for over 60 days. Recommending 7/14/X does not address this. What X is sufficient to ensure the community inspects new code? X=60 didn’t cut it.

2) Private signing keys are only private from us, the general public, not necessarily from maintainers, and may be sold and transferred with ease. If I were buying a codebase, I’d require the signing private keys for continuity reasons alone. (CAB EV rules permit this!)
No, he never acknowledged Empire.
It is because those things are simply not needed to parse or understand the code.

Everyone indents anyway. So why need braces?

Most people write one statement per line. Who needs semicolons. I've often called it the most useless character in programming language history. Whenever I switch from a language that doesn't use them to one that needs them, it's a horrible transition. I have to mentally remember to add this character at the end of most lines.

Parentheses for function calls - in some contexts they are helpful. In most, though, they are not needed. Wherever they are needed, you will have them in F#. For people who went from Python 2 to Python 3, you'll know the pain of suddenly needing parentheses for print statements, and for most of those people, you will not see any benefit to adding those parentheses. Extend that to other functions.
This is simply not my experience with exceptions. Exceptions are frequently thrown and almost never need to be caught, and the result is easy to reason about.

My main use case for exceptions is in server code with transactional semantics. Exceptions are a signal to roll everything back. That means only things that need rolling back need to pay much attention to exceptions, which is usually the top level in jobs, and whatever the transaction idiom is in the common library. There is very little call to handle exceptions in any other case.

GC languages make safe rollback from exceptions much easier. C++ in particular with exceptions enabled has horrible composition effects with other features, like copy constructors and assignment operators, because exceptions can start cropping up unavoidably in operations where it's very inconvenient to safely maintain invariants during rollback.

Mutable state is your enemy. If you don't have a transaction abstraction for your state mutation, then your life will be much more interesting. The answer isn't to give up on exceptions, though, because the irreducible complexity isn't due to exceptions; it's due to maintaining invariants after an error state has been detected. That remains the case whether you're using exceptions, error codes, Result or Either monadic types, or whatever.
>it's a "peacekeeping mission" or a "humanitarian mission" when a Democrat is in office.

Bull-fucking-shit. The Boston Commons tankies were out every Saturday protesting "illegal war" this and "unconstitutional" that through all of Obama's term.
There is nothing more frustrating than doing things you are bad at, regularly, especially if you are bound to get somewhat worse as time goes on. To your point, even if that were the reason for a significant number of departures, it would not go against the conclusion.
For me, `with` is enough. e.g. `let output = { input with status = "failed" }`. For all those times you want to be able to return a modified value but not mutate the original. Once you're used to doing this in F# you take it for granted.

Going back to a project with the C# mindset of `{get;set;}` everywhere, passing "records" into functions and not being able to prevent those functions to mutate them, it seems so unprincipled.

The other stuff in F# is also great, but even with none of it, the simple `with` operation is the thing that changes the whole game.
to #2 - FSharp.Charting should work from the REPL (though I haven't tried it myself). You can get the REPL within an IDE from both Visual Studio and VSCode.
Evelyn Berezin, Computer Scientist Behind Groundbreaking Word Processor, Dies
I use IntelliJ on all languages I use on Mac but VSCode's font rendering is more natural and better. There's something weird about Java's rendering implementation for not being crisp.

And VSCode doesn't take 30s to launch.
Don't forget ATV0 (I think....memory is hazy) to set the modem speaker volume to zero (silence) before dialing. :)
Have you ever taken these sorts of tests? They are not fun. Many questions are childish. Others make you feel stupid for not getting them right. Both extremes are necessary to the study.

I'm reminded of a study using the Nintendo Wii to help keep elderly people mobile. 90+% of them stopped playing immediately, within days, of the researchers leaving.