skysight-inc/HackerNews huggingface dataset:
We use Jira to track development tasks, and have two states for review: Awaiting Review and Under Review. Every branch (and thus every PR) has a corresponding dev task. We configure Jira so it lights up the Review column in red when there are too many items in it. It's a fairly unsubtle hint that items in the column need to get reviewed before moving on to the next dev task.

We also use Stash (now Bitbucket) rather than Github, so we can configure it to trigger Jira state transitions.

Depending on how features get factored, you can end up requiring certain tasks as pre-requisites before other tasks can get started. Then there may be direct communication / nagging involved. But we try and cut things up a little bit differently, so that there's less scope for lag to impact overall feature delivery time. The main idea is to prevent PR reviews from being blockers for multiple people.
Tesla may need cash to deliver on the Model 3: Analysts
Looks like Putin's offshore assets are being exposed. About damn time.
You can create PRs against branches other than master in github, which lets you create dependant releases. Don't know if that helps at all
> "Shut the fuck up Donny, you're out of your element."

> really fucking pissed me off

Please don't. If you're "really fucking pissed off" by a bad or unfair comment, wait until you can post something civil. Otherwise the signal/noise ratio gets worse and we end up with a flamewar.
75% Off Photive PH-BTE50 Bluetooth 4 Wireless Sports Headphones with Microphone
I'm not indicating whether I agree or disagree, but: the stakes are high with both. Bad lawyer can doom a client for the rest of his life. Bad doctor can take life. I expect compsci to become more difficult as our stakes continue to increase, and we are already getting there with Ashley Madison/USG level PII disclosures and mass surveillance engineering, for example. Some life or death fields within our own are already there or on their way.

Think about all the bad programmers you are aware of, and think about how many are employed. I believe medicine is trying to avoid that, somewhat understandably, with collateral damage against people who would otherwise be good doctors but are unlucky. Calling it a conspiracy might be a bit of a reach. Take that sentiment into watching Patch Adams, for example, and the big bad mean medical establishment might make a smidgen more sense. On grounds of dignity and tradition is one thing, but competency is another and I think the root of the conflict.

This is all interesting of course when you also, correctly, notice that there are many bad doctors and lawyers all the same. My ex-wife's divorce attorney needed help from my own understanding notary procedure (yes, really). But hard to say whether there are fewer with the system in place. Maybe there are.

