skysight-inc/HackerNews huggingface dataset:
> Communication by redefining established terms is getting painful...

And here I thought I was telling you that not everybody uses "first-class" (or even "first-class values") in precisely the same way. I agree that the strictest definition only deals with how you use the various types of values you might have in your program, and not with the types of names you can give them. I hope you can also agree that not everyone limits themselves to just the values; they see the differences in how functions get stored in the environment, and recalled from it, and see this as treating the functions differently than the variables.

This does mean that many people are operating with a broader definition of what "first-class" means. It would be perfectly clear to call it "first-class naming", for example, but polysemy is not unique to software engineering; we must allow for it in all fields of endeavour.

My only point all along was merely that when someone hyperbolically calls Common Lisp a "Jim Crow" language, they are not wrong merely because they are talking about names instead of values.

As an aside, I didn't mean to imply that Clojure invented callable arrays, merely that Clojure programs use them frequently; probably just as frequently as they use higher-order functions.

I take no position on whether any language is "write-only" or not; that would be nearly as productive as talking about "virtue signalling". ;)
It shouldn't be 'the most common testing action'. In my mind, the number of mocks required for a test is usually inversely proportional to the quality of the code; if you need to mock out 20 random implementations to test something, you've either got an integration test masquerading as a unit test, or you've got very tightly coupled code. Mocks that need to be injected via monkey patching are worse than 'normal', dependency injected mocks. `quality = mock_count^-1 + monkey_patched_mock_count^-2`

Monkey patching is a sign of bad code in 99% of cases. In that 1% of cases where it might be justified, you can restructure your code to use indirection and dependency injection, and avoid having to use monkey patching. It might not be as nice as monkey patching in that 1% of cases. But I'd rather work in a language without monkey patching, precisely because it makes it incredibly obvious when you've coupled your shit.

Working in Go changed how I write my JS code. I don't know if you write much JS, but to my mind, `sinon` is mocking. `proxyquire` and `rewire` are monkey patching; monkey patching with the aim of helping mocking, but monkey patching none the less. My JS tests now don't use proxyquire or rewire, though they might use sinon. I find this produces easier to read code.
The one caveat is that there are times when the business realizes that their old workflows and features aren't what they now need. The rewrite becomes a new project competing with the old rather than a functional rewrite.

This is also fraught with peril. However, it is a different set of problems. In an ideal world, you have engineers who can make reasoned decisions.

However, if the company culture allowed one application to devolve into chaos, what will make the second application better?
> Wouldn't an AI that can be a judge in a Turing test be able to pass the Turing test?

Not automatically, unless it had unlimited time and/or compute power. Verifying a potential solution seems to be much easier than generating a valid one. See also: P versus NP.
There is actually a lot of research into how to conduct interviews for useful answers. They all come down to you need a deep discussion.

What works well is some form of "tell me about a time when ...". The candidate gets to tell a story of their choosing, but the discussion is long enough that they can't keep track of their lies...
Great point. I still read every word even I knew the core ideas in a book already. The purpose behind is to look at the same thing as a different identity, from a different identity.

Yes, there is no point to rush, because you're RIGHT. I believe in implementation and taking action too.
The x86 desktop application support is for the desktop use case. For a phone you'd plug it into a dock and use it as a desktop or into a laptop shell and use it like a laptop. Like this for example: https://www.youtube.com/watch?v=KNzatcI9Fqw
No that's true for Scala. Scala has, in fact three kinds of "properties":

* `val foo: Int`: always immutable, really. Every access always returns the same value

* `var foo: Int`: mutable

* `def foo: Int`: "getter" of sorts; cannot be written to, but can return different values when called several times
Define Robot..

Would you consider the relay in your internet connected smart bulb a robot?

Maybe it needs to also move to be considered...

Could the remote controlled computer and motor that pushes your car window up and down be considered a robot?

Maybe it needs some AI then...

What about the Nest brain to your house that switches all manner of things on and off to you liking?

Semi autonomous teslas, vending machines, drones, roombas, parking garage entries, energy efficient elevators....

Robots are fundamentally control systems, and they are absolutely everywhere. They just don't look like a T-800 (o;
My first thought was that this would be whiney, but the author lays it out in detail and makes a lot of great points.
Windows MsMpEng remotely exploitable UaF due to design issue in GC engine
CRISPR-Cas9 gene editing causes hundreds of mutations
It is certainly possible. I started charging last November and am just passing this threshold without spending any money on marketing at all. This might not work in all cases though. I have a bit of an advantage in that my users are podcasters and they tend to be good promoters with built-in audiences of their own. Also, my service is just naturally viral. The hosts have new guest on their shows all of the time so new people are getting exposed to the product regularly. When they see the ease of use, many of the guests sign up themselves. Not sure how you would recreate this in another domain but hope that helps.
I think instead of "as many as you can" it's "as many as you can afford."
Super ignorant comment. I just wrapped up an app for a client. They only had $10k to spend on it and it HAD to be cross-platform. I'm not writing two native mobile apps and a backend for $10k, that's at least $50k of work.

