skysight-inc/HackerNews huggingface dataset:
That's correct. Around the time that Rails became popular, Django was undergoing a major refactoring to remove "magic" and make its underlying logic more explicit.

Further smaller changes have been made since then for the same purpose: explicit over implicit, code or configuration over convention is part of Django's philosophy.

IMO that also makes it easier to graduate from a beginning to an intermediate level use of the framework because while there are sane defaults in many places, in others you're required to define your specific implementation explicitly from the start. It's a tiny bit more code up front, but all the details are exposed and it's obvious how to override default behavior. And at the same time the framework supports keeping your code reasonably DRY and takes care of much of the tedious, repetitive stuff.

There's still tight coupling in some places (ModelForms, for instance, are arguably part of the controller layer and are tightly coupled to the ORM). But they're reasonably optional (you can use plain Django Forms instead of ModelForms in your views or not use the Forms library at all.)
And indeed, many of the criticality accidents listed on the Wikipedia page https://en.wikipedia.org/wiki/Criticality_accident happened while handling fissile material in solution.

There is a very interesting book on criticality accidents, which includes photographs and sketches on laboratory layout etc.: McLaughlin, T.P., Monahan, S.P., Pruvost, N.L., Frolov, V.V., Ryazanov, B.G. and Sviridov, V.I., 2000. A review of criticality accidents 2000 revision (No. LA-13638). Los Alamos National Lab., NM (US). https://www.orau.org/ptp/Library/accidents/la-13638.pdf
Assuming the random events are also based on how the game progresses, and not just from the starting seed (if they were, then at the start of the game you would be able to predict all random events for the entire game to come, which sounds implausible for a complex strategy game), then the seed won't help you much in predicting game events. Pseudorandom number generators are chaotic, otherwise they wouldn't be called pseudorandom. This means that if there is, say, an extra random number generated in the middle of your game, it would likely completely change the random events in the remainder of the game.

What would help is, instead of prioritizing seeds, looking at optimal distributions of random events that lead to fun gameplay. This might mean for instance making your next random event dependent on previous ones (e.g. to compensate previous bad events with more fortunate ones, and vice versa).
The Demon Core and the Strange Death of Louis Slotin
I disagree. I think that this type of "late type binding" is actually an advantage of dynamically typed languages. That way it does not matter if you pass a map/array/dictionary or an instance of a class as long as the properties are the same.
Sure did. My mistake
Just escape the .: https://en.wikipedia.org/wiki/Renault_Fluence_Z%2EE%2E
You'd think this is a joke, but have a look at this comment at https://hacks.mozilla.org/2016/05/css-coding-techniques/comm...

> Now that we’re writing almost all of our html in modular fashion, I have found mix-n-matching pre-defined css classes works the best. i.e. class=”inline-block bg-bbb text-333 padding-5-15″
Kitten: a statically-typed stack-based functional programming language
So here's the thing. We (the playing public) expect different types and standards of "fairness" from games of skill and games of chance. We expect that games of skill are beatable by playing better and that they should generally be beatable. People get very upset if they've sunk hours into something to discover that it's unwinnable, especially if it was unwinnable all along as soon as the random seed was chosen.

In games of chance on the other hand, people understand that you can work at making better bets but you can't make yourself "luckier" by force of will. So it's easier for people to blame the RNG gods than berate one another for lack of skill.

Edit: remember in game design, especially human vs. AI, it's not about beating the player but about maximising their enjoyment of the process. You have to make the defeats fun as well.
Note that std::deque is not really implemented as a linked list, as it would prevent O(1) random access. The classical implementation is as a dynamic array of pointers to fixed size chunks.
There's certainly a lot of stuff inspired by Hack. If Hack did something well, sometimes PHP copies it. The syntax of all PHP 7's new type stuff is very close to Hack's.

Though the details may differ significantly. Hack and PHP's type systems are only superficially the same (AOT rather than runtime validation, disabling or ignoring type checks versus using "weak" type checks, type inference vs. no type inference, etc.), for example.
Sign me up. When I'm flying home I get very irritated passing over my house on the way to the airport, knowing that it will take me another couple of hours to get back to my house.
Not always. I try to give people th benefit of the doubt.

