skysight-inc/HackerNews huggingface dataset:
In the real world, at least mine, once it works you get pressure to move on. Both my own mind saying, it works so it's good enough, and external pressure from a stake holder who says it looks good lets move on. I don't feel like I get to that latter 20% - 30%. As such, I try to be thoughtful on my design, but I also realize the need to get stuff done. It's a balancing act.
MONDO SMOKE – sigarette elettroniche da acquistare online
Yes, actually. My ex, sister, and nephew all got bit. Wan't American netflix on your phone, do x, y and z. Want to play games free, just follow these simple steps. You're not seeing it because you probably have a good BS detector and google/research first. But they very much exist.
I read this and thought it sounded a lot like my reality. Then, I expected to come to these comments and hear arguments against these thoughts. Glad to see a lot of us agree with much of it.
Be reasonable; all social science studies have that flaw. So we look for correlations.
The Real-Life Indiana Jones
Ah, that's an interesting way to look at it. I hadn't considered that. Was that how the term appeared in math, I wonder.. Thanks!
Or they had enough time, but focus was shifted elsewhere during the project, or resources were taken away, or the stakeholders kept changing their mind about what they wanted, or the projects were mismanaged, or the people working on them were incompetent/lazy to an extent that no amount of time would have been enough. Ect, etc, etc..
He is referring to traditional chaining of programs through STDOUT and STDIN. For example, a "program" that counts number of occurrences of foo in a file:
cat file.txt | grep "foo" | wc -w
Couldn't agree more. Writing a single line of code that can fail multiple ways (especially the same way on multiple parts) is one of my constant source of annoyances. Not from a DRY perspective, but from your code has a bug, but I can't give you enough detail to immediately fix it because it could be one of these X reasons. Especially on production systems, these become the sorts of issues where the developer makes some temporary fixes to the code, then has wait to observe the bug again to work out which line is broken.
>I don't own a smartphone, because it's a consumption device rather than both consumption and production, is just silly. So is a photoalbum, so is a book, so is a TV, so is a music player.

