skysight-inc/HackerNews huggingface dataset:
I've always really, really liked Ada's rendezvous-based concurrency.

There's more to it than I can really describe here, but in effect it allows you to treat a thread as an object with methods; calling a method on the object sends a message to the thread. The thread's main code can, at any point, block and wait for a message, or combination of messages.

The handling code looks like this:

...some code...
accept DoSomething(value: in out integer) do
...some code here...
end
...some more code...

That causes the thread to block and wait for the message. When the message is sent, the caller blocks, the receiver runs the handler, then the caller resumes.

The beauty here is that inside the message handler, you know that the caller is blocked... which means it's safe to pass parameters by pointer[]. Everywhere the parameter's in scope, the parameter is safe to use. The type system won't let the thread store the pointer anywhere without copying the contents first, so you get zero-copy messaging and* it's failsafe.

You can also do really cool stuff with timeouts, guards, automatic thread termination, etc. Here's a simple multithreaded queue (syntax and logic not guaranteed, it's been a while):

loop
select
when usage < capacity =>
accept Push(value: in integer) do
data[usage] := value;
usage := usage + 1;
end;
or
when usage > 0 =>
accept Pop(value: out integer) do
usage := usage - 1;
value := data[usage];
end;
or
terminate;
end select;
end loop;

Multithreaded! Blocks the client automatically if they pop while the queue's empty or push while it's full! Automatically terminates the thread when the last connection goes away and the thread leaves scope! Thread safe! Readable!

I'd love to be able to do this in a more mainstream language.

[*] This is a simplification. Ada's pointers are not like other language's pointers.
Interesting. I have about 10 Hue Taps in my house. The nice thing about this is that I was able to gauge the performance of each switch against the others. In my experience, some of the switches work better than others. The poor ones can be so bad that they are borderline useless while the good ones function more or less like a standard light switch. I returned and replaced all of my finicky switches. I recommend that you do the same if you are experiencing issues.
> No one can come up with a single abstraction for synchronization without it failing in some regard.

Erlang did. Or at least it's as close as possible.
I did look at using PIR sensors - but the problem is that we quite often want the lights off when we're in a room. For example, watching a movie.
Whitfield Diffie – The cypherpunks vs. uncle sam (YouTube)
Fans Arsenal menyuarakan ketidaksenangan
I imagine that's not enough, because changes to bus routes tends to be bursty. For example, I'd imagine thousands of those transit systems to suddenly add routes in September to coincide with the start of the school year, and then remove those routes in April or June to coincide with the end of the school year. With a team of ten, some of those systems' maps wouldn't get updated until Christmas, which would be too late to be useful.
>While the Method #2 format for requirements.txt is best practice, it is a bit cumbersome. Namely, if I’m working on the codebase, and I want to $ pip install --upgrade some/all of the packages, I am unable to do so easily.

$ pip freeze --local | grep -v '^\-e' | cut -d = -f 1 | xargs ./venv/bin/pip install -U

Ought to be a first class command, though.

After running that the first thing I do is run the tests. Then I freeze, commit and push.

This is usually a good thing to do at the beginning of a new sprint so that more subtle bugs caused by upgrading packages can be teased out before releasing a new build.

For my projects that I release on pypi I don't want to use pinned dependencies, but for them I run periodic tests that download all dependencies and run tests so that I'm (almost) instantaneously notified when a package I depend upon causes a bug in my code (e.g. by changing an API).
I'm suggesting they're doing both, breaking into new markets as a long term strategy, increasing buzz/rumors as a short term strategy.
The eerie math that could predict terrorist attacks
I suggest to start now. Benefits: you will know sooner if this business is sustainable, and you won't piss off customers "down the line".
Pro Tools is still pretty much _the_ standard for audio recording, mixing and AV post-production.

If you're just producing electronic music, want VSTs, and/or just using a few live tracks, then yeah; you're probably far better off using something else.
I wonder if there are any compilers which can replace