Again, no opinion being shared on whether I agree with the practice or not (I'm honestly unsure, if you want the truth), just an observation. Maybe some of the issues in our industry, particularly incredibly lax security practices, might be mitigated with a bar to entry similar to medicine. I simply don't have that answer and I can see arguments on both sides.
Yeah this app has been around forever, iirc I used it on the original G1! (Or N1? It was a long time ago.) One issue they have is that for optimal accuracy, you need raw access to the multiple microphones but the manufacturer uses the mics to perform audio scrubbing before the data gets to the app.
>I tell you from my experience working in finance that you will never ...

Famous last words. As long as you define 100% to be residual errors at human level.
The Panama Papers – ICIJ
Although not all pair programming environments are healthy, I do believe that when it works well, teams tend to have better collaborative cultures. Many developers prefer the anti-pattern of (long lived) branch-based development because it defers feedback and sources of potential conflict.

Ugh, such a false dichotomy. Does anyone actually think http://nvie.com/posts/a-successful-git-branching-model/ is a good idea?

Instead, compare to any one of hundreds of successful examples on github, all using feature branch based models.

Thoughtworks (and other consultancies that take the CD book to heart) would have everyone pair programming and committing directly to master. This simply doesn't scale beyond a small team. It also actively discourages collaboration across teams, because there is no process in place to review external contributions.
We used to sit down together to the do review. The reviewer set an open timeslot for a possible review, the first who grabs it sits down and together they review it. The calendar entry helps to timebox the review process, the verbal communication speeds it up and helps to avoid conflict.

One more addition, take care of the important bits only, don't fight over coding style or such.
Then there's destruction of evidence, complete with a physical totem to illustrate your witchcraft - imho this idea is going the wrong way.

By their very nature (treacherous computing), smartcards will enable more user-hostile capabilities than user-empowering ones. Not that they can't be useful for some properties - a custom applet could implement a time-delay dead-mans switch iff you can count on them remaining secure against government thugs.

The right way is to implement and encourage popular operating systems to adopt n-volume steganographic storage. Then there's no discernible difference between a truthful and lying "I've given you all my keys". While this won't really help your low-status undesirable that the government is just looking for justification to purge, it will cause social change when upper class people are in the same position.

(The common retort to steganography of "then they just torture you" is really just a reversion to the underlying truth from the dawn of society, exposing the modern farce of "the rule of law". Which means things either actually get reformed, or we have another bog-standard revolution to overthrow the unaccountable thugs.)
Prolly an etiquette violation to crosspost to reddit, but I wrote a little "bootleg" version of unums in C++. There seems to be some inherent problems with the unum2 concept though:

* The smallest non-zero value is 1e-9.

* The biggest non-infinite value is 1e9.

* The first integer that shows roundoff error is 3.

* The integer 100001 loses its last digit. 100001 -> unum -> float = 100000.

See the link at:
https://www.reddit.com/r/programming/comments/4d08g0/a_radic...
"Please disable your ad blocker… thanks!"
I don't mean anything utopian. I mean that my understanding is that environmental risk due to fracking is very carefully monitored and can be controlled to some acceptable epsilon.

FWIW, there IS very little risk of operating a nuclear power plant. Incidents, while spectacular, are extremely rare. They say ( whoever "they" is ) that molten salt and other technologies are safer yet.
Some of the data is available here[0]

For those of you who are wondering. ICIJ is funded by the CPI, one of the more "liberal" (e.g. if you consider the NYT 'liberal') think tanks. In my mind it's a very respectable institution, but check out their supporters[1] to see what sort of 'slant' they might have. Maybe read their take on the Citizens United decision[2] too.

[0] http://offshoreleaks.icij.org/about/download Not too much though..
[1] https://www.publicintegrity.org/about/our-work/supporters
[2] https://www.publicintegrity.org/2016/03/11/19418/citizens-un...
Model 3 announced by Tesla this weekend
> "Ubuntu will primarily run on a foundation of native Windows libraries."

I think that you're predicating an entire argument on what was probably a bit of slipshod writing. After all, we know (now) that what this is is Linux binaries running on the Windows NT kernel, and that Microsoft hasn't actually done anything to those binaries at all (and indeed touted that as a feature). So Microsoft hasn't taken any steps to make Ubuntu softwares specific to the new Windows NT Linux subsystem.

Nor has this even been positioned as an "Ubuntu on Windows server". Indeed, the Microsoft people promoting it have been stating (in all-capitals or boldface, no less) that it's for enhancing developer command-line workflows. It apparently doesn't even have the server capabilities (i.e. running programs as services) that even the old (Interix) Windows NT POSIX subsystem had.

You're also discounting the other Ubuntu news of the month.

See https://news.ycombinator.com/item?id=11415985 and https://news.ycombinator.com/item?id=11416376 .
Back in 73/74 we had to send out code off on coding sheets that where processed at the local college.

The first language we learnt was a cut down training assembly language CECIL we moved on to BASIC the next year.

BTW I was the CSE lower stream ie the exams for those leaving at 16.

Funny thing was as computers where the maths department as I only did a CSE I wasn't allowed to do the A level computing in the 6th form - even though I got the highest possible grade in my CSE maths.
You can think of it as theft if you accept that science should be done behind closed doors. Many people think that scientific discoveries belong to everyone.
We had a similar problem - a lot of pull requests being stuck in a back-and-forth remarks and fixes. The "social" solution was to increase the amount of communication in the team: instead of everyone having their own tasks and working in a silo, we made multiple people (ideally, the whole team) responsible for a task, splitting work as we go. The technical solution was to use pair programming instead, at least for some changes. Both worked really well.

Pair programming achieves a similar result to code reviews (another person knows the code very well, and is able to criticize it and improve on the design). It also does it much better because the review is done as the change is being made, and not after the fact, which improves the understanding of the reviewer and allows them to give immediate feedback.

The old code review process still works as a fallback, and is especially good for small but tricky changes: I need to do something novel, it's not a big change but there are a lot of ways to do it, can you comment on my approach.

One other thing that we also ended up doing is "ping-pong pull requests": if you give me a pull request, I don't just criticize it leaving the issues for you to fix, I fix them and leave that for you to review. Then you can do the same, etc. As a result, both people get better acquainted with the code, instead of just one of them being the "owner" of a change.
> Sure, people get addicted to it, but not a huge number percentage wise.

Is that because they don't get addicted, or because they don't try it?
Hilarious that BBC, a broadcaster paid for by British tax payers, has a subheading in that article titled "Russian connection" describing various dealings of Russian characters who are "close associates" of Putin and an equally sordid "Iceland connection" but not even a mention of David Cameron's father's tax evading schemes listed in the documents which the people of Great Britain should be vastly more interested in. Not to mention direct implications of various other western puppets (Saudi King, Ukrainian PM, Iraqi former PM) and other dubious "connections".
> as well as Ukrainian President Petro Poroshenko, who has positioned himself as a reformer in a country shaken by corruption scandals

I wonder how Ukrainians ,who fight for him and his "freedom" ideas, will react to this
We use Jira, GitLab and Slack in our agile teams at work. I've written some automation that listens to GitLab webhooks and (a) announces new Merge Requests in the #team-review channel, which all team members are in, and (b) creates sub-tasks on the original Jira story or bug, which appears on our Jira boards.

But yeah, most of it is about setting expectations. I think our conclusion was mostly that review times under about ~24h are okay, so within that space people can organize their own time.

That said, I have been trying to get my team members to create smaller commits. I'm personally convinced that review time is exponential in commit size, such that reviewing a branch with 20 small commits is much more efficient than one squashed commit. That said, this hinges on actually doing the work to create good commits: no fixup commits, one logical change per commit, etc.

This has come up enough that I think I should write a blog post about it some time.
This is precisely what I was going to respond with. I "manage" a technical group of 27, and we have people that run the entire stretch between one guy I check in with every 4 hours, and another guy I talk with once a month to make sure we're on the same page and then just let him crack on until he needs something.

I wouldn't say I'm particularly good at being a manager (or, for that matter, enjoy it particularly), but the only universal truism I've discovered is that you have to let each person decide on their own what makes a good manager and try your best to be that manager for them.

Specifically, wit respect to one on ones, I just decided to punt, errr... delegate their scheduling to my reports at whatever periodicity they think is best and just make a point of asking at the end if it's still working on the current schedule for them.
Can you point to app, please?
The Panama Papers: Victims of Offshore
Leo Messi too, who had already been caught on another scandal by Spanish Tax Office.
As a women who has serious needle-phobia, I can't believe I've never even considered this possibility.
I own a small vineyard. I can tell you without a doubt that the process of making wine is literally BEGGING to happen. The skin of the grape is covered with yeast cultures that are ready to ferment the sugar inside the grape. The second that there's a breaking of the skin (aka a deer comes by and grabs a snack), the process kicks off. After a couple of days, there's enough alcohol content in the grape that bees can hone in on the broken cluster (via smell or whatever). Get enough bees around, and they start eating more grapes, and voila. Bee-booze-chain-reaction. Ruined crop. RIP2015.
Pejorative adjectives are a form of calling names. There are no grammatical loopholes here.
I look at articles like this and ask myself is this journalism or is it a shake down?
Extensive earlier discussion: https://news.ycombinator.com/item?id=11402101

(and dozens of other posts)
>companies like Apple and Google will be forced to spend like the rest of the economy does

Spending on what? I think one big problem here is that the capital is possessed by entities that were nurtured in very specific markets. Take Apple. They are really nothing more than a "shiny gadgets/personal computing" company. They have a ton of potential to invest in other markets but they do not have the expertise to do so. What are their options: 1) start acquiring and undoubtedly mismanaging companies that are outside of their market domain 2) setup a wealth management unit that invests passively in equity markets and such.