I think I am a good judge of character (I imagine that most people think the same). There are a number of people who I have initially judged as assholes and I decided they are good people after getting to know them better and likewise there are people who I have liked at first and they turned out to be sneaky and manipulative assholes. (There were far more in the second category funnily enough).
Heh you know I didn't even consider that factor.
If you choose nit as your programming language, are you nitpicky ?
Yeah sure, but my point is not about how flexible JS is or isn't, but about how multiple inheritance is a good fit for certain areas, such as UI code.
> Catching multiple exception types

> Support class constant visibility

Reminds me of what Rob Pike once said, "[Java, JavaScript (ECMAScript), Typescript, C#, C++, Hack (PHP), and more] are converging into a single huge language".
It makes it easy to deploy Lambdas and integrate them with those services. Underneath uses CloudFormation to orchestrate it
> If they're not enforced at runtime, then they're unsound if you have typed code calling untyped code.

I think types specifications in interpreted (not compiled) languages should be only hints (for IDEs, code analyzers and JIT compilation etc.). This type checking for every method probably also adds some overhead does it not?

EDIT: correction
I think I'd have to assume anyone using that on a project I was paying them for really was trying to be funny. I mean, really, take a look at this: https://github.com/tachyons-css/tachyons-visibility
I would like to see Australia version of this tool.
That's true about consumer grade stability systems which are engineered with great margins for safety.

As you can see by looking at the F1 active suspension ban in the 90s, when tuned for performance, these systems provided a real edge to even the best pro-drivers.
I used my own C code generator for CGIs for years, along mongoose for other tasks. Nowadays I'm using https://kore.io and I'm VERY happy with it, great developer experience, well written and understandable code, minimal in dependencies and no bugs so far. I'm using it quite heavily in a project, it was easy to add templating and other amenities to it. Highly recommended.
I understand.

You're not forced to use the CLI create/build/run commands for anything. They just make it easier, but you are in no way tied to this.

Building the module itself can be done on your own for example, as it is just a normal dynamic library you can use whatever build system you want.

I've considered time and time again to turn kore into a "library" that you can link against and include into your own applications but every time I decided against it as it didn't give me any real benefits. It would make certain things considerable harder, who takes care of the worker processes? Who takes care of the logging and the internal message relaying? Having this abstracted away in a library is probably possible but adds tons of expectations on your own application.

Having Kore as the platform your code runs under makes this easier.

Thanks for explaining however, very insightful!
Mode Analytics: iPython Notebooks
Yes, although in XCOM it's applied across all shooters and all targets, so a miss by trooper A against alien B will improve the chance of trooper C to hit alien D.
Big Data or Smart Data?
No. For an entertaining explanation why, see https://www.youtube.com/watch?v=uNS6VKNXY6s
Exactly. And adding to skype contacts didn't work for me on Mint Linux, signed in and launched the app but nothing new appearing in contacts.
Show HN: Flex Layout Attribute – layout helper based on CSS flexbox
Why not do an elliptical orbit that takes you close enough to the sun to burn up? That seems like less energy than dropping to zero no?
Pay cash upfront like a large drug deal between gangs.
That's what I don't get about 'car sharing'. Everybody wants the car on the weekend. If the service has to have enough cars for everybody, what's the difference between that and leasing/owning? It doesn't save on cars that's for sure.
I used and am using this in production.
So are others.
It works really really well.

Here's the rational: http://mrmrs.io/writing/2016/03/24/scalable-css/
I'd actually suggest MOO 1 as a good place to start, as it's considerably simpler.
> if batteries continue to improve over the next four years as they have over the past four years

If CPUs had improved similarly, we would now have machines running at 100GHz. Just saying that extrapolating technology is a tricky business.
Facebook photos sporadic error.
Wow too much work.
Generic Software Solutions Are Unicorns
ARM-ed with Reason: Building Reason Apps for ARM Target with Docker
Tutorial on how to build Reason apps for an ARM target with Docker for Mac beta.
ObjC ain't going anywhere.
PHPDoc is supported by most IDE's. Using this you can specify parameter types without using the actual type system.

