skysight-inc/HackerNews huggingface dataset:
The problem of software knobs is that the one that helps you is almost never there, and you usually can't get similar functionality from mixing the ones that are there.

That said, there are exceptions. I don't think GC is something simple enough to be an exception, but those exist.
Yep. I view ISP as simply a reminder that an object's public interface should be focused and cohesive.
Ah yes! That's human's biggest downfall perhaps.
> but the lot was a drainage pond for a year or so

That's okay. Last laugh as I'm sure they're dealing with settling/water issues (especially if there's a basement).

'Member when builders used to build around the landscape? I loved growing up with 100-year-old maples (especially around fall)

I 'member.

Now they're stacking 3x median homes right next to each other.
Provided that by "extremely well" you mean being able to give up control over allocations, making it easier to spew vectors, and worse, maps, all around the place.

I think it was ryg who said on twitter that these abstractions are not really "zero cost". C++ abstractions get you in a mindset that might be detrimental to performance.

> The problem with the “write like C” approach is that it forces you to write low-level code

No, you have to think in what order to do things. Yes, you have to write low-level code, but not all the time. Ideally you write the low-level code in one place and the high-level code in another place.

If you do allocations in your high-level code (which is admittedly what you see in many code bases), you are doing it wrong. (speaking of separation of concerns, for example). This has ramifications on maintainability as well as performance.

I'm currently writing a little game engine, where I explore an architecture where these things are neatly separated out. (coincidentally, most allocation is done at compilation time, and much "code" is done by the linker).

There is of course still a place for script-style code that lacks an elaborate architecture. And I guess C++ is the right choice to do that if you need "tight loop performance" or need to interface with C code.
It most definitely matters. I have read Face ID tries to learn more about your face if you unlock it with the passcode after having issues unlocking with your face. What are the chances it learned the mask?
It would be more surprising if they had accepted.
And then there are many Go users, who don't really care for generics, or like me, think generics could be nice, but could also make the language more complex than desirable.

If someone came up with a practical, clean, working proposal for Go - then absolutely. But so far I've only seen complaints and proposals where the conclusion starts with "this proposal will not be adopted" - mostly because it's somehow flawed.
Skype for OS X updated: version 8.10
Yes. The thing is once you are an Alzheimer's patient, you are doomed because your brain basically stop being able to function at the very end. It's like a death kiss from the above. Unlike cancer, which is scary as hell, and has a high death rate, has better chance of surviving. The pressure on Alzheimer's patient and on the family is just unbearable. While there are some treatments to slow down the progress, we are far from understanding the disease itself, let alone knows how to combat the plaque and tangles effectively. Right now I think one of the best treatments is let patients be more active, whether it's playing chess or gardening, while receiving family support. The more positive we are the better we are overall health wise. This is evident in patients who suffered depression.
Using classes or traits to model dimension numbers is something I did in C# when working on Bling 10 or so years ago. If you only have a few dimensions you need to handle anyways, it works out, and you can embed predecessor and successor dimensions in the types. Good days, though I guess I’m not that reckless anymore.
It would have been probably been rejected by anti-trust regulators.
Nobody said there are guarantees. Please read my first comment.

Comparing a 80 year old company production with a 14 year old company and expecting the same production power is unrealistic.
> The probabilistic analogy is flipping a billion coins and having them all come up heads. Flipping a billion coins and having them all come up heads does not have measure zero. It has a positive measure.

wut? 1. in each instance it's 1MM conditionally independent trials so i don't see the difference 2. any realization of any continuous random variable has measure zero

>Contrast this to measure zero events. Flipping infinitely many coins and having them all come up heads has measure zero.

you're playing fast and loose with the difference between a counting measure (no measure zero events) and a continuous/discrete measure.