I think this could easily be elaborated into an argument against the orthodox liberal economics claim that says that markets allocate capital to the most able entities; the implication being that those same entities will make best use of said capital. I think here it is clearly not the case. Sorry, but I don't really trust Apple to come up with a decent EV solution (I know they are trying). I don't even trust them to invest in the correct EV startups. What do they know? It's not their market domain.
You seem to legitimately misunderstand this, so let's make this very very clear: of all the thousands of papers on that website, the publisher aka Elsevier and others had no part in the actual research, they have not funded the research, they have in fact very likely taken money from the very researchers.
The reason why they don't work was actually on-screen, very briefly until Russ Alexander cleared it (again), in the Microsoft demo video. See https://news.ycombinator.com/item?id=11415843 .
It's an interesting question, but the general problem is that even small projects have problems when bringing things to production. For example, let's use Django:

- How do you make sure the version of Django on your machine matches the one in production?
- What if you do brew update on your Mac and the package for your repo in production is out of date?
- How do you roll out a new version of your app (even allowing for downtime) and make sure it did it "completely"?
- How do you make sure your app keeps running even if your VM goes down (let's say you need to do a kernel upgrade)?
- How do you use one password for your local development database and one for your production database (and not hard wire it into code)?

These are super common problems - you're going to have to solve them no matter what. Lots of folks do this with scripts, but one small change can cause all kinds of annoyances.

This is why containers have taken off, and all of these are addressed via the combination of containers & Kubernetes. It's a different way of thinking about development, but I've been able to accelerate my velocity substantially once I adopted them. I'd argue that the complexity that you accept as 'normal' for a small site is an unnecessary tax, but I'm biased :)

Disclosure: I work at Google on Kubernetes.
Only if we're recruiting a neurosurgeon.
Our code review policy is to require a minimum of 2 people who did not contribute to your changeset review and approve your code prior to merging. We've been able to reduce the amount of time a review takes in four big ways:

(1) Automated style checker. By adding a pre-commit hook to validate code style in an automated way, the amount of noise in PRs went down dramatically.