So I explained to them that we could use Cordova, and that it would probably suck, but that's all they can afford for $10k. And they were happy with the delivered product.

Cordova has its place. You probably wouldn't use it on a team with many developers or at an enterprise level. But if you do client work and your clients don't have money to spend on native, then this is the best solution.
AWS Summit 2017 in Auckland
>Lots of people say it's around the corner but people have been singing that song since the 60's.

People say lots of silly things though. The predictions based on Moore's law and neural equivalents have always been for around the 2020s. Check out Moravecs thing for example http://www.jetpress.org/volume1/moravec.htm - and it's not rocket science - you can do the calculations yourself is so inclined.
Chrome Flaw Allows Sites to Secretly Record Audio/Video Without Indication
> the top left of a matrix A is always A_(1,1)

In maths notation it usually is, yes, but in a zero-based language it's usually a[0, 0] (and I've seen maths and CS papers where it's 0, too). The number of elements in a mxn array is still m*n, but the indices don't go that high. For example, in Python you'd loop through m rows with "for i in range(m)", which will go from 0 to m-1 (actually, you might do "for row in a" and not bother with indices). You hardly ever need to do m-1 manually - if you want the last row it's just a[-1, :].

I'm not saying zero-based is always better, but I haven't seen many situations where one-based is preferable.
> What C++ (and Lisp) gets right is providing user code with the same powers as the compiler.

So what part of that isn't fulfilled by compile time function evaluation and mixins and it's extensive introspection features? I feel like maybe you haven't looked at D quite hard enough to see why it's awesome.
Supreme Court Patent Ruling a Step in the Right Direction
No, it isn't the same confusion. The article describes a different problem (worse, IMO). Read it again, or read the following comment in this HN thread: https://news.ycombinator.com/item?id=14445829
Promoting newsletter sponsorships as a vehicle for side project growth is a great idea. I think using an email newsletter itself is not the right format but looking forward to a searchable database.
This reminds me of radar detectors.
I wonder if this would work with NodeMCU development for esp8266 boards.
>I've had jobs where I had to sit around and pretend to be busy. They're awful. I much, much prefer to have challenging work to do.

Agreed with this. I haven't been more miserable in my career than when I was just moldering in a corporate body shop.
Honestly, it seems like implicit variable declaration is a bad idea. Some minimal keyword to indicate "this is a new variable in this scope" seems necessary for sane scoping. It nicely prevents a class of bugs of "oops I made a typo in that assignment and created a new variable" gets caught.
I have years working experience with Clojure. The tooling in Clojure is much better than this. If you want a debugger, Cursive has it out of the box, if you are used to Intellij, you can use it right away.
If you are an Emacs user, then you know your way around CIDER and its tooling.
It's not that I don't agree with the author's post. But I mean for simple functions, good enough tooling and unit tests are your friends.
His voice is synthetic, so no. This is not a Turing Test.
Though, you can add an annotation to get field behavior - it's mainly for java compatibility from what I can tell (and it's documented in the java interop section).

I'm not sure if using that annotation also generates the getters/setters though.
In C++, there need to be e.g. two overloaded versions of the index operator on a vector: one taking a const vector reference returning a const reference to the value, and one taking a non-const vector reference returning a non-const reference to the value.

With only the first one you couldn't modify values of a vector using nice [] syntax. With only the second one you couldn't use the same nice [] syntax on const vectors. So you need both. The implementation can be identical, but the method signature is different. You end up with such duplicate functions all the time for accessor methods.
Why the downvotes to the parent?

The evidence is there. https://www.cvedetails.com/top-50-vendors.php
Refuting Lucas is very simple: Godel sentences can only be constructed for circumscribed systems, i.e. a system where you have written down all of the axioms and inference rules. So the only way to circumscribe a human brain is to isolate it from its environment. As soon as you let it communicate with (say) another human brain, you can no longer Godelize it because that brain is not the system any more, it's the two communicating brains working together. That system might have a Godel sentence of its own, but it's not the same as the Godel sentence of individual brains.

So if I can put you in an isolation tank and model your brain, then I can in fact (at least in principle) construct your Godel sentence and know for certain that you will never come to the realization that this outrageously complicated mess I've just constructed (the one that says of itself that you will never come to see its truth) is true, and I can feel smug about the fact that I can see that this is true and you never will. But here's the kicker: I can never gloat about my superiority to you, because as soon as I do you are no longer in isolation. You are communicating with me, and the sentence I've take great pains to construct is no longer your Godel sentence. It is the Godel sentence of you in isolation, but as soon as I tell you your Godel sentence -- indeed as soon as I (or anyone else) say anything to you, my construction falls apart and I have to start over.