anyway my point was exactly that quantum tunneling is counterintuitive exactly for the same reason that measure zero events are counterintuitive
This article makes a case that the creation of new coins (or blockchains) is inherently 100% wasteful. This is to some extent talking past the actual advocates of proof of stake systems, who claim that PoS can provide security, not new coin distribution, at a lower total cost.
I guess that´s why many people don´t even start with trying to implement GTD into their lives. They fear being "too organized". What many people don´t get is that after "clearing your head" and really using GTD you have more space in your mind to actually live and be creative.
> 3. The CPU eco-system including ARM's is a bit sclerotic.

Silly question, but what do you mean by "sclerotic" here? I had to look up the word and only found medical definitions.
I am not quite sure but are you talking about something other than dishes? :)
AWS just announced a move from Xen towards KVM. So what is KVM?
What Tech Can Learn from the Fruit Fly's Search Algorithm
Huddle's 'highly secure' work tool exposed KPMG and BBC files
This blog is more of a rant. Official blog announcements and marketing material are not the place to delve deeply into technical tradeoffs of designing GC. He compares it with Java which is rather ironic considering I have not seen Java official announcements talking about things not done. It would like saying 'We have not been able to deliver value types, module story is still half done, and we couldn't write an official http cient in whole development cycle in Java 9' in release announcement of Java 9.

Also there is no data provided to show how bad is Go's GC compare to Java
And yet you get penalized or outright refused to build up in order to get your view back...
I believe rust would be a better example here, with zero-overhead being a primary design goal. For C++, it's more of a mixed bag.

As long as all the abstractions and language features are compile-time evaluated to what people may consider to be "C-like code", then it's all the same.

I don't like the term "C-like code", though. It's not C's fault that fast code looks like that, and it is certainly possible to write "prettier" C code than what people have in mind.
A similar trick works for avoiding sugary treats: don't strongly oppose this desire - instead say to yourself you can eat it at a later time and move your mind to something else.

