skysight-inc/HackerNews huggingface dataset:
Ask HN: Why not release software versions with yyyy.mm.dd.hh?
We see very often on HN that we're discussing about an interesting software package, and it is left to the readers to dig up the relevant Github or other repositories to find out if the software is maintained or not, and when was the last time the software was released.

Is there a reason to use something like semantic versioning instead of just dates?

Example - redis.2017.10.27.11 is easy on the eyes as a current package...
Who really loses out in this scenario though?

It sure as hell isn't going to be Nvidia who hold all the cards as far as CUDA based computing goes.

People who want to use this tech will go where the tech is, people even switch away from Mac to Windows to access this tech.
> Dependent type systems, like HM and other type systems, only constrain programs, they do not enable any behavior.

The question arises when you have languages that compile to native code: you want your constraints to still be valid when you load new types in your program at run-time.

eg

obj = dlopen("libfoo.so")
factory = /* insert some cast here */ dlsym(obj, "some_factory_function")
a_value = factory.create_value()
some_constrained_function(a_value)
Fantastic read and all the best
Stable branches come to mind. How would you version those?
Faster Coding Interview Prep Using Interactive Visualizations
It's not a linear outcome space. There's also the outcome where automation enables tons of new dull (but in different ways) jobs, currently embodied by the so-called gig economy. I think this area is nacent and has a lot of potential[1].

Also, incidentally, this outcome is consistent with a couple of centuries of economic history.

1: No, these jobs aren't great compared to classic middle class jobs. But going from shelf stocker or check out clerk to Instacart shopper and/or Uber driver isn't obviously a step backwards on net.
Integration tests are very important and in many cases mandatory. I'd argue though unit tests with good coverage are more important. The latter helps you make sure your application has the correct output. Nothing worst than having a piece of software you think is working and silently introducing errors. The former (integration tests) makes sure your application starts and probably works in some scenarios.

With docker and containers, integration testing is easier than ever.

I've written a very simple integration testing tool (a quick hack to be honest) that executes commands, checks their exit code, the output through regexp, etc and produces a nice html report.

https://github.com/landoop/coyote

Originally written for testing some configuration tools and scripts, we quickly found a use for it for our Kafka connector collection (Stream Reactor). Our connector integration tests are at github as well:

https://github.com/Landoop/kafka-connectors-tests

Obviously unit tests make sure that the connectors work as expected. Integration tests catch simpler errors that can be showstoppers. For example an internally renamed configuration option that didn't trickle down to the configuration parser, class shadowing issues between the connectors, unexpected errors in logs that the developers should check out etc. As the tests are written by people who don't do development, they also expose problems in the documentation. In some cases they provide us an easy way to quickly run locally a connector and catch some issues manually, like extensive CPU usage or way too much logging (e.g a function with a log statement was inside a loop that run hundreds or thousands of times per second).

It gives us confidence in what we ship with every release.
Spain's lunch/closing times are much later with the day being split in two periods, the second of which is 4:30-9: https://www.google.ie/url?q=http://www.spain.info/en_IE/info...
Kaspersky acknowledges retrieving NSA's Equation Group source code for analysis
I've heard that joke once, but in C++
The difference is night and day - writing tests first means you write 'testable code' from the beginning. Following the red, green, refactor mantra means that for every change to your code, you already have a failed test waiting to pass. The result is your test cases make a lot more sense and are of a superior quality.

To liken it to something you may be familiar with - when commenting your code, do you think it's better to add comments in as you write the code? Or add in the comments at a later date after the code is all written? I'm sure you immediately know which approach results in better quality commenting, and it's the same with TDD.
The farmers that are in trouble are those who are not using monsanto crops.
It’s Saudi Arabia so most of these aren’t relevant questions.

A better question should be would the robot be allowed to operate without a male companion.
> My history texts taught me to be once quite strongly of the belief that the atomic bombings of Japan were necessary, and even saved lives

So that's where that attitude / excuse comes from whenever I talk to americans about the bombings of Japan?! Is that literally taught in history classes? It always seemed to me like a statement made by an indoctrinated mind. It was nuclear bombs used on civilians in two densely populated cities. How can people spin that into something good?
Less meetings with more communication
Perhaps awesome_package_stable.yyyy.mm.dd.hh ?
Show HN: Pitch Your Startup Story to 100s of UK's Journalists
> If your app relies heavily on using a database, your app naturally integrates with a database then it makes no sense to test without it. You are intentionally avoiding testing in a way that will pick up bugs.