Visibility and typing features are good. Visibility helps to design and write better code. The typing features are also welcomed in my view. I would rather a request completely fails because a variable is the wrong type rather than PHP's type coercion leading to an unexpected result with no errors or warnings.

That said, I use PHP for my day job. I see no reason to start new projects in it. I never use it in my side projects. Introduction of the single pipe operator to represent OR instead of a double pipe operator is baffling in my opinion.

7.1 does more work to improve consistency and error handling which is definitely welcomed. The problem is there is much legacy crap in PHP. It only exists for web applications and there are a growing number of languages which do this better.
personal self-observation - we want to be happy with ourselves, or at least in content state, feeling our actions are well justified and have good reasons. but some people live truly bad lives, hurting people left and right, doing all kinds of undeserved negative things to others. so there is some background process in sub-consciousness that goes over memories, highlights positive intense parts, and lights up the negative ones.

which is crap. I don't want to iron my memories, I want them to be exactly same as they were when experiencing them. I don't need to remember shitty girlfriends as actually nice ones, miserable travels as actually nice ones etc.

so I am always trying to counter it consciously - nice memories are OK, but the less positive ones I try to specifically remember the full mix of emotions associated with them. not 100%, but works quite well. since people generally don't change much (at least don't improve), this also helps to set expectations when communicating with some (ie family black sheeps).
It takes years of training before humans can demonstrate human level intelligence. Unless the first strong AI is super human it's not going to look like a strong AI for several years.
I used to get up before the sun, drive 30 miles to the regional airport, wait an hour to get on a plane to Chicago, fly there, wait an hour for another plane to San Jose, get on that and fly for half an hour and then...look down and see my house. THAT sucked.
TL;DR: schoolkid created a program that progressively filled the storage of the computer's shared servers, which began to cause issues-- for literally no other explained purpose other than to "be annoying".

Annoying or not, it's still attempting to cause mischief. Teachers throwing around the "Computer Misuse Act" are blowing everything extremely out of proportion however.
OTOH doctors are literally working with life and death scenarios.
My thoughts exactly! Apart from embedded systems (or using it as embedded in an application, e.g. to provide an application's help system via an internal web browser) I'd find it weird to build websites in C. I'm looking for something along these lines for embedded systems, but GLib & external webserver disqualify balde. Still looks like a nice, clean project, though I was disappointed to find out I can't try it out :)
I think one problem is when your object quacks like a duck, but the quack doesn't mean what you think it means.

Having methods that just have the right names is a pretty weak assurance, isn't it?
Do you really want a car every day of most weekends? What for?

(I suspect the "good, cheap, reliable public transport" thing the parent mentioned is important)
Hi guys, here is also the github repo: https://github.com/timcreative/paper-dashboard

If you have any feedback, issues, suggestions please let us know, we want to make this product better.

Thank you!
It takes years of training before humans can be trusted with pants. Really, we should lower our expectations of AIs by three or four orders of magnitude. If they can walk in less than a year of trying, then they win.

http://www.gocomics.com/monty
Can You Behave Randomly? (1998)
The amount of ObjC sessions at last WWDC 2015 and the upcoming WWDC 2016 send another message.
Oh, when then we are in total agreement. Rereading your comment in context I see how I misunderstood. Thanks for clarifying...
>Bootstrap V4 recently introduced spacing utility classes like m-t-1 (which translates to margin-top: 1rem!important), and we thought we'd expand this idea to more classes.

Which is worse; when it's done as satire, or seriously?
People actually suck at (a) knowing when they are being an asshole, and (b) not interpreting anything that doesn't benefit them as hostile to them. @see Why Everyone (Else) Is a Hypocrite: Evolution and the Modular Mind, by Kurzban. https://www.amazon.com/Why-Everyone-Else-Hypocrite-Evolution...
Yes, it adds overhead. But it means the type declaration can actually be relied upon: the code inside the function always gets the type it wants, the optimiser can elide type checks safely, and humans and computers reading the code don't have to worry about the type declaration being a lie.