(2) Don't do architecture review in PRs. If you're going to make architectural changes, do so in a lightweight design document and get approval there first.

(3) If it languishes, go and physically (or virtually) ask the specific people to take a look. This works best in my experience when you find someone else who's having trouble getting their code reviewed and offering a trade. This person is then likely to review your code quickly in the future if you do the same.

(4) Feature flags allow you to get incomplete but atomic and correct units of work merged to master without showing them to your end-user.

This way, code reviews are not about style (much), not about architecture (much) and simply about making sure you executed on the plan correctly. Turn-around times went from days to hours in many cases.
Lily – A programming language focusing on expressiveness and safety
How about just when your current machine (e.g. Mac) has a different supported version of Python?

Disclosure: I work at Google on Kubernetes.
Return the money to shareholders who can spend or invest it.
We're currently the primary cause of an on-going mass extinction. [1]

[1] https://en.wikipedia.org/wiki/Holocene_extinction
We use Gerrit. Gerrit is a review system derived from the Git technology.

From the Git user's point of view, Gerrit is installed as a git remote. When you develop some changes, you push them to the Gerrit remote, using a special branch naming convention. Gerrit dynamically takes this push and converts it to a review item, which is then subject to a web-UI-with-email-notifications-based review workflow.

A special "Change-ID:" item in the commit header identifies the change. This lets you push revised versions of the commit: if the Change-ID matches, Gerrit recognizes a push as being the new version of a previous push. These versions are organized in the review process under one item. You can see what the differences are between different versions and so on.

The review process involves multiple users in reviewer roles. They get notified via an e-mail that there is something for review. Then they can look at the changes, and approve or reject the commit. General comments can be added to the item and comments can be attached to individual lines of code, also, so you can easily say very specific things about specific pieces of code.

We have automatic reviewers who participate also. For instance, if a kernel change is proposed, then "checkpatch" is run on it automatically, and posts an approval or disapproval to the Gerrit item. The code also has to build for several targets and pass automatic smoke tests.

Commits are ultimately merged by users who have the power to do that. They take into account all the other votes and then cherry pick the change.

Gerrit is far from perfect, but it provides a decent workflow, and is a huge improvement over ad hoc development. For instance, the Change-ID can be a pain. It's assigned by Gerrit when you first push something, and then you must remember to add that same Change-ID to the new version of the commit. I wrote myself a script which generates a Change-ID; I stick it into the very first commit, so Gerrit doesn't have to make one up for me.

To use Gerrit, users have to acquire a somewhat better than average understanding of git; it's just a little bit more advanced than the "pull, commit and forget" use cases whereby you pretend that git is SVN or CVS.
Things should be set up to prevent common mistakes; for instance, lock the repository from direct pushes, so only pushes to Gerrit are allowed. I would make a blank "Change-ID:" part of the commit message template, and give users a way to generate these things, to avoid the common mistake of pushing a new version of a commit without a Change-ID, causing Gerrit to generate a whole new review item.
If none of the "stay there" solutions work for OP, and you've mentioned it to management, then leave. The majority of your day should not be stressful when there are alternatives.
Correct racket version 6.3 is 6 months old. But 6.4 came out two months ago, that seems to be the relevant age statistic. That seems a little disingenuous of you?

The software distribution and management scheme you are advocating for sounds like a security nightmare. Administrators are already bad enough with applying vendor updates. Can you imagine what things would be like if administrators had to track all of the different upstream security announcements for everything they installed?
Got it mate. It's just my style, but I will keep your suggestion in mind in the future.
Not Leo messi, but the company who operates his money. The recent case that Spanish tax office opened against him was in regards to a payment that has happened when he was 17 year old...I doubt that messi at 17 yo was the one who was dealing with his taxes
So, I'm torn, because there's really something to scratching your itch your way.

But there's a saying: A year in the lab saved me hours in the library. It applies to code, too.

Make has some profound science and experience crystallized in its approach to the world. Anyone starting down their road with a new code base is making a strong statement, whether they realize it or not.

I'm not sure I know what you mean by 'parameterized rules'. but if you mean something as simple as 'A target to be built can imply more than one token to be used in the rules to generate it' then I think you're reinventing wheels.

It's a lot of fun to build a green field that does just what you (think you) want, and then take the first few steps to generalize it, and think "I've built a new tool!". But somewhere in there you'll become an old fart, and wonder why These Kids keep on re-inventing tools that have been written well, and worn butter-smooth by the passage of many nerds.

Meh. Take a look at how you can calculate multiple tokens from a target string,

https://github.com/rout39574/make_an_example

it may not be your cup of tea.

old fart out.
damnit...
somebody already took :
https://github.com/PanamaPapers