Ironically, far from proving that we are not machines, Lucas's argument actually goes a long way towards demonstrating that we are, because coming up with examples of things that we interacting brains know to be true that a particular isolated brain will (with extremely high probability) never come to realize is not difficult. The four-color theorem, for example, is probably beyond any single isolated human brain. Indeed, the very argument you are reading now is probably beyond any single human brain because the brain that's writing it would never have come up with it had Godel and Lucas (and Turing) not paved the way.
Can't say I agree with the big bang rewrite part necessarily - at my last job, I found myself having to do significant refactors. The reason was that each view had its own concept of a model for interacting with various objects, which resulted in a lot of different bugs from one off implementations. My refactor had some near term pain of having to fix various regressions I created, but ultimately it led to much better long term maintenance.
Speaking from my own experience it can still be a challenge because you have to context switch a lot and never go deep enough to truly understand a problem. You are relying on your engineers to be your eyes and ears. If you have all good people in your team you are really lucky. Otherwise it is a balancing game coaching some engineers to learn and get better, quickly figuring out solutions to technical problems that are raised, fighting back the upper management pressure while not trying to frustrate your team.
UK Government to restart war on encryption after the election
True, I read mostly self-help, some behavioral science, and marketing.

Haven't really explored fiction and novel yet.

Love physics too, but mostly consume that in video format.
>AlphaGo did a lot of things that the professional commentator found odd

AlphaGo is maximizing it's odds of winning, not maximizing it's score. Humans usually do the inverse, which is not an optimal strategy.

AlphaGo really is better.
The searchable database is the real product, but to protect myself from procrastinating on this I forced myself to launch quickly. Hence the v0.5 solution.
> add instrumentation. Do this in a completely new database table, add a simple counter for every event that you can think of and add a single function to increment these counters based on the name of the event.

The idea is a good one but the specific suggested implementation .. hasn't he heard of statsd or kibana?
How will you validate active subscriber numbers so new buyers can ascertain the value of a particular newsletter?
with your it skills you can easily go global. make a great website with a customization widget or twitch the making of a guitar. lots of possibilities to distinguish yourself
Styled Components V2
I find the Home product more interesting than the phone: https://www.essential.com/home
Photos from social media users perform better than stock
Getting Domain Admin with a push of a button
Yes, Matchbox was WAY BETTER. They rolled better and looked more cool. I still remember the sound of matchbox cars rolling on linoleum floor.

I recall being super protective of my favorite cars. Whenever I allowed the wrong kid to play with it, they would get rough with it and end up bending the axle. After that, the Matchbox would NEVER roll straight again. Pissed me off so much!
I helped people cheat because it paid better than working fast food. I never took an exam, but I did a lot of assignments. I kinda felt bad for some of the students who were taught Java for a couple semesters and then thrown into C for an operating systems class. I also figured that they'd just fail the exam if they didn't learn it eventually (which happened frequently, usually resulting in more work/money for me next semester).
the name is the same/similar to an existing loan company.
Steve Cohen is reportedly prepping the biggest hedge fund launch ever
Personally I don't think the distinction between Lisp-1 and Lisp-2 is a very important one, in terms of practical engineering. I just wish I could use any Lisp more often; Lisp-1 vs Lisp-2 doesn't really enter in to it.

Now, I have to go back to working on this Automake/Autoconf mess I'm working on. mumble mumble M4 mumble...
People who like to make stuff, they make stuff. No reason to build "businesses" around their stuff.

People who like to exercise, they exercise. No reason to create "routines" for exercise.

People who like to cook, they cook. No reason to develop "recipe" and "meal plan" to cook.
Weird, it's not listed on the main page....
How do people handle this in dynamic languages like JavaScript? I have done a lot of incremental refactoring in C++ and C# and there the compiler usually helped to find problems.

I am now working on a node.js app and I find it really hard to make any changes. Even typos when renaming a variable often go undetected unless you have perfect test coverage.

This is not even a large code base and I find it already hard to manage. Maybe i have been using typed languages for a long time so my instincts don't apply to dynamic languages but I seriously wonder how one could maintain a large JavaScript codebase.
Amber Rudd doesn't think you need WhatsApp encryption
Not available on all platforms. Think: mainframes, platforms no longer with the times, non-unix and so on.

If you have access to a tool like that by all means use it, the specific implementation is not relevant, the article merely tries to show a simplest way to implement this very useful functionality that will work without limitation on just about anything that I can think of.
A friend of mine asked me to clarify a bit and to cut out my silly jokes.

The main question of Eastern philosophy (What is real? What is?) is way too far away from being answered adequately. One very old and very naive view is that nothing is real, everything is constructed by the mind. The question is - what is mental and what is real and how​ to get them apart.