Also, with Docker it's now actually feasible to automatically test against a real database at a reasonable speed. A Postgres container spins up in a couple of seconds, a SQL Server one in a little over four.
wow just look here it's an amazing source https://goo.gl/Sp44mn
TDD is completely orthogonal as to whether you write functional code that doesn't have a default receiver for routines, or OO code.
Shortly after I started using Fedora as my daily driver I was attempting to dd if=/dev/zero the MBR and partition table off a USB disk sdb and accidentally wiped the one off of sda instead.

As luck would have it, I had the output of fdisk -l /dev/sda in my terminal scrollback buffer and was able to recreate the partition table with no damage done.
Maybe we should have our worst historical enemies write our history textbooks for us.
Southbank isn't the CBD - it's is a dump in general, terrible amenities, and the new apartments there and in the CBD tend to be tiny. I live in an apartment in the CBD and have done since 2009 and it's awesome; ~80sqm internal with a semi-usable balcony overlooking the state library and RMIT, but it cost me much less than twice what it cost the original owner 13-ish years ago off the plan.
I don't see why TDD requires ruling out static methods and insisting on hiding everything behind an interface. Static methods are straightforward to test, certainly more than a class with multiple dependencies which need to be mocked. Usually the complaint is about coupling when calling static methods but these can be wrapped in a delegate if required.
Lots of unit testing can cause tightly coupled code, if the units are too small and/or against internal APIs: The tests are tightly coupled to a piece of code which should have been able to change freely.
In alphabetical fields people avoid saying "Author et. al." for this reason. Lots of famous papers are known by their three- or four-letter acronyms.

If you called "BCS" (superconductivity) "Bardeen et. al." it would take everyone a minute to figure out what you meant, and they'd wonder about your background.
> But how complex can these programs be? Surely anything written before 1992-ish can’t involve that much code just because of the limitation of the machines they were designed to run on

An ex-colleague used to work for a major US insurance company, and this is what he told me: They had a bunch of products, and due to the state-by-state nature of US insurance regulation, they had a slightly different version of each product for each of the 50 US states. And then, for every one of those different versions of those products, they had a separate suite of COBOL programs to manage them. And, all these COBOL programs basically did the same things, but all with slight variations due to the different rules of each state's insurance regulators. So they basically had hundreds, maybe even thousands, of separate COBOL programs to maintain, a mess of horribly repetitive code. Their problem with moving off COBOL was not that any of the code was particularly complex, just that there was so much of it, and trying to rewrite it into another language (or, maybe more sensibly, translate it into some sort of business rules engine or insurance policy automation product) would take major effort and run a big risk of getting something wrong in the translation. (He worked there more than 15 years ago, so things at this insurance company might be very different by now.)
This is my experience as well, very frustrating being locked out of your account when you need to take care of business. Nevermind cracked, they are fundamentally broken if a human can't get a nearly perfect success rate.
I disagree that 5 years is a short period of time from 2009 to 2014 in the context of their own estimates saying completion in 2020.
> the alternative, having no formal history lessons, is far worse

It depends. If the history lessons are strongly indoctrinating, then it's better not to have them. How many of the very good principles of Communism are being dismissed because people have been taught that communism == the Russian implementation of it?
For what it is worth I'd be categorized as far right and I agree with the spirit of what you're saying.

There are a lot of failure modes in politics and the widely held feeling that if only we nipped the 'extremes' at either end of the spectrum and everything would be alright, that is bunk.

I continue to see a conflation of violent extremism and how far the political orientation is from the center of politics.

One of the most important failures of the political spectrum model is the inability to recognize the center is a homogeneous place while the edges are extremely diverse. Like everything else it's a tree structure.

As I see it the most important error in recent years was the Iraq and Afghanistan invasions. That didn't come about as a result of far right extremism or far left agitating. Broadly speaking neither faction wanted the war, so it must have come from the center.

It irks me that most attention is paid to the handful of violent ideologues, when the worst strategic errors are overlooked because they are closer to the center and have a body of political support. This is not a coherent way to police political violence.
VAASTU FOR KITCHEN-DIRECTION AND PLACEMENT
I got that mad cow on Snapchat, though.
For some reason I always type FORM in SQL and FROM in HTML. Then I edit.
Since jakebol is involved in both TileDB and Julia, this might be up and coming?
In design work (print, web) where it can't do much damage, yes.

In residential and public buildings, not so much.
HomeHack: How Hackers Could Have Taken Control of LG’s IoT Home Appliances
The problem? They don’t really rent them out. Even if they do, they are highly unlikely to rent it for a below or market price. Basically many of these investment aren’t really asking or looking for return. They are like buying a brand new car and let it Stay there until you use it. Which rarely happens.
I have no idea about entry level rates, but I wouldn't think it would take many years to break 100k in IT. I know many non-management people making well over 100k/year.