(When you finally eat whatever it was you so much desired, you didn't really fail, because you are only consuming 1 unit for those 3/5/whatever days, instead of one every day...)
I might test that today!
it’s not equivalent because there’s very different penalties in hacking someone vs torturing or coercing. So it requires different levels of motivation.
Oh good example. It shows everything that's wrong with OO thinking

I could split the file interface like this, thinking that some modules will want to read only, some people will want to write only (in rare cases you want trim only, but that is obvious except to "enterprise architects" apparently)

Except it's splitting hairs. And my readers can ignore the write interface and my writers can ignore the read interface and that works in most languages.

> This gives the flexibility for the clients to combine the abstractions as they may see fit and to provide implementations without unnecessary cargo.

Your compiler won't let you call an abstract method. It's that simple.

It's not increasing flexibility, it's increasing red tape and maintenance costs.

One of the reasons C# feels more fluid is that they reduced the level of lunacy created by this way of thinking where you create two or three classes to solve a problem that's solvable in 2 lines in other languages
Proxima Nova Font
Liver spots are the result of aging sun exposure. A long time ago they were thought to indicate an issue with the liver, but there is no connection between the two. They are not at all an indicator of health. The only affect they have medically is that they can make it harder to detect skin cancer when doing a visual exam.
There's a video (now pay-walled) from Cameron Davidson Pilon of Bayesian Methods for Hackers fame, where he takes this approach to build a basic Markov Chain model to predict patterns in his browsing.

https://dataorigami.net/collections/all/products/create-mark...
My mom has a master's in education, and after 30 years across two public school systems, she's finally broken $40k salary. Where do you live that public school systems pay well?
Lumen – a modular audio synthesizer written in Go
I don't understand...
Why are people acting like cooking for your friends and family is a super formal thing?
Because a function is not a contract enough - it doesn't have a strong name at point of injection. But yeah, pure functions should be used way more often.
Well, the board rejects it, but the shareholders can still sell, no? Hostile takeovers have worked in the past, e.g. Oracle's acquisition of PeopleSoft.
I'm in a similar boat right now, I started exploring Vue with the vue-cli default template and VS Code.
Webpack and the associated npm ecosystem scares me to no end. When it works, it works wonderfully but it is so incredibly fragile and built upon assumptions that might change if you do not use the exact flavor of tools and utilities the creator of the template does.

For a long time, the way webpack worked in the Vue template was at least 70% black magic to me. I had some issues with it, sometimes I solved those issues after google-ing a lot and landing on completely unrelated projects Github issues for a fix. I never quite felt that I had mastered that whole ecosystem like I felt I had mastered my regular programmin languages and tools.

My day job is C# and my day IDE is VS2017. I've been given permission to explore doing a new application in .NET Core with Vue. So, I've started to translate the default template from vue-cli to Visual Studio and I have learned a LOT by trying to glue these pieces together that no one else seems to have glued together for me. Luckily, MS has done a lot of work to make React play nice with VS2017 and that seems to benefit Vue as well.

I'm not quite there yet, a few last issues remain. Most of them have to do with Intellisense's understanding of Typescript vs. Webpack's understandinf og Typescript. Some remain unsolvable for now (Single File Components using Typescript and SCSS).

Still, the point I'm trying to make is that being forced to read through the entire thing has increased my understanding of the Webpack process immensely. I feel like I'm at 80% mastery now.
what makes you think so? I mean it should be, but I don't think the govt is currently being run by a sane administration.
For me, it's Grails. But really, go with the "use what you know" mantra unless there's a really compelling reason not to.
This works very well for me. The trick is put the gym clothes without thinking about your feelings and thoughts. Then proceed to walk out the door with the same attitude, supressing the internal chatter..
I think you are basically right, though I don't think the explanation needs a specific hypothetical victim. Lying, like violence, is often used to advance the perpetrators' interests at the expense of others. When there are victims, most of us, I think, empathize with them and regard the perpetrators with at least distaste, even if we are at no risk of being victims ourselves, and even when the victims are unknown to us. If this were not the case - if we were only concerned with our immediate self-interest - ethical society probably could not exist.

Furthermore, knowing that someone has lied in the past leads us to distrust them, and even warn others about their behavior, even if there is no apparent victim, or even without clear evidence that they are currently being deceptive. Reputation is an important part of the network of trust that an ethical society depends on, and furthermore, we have probably all learned to be wary of deception even when we cannot immediately see the harm. Liars are suspected of being up to no good, and for good reason in general.

It also seems to be that blatant lying provokes more anger, even though subtle, minimal lying is often more effective, perhaps because blatant lying signals confidence in the perpetrator that he will prevail. In this case, the lying is blatant from the perspective of the author, who is knowledgable about the domain.

I recall a study from years ago - some sort of game-theoretic simulation - which showed, given its assumptions, that it was not enough that rule-breakers be punished for the society to remain whole, but so also should those who were tolerant of antisocial behavior. Unfortunately, I have lost track of it so I cannot check the plausibility of its assumptions, but note that someone getting away with something sometimes provokes more anger than the original offense, and then it often extends to those who permitted it. To the author, the lame rationalizations of the womens' defenders probably feels like collusion. Also, I see that in this thread, pfarnsworth's 'but there is no victim here' comment has been downvoted, while khazhou's 'no quarter' comment goes unremarked.
I'm curious if using that feature could lead to other charges.
Show HN: Socratease – A Joyful Way To Learn Things
I was mostly commenting on the start slow and simple and get going.

Sometimes having a low entry barrier and then have some inertia in the activity does create a good rhythm/regular schedule. But sometimes I just give up.

Other times what I need is some god damn good old drive to start rolling up my sleeve and get done with that pile of whatever.

So yes in theory, breaking things down is good, but it's not always the determining factor. I hope it's a bit clearer.
Proxima Nova Free Font
Time zones, daylight saving, and cancer risk
It's not just a fixed-length hash, but it does computations on the curve points, which are represented by big.Int's, that take a variable size and are likely to end up on the heap.

Also, Go crypto makes a heavy use of interface that also make stuff escape to the heap. Of such things are a bottleneck, it might be worthwhile to "un-interface" them.
Yeah! I consider discipline a conscious thing and that only works for so long. What you actually want to achieve is that tasks that require discipline eventually become a habit. Because then you´ve internalized the task and relaxation and peace of mind become part of the equation.
Maybe doing widgets is hard? If you just want to draw shapes on the screen there honestly isn't an easier way to do it.
thanks! The code in my post is mainly more of a POC than anything else, but in my next post I’ll try to be more Pythonic.
To add to the sibling comment here, when you have a realistic choice, you can choose the better one. Lyft is a clear matching competitor, and if you can afford any small price differences, you have no excuses. Amazon doesn't really have a competitor. While some can afford fair trade clothing, most cannot. Just because no company is perfect and sometimes supporting pretty shitty practices is more or less unavoidable doesn't mean you have no choice in every scenario every time.
Recursion Without Recursion – Tearing Down Trees in One Line of Code
The post wall still interesting showing the information war between sides and where they gather. The fact that UK citizens are do active is alarming to say the least.
Maybe. But I think the method is not supposed to be applied word by word. Reading the book taught me some very important lessons nevertheless. What is an actionable item. Tasks must be clear. Small task should taken care of right away. etc.
C++ allows zero-overhead abstractions, but in my experience it's pretty idiomatic for "stack" variables to implicitly do heap allocations or similar possibly-expensive operations (acquire mutexes/semaphores, exchange IPC messages, etc.) in their constructors. Maybe this isn't true of modern/Core Guidelines C++, but it's true of a lot of code I've seen.
The Next Platform has a nice little primer on what Graphcore's IPU is about (though specific details about the architecture are still under wraps):

https://www.nextplatform.com/2017/03/09/early-look-startup-g...
I've been tempted by this one:
https://www.sinewavecycles.com/products/sinewave-revolution
Can we talk about how to hack this? Is there camera-defeating reflective make-up that I can apply before going through an airport? How does one defeat these technologies effectively so that they are no longer useful to governments?
Indeed, I also started moving from documenting what code does to explain what I intend the code to accomplish (because code already explains clearly find what it does by itself). By communicating at this level the overarching idea does not get lost and allows for much better refactoring or debugging.
You need some cleverness to code an add(x, y) method with only bitwise operators.

Then, you need to code a multiply(x, y) method using some more bit shifting cleverness and your new add method.

Then, do repeated squaring using your new multiply method.
Are Qualcomm and Broadcom subjected to EU antitrust laws when it comes to acquisitions? Or just limited to when one side is registered in a EU country?
The first paragraph is a reference to this gem from the 80's called "Safety Dance"

https://www.youtube.com/watch?v=AjPau5QYtYs
Lyft tends to pay better than Uber. Have asked drivers who drive for both in about 5-6 cities, all same answer. Lyft is the one you want to drive for.
No, the operator is like the same operator in Ruby. You define an operator<=> for one or two types and then whenever you use one of the normal comparison operators in code (say a < b), the compiler replaces it with a<=>b < 0.
That is absolutely true. Wihtout actually getting started, nothing happens. No system can "make you" more productive. You make yourself more productive by implementing the system.
It's awful. I can't sit in aisle seats anymore; I'm a particularly awkward combination of tall and broad-shouldered, so my knees are already jammed into the seat in front just sitting there, and my shoulders jut out a couple inches over the width of the seat on each side. With a window seat, I can kind of twist myself around into the window well on all but the smallest planes, but on the aisle I get trucked constantly by the drink cart or people streaming to the bathroom.
Channels pass ownership of allocated objects, they don't perform copies or allocations themselves (once you've allocated the channel and the objects you want to pass).

I don't think the article says anything about concurrent allocations; in fact, the various signers don't need to share anything (mutable) to sign the requests they get.
> Garbage collection usually works out to a performance / latency tradeoff. (A GC app runs faster than a non-GC app, but has latency.)

I think there are several layers to this. First of all, GC'd data is on the heap, and often you are already doomed if you do stuff (in spread out places) on the heap at all because of cache issues.

Secondly, if we consider "normal" applications that have small parts of perf sensitive code, while a majority of the codebase is not (such as e.g. a 3D rendering application where you hit a button and it goes of and renders an image for 1 minute), then you'd have plenty of time to set up your data, and then you just "operate" on it for the critical part of time. The same isn't true in all scenarios.

Same thing with e.g. a game engine. It's fine to allocate massive amounts of memory, but then in each frame when you have a 16ms budget you allocate nothing. Because the delay loading a level doesn't matter whether it's 5 sec or 10, but you can't spend 17ms in a frame instead of 16ms.

Another problem (and benefit) in most GC'd languages is that the GC is there for developer convenience, and the class libraries know its there so all standard library features (such as just iterating over a collection of items) risks creating new heap allocated objects, which might trigger new garbage collections. In e.g. C# I can't make a standard list with a custom allocator. And I can't "foreach" over something and be sure I didnt' allocate etc.

> A GC app runs faster than a non-GC app, but has latency

I didn't mean to compare an app that does "new Foo()" in the inner loop with one that does "malloc(...)" in the inner loop, I was trying to make the point that you can't do either in the critical part.

> then I know I chose the wrong language.

Right, but the thing is you might have chosen the perfect language for 90% of your code. The language choice might be too late to change and you just need that concurrent inner loop (rendering loop, encryption pass, whatever) to be quick, and the solution is a lot of time to just allocate nothing.
Embed Slack into internal tools
Only for the currently active project, nothing stops you to not use their service for the next project with the same client.
I thought Qualcomm had better revenues?
> Tesla is positioned to dominate here. I wouldn't doubt that they're working on the apps internally to create the shared vehicle system that Elon speaks of.

Is Tesla Preparing to Roll Out its Ride Sharing Program With the Model 3?

http://www.thedrive.com/sheetmetal/13075/is-tesla-preparing-...
I suppose it depends on the definition of dinner party. (I only skimmed TFA, so apologies if you're addressing something specific in the article.)

IMO, a dinner party doesn't have to be some stuffy affair. It's just a group of people getting together to share a meal, typically in someone's home. I often host a Sunday dinner for family and occasionally a friend or two and their families. The numbers are sometimes in the 10+ range, including kids. It's usually a pretty casual event, some food, some drinks, some nice conversations.

You might say that's just having a few people over for dinner, not a "dinner party." Maybe you're right. But I think the act of communal in-home dining, involving some family and/or friends, is very common across cultures. The WASPy "dinner party" is just one variation on that.
Marketplace Payments for Developers: Paypal vs. Stripe vs. Braintree vs. Dwolla
> Garbage collection usually works out to a performance / latency tradeoff. (A GC app runs faster than a non-GC app, but has latency.) If I get to the point where latency, even with a pause-free of concurrent GC is a problem, then I know I chose the wrong language.

I think you mean "throughput / latency"? Latency itself is a measure of performance.

It's a fair bit more complicated than that once you start tuning the GC, because the GC can be tuned towards either throughput or latency, and it can be tuned aggressively towards either end. For example, for a given program you can tune the GC so you get fantastic throughput for batch programs. Use a copying GC, and set the heap size large enough that the percentage of live pages is very low when you collect. On the other hand, you can use something like the tri-color collector, which runs in parallel with the main thread and kills throughput, but has minimal impact on latency (sub-millisecond pauses).
Roomi raises $11M to find you a roommate
Better yet: repeatedly divide and then take the inverse.
For me it’s “just take off the covers”.