I owned a smart-phone for a year. I didn't replace photo-album, book, TV, Music player or camera with it. I only replaced a dumb phone. So I gave it away. I do enjoy many consumption devices, I don't need one more, if it just means consuming more. But I might adopt consumption device if it allowed me to consume better.
Leaderboard should have a points per guess score (perhaps for a minimum # of guesses) as well as total points, which only values persistence.
https://blendle.com/

It's only targeting the Netherlands and Germany right now, but a few big name papers from the US are already available. And it's an app instead of a website. Apparently you can even get refunds for articles after reading them.
What's the point, seriously?
Thank you so much for the interactive tutorial! Due to its LISP-like nature, hygienic macros, and interactions with user interfaces, is Nulan related to Dylan? https://en.wikipedia.org/wiki/Dylan_(programming_language)

I'd love to see some examples of pattern matching in the tutorial as well!

I see that you're in the steps of developing a 0.2... what are the expected changes going to be?
In academia.
"1. Nobody had the guts to kick off the project until the competition proved it doable and desirable; by then, the project was in catch-up mode and had to be finished lickety-split.

2.If the project were started long enough before its due date to finish on time, all involved would have had to face up to the fact from the beginning that it was going to cost a lot more than anyone was willing to pay."

In other words, projects are late because business justification is usually weak for software projects. When faced with "in order to ship this by 12monthsfromnow we need to hire 5 more software engineers today" management stalls.
If you try an fix a kib
Samsung Warns Customers to Think Twice About What They Say Near Smart TVs
I liked Spook Country, part of a loose Gibson trilogy. https://en.wikipedia.org/wiki/Spook_Country

I read it before I knew there was a predecessor and successor.
The article crows about how they broke the news, and touts it as a great example of journalism, which I totally agree with, but one of the commenters there asks a really good question:

>Vianna Davila, Tyler White, Richard A. Marini and John MacCormack: What was Scalia doing as guest at convicted felon Admiral Poindexter's resort property? What was the nature of the party he was attending? Great, you broke a story...but now what? Where is the journalism here??
Not forgetting massive variations across nations. A company I used to work with did some FB advertising, targeting nations they did good business with via Adwords.

UK and USA were the worst for clicks, the rest of Europe a little higher, and apparently in the Far East everyone clicks everything multiple times. Click through rates were ridiculous.

Also interesting to note that despite being online and profitable for yearss they never did find a way of making Facebook pay, in any nation.

We never did make sense of it!
My guess would be public vs private. A lot, if not all, of the stations on that list seem to be government owned but in the USA they are corporate owned. 2000kW is fine if you own all the airwaves and don't have a company in the next city over complaining that you are crowding out their airwaves (of course they might have had other countries complaining...)
UK: Radio 4 still puts out at least 400KW am on 198KHz for the time being, but will be phased out in the next decade or so. There is something slightly magic about pumping that much power into an impedance that is basically the air...

https://en.wikipedia.org/wiki/Droitwich_Transmitting_Station

http://www.bbceng.info/Operations/transmitter_ops/Reminiscen...

Edit: typically I can't find a definitive figure for the power output...
Yeah but we're old guys. The young folks don't have old bought copies of things. I think its a losing battle, and pointless to proselytize to the young about things they cannot do or experience any more. But good points.
The 2nd type of process is just an ordinary Unix-style process. It refers to the way that on older hardware process switches were cheaper on account of the smaller amount of state that needed to be shuffled about and cheaper system calls. So no need to (as you might today) prefer green threads over OS threads, and/or OS threads over processes, on account of the overheads.

This is mentioned in part 1 near the bottom:

When UNIX was still young ... you were supposed to fork a
new instance of the process for each TCP connection

I guess it made sense from performance point of view back
then. All the stuff that makes process switching slow today
haven't yet existed. ... In such an environment process
switching was closer to what we call green threads today.
I do not like this approach, and I think it is not the right way for medium to large software projects. Maintaining lots of interacting 'just-good-enough' code is a nightmare - and it can easily cost you way more than you saved writing it.

People get lazy and sloppy early enough. I would try to encourage teenagers to go for the best and most beautiful solution that they can possibly find.
You probably meant GTA04 phones instead of Openmoko Neo Freerunner - the latter was sold in more than 10 000 devices.

Yes, not counting GTA04, N900 was pretty much the last phone out there that you could call "openish". However, I can tell that Neo900 is not quite done yet and even though with time passing by it obviously gets less exciting than when it was announced, I'm still looking forward to it.
I'm not sure I object to just-good-enough solutions, but, there's still an awfully large benefit from paying down technical debt, and I hope your students appreciate that.

My approach is to pay down the technical debt before starting the next big change. I consider it akin to prepping my work site. As an example: consider a project where you're modifying some large continuously running system in production, creating an alternate codepath to ultimately replace some legacy codepath. You'll likely add the new codepath first and then migrate some subset of users to it.

There might be some diminishing returns from migrating a long tail of users to the new codepath (perhaps they were better served by the legacy codepath for reasons that don't quite justify the maintenance of both codepaths). And even when they're migrated, you quite likely don't need to rip out the legacy codepath. So at some point, perhaps before all the users are on the new path and perhaps before you rip out the legacy codepath, you'll consider the project a success and move on.

To me, that's quite reasonable. But consider then that any project on the same codebase in the future has to account for both of these potential codepaths. That adds an expense to every future change you make, as you have to maintain and support twice as many things. In my experience paying down that debt will pay for itself over the course of an astonishingly few (but greater than zero) number of future changes.

I mention greater than zero because quite a lot of systems get decommissioned, for one reason or another. If someone is going to bulk delete your code and everything near it, it doesn't really matter how the code smell was right before: the code that smells the least is the code that doesn't exist.

This is why I make various forms of cleaning up code - in-depth refactoring, deleting all unused code and tests, etc. - not the last thing I do when I finish a project, but rather the first thing I do when I start the next project. It's also much easier to explain why you're doing it to outside observers at that point - you're doing it not just because it "improves code smell" you're doing it because it makes what you're trying to do now substantially easier.

The only time I think this can start to fail is if you aren't the person who would be doing the next project / you could do the code cleanup far more efficiently than the person who is doing the next project. In which case this all becomes much more hard, and you should just remember to treat others as you'd wish to be treated. But I'm not sure it totally doesn't work -- for the person inheriting your work, getting to do some amount of refactoring and cleanup may well end up being a decent way of them getting to know the codebase better (if they knew it as well as you they could clean it up just the same).
It seems to me what you're describing was a deep and wide inheritance tree. I hate those too. In my experience they have always been very brittle, and lead to confusing code. I'm a huge fan of the recent movement to prefer composition over inheritance.
Perhaps they were automated click-throughs? Asian browsers are different technology (every page needs automatic translation) - perhaps that tech was doing the clicking?
Unless you get the pheromones and skin chemistry right there really isn't any point.
What Google’s Accelerated Mobile Pages (AMP) Means for the Future
Operational control of autonomous vehicle fleets powered by SpatialOS
Doesn't the std::vector calls mess things up? Now the compiler has to track those as well, they involve the allocator which calls into the OS.

So for the compiler to be able to statically compute the result it would need to know that the std::vector stuff doesn't have side effects.

Of course, the compiler could have special knowledge of std::vector, like for example in general it has about memcpy.
Go example seems off too from what the author intentions were. As for the dispatcher, I don't believe it will actually give any resource to a future that is already complete? OP wanted to have messages going through 1M actors, so there would be a moment when each actor gets a thread from a thread pool.
Your first paragraph just nailed. You were able to mix the post content with real world mechanics.

One thing I find really hard is where to draw the line to an uncleanable ball of mud.
> go doesn't have runnables, futures, actors, completionstages, executioncontexts

Some of us (most of us, I would contend) who have been successfully programming highly concurrent software without them for 20+ years are totally OK with that.
Hey! I've got three Aunts in that category!

But, to be honest, they're always Likeing some junk they found in an ad or a survey or "10 ways to do something" junk article. So, fair enough.
https://grsecurity.net/announce.php
> On the desktop, you have your text editors, word processors, photo editors, video editors, 3D modelers, IDEs, file sharing utilities, digital audio workstations, etc.

Could have sworn i have seen examples of all but 3D modeling in the Android Play store.

That said, some of those uses can be very RAM demanding, and phones do not have much to offer there compared to a desktop.
DHH captures this very well http://david.heinemeierhansson.com/2012/dependency-injection...

I think his example of system time is a good one because an abstraction in that case often only serves to enable testing. If testing is already possible, then that abstraction is just unneeded complexity
That's not fair! Lots of sex toys sell today. Very very few of them get that right. In fact, all they have to be is soft and lubricatable.
I loved the resistive screen of Neo Freerunner and Nokia N900, as it allowed me to write code on screen (surprisingly, the awful bezel around Freerunner screen actually worked great as a resting place for the finger, N900 while more comfortable in every other situation is more tiring when writing code). I've written quite a lot of Python on those phones in my life.
This kind of benchmark can show off what v8 is capable of (when used with a library that has been carefully tuned for performance)

Code is pretty-much copy pasted from .NET Async version with bluebird promises instead of Tasks. Ends up being almost 2 times faster:

https://github.com/atemerev/skynet/pull/16

(Only 50% faster if we return Promise.resolve(num) though)
The pressure you put on yourself is your responsibility. Don't pretend it's something you have no power over.

The stake holder should be your customer, not your boss. Even if that dynamic is broken, you don't need to tell them it's shippable until you're happy with the code.
This Valentine’s Day, Go Public or Go Home
Or Data's girlfriend Tasha Yar.
Sorry, I'm not the author.

About the features of the new version, maybe, you can ask him with a github issue...

Edit: Here is the issue

https://github.com/Pauan/nulan/issues/1
The trick is to think of the last little bit that makes it complete in terms of the 'cleaned up' approach, which means you bake in the cleaning up/abstracting as necessary for completion.
Adding more manpower doesn't mean faster completion.
The languages tab on GitHub (click on the multi-coloured bar) is another interesting metric, is it somewhat representative of the conciseness of the languages tested?
I use https://hub.docker.com/r/goldy/tor-hidden-service/ (just 2 commands) ... it just simply works
Generally, the reality is that while the Android is open, the devices that run Android usually aren't, so in the end it doesn't really matter.

For very similar reason I wasn't crying after Firefox OS, even though it had some progress when it comes to platform openness in some other areas.
Reminds me of "The Shining"
http://uncyclopedia.wikia.com/wiki/All_work_and_no_play_make...
Google looked poised to take Android beyond consumption when they introduced 3.0.

But then they did one misstep after another that effectively neutered it, and tried to pitch ChromeOS for office uses (watch them demo Citrix during the unveiling for example).

Now they seem to be coming back around, but can't get their ducks in a row (shipping hardware before the software is ready etc).
That seems like more of an argument against mocking in general. Even if you DI you are still expecting X method to be called on the mock object and have created that coupling.

I think DHH describes a great example that illustrates a big difference in philosophy around this: http://david.heinemeierhansson.com/2012/dependency-injection...
1 Month = 4 Weeks seems better. A week is a very natural measure of time and this has less fudge-days (at most two).
And include multiple implementations of each one, as that is what really counts.
That's possible I guess. They were gaining page likes and post likes pretty well off the back of it, it just in no way compared with Adwords click through rates.

It was killed off fairly quickly outside US and Europe as it was just burning money.
Then "Skynet" should be removed from the description, as well as Actors. I guess the word "whatever" deserves to stay though.

Summing a bunch of numbers is a silly task anyways
Very interesting write-up. Definitely cuts down on the boilerplate.

Would be good to explain what `react-redux-provide` does under the hood. It might help convince redux users that the package is doing some of the work for them.

Also what would the code look like without the @provide decorator? [Stick to ES6, it's already crazy enough, no need to jump to ES7 stuff]
Well, it’s not about money.

More: I accidentally click an ad, get angry, click it another 100 times, and end up laughing about it.

Next week, when I have time, I’ll just root my device again and install AdAway and XPosed with YouTube-AdBlock and YouTube-Background-Playback, and the issue is resolved.
I don't like staring at the small screen that will damage my eyesight along the way, I also don't like some unnecessary time wasted on it.

However its benefits outweighs those drawbacks way much, so no, I do like my smartphone.
And few professionals are going to be satisfied with a tiny screen, tiny processor and throttled connectivity. And no mouse or keyboard or Bamboo pad. Heck, I need three monitors to be most productive!
I'm living in Germany, downloading 100 GB wouldn't be a problem for me. But no, haven't tried to compile it yet. I'm trusting CyanogenMod.

Also I guess very few people are compiling Sailfish, Ubuntu or Firefox OS from source either ;)
This is pretty badly done. Dear freddiearch, it's ok if you know that it's low-quality and no real effort has gone into it (as you yourself have said), but then please don't post it on HN and waste everyone elses time.

Notes/suggestions, in the interest of helping you get better at Ansible. I hope you find them helpful:

* It leaves your Apache bound on all interfaces, exposing where your files are really hosted. Security fail. (And because of the port conflict I doubt it even works in its current state.)

* It doesn't even work, due to the double "command" in "add keys". Only the second one will actually be run. (It's obvious you never tested on a fresh system. Learn about Vagrant next. It also has super-easy ansible integration. That fits the scenario really well too. Wouldn't that be awesome? "vagrant up" from any machine, wait a minute, and you have an .onion server in the Tor network?)

* Please spend 10 minutes and read the module list at https://docs.ansible.com/ansible/modules_by_category.html completely and use them. If you have to use "command" tasks (seldom the case), at least implement "changed_when" and think about if you need "when" and "failed_when". Also consider --check mode. You used command in cases where you could have used: apt, apt_repository, apt_key, service,

* Use the long key id in the --recv command too. The short will work even when there are conflicts, but it'll leave the additional (probably malicious) key in your local keyring, which may or may not confuse you later.

* The apparmor restart should be done in a handler, conditionally the config actually being changed. It also should use the "service" task.

* /home isn't the right place. Read the Filesystem Hierarchy Standard. Put the directory somwhere under /var or /srv.

* Add some blank lines for readability.

* As it is, your play isn't really reusable and not modular at all. It's ok since your intention clearly was just to show how easy it was to get Tor running. But if you want you could still turn it into a role.

* "state=directory owner=debian-tor mode=0700 recurse=yes" isn't really a good idea; it'll make all files executable too.

Getting automation right (whether via ansible, puppet, or whatever) requires careful attention to detail.
Good to know :) Were these steps to enable installing apks from 3rd party sources or really rooting the phone though?
Sure. Overall, lowered tariffs are a good idea (although individual industries may find a more level playing field uncomfortable), IF companies can't just 'export' their toxic waste and terrible working conditions by exploiting lack of labor and environmental regulation or enforcement.
Oddly I am reminded of a comment about New Mexico. There the ratio of non-imprisoned men to women is something like 90:100 in the non-White community, and so apparently women are more
Likely to acquiesce to the sort of male demands you can imagine - so less marriage, more polyamory, and apparently more sex more frequently.

(I am now racking my brains for a reference - it could be Tim Harford?)

The point being, that real people competing against a free "good enough" alternative are going to be the unusual example of economic Uberisation
That's just... not accurate. I know lots of people who do real work on smartphones. Hell, I'd be dead a few times by now if I didn't use mine as a radar HUD while photographing tornadoes. (While also using it to report digitally directly to the weather service, and running a GPS tracker so that they both can see me on a map and so that I later can geotag photos taken on cameras that don't have integrated gps). To say nothing of how much I use my phone to take photographic and text notes. Don't make the tremendous mistake of assuming that just because you can't find a use for a smartphone in your line of work that nobody else can or does.
> Now the UI is so giant that it cannot show a list of 6 account names with a balance next to it

Yep."Our 2015 default theme is clean, blog-focused, and designed for clarity."

https://twentyfifteendemo.wordpress.com/
https://twentyfifteendemo.wordpress.com/about-twenty-fifteen...
https://twentyfifteendemo.wordpress.com/image-alignment-and-...

"Ruined" is an understatement.
Not only that, usually all the ones applied via gut feeling instead of a profiler are meaninglessness.

Additionally, depending on the application domain, it might not even matter.
He prefaced this saying it might sound too obvious. My reaction was that it's a non-obvious but brilliant way to think about it. That was only reinforced as I continued to read his reasoning.

Thinking this way acknowledges in advance that software is complex, it's more complex than you think it is, and any software project you start is likely to take longer than you think it will. Both sides of a software project or contract ought to know this and say it out loud before starting. More importantly, it underscores that a large software project nearly always starts under pressure. Rarely is something big and expensive undertaken without at least mildly unrealistic goals. Having been there many times, I know the management thinking is often that if we don't have pressure and forces squeezing every bit of developer performance toward unrealistic goals, then we won't even achieve the realistic goals, and we'll be even later than we are.

Contractors are probably most affected by and in need of this way of thinking, though I'm well aware of how hard it is to admit you might be late on something when you're trying to win a contract, especially when the competition makes impossible promises.
"Consider this: Many commercial transactions now take place with some short-term credit attached — for example, a company that gets a 60-day grace period to pay bills from its suppliers. Would that flip, and suddenly suppliers would prohibit upfront payment and insist that their customers wait 60 days to pay?"