skysight-inc/HackerNews huggingface dataset:
> These systems seem (from my outside view) to have a tendency to become giant monoliths. So when developing you must fight against increasing monolithic complexity.

You aren't wrong, that's my experience as well. It's just as annoying for programmers (or, at least, for me) as it is for users. The following question has popped out countless times in my head: “Why do I have to rely on an implicit convention that this application module never touches this database table?” There was never a good answer.

The only reason why I put up with such things is that I have no idea how to prevent more modular designs from turning into a data integrity nightmare. (I'll freely admit my lack of education is to blame here.) For instance, let's say we have three modules: inventory, sales and shipping. Furthermore, let's assume each module is its own actor and uses its own backend database. We must implement the use case “enter a sale in the system”:

(0) The sales module queries the inventory module whether there is enough of a product in stock to satisfy a customer order. The expected sequence of actions is:

(1) The inventory module “locks” the requested quantity/amount of the product [so that it can't be used, say, for another sale], and gives the sales module a “token” that can be used to confirm or cancel the withdrawal.

(2) The sales module queries the shipping module if there are enough available trucks/ships/whatever to ship the product to the customer's location by a given delivery date.

(3) The shipping module “locks” however many trucks/ships/whatever it deems necessary to ship the product, and gives the sales modules a “token” that can be used to confirm or cancel the shipping.

(4) The sales module queries the user for the customer's credit card number and verification code, interfaces with the bank's system, blablabla...

(5) The sales module confirms to the inventory and shipping modules [in this specific order] that the product will be withdrawn and shipped.

Now some exception handling:

(6) If step 3 fails, the sales module cancels the product withdrawal.

(7) If step 4 fails, the sales module cancels the product withdrawal and shipping.

(8) If any system [inventory, sales, shipping] goes down, neither the product nor the trucks/ships/whatever can be kept locked forever. So each lock must have a timeout, and, if it's neither explicitly confirmed nor explicitly cancelled by the sales module, it will be implicitly cancelled by the inventory and/or shipping module when the timeout elapses.

(9) It may happen [unlikely, but not impossible], that the inventory and shipping module's clocks get unsynchronized in such a way that, when the product withdrawal has been been confirmed, the shipping lock has already elapsed. Oh, the nightmare.

Implementing all of this correctly in all cases is actually tricky! And if anything is implemented slightly wrong, the whole system goes kaboom! With a monolithic database, there is no need to “lock” any resources, nor issue “confirmation tokens” - just use the DBMS's built-in transaction system!
While this is a good goal, it's pretty clear this isn't the way to achieve it. It appears that the author hasn't thought it through - if the Facebook approach was rejected, why should exactly the same thing (as far as I can see) be accepted from another company.

It seems to me that the experience with rapid mobile take-up in Africa indicates that market-based solutions can work, but the key is high levels of competition. My understanding is that in most of Africa the landline phone companies were government owned monopolies and under serviced rural areas which forced the private sector to act.
Non centralized is probably the best one. But agree it's harder from there.
Fair assessment. Commits should represent logical groupings of modifications. This is always a trade off between the extremes of recording each change atomically and dropping one tarball release of all code to replace the last with no changelog. However, the purpose of having a history is to, in as much as possible, reconstruct the contents of the writers mind when evaluating their actions and the changes they have made. This is the heart of why we have revision control -- to allow us to manage this information and query it effectively.

Since the purpose of a revision history is to enable historians to gather a complete picture of a feature's genesis so as to interpret the author's changes and mental states prompting those changes in their correct context all of recorded history should facilitate that purpose. If rebase workflows do indeed encourage big atomic commits which drop features into a repository as though they were commandments from a god then obviously they do not help historians understand the authorial intent that went into their creation. You yourself argue for just that as do, in my observations, most users of rebase oriented workflows. Additionally, the heart of rebase workflows themselves, namely retroactively changing the parent of a commit, misrepresents what the author knew at the time that code was written. This clearly misleads the historian and I find the workflow to be dishonest and unhelpful in preserving the very reason we use revision control and thus I judge it harmful.

If one uses rebase (say, in interactive squash mode) to clean up and regroup commits into small logical chunks in order to facilitate the understanding of authorial intent then I don't have any issues with it at all. It's when it is used to misrepresent, overload and mislead the historian for the sake of a "good looking" git log that I find the usage of rebase distasteful.

An author should never be so self-absorbed that they believe that no-one but themselves could possibly care how they did their work and arrived at the conclusion they did. Authors that abuse their tools really have no excuse and best remember that they themselves are also historians with respect to other people's code and, in time, their own.
How DHH organizes his Rails controllers
This is not true in the UK. You are paid a tax free stipend (currently ~£14k) and not considered a full worker - you certainly don't have the rights that full time staff have.

There is no salary progression, bonus or pension and your funding cuts off at 3/3.5/4 years. After that, you aren't eligible for any govt. benefits as you are a full time student.

In some parts of the UK £14k can go a long way, but UK PhD students definitely aren't equal to full time staff as it stands.

The pay can be higher with industry partnerships (£30k tax free!!) but this is the more usual research council level.
Setting Up a URL Shortener
I'm not seeing how this solves an NP-complete problem at all.

First, the actual press release from the researcher: http://nicolau.lab.mcgill.ca/?p=1207

However,

> We provide a proof-of-concept demonstration of such a device by solving, in a parallel fashion, the small instance {2, 5, 9} of the subset sum problem, which is a benchmark NP-complete problem.

> Actin filaments exploring the {2, 5, 9} device. The movie shows a time lapse of 200 typical fluorescence micrographs of actin filaments (shown in white) moving through a network (shown in blue) encoding the SSP with the set {2, 5, 9}. Exits labeled with green numbers represent correct results, and magenta numbers represent incorrect results.

They have 17 different exits. What isn't clear to me is how the exits from the device map to actual solutions or non-solutions of the subset-sum problem. {2, 5, 9} has only 8 subsets (including the empty set), so there's more exits than what I'd call "possible solutions". Roughly half of the exits map to a "correct" answer, roughly half do not. (If you ignore the "which subsets?" questions, and just as is there a solution?, then I suppose half makes sense, in that half the exits are "no solution" and the other half are "a solution exists".)

But my other question, and the one I feel like neither site adequately answers, is how do you set up the device that the protein moves through? If it requires as many exits as possible solutions to the problem (i.e., one for each brute-force "attempt"), then creating the device requires as many exits — and at least as many gates, if not more; creating the device then is still hard, and has the same issues scaling that a computer does. That you can evaluate the device quickly becomes meaningless: you must build it, first.

Edit: The 17 exits correspond to the sums, not the subsets. (I was also missing how they never specified what the target sum was; this is how.) So, "correct" exits are exits where there exists a subset that sums to the number of that exit. (They're solving all possible values for the sum for a given set.) As an example, exit 14 is "correct" because there exists a subset, {9, 5}, which sums to 14.

Edit: Also, here's the paper[1]. This is the weirdest hyperlinking job I've seen in a while. The only link Ars seems to give to the researcher's press release is in the image credit (and even then, only to the site's home, not the release itself…). The press release only links to the paper on the page title?

[1]: http://www.pnas.org/content/early/2016/02/17/1510825113.full
Fascinating. Here's the location : https://goo.gl/tji5ch

Seems they're not so far from main roads, so it's a bit odd about use of GPS and four wheel drive vehicles.
Legacy software is software that served a purpose but no longer meets the business objectives. Some common factors that influence the decision to replace a legacy system with a new one include: maintenance cost, scalability, flexibility. The usual approach in startups is to build something at minimal cost, then replace it later if the business requires it. Everyone has a different opinion regarding the importance of these factors at various stages of software life.
Why India’s newspaper business is booming
The article is light on details. It looks like EVC is acting as a bank but how do you enter money in the system? Example: I'm going there tomorrow (not really) with a 100 USD bill, then what? It seems I have to buy one of these vouchers http://mogaguide.com/comp_catalog/index.php?ct=1&q=2&in=2&id...
I wonder if there is a way to turn what will be left back to cash.

In any case, it's not like everybody is its own bank. There is one company doing the bank for everyone.
Bigcommerce/sass-style-guide
3 Lessons from Purple Cow That Are Hard to Believe Seth Godin Knew in 2003
You Might Be a Tech Company If
The summary is dense, yet the chapters remain readable. The figures disseminated across the pages make it really easier to grasp the concepts.

I don't know anything about robots, but shuffling thru the pages I found similarities with the video game programming field.

Thank you for this !
Unless of course he sees an error and runs `git push --no-verify`.

I'm not really saying any of the advice around git workflow is bad. It's that too much time spent on process instead of development is. If you take the advice for what it is - a good starting point - I think it's great to use.
How I hit the headlines on Siberian TV
His advice flies in the face of every negotiation course/book. Yes, you must know the range they are willing to pay; but once you know... you don't wait for them to make an offer, you ask something at the high end of what they're willing to offer, possibly above (but close enough to) the higher margin(* ).

The one who first names the price forms the baseline of negotiation. Say their range is 100-140k. If you say, "tell me what you would pay" and they say 100K, you're screwed, no way you can say "150k" from there and still be taken seriously. If OTOH you say 150k at the start and are lucky enough to get the answer "no way we can give you more than 140k", from there it's a simple job of asking for an extra concession that you know they can make ("Hmm... ok, say I could accept 140k, but only if the company allows me to WFH when I need to")

( *) Of course, not from the start. He's right about that. They need to be invested in the hiring - if they already spent a lot of effort trying to assess your skill before making an offer, you're in a much better position to ask a lot. Presuming that they like you, of course.
Tests significantly help with understanding a codebase and safely making modifications.

Unit tests describe the behavior and usage of the individual systems, while integration tests describe business use cases in core workflows (usually just the happy paths). Integration tests should ideally be written in a gherkin style with feature description and acceptance criteria clearly outlined.

Tests should be optimized for readability foremost. For example, most people try and make their tests DRY (which is an abuse of DRY because it should only apply to concepts, not code, but I digress) while they should instead be making them DAMP. Each test should be able tell a story without jumping up and down around the file and outside the file. It's a lot more dangerous to misunderstand a test than it is to have a little bit of code duplication in your tests.

When I come across a project that has no documentation, I look at the tests. This isn't an excuse not to write proper documentation of course.
Cool app! Where does the data come from?
geared towards quick cheap labor for the PI's idea.

I am not sure the phrase "quick cheap labour" really gets to the heart of the matter.

The real reason why most PhD students work on their supervisor's ideas is different. Most students would drown in the ocean of possible ideas, would simply fail without strong guidance from an experienced supervisor. It's probably best to see a PhD as a warm-up exercise for future research. The ocean of previous research one must master before being able to do original research in mature fields is simply so large that most students can't handle it on their own. Supervisors would love PhD-students who are intellectually mature enough to come up with their own ideas and execute them to a publishable standard. In my experience, at best 1 in 5 PhD students can do this.

I used to think my own PhD work was 100% self-invented. But now, having supervised a lot of my own students, I see clearly how my intellectual mentor gently nudged me in the right direction at all critical junctions where I would have gone astray otherwise. Without him, I too would have failed.

US PhD typically last a lot longer than UK PhDs, so comparing the two is difficult. I'd say UK PhD+postdoc is a probably comparable with an US PhD.
Most of youtube (and photos archiving even more so) is 'write-once, read-never'. Only a comparatively small number of videos become popular.
וילות בגליל המערבי
'building from source' shouldn't intimidate you no matter which distro you use. Every distro does builds from source and lets its users build from source too. If anything, Gentoo makes it easier to build from source.
Flogging a Dead Degree: On the Self-Dealing of Universities
Indeed. Look at the institution best paper awards: http://jeffhuang.com/best_paper_awards.html#institutions

There are several companies (and not just universities) in the top 20. Microsoft leading.
Microsoft's singularity also ran everything in the same address space (iirc)
https://en.wikipedia.org/wiki/Singularity_%28operating_syste...
Perhaps it's slightly subjective, since I would place FreeBSD ports in between rpm and deb in terms of difficulty.
Intelligent birds: What does their behaviour mean and are we anthropomorphising?
You can set unicode ranges for custom fonts [1], to e.g. only load the basic range initially.

[1]: https://developer.mozilla.org/de/docs/Web/CSS/@font-face/uni...
Well, I went to St.Andrews during the Napier days.

I didn't use Napier myself, but some of my colleagues did, and there were frequent cries of 'aaargh! My persistent store has been corrupted!' followed by rebuilding it from source.

But that's not really a criticism of the language itself, merely the implementation, and I didn't have enough experience on it to usefully comment.

The university was deeply into pure research, doing stuff like pure research on garbage collectors and theorem provers in Prolog (one of the lecturers wrote a theorem prover package for the Mac that we used a lot. It was all in Prolog. INCLUDING THE USER INTERFACE). But they were less good at the practical aspects of software engineering; I remember one of the lecturers arguing that we because our DEC Alpha workstations had 32MB of RAM, therefore a twin-space garbage collector of 16MB per space would be optimal...

I did the persistence parts of the course in Smalltalk, which was so much simpler.

The paper references PS-Algol and S-Algol. I did a lot of S-Algol; it was a teaching language used by Glasgow and St.Andrews for basic algorithms courses, the intention being to decouple the algorithm from the implementation. I quite liked it, but --- remember how I said that practical software engineering at St.Andrews wasn't so great? The Mac version had an IDE which did not support cursor key movement. The Unix version didn't have a garbage collector (it just hadn't been implemented).

Good times, good times...
Well the truth is you can build React apps any way you like. React doesn't dictate anything beyond the rendering. Redux, with Redux-Immutable & Immutable.js is my current "stack" (hate that term) - but when I first got started I built a component library with barely any logic behind it. That's when I realised just how great React is.

It's made building my web apps front end fun again and bring in big changes is so much quicker than old school dom manipulation.

Took me a long time to become a believer, intuitively I rallied against frameworks, but React is amazing.
Some commands that can help with nuances of shell:

Check syntax:

sh -n myscript

Check for bash-specific syntax:

checkbashisms myscript

Check for various gotchas:

shellcheck myscript

Check for style:

bashate myscript

Check for badness:

grep -rE '(wget|curl).\|( sudo)? *(ba|z|)sh' myscript
Hello, I'm a PhD doing agent-based models. Is your site (of your dissertation) still working? Can you share the resources? (I checked your personal site but couldn't find it).

Thanks,
If you don't have Linux in each app bundle, it won't run everywhere. Linux breaks userspace ABI sometimes.
FB+Commission+Formula+with+Mario+Brown+Surprised+Me
But "how it will change the repository" depends on "when" did you change something, e.g. parent commit.
If you don't just to want beat up a strawman, the US interference in health care is not a good argument against government interference in health care in general.

The NHS in the UK has its problems, but they are not nearly as bad.

(I don't know which country's system is the best to look at as a good example of private health care. Perhaps the best parts of India? (India ostensibly has government healthcare, but it's so bad that everyone who can afford it gets private health care. I don't know how bad the interference is.)))
UK has rather low salaries for engineers. Even Singapore, Hong Kong or Australia are higher than UK.
I suspect the 700MB dependency is Haskell Platform. Which you don't need and is not considered a good way to install Haskell. Just GHC and Cabal (package manager, sort of ) are nowhere near there. Or even better, use Stack. See how large the binaries are.
Yes of course, I meant testing cycle while you develop. After that all browsers before releasing.
iPhone 7: Video Shows How Dual Cameras Would Work
Nah, professing your love of `football' works very well in casual conversation in America. (Just make sure you never mention any details, so they don't pick up that you are talking about the other football.)
> you should leave the typography to the client

Who is 'you'? A back-end developer? Then, yes. A front-end developer or UX person with design background? Then: no. We don't make websites for 'the client', we make them for their clients.
This was the point of "New Yen" in William Gibson's Neuromancer, in fact.
The only remaining real-cash currency, used mostly for illegal trade but still very much sought after because was not traceable by anyone (and had incredibly favourable exchange rates with electronic money)
The global Apache Spark market to grow at a CAGR of 67% between 2017 and 2020
It might be more "economically efficient" whatever that means but it is only taxing a small percentage of wealth owners (those invested in land). I don't see how that is politically viable given that they aren't the only ones benefiting from all that government and society provide.

It seems to me that this only made sense when land was the main form of wealth for any given estate at the time.
Show HN: Jukebox – Collaborative music player
I think lwf was talking about the human cost of having two versions. That doesn't go away when they are both named foo instead of foo0 and foo1.
AirBNB is struggling in London
The regressiveness of the tax can be fixed. Most countries with land taxes have them so you only pay tax on land that is not part of your main residence. So in that case the middle class only starts paying the tax when they start investing some of their savings into real estate.
> >Stateless programs; No side effects

> Which is not all it's touted up to be.

It's not even true!
German authorities approve the use of home-made Federal Trojan
Why hasn't Gentoo made the same changes Calculate Linux has?
Except for the fact that land taxes are regressive and extraordinarily evil toward the bottom ~50%, the people that have by far the most difficulty affording their property taxes each year.

Ted Turner isn't having a problem paying his property taxes. The rich will never have a problem paying their property taxes. It's the poorest that struggle with it. Fully distributed land value taxes discourage property ownership by the non-wealthy, which will increase wealth inequality.

If you then plan to create exclusion lines based on wealth or income, that drop people out of having to pay property taxes - well then you're just going to create a lot of other problems in which you're punishing people just above that line that can hardly afford the tax either.

If you want to use a very finely graduated property taxation approach, good luck fairly managing it across a nation as large and diverse as the US in terms of incomes / land values / standards of living / et al.

If you make a person pay $3,000-$4,000 annually on their homeowners taxes per year, with said person having a median income in a house valued at the median, then what you'll accomplish is every ten years you're guaranteed to have completely wiped out all value gain created by that person owning their home and paying down their mortgage.

Property taxes are just about the most regressive taxation device ever implemented. The only thing worse is the basic income, in which the rich are given a welfare hand-out.
The Apple Newton PDA was single address space. The ARM 610 MMU was designed specifically for the Newton (the Domain protection system and sub-page protections, in particular).

This was circa 1992, if it matters.
And yet it survived, or at least the sound reoccurs every year for how long? I would think a malformation would doom its ability to communicate and feed correctly, no?
I think it meant the browser, as in "the web client".
(There is a mention of overriding all websites fonts).
So you basically agree on the goal: satisfying the end user.
The client is the person paying for the website. They want fancy fonts because they want a strong brand and all that bullshit. The client's client is the person reading the website. Fancy design is actively harmful to them.

I make my "should" claim as somebody reading websites, not somebody paying for website design. I'm fully aware that designers are less likely to listen to me than to the client who's paying them, but if I can at least shame a few into reining in their worst excesses I've done some good.
Our Fragile Intellect [pdf]