Out of this comes a few simple notions, such that, while math and probabilities in particular could be used to produce a model of what is, nevertheless they cannot be the causes of phenomena because math and probabilities does not exist outside people's minds.

Of course there are certain physical constants - an angle between atoms in a water molecule, but there is no way a cell could measure it. It happens that other molecules assume certain positions in a water solution, but there is no notion of an angle anywhere. It requires an intelligent observer, which isn't here.

Same logic applies to numbers. Yes, of course, two apples and two apples would he be four apples, but there is no one to notice this at a molecular level. So, cells does not count. They pattern match, because it requires no observer and interpreter.

These notions could be generalised to a simple rule of thumb - do not try to establish causation with mere abstractions of the mind - they aren't here. Numbers, leave alone probabilities, are abstractions. Out of abstractions one construct simulations. But simulation is not reality the same way a map is not the territory.

Now about logic. It is a path from what is real to what is real, each step of which is validated by all the previous steps. It is a result of a domain-specific heuristic-guided search process, where a heuristic not choices the next step, but validates the current position by tracing it back to what is real.

Nothing much to see here. Just applied Eastern philosophy. To arrive at what is an observer with all his mental constructs has to be removed, similar to removal of the illusory self which obstructs reality. It is an ancient hack.
Getting data (Open rate, CTR etc.) from a recent email campaign, should already give a good indication of the level of engagement each newsletter has.
English Wikipedia has 5.4 million articles. I imagine many of them would be notable in Chinese too.
Read stuff about your work?
Looks like you had a too ambitious goal. Your rewrite would suffer from even more unexpected bugs, and the same urgent features, but worst, because you will have to fix them in 2 different systems. When your organization won't help you, you have to do less.
Our brains evolved through a chaotic, organic process. We're all the time storing new data and even losing data (selective memory). I'm thinking there's no mitigation process. If anything the random environmental noise might play some role in consciousness.
This is where naming is key: specifically, web applications vs. web sites. Many confuse the two, but keeping them distinct is helpful with questions like this.

A web site is normally a public-facing collection of HTML and JS where the JS is primarily decorative and the site is primarily page-oriented. Navigation is done via physical pages using the normal browser mechanisms such as links.

A web application is normally a software service that more resembles a desktop application due to its "load once and let the JS take control" architecture. Navigation is normally not done via physical pages, but rather via hash navigation that navigates within areas of the application, as opposed to physical pages. And, you'll see a lot more application-oriented UI techniques like modal dialogs and more elaborate controls (treeviews, listviews, etc).

There are, of course, applications that straddle the line between the two, but it's still helpful to make these distinctions because:

Web sites should optimize for load time first. Otherwise, you're going to have visitors bounce.

Web applications are different, and while they need to keep the load time down, they will most often be already in the browser cache. So, the performance shifts towards focusing more on the actual run-time performance of the application, and that is where issues with raw DOM manipulation may become problematic without something like a virtual DOM or some sort of property caching.
That's a nice, short answer but t's a bit unsafe, isn't it? The standard order of terms doesn't know anything about dates. The above works because compounds are compared recursively on their arguments.

For those less familiar with Prolog, in Prolog terms, a date in a format like 2014-5-1 is a compound term, a predicate -/2 with the operator "-" as a functor and 2 arguments: 2014-5 and 1. The first of those is, again, a compound, also with functor - and two arguments, 2014 and 5. So the entire date is a recursive term.

A comparison predicate, like @>/2, etc, will walk over the arguments of this term and compare them as it goes - but since a "date" is not a Prolog type (only "number" and "atom" really are) it will not treat a term meant as a date in any special manner.

Which, in the end, means that the following queries are all true:

?- 2014-5-1 @< 9999-1-1.
true.

?- 2014-5-0 @< 9999-1-1.
true.

?- 2014-5 @< 9999-1-1.
true.

?- 2014-50-1 @< 9999-1-1.
true.

The third query has some merit, but the rest will need some type-checking somewhere above the comparison line, to make sure you're processing dates and not just arbitrary numbers. In that sense, wrapping up dates in a date/1 term, as the OP did, may not be such a bad idea after all - or at the very least one could write a is_date/1 predicate to handle type checking:

?- is_date(2014-5-0).
false.

?- is_date(2014-5-1).
true.

But er, that's left as an exercise to the reader :)
Most of the time I see a cracked display it is on an iPhone.

Is there a reason Android phones don't shatter as easily? Is it the elasticity of the plastic frame that causes this?
Had there been any scaling problems for Lapis-powered apps that you have worked on?
Yes, I agree with that; MVPs and fast iteration!
Had a wizard and a Tytn, terminology aside, they were completely products than the iPhone. 'Smart phones' prior to the iPhone were really just mobile MS exchange connectors, the web browser was unusable and there were few if any lifestyle apps. The iPhone really was the first of it's bread.