The cost of living calculator they put up[1] suggested that I'd be losing money as a single income earner for my wife and daughter in Auckland, while I can support them here and bank literally 1000s on top of my living costs and mortgage here.

I don't know exactly what I'd get in Auckland though, I assume it's estimates are middle of the range, so it's not quite a fair comparison but the general picture fits; in general living costs in NZ are a bit lower (excluding Auckland housing, which is more expensive than anywhere in AU except for Sydney) and the median salary is _far_ lower.

Also, preferences may differ, but I grew up in rural NZ and inner Melbourne is a much more interesting place to live as an adult; the country was pretty fun as a kid though.

[1] https://www.newzealandnow.govt.nz/living-in-nz/money-tax/com...
Inbox actually has a signature feature in the "Settings" panel. It doesn't provide any formatting options, but you can copy-paste your signature from the Gmail signature settings, and it'll keep the formatting and any images you have.
One idea I like is randomly flipping a bit on the root partition every day or so. You'll have to take an incredibly long time to find the problem, of which there will be one eventually.
"it doesn't work very well" for the purpose of ensuring the absolute optimal immunity, but it does work very well for ensuring the absolute optimal individual liberty. I vaccinate, always, and I am hopeful that other people will too, but I absolutely do not want to force people to do what everyone else thinks is best for them, because then, where does it stop?

How far might we go in the pursuit of perfect immunity? Some contagions have no vaccine, will we require masks at all times? Will we criminalize handshakes? At some point, the benefit of immunity is outweighed by what you have to pay for it.

I guess I sound like an antivaxxer here. I probably sound like a Nazi elsewhere. All I am though, is pro-liberty.
From Brainfuck to Domino Computers [pdf]
super crazy stuff
Simply because you can't mock the static dependency, therefore that method is now dependent on the static class and you don't have any control over it. This is problematic - what if at some point later another developer adds a database call into the static method to do some logging? Now your testing will dirty whatever database you're using, as well as run 10x slower - and yet the test will still pass and everyone will be none the wiser as to what happened.

If you start using a custom delegate solution, then your code is not consistent with everything else that uses DI, making it harder to understand. I can understand interfaces are annoying when navigating code, but the IDE still helps with that even if it is a few more button clicks, and the pros outweigh the cons.
Can I combine it with the one about Bill Gates donating $10 per forwarded email, or does it have to be separate forwards?

Please clarify, happy to do either.
Are people still using it? I thought COBOL is extinct like dinosaurs
I'm sure it has happened but it's also funny to see as an observer how both American political sides feel victimized the same way. Basically, both sides blame same things.

I'm not bothered about big Silicon Valley companies, but it can't be easy to satisfy both sides and keep making more money.
And you don't count by hand I assume because you should've mentioned it. Is that incorrect?
Sponsored Video Content: Trend for 2018?
Elixir web development 101: collaborative todolist with realtime updates
Yeah, I've been in a meeting with nobody using the internet and our phones just merely sitting our pockets. 3 hours later I saw ads relevant to the conversation in the meeting, for which, again, I had not googled or used internet for, on Instagram.
How Twitter pushed RT to spend big on 2016 US election
Building ReactPHP Memached Client: Errors and Connection Handling
As horrible as they were, the British Empire probably was a positive influence on the world. Without them I doubt we would be able to have a conversation 1000s of miles away right now.

The same argument can be made for the Roman Empire. Empires of the past are looked down on because they are a unified machine of violence, a center of evil we can point to and hate.

Creating civilization is brutal, but the alternative is much scarier. A world of tribes and decentralized violence & oppression toward no end. Just as much pain, but not recorded, all in vain.
I'm curious about something. Why this:

if shipping-method <> 'FX'
move normal-ship-date-yyyymmdd to expected-shipping-date
else
move nextday-ship-date-yyyymmdd to expected-shipping-date.

And not the following?

if shipping-method = 'FX'
move nextday-ship-date-yyyymmdd to expected-shipping-date
else
move normal-ship-date-yyyymmdd to expected-shipping-date.

The latter seems clearer to me, and the line below (regarding the cust-type variable) suggests the syntax would be okay. It would also have the advantage of avoiding the column-length issue described in the post. What am I missing here?
https://www.nbnco.com.au/learn-about-the-nbn/rollout-map.htm...
did you mean `Can he read?`?
> Not being a news platform also helps a lot.

I'm not sure what you mean. On the Stories screen, in Featured, I can see things from the WSJ, the Washington Post, National Geographic, and the NYT. I ignore this and go to my subscriptions from Tastemade, Tasty, and The Food Network, but news is available on Snapchat if you want it.
Sounds like a cool idea!
There is absolutely no reason (except to fit into a particular pattern of testing) to turn everything into an interface[1]. That has nothing to do with type safety.