mutex.lock { x++ }

With a 'lock xaddl x 1' instruction.
Whenever I read about Russell's Teapot, I envision it as a Utah teapot specifically.
Threaded discussion support is a major feature their competition touts, so arguably by adding it Slack would be crushing their competitors and serving their customers at the same time.
Good points.

The author points out that channel teardown is hard. He's right. Figuring out how to shut down your Go program cleanly can be difficult, especially since calling "close" on a closed channel causes a panic. You have to send an EOF on each channel so the receiver knows to stop. When you have a pair of channels going in opposite directions between two goroutines, and either end can potentially initiate shutdown, it gets messy.

At least in the original implementation, "select" for more than one option was really slow and complex. The single-input case was handled efficiently with generated code, but for N > 1, a very general library mechanism with several heap allocations for each message was used. This means having both a wait for data and a timeout in a select puts you through the slow path. Not good. Someone did an analysis of existing programs and found that N=1 was most common, N=2 was reasonably common, and N>2 was rare. N=2 needs special case support.

QNX interprocess messaging has a similar architecture. But they don't have the panic on close problem, and timeout is handled efficiently. So you can generally shut things down by closing something. As each process is notified about the close, it closes any channels with which it is involved, even if some other process has already closed them. The closes thus cascade and everything shuts down cleanly. Processes that time out at a message receive check to see if the rest of the system is still running, and shut down if it's not.

Go's "share by communicating" would be more useful if Go had Rust's borrow checker, so you could share data without races. Yes, Go has a run-time race detector, but that's only useful if races are common enough that they occur during testing.
Thing is, almost none of that requires software, wifi, an app, an internet connection, etc.

It's an insane amount of implementation complexity for what is a very simple problem.
Nanex Gets $700k Whistleblower Award from SEC
Basemark PAT enables real-time measurement of mobile app power consumption
I'm probably going to get downvoted to hell on this; but as a Rubyist who has been working on a Python project, I've been finding pip to be really weak against rubygems/bundler.

With RubyGems/Bundler I love the ability to point to github repos, lock versions (or allow minor/patch versions to update), have groups, etc.

requiresments.txt and pip just feels, awkward and weird. Especially when combined with virtualenv, in comparison to Ruby this is just stiff and strange.

I've had nothing but problems with more complex packages like opencv and opencl as well.
US Expats: Whoever you vote for, get out and vote
Sure I mean who wants to visit Госуда́рственный Эрмита́ж or eat 삼겹살? Moonspeak's not really text right?
Super puper!
If you're dealing with text from outside you have to handle encodings whether you like it or not. (I mean you can blindly copy bytes if you like, but you end up with corrupt data that you have no idea what it means, and may ultimately have to spend months or years recovering that information. I'm speaking from experience here).

Internally it very rarely matters what representation you use as long as you know what it is - pick one particular representation to use for all your internal functions and stick to it and you're fine. You shouldn't need to do any detection except at the boundaries, and efficiency concerns are usually overblown.
Reminds me of that scene in Snatch where Dennis Farina says "yeah, don't go to London."

Don't make any plans to have a physical EU footprint and you can care less what the EU thinks of your internal policies. EU customers can take it or leave it. Their choice. It's not a warm stance to take, but you've probably got a dozen other balls in the air that you're juggling. EU data compliance probably isn't one your worried about as a small startup.
I think it's clear, however, that EA's sports games are a bit of a monopoly. It's easier to be successful if you have no competition because they're not legally allowed to use anything related to real professional sports players or team names and iconography. The general world of gaming is different, though, because it's so (comparably) easy to take the fun bits from games you like and throw your own clone up on steam.
Criticising how information is communicated is wholly valid.
Would someone care to explain what the graphic shown means exactly? I have a hard time understanding what the vertical axis tells me.
Windows 7 Home Premium Product Key 32/64 Bit Free
Instead we get the debate of whether "and you should feel bad" is appropriate in a title.