Unenforced type hints don't give these guarantees. They have no requirement to be accurate because the runtime won't enforce them, so they're essentially documentation, not code. They can't be safely relied upon by the optimiser because they're unenforced. The code inside the function body can break at runtime if given the wrong type, so if having a specific type is particularly important, you have to add manual type checks or coercions yourself.
In all seriousness, what advantages do you see over writing inline styles?
https://github.com/Idnan/furnish-js
Researchers find invasive, 'man-eating' crocodiles in Florida
Hi, we are working on an Angular JS version too, here is the github for the plain HTML/SCSS: https://github.com/timcreative/paper-dashboard
I don't like PHP either, but that doesn't mean kneejerk reactions are excusable, and at the least on the first point you are wrong. Using | instead of || is not an inconsistency, but actually quite consistent.

|| is a short-cutting or comparison operator which returns the first true thing it encounters.

| is a bitwise or combinator, which takes two sets of flags, and combines them into one set of flags that has all flags activated which were also active in the input sets.

Semantically, | is absolutely the correct choice here.

A better question would be why there's a $2 there, though i hope that's just a typo and means $e.
And?

There is no repository in the world available, that is either guaranteed to be secure for thousands of years of accepted by the population.

Also putting it in the earth has one huge disadvantage: You cannot get it back if something goes wrong.

I can recommend this documentation about the waste disposal problem http://www.imdb.com/title/tt2979302/
It's entertaining that the argument centers around Dylan, given the huge controversy over Dylan 'going electric'.
My Windows coding experience goes back to Windows 3.0 and I am looking forward to the day Win32 and Hungary notation are nothing more than plain maintenance coding, replaced by a proper type safe OO ABI like WinRT.
[Ruby on Rails Screencast] Eager Loading with Goldiloader
The effect of the joke is lessened when it is labeled as a joke, doubly so when every comment here copypastes the line saying it's a joke.

See also the latest reprinting of "A Modest Proposal," which kindly has "SATIRE -- DO NOT BELIEVE" in large caps on the front and back covers.
The problem for Chrome developers is likely priorities. Tough to sell that hard work you do for a small minority when there are likely a lot more pressing tasks to be done.
Website Meta Language (2006)
That's something that indie bands could consider, and would be an easy addition to a Super Deluxe fan edition of a release.

I also wish more bands would release instrumental mixes of their albums, like Imogen Heap, Celldweller & Blue Stahli have done. Sometimes I want to listen to an album while I work but the vocals are distracting. I've been happy to pay a few dollars extra to get the instrumental versions when available, it's an easy way for indie bands to make some extra money from fans.
If the port knocking was obscuring an unauthenticated root shell then you would have a good point, but this is a defence in depth measure that adds to the security. It helps because it's one more hurdle for an attacker to bypass.
(repost from the blog comment thread. Would dig any feedback with HN readers who use lambda in production)

Here's the setup I'm hoping to leverage lambda for: light workers. I have kue.js/redis for submitting jobs to, and creating workers. My subscribed worker listeners will simple trigger lambda.invoke with json packages (no need to call or support http endpoints etc). No need for api gateway either.

I'm starting with apex.run as a deployment tool and writing/running all tests locally. I assumed local testing is doable by hitting the same func exports with mocked inputs - this could be off.

See any big hurdles with that usage plan?

As an aside, I've got a backlogged task to explore serverless, and their moving away from cloudformation shouldn't be an issue (assume terraform?)
If you only use it a couple of times a month, it would be cheaper to rent one than to own one.
Believe me, vets have quite a lot of training in making this kind of decision.
cornflowerblue was a nice touch.
5 ways to speed up JDBC inserts
The type hinting is optional, so if you want "late type binding" you can just omit the type hints.
Really dislike the IBM meetups, they're full of marketing speak and people they have no idea what a load of bs the "sponsor" heavy presentations are. Meetup should ban groups like this.
How the Signal messenger creates a lock-in effect
I'd say PageRank is pretty much AI, and anything running on distributed map-reduce implementations is some form of crude AI. [Except the word count! there must be always at least one instance of that running somewhere.] (Netflix, Amazon and anyone who was doing precomputed recommendations before 2005.)