[1] Obviously some things do make sense to put behind interfaces, but I find that most Java developers go interface crazy and the code ends up being an unreadable mess.
Help me find a 20h/w job and I'll be grateful for the rest of my life.
One could argue that if you have nice things (e.g. nice car, upscale shop windows) certain groups that are assumed under the antifa umbrella would not hesitate to set fire to your car as a protest against capitalism and the power gradients it strengthens. Examplary incidents are G20 protests in Germany.
Exactly this. Confidence is everything.

I can actually write entire features with appropriate test coverage from the ground up and they work first time and have close to zero defects in production.

It's amazing when you spend 5-6 days writing code that does nothing and at the last moment, everything slots together with a few integration tests and wham, feature done. Not talking trivial stuff here either; big integrations across several different providers/abstractions, bits of UI, the lot.

You see a lot of people arguing against this but I'm going to be honest, they churn out a lot of stuff that doesn't actually work.
I also find when following red, green, refactor that you end up producing more targeted unit tests that are more expressive of the code you are testing.

Trying to write unit tests afterwards lands me with something that appears as more of an afterthought or add on. It doesn't have to be this way I suppose, but it is more prone to.

This might be because I am more used to the red, green, refactor method though.
A Geneva Convention for Software
Is GUI code that 0.1%?

Because I am always keen to understand how to TDD GUI code and I don't mean the data model behind the pixels.
You just describes every American president . Trump is a fool, but the witch hunt is ridiculous.
People test private methods because edge cases occur in those private methods and the test for the edge cases do not belong in the unit test for the consumer of the private unit. If the consumer simply loops over a list of objects which it receives from the private unit, the consumer does not need to know that particular integer arguments are special cases in the private unit; that would be a leaky abstraction. However, it still makes sense to verify that you have correctly handled each special case via a unit test.

As for the difficulty or refactoring, if you refactor the private unit, you ensure that its tests continue to pass, since its consumers depend on that behavior: you ignore the failing tests of the consumers so long as the subordinate unit's tests are failing. If you eliminate the private unit, you eliminate its tests. Modifying the behavior of the private unit may be equivalent to eliminating the unit or refactoring it. The number of tests you will have to modify is equal to the number of units you modified the behavior of: the branch count of the private unit, or that plus its consumers. If each private consumer was responsible for testing all of the edge cases of the private unit, then you will have to change its branch count multiplied by the number of consumers worth of tests instead.

The distinction between private and public is wholly synthetic. It is a binary layering mechanism that does not map well onto most architectures which have many layers. From the perspective of many full architectures, everything down in the data layer is private: no customer will have direct access to the data layer. Yet you will still test the data layer.

The internals of a library are not special simply because the layering is thinner and binary.
Dates communicate useful information, but version numbers tell you other kinds of useful information that a date doesn't.

If I told you that I had three versions of OS X called, 2014.10.16, 2015.04.08, and 2015.09.30, all that you'd know is the release order. But if I told you that these were OS X 10.10, 10.10.3, and 10.11, you'd know that the first and third were major releases and significantly different, and that the second one was presumably a bug-fix or minor feature release.

Also, a name like OS X 10.11 is easier to remember than a date like OS X 2015.09.30.
Building a Fast Search Experience
That's interesting. It's a form of adverse selection. The least maintainable and readable languages end up sticking around the longest whereas the clear, concise and readable languages are likely to be replaced regularly with the shiny new thing...
I'm actually extremely surprised that volatile prices aren't already common in the US. The grocery chains here in Norway update prices across the country as soon as they notice that competitors sell the same products cheaper (provided they want to be the cheapest for that product), often several times a day. ESLs have been very common in big stores since perhaps 2013.

Our BestBuy alternative Power actually had a big ad campaign last year about how their digital signs and their price robot allows them to offer lower prices than what their competitors offer.
The Evolution of the CIO Role
Wondering if you could clarify what you mean here? All current Macs that have discrete graphics use AMD GPUs, so they are definitely supported by macOS - or are you talking about Hackintoshes?
And that's a good thing. We should be relieving humans of all kinds of monotonous jobs, which means that yes, we'll not have those jobs, and people won't be able to get this work; and again, that's a good thing - a job isn't some kind of gift or value by itself; if some task isn't intrinsically fulfilling for humans, then we should be working to get humanity rid of such tasks.

Coincidentally, "tasks that aren't intrinsically fulfilling for humans" is pretty much synonymous for work, if it would be fulfilling by itself then quite likely that it'd be or become an unpaid hobby instead of a paid job.
If you write the tests afterwards, you find where all the tight coupling and crap abstractions you accidentally did are afterwards.

That leads to you either not writing tests or having to refactor bits of it. It's easier to do this much earlier on.