I don't believe it is, but ultimately click bait is click bait.
Build a Weather by SMS Service with Twilio and Node.js
Pixie dust that makes concurrency problems go away is an antipattern.
I felt the same way so I made a bookmarklet to blank out images. I see it's not needed now, but I'm set for future pages that do this.

javascript:(function (){var x = document.getElementsByTagName("img");for (i = 0; i < x.length; i++){x[i].setAttribute("src","");}}());
Thank you, finally someone who actually looks at the photo rather than the headline
This is a frustrating and overly-exasperated post which reaches conclusions that have always been part of the Go canon. APIs should be designed synchronously, and the callers should orchestrate concurrency if they choose -- yes! Channels are useful in some circumstances, but if you just want to synchronize access to shared memory (like the author's example) then you should just use a mutex -- yes! These are well understood truths.

Novices to the language have a tendency to overuse channels. Here is Andrew Gerrand addressing precisely this point two years ago at GopherCon: https://www.youtube.com/watch?v=u-kkf76TDHE&t=815

Neither the referenced performance characteristics via Tyler Treat, nor the FUD surrounding channel-based program architecture, invalidate channels generally. One does have to think carefully about ownership hierarchies: only one goroutine gets to close the channel. And if it's in a hot loop, a channel will always perform worse than a mutex: channels use mutexes internally. But plenty of problems are solved very elegantly with channel-based CSP-style message passing.

It's unfortunate that articles like this are written and gain traction. The explicit instruction to [new] Go programmers is that they should avoid channels, even that they are badly implemented, and both of those things are false.
In my city the transit authority considers five minutes early to 1 minute late to be on-time. I don't know how normal this is, but it's actually pretty infuriating to have transit apps seem to treat it as the inverse.

A lot of issues like this tend to get glossed over in transit planning apps. Another issue is transfer timings, where the more transfers you do getting to your destination the more likely one of the transfers goes awry and throws off the whole schedule. For that reason I, as a person who exclusively uses transit in a city where it's not terribly good, almost always avoid a trip with 2 or more transfers if there's a 1 or less transfer option with more walking. Convincing transit apps to give you these kinds of options can be difficult (though google does have some knobs for controlling these things).
I would additionally recommend to use :

pip freeze -r requirements-to-freeze.txt > requirements.txt

instead of just:

pip freeze > requirements.txt

So you can keep your file structure with comments, nicely separating your dependencies from the dependencies of your dependencies. Actually I only used one requirements.txt file, removing everything below "## The following requirements were added by pip --freeze:" and regenerating it when I changed my dependencies.

And sure, beware of git urls being replaced by egg names in the process.
Does Go not have finalizers? These are mostly solved problems since the Smalltalk era. Haven't learned Go yet and from what I read I'd be better off with Rust or something that would stretch my brain more like Haskell. When I read about it I get the sense that we are reinventing stuff from the 90s. But hey, it's hip.
I've met Steve and worked on a project he was involved with. I'm curious why you think it is a pretty big deal that he is involved?
I'm a big fan of Moxie's work, but would you mind elaborating on for which work he'd receive a Turing award? I'm not familiar with their eligibility standards. Thanks!
With this workflow, what purpose does requirements.txt serve? Would the file ever be used directly?

Only thing I can think of is you'd track top-level packages in requirements-to-freeze.txt during development, while your deploy would use requirements.txt to get a deterministic environment.
Yes. You can implement sequence/traverse/etc. for each specific monad in OCaml, but if you want to write a generic implementation that will work for any monad then you need typeclass-like functionality.
Let me state flat out that I don't think there are any good books about algorithmic trading all all.

Most will talk at surface level about what they are doing but non will give you a start to finish example that can be deployed with a brokerage like interactive brokers.

Trading & Exchanges I see was recommended. I'd skip it, most(All?) trading strategies that the average person will come up with won't be market micro structure related, and if it is then I'm going to flat out state that you've lost before you started.

If you really want to get into it, then please don't start with machine learning.

I've said this many times but ask your self

- "what machine learning techniques could I apply that 100 fresh PHD's haven't done on their first week at a hedge fund?"

- "What data source do you have that the average hedge fund doesn't have access to"?

- "What market insight do you have that someone whose done this for years doesn't have?"

If after all that you still want to get started then honestly your best bet is to start with quantopian. Don't look at market data changes at a granularity of less than 1 day until you can create a strategy on your own that makes money.

Quantopian can give you access to a backtesting platform and clean market data, which is the step most people get stuck on, and usually quit at.

Once you've found a strategy that makes money, put your money into an account with Interactive brokers, If after 3 months you still want to continue then start looking at market data slices of less than one day.

Tl/DR

- first step is don't

- second step is to focus on time slices of 1 day or more

- third, put your own money into action on you strategy for 3 months

- fourth step, there is a very small chance you'll make it this far, look at time slices of less than a day. At this point you can start to apply machine learning and build your own software. Even at this stage you are more likely to be an ATM for a hedge fund than you are to make money.

Good luck
I added the option that specify IP address (and port). I hope this will meet your needs. Thank you for the suggestion,
That doesn't mean its the way it should always be done though.
I wonder if these new rules also apply to the big tech corps consistently breaking them (as mentioned on HN a few days ago), or only the smaller devs aka most of us.
What happened to Shumway by the way? A few bugs I filed for it are now marked as referencing "Mozilla graveyard" product. It doesn't sound encouraging...
South Korea breaks filibuster record fighting new surveillance bill
"If you have something that you don't want anyone to know, maybe you shouldn't be doing it in the first place."
In non-critical things (not important to execution speed), is it still acceptable to use go channels? I'm always weary of using a mutex because then I have to spend a much larger amount of time checking to see if it will lock.
I had a similar sense with the app. Despite the very slick UI, it just felt awkward and inconvenient in all sorts of little ways. I couldn't quite get at the info I wanted -- or couldn't do so fluidly. I couldn't quite do what I needed -- or couldn't do so fluidly.

I gave up on it in under an hour, which is kinda record time for me. I gave SourceTree a couple days, GitX/GitY/etc each got multiple hours, etc.
An interesting concept, I bet it could be applied to traffic prediction as well. If an article is posted linking to your site, you could expect a spike of incoming clicks that gradually trails off in a similar way.
> Impressionable children are indoctrinated against drug use, by US law enforcement, in US public schools.

If you mean things like DARE, its worth noting that studies of DARE have shown that (despite its name and how it is sold to parents, etc.) it has no effect on participant's attitudes toward (or propensity for) drug use, but does make their attitudes toward law enforcement more positive.
I spent over 20 years in the software industry and I've never seen anyone describe software as in "maintenance" except when staffed by a skeleton crew who does not do user research or anything forward thinking. That's ok, I guess, in industry, not ok in government when a fixed size market is not a business indicator, but a fact-of-life.
I still find myself automatically thinking of this PIP.

http://www.shaels.net/index.php/cpm80-22-documents/using-cpm...
I've wanted to compile a list of canonical simplified problem settings in various fields. Their longevity is interesting to me.

Things like the relativistic boxcars in physics, the urns and balls in probability (http://www.arcaneknowledge.org/science/ehrenfest.html), the teapot, Lena, blocks-world in AI.
Similar experience here. My favorite parts of the movie are the scenes with music showing the city, like the scene on the river. Beautiful movie and thought provoking. I always wondered after if its possible for a distributed AI to hide on the net without the public being aware of it.

Given the great effort to build out the internet and datacenters its a fun conspiracy to wonder if we are serving a sentient AI on the net.
The more precise version of "friendliness" is value alignment - Stuart Russell describes the problem well here[1], if you're interested.

1: http://edge.org/conversation/the-myth-of-ai#26015
I love branches in theory, but the main problem has been in practice around CI. It's a nightmare trying to manage a staging environment with feature branches involved... given better tools/a better build pipeline I'd go back. I agree, toggles are basically programs branches compiled in... analogous goto vs if/else control structure.

But day-to-day, stakeholders want to test feature X that they've heard is going well but it's not stable enough for develop? Okay, let's [engineering time and $$$]. vs. adding FEATURE_NEWDB=true to the upstart script. We've already got automation engineers helping us out, but until the deployment problem is solved toggles are more practical in our case.
Can someone explain to me exactly what this is/does?

I understand that I can link Google Docs to Slack.

Is it like a linking tool for third-party APIs?
The interesting, or sad thing, is that many of us that had already commercial experience saw this coming and always stated that in the eventuality of GNU/Linux becoming successful it would be bend by corporations like any other OS that went big.

But, as usual, youngsters stated we were just naysayers.

And now GNU/Linux distributions are basically a 2nd coming of UNIX wars.
Sometimes you need to guarantee that resources are cleaned up in a timely fashion. Finalizers don't help here.
>With RubyGems/Bundler I love the ability to point to github repos

You can do this with pip.
Password managers usually have a way to add serial numbers or secure notes, that's where I store mine. And you should be using a password manager anyway, if you aren't already.
A lot of it is that consistently people design things on the assumption that 80% of labor will be in the first release, rather than the 80% going into maintaiance which is what happens most of the time.

This is closely linked to the idea that least cost development is a matter of doing every individual action 'cheaply' and pretending you are not going to screw things up. If you want least cost actually least risk is a good approximation.
I'm not saying Erlang isn't great, but if you need to pass a large datastructure around between Erlang processes then copy message passing starts to be a lot and you need to share memory. You can do it in Erlang, but I'd hardly call it great, and you're avoiding the sync primitive that Erlang offers.
> $500k is a pretty hand waved calculation.

Maybe, but there are lots of ways to calculate opportunity costs.

The OP said his friend was making more than $150k/yr. So if he estimated his potential net worth in thirty years staying course versus his estimated net worth in thirty years with an MBA, then discounted it to present value, a difference of $500k is somewhat reasonable.

There are plenty of other, equally valid ways for a person to calculate opportunity costs. It depends on what that person values. For example, lost wages that would have paid for vacations would not necessarily show up in a comparison of net worth, but it is certainly an opportunity cost for some people. Or having to put off starting a family, or many other milestones in a person's life.
Not remotely true, though any ridiculously broad statement like probably won't be true.
The Best Travel Deals and Coupons for March 2016
Yes, this seems like more of an issue of semantics. It's true, that you can't set this up on your own hardware. Though, that may be something we are open to in the future. Our definition of open in this context is being able to contribute/share modules.
What city is that? That is a rider-hostile definition of "on-time". In my city if the bus arrives at a stop early it will just stand there until the scheduled time.
Piggy backing off @catnaroek, go does have finalizers too though.
I don't know if I agree with the branch on every deploy particularly if you have a small team and use Mercurial where named branches live forever. I wish the article discussed dependency management more.

Instead of branching we tag every deploy and use dependency management heavily (ie maven, npm, etc). That is the project that gets deployed never really has any branches but is composed of lots of smaller projects each in their own repository which may have branches but they have to be released.

This approach cuts build time, improves coupling/cohesion as well as facilitate a possible transition of OSS useful components (that do not provide a competitive advantage nor or proprietary).

I have seen way too many projects that have this giant monolithic source tree (particularly PHP projects) and thus have to rely on branching much more heavily. I firmly believe this is the wrong approach.
That to me sounds like the worst job, from the start he's an outsider trying introduce massive change, but in an advisory role.
you just made me angry at all my college math classes again. grr.

did anyone have an undergrad math education that was NOT like this?
a nice feature of this post would be the ability to click on images to hide them.

Normally I have ublock to remove distracting elements.