Also, the ridicolously simple "recency algorithm" used by Mozilla to show things in the awesomebar (the merged search and location bar) probably saved more man-hours than the Netflix recommendations, but I completely agree that it doesn't feel AI at all. Just as the wheel doesn't seem like technology compared to the loom, and sometimes the inverse is true, as the James Webb space telescope doesn't feel like better technological achievement than going to the Moon, but it probably is.
Some pictures are pretty fun like "What if John Cena was a singer ?" but others don't work that well..
That's what he just said...
They've discouraged people from compiling builds and then uploading it to the store, but I believe this is because they don't want a half-implemented/untested PGP library posted -- especially one with their name on it.

I haven't seen any concrete plans about how they plan to distribute it when it's done, but I didn't get the same sense about them not wanting to upload it themselves. In fact, I think Google would be thrilled to push proper end-to-end support in Gmail.
Yeah, it can be really heavy for some systems. I'll work on that.
Nice.

But I prefer Afterlogic
http://www.afterlogic.com/

Wish I was open source/freeware
But then I can't see the original samples if I zoom in. Plus that is a workaround rather than a fix.
"proof" is not correct term. Find evidence supporting some hypothesis, they don't provide proofs.
Here is a list of similar languages that operate on the fringes and work in a similar compiled-yet-readable (somewhat) fashion:

http://nim-lang.org/

http://crystal-lang.org/

http://lbstanza.org/ (posted a few days ago)

Here is the 1 clear and important problem these languages have (which is similar to the marketplace-dilemma for ebay-type businesses):

They lack support from the community because the community would come only if they had a strong set of libraries/packages to do "actual" work OR if they had the financial-muscle of a big company backing it (Go from Google being the prime example) AND they need the community to actually build these frameworks/libraries to make the language popular/usable to more than 40 people.

If any of these languages want to expand beyond "we're an amazing systems-language that you can build: games, web applications, OSes, desktop applications, mobile applications with", they need to focus on a problem-domain and address it.

Here are some examples:

- Elixir - although not explicitly saying it, with the rise of Phoenix, they are clearly targeting web-backends with good performance

- Kotlin - Java is shit, so they are addressing the Android issue with a language that some say is better

I'm not exactly sure what specific problem-domains the 3 languages above are addressing, but ask yourself this:

If you are going to use a systems-language (similar to those above) to build some micro-service or web backend, why use anything over than Go?

It has community support (and is presumably the 1 systems-language that is growing/being-used more and more), which is 10x more useful when you have a StackOverflow question or a situation where someone else has probably experienced and fixed it.

I say this as someone who likes these fringe-languages, but nobody is going to be building their bank-IT-infrastructure in "Nit" any time soon.
Here is an example of such a street: https://www.google.de/maps/@51.2310008,7.0720156,3a,75y,127....

You bascially park your car somewhere half on the street, half on the curb. The sidewalk is just wide enough for people to walk there.
Regarding Japanese websites, one thing I've noticed is that the images used tend to be smaller than those in UK websites. For example, compare Yahoo UK to Yahoo Japan:

https://uk.yahoo.com

http://www.yahoo.co.jp

I saw similar differences in video game magazines. I've only had limited exposure to Famitsu, but it seems to favour a collage of smaller images laid out more evenly across the pages compared to something like Edge.

http://www.rpgland.com/content/media/2009/10/rpglanddotcom11...

http://perfectdark.retropixel.net/pdzero/scans/edge_november...

I like both styles, it's just an observation.
You'd prefer no mastering over well-done mastering?
Why You Should Disregard Social Value
Better yet, don't reinvent the world and just use commas?