skysight-inc/HackerNews huggingface dataset:
This is a poor and incorrect analogy for rebase. Someone using rebase is conducting the reconciliation and then rewriting their commit to account for it, while simplifying the commit history and hiding it.

When a commit lands in master, it doesn't matter to anyone else how it was developed. Those events are almost outside the "light cone". Those who rebase a commit onto the upstream branch recognize that the little details of how it was made have no relevance to others and thus do not belong in shared history.

People often speak about preserving history while missing the point that source history is most meaningfully logical, not physical. Imagine an editor that made a new commit for every key press. That would be a true recounting of history, and yet would be irrelevant. Most feature development can and should land as one commit; the details of how it was made are, like the key presses that composed it, minimally relevant to anyone but the author.
> https://www.youtube.com/watch?v=aT7mnSstKGs

Interesting talk.

I did find that <takes a drink> later in his talk he kept <takes a drink> taking a drink every 10 seconds or so <takes a drink>, which ended up being more than a <takes a drink> little <takes a drink> irritating to watch and listen <takes a drink> to.
I need to update or GitLab ...
Yes. Though sieve of Eratosthenes really cries out for a sort-of-lazy infinite array.
Rebase also doesn't change when you did something either.
PS Another way to implement function calls (and thus recursion) is transformation into continuation passing style.
"How changes get live" is one of the first, most important things I tackle with a new project. This means I consider my "live system" is effectively part of my development environment.

Right now, I have a "live system" repository, and then development actually occurs in a second repository which is a submodule of the first.

This has a lot of advantages:

• Configuration and data is out-of-tree, so it is easy for me to have a read-only view of the live database, and read-write to a local (temporary) database

• I can select a branch using a signed cookie or a URL which makes it very easy to demonstrate features on the live system

• I can try out tags on 1% of traffic, or 5% of traffic, testing some features with my live users

• I can use git bisect on the live system to find regressions

There are a few disadvantages, but most of them are psychological: Testing on live sounds scary; how to make database migrations is a lot more work; etc.
It's not accurate to say there's no fitness function. There is a fitness function, but it is not a continuous function. (There's no way to have a GA without some notion of fitness.)
I'd assume laymen think in terms of combinators, ie like map (do this operation to all the things I have), or filter (through out all the widgets that fail the test). Thinking in terms of indices is pretty painful.

> Those are just abstracted loops though, not recursion.

Map and filter on a tree is about as recursive as it gets. Loops are the special case of recursion that does work well on linear data structures like linked lists and arrays, yes.
I would hate it if LinkedIn fails to be successful as I'm a frequent IN user. I agree with the fact that 40+ people tend to reply sooner than others. This is one of the reasons I'm on IN as my target audience is on it.
One thing you don't mention in your paper reading method is a stopping criterion. I'm opening and doing some level of "looking at" --- not necessarily reading! --- probably 10-20 papers a week. More if you count revisits to papers that I've "looked at" before.

The question is, how do you decide which papers to promote to further attention? It's always a ranking problem, because there's always other work you could be looking at. You start your reading method at the point at which you've already decided to read the paper. But how do you get to that point?

(I can describe how I decide, but it's not exactly easy to replicate. It's a pretty insidery perspective. Here's how it played out for this paper.

I looked at this paper soon after it was published because I follow the first author on Twitter. When I opened the paper I looked at who was on it. I know Phil, and I know the sort of work Ed has been doing. I glanced over the paper and looked at the experiments, and saw that it was similar to the neural turing machine and algorithm learning line of work, that's still being evaluated on toy problems. This work is interesting but I'm not doing research on these things, so I won't commit to learning it while it's moved <1 mountain empirically. I did read the idea enough to contrast it with Chris Dyer's stack LSTM parser, which is a model that performs very well empirically. I checked the related work for criticism/comment on that work, and the paper said it's inspired by it. Cool. I'll watch for future empirical evaluations.

In total I probably spent about 10-15 minutes looking at this paper. This is enough for me to remember I'd seen the work, and help me understand future related ideas a little bit better.)
> I often don't want to record my development history in the master branch because it's messy. Instead I squash my work into a single cohesive commit

personally i rebase my commits into fewer ones so the result is a reasonable compromise between how-the-code-actually-evolved (which is messy, true) and a clear, simple progression from start to completion of the feature (one single commit if taken to the extreme).

> I can say "hey Joe, you broke the frobber when you implemented the new gizmo."
that breaks if joe is not available anymore or the change is complex (or old) enough that the detailed history would help debugging, but joe doesn't have the branch lying around anymore because he deleted it or switched machines etc.

There are certainly advantages to a single commit per feature :) I just think having more information available through more commits is a good thing, and i don't see large disadvantages of having larger amounts of commits, provided you really do squash those "fix last commit" commits etc. to keep the commit count reasonable.
The opposite. I haven't heard anything in a while. Please do mention it when it's relevant.
Perhaps expand SF to San Francisco? I was expecting an article on science fiction.
Airware (YC W13) is hiring engineers, managers, and product
We're looking for engineering managers (in a number of disciplines), product designers, and software engineers who want to work on APIs, geospatial data processing, and analytics visualization.

Check out our engineering & design blog to see what we're about (check out our open positions in the footer if interested):

https://makers.airware.com/

Thanks!
The typical effective way to work with Git is to develop on master while running "git pull --rebase" regularly, and before you commit. Prefer to build up a feature as one commit, with "git commit --amend" or "git commit --fixup". Since you pull and rebase regularly, your code is closely in sync with all shipped changes, and if there are any conflicts you get to resolve them in small incremental pieces. When your change passes CR, push it.

The result is a simple, clear, linear commit history with a minimum of effort spent on branching and merging fuss. The fuss is rarely worth it. This model works for quite large teams. After a certain size, it might be better to split the package into several rather than add branching/merging complexity.
WhatsApp Ends Support for Major Mobile Platforms
And you can choose to not be an asshole and not get downvoted, but you'll just have to take what you deserve.
The first time I used it was for my personal mail & web server. I did a little research and found OpenBSD's reputation for having some of the cleanest code out there, as well as the project's focus on security and correctness. That sounded like a good fit for the application.

A year or two later, I bought a netbook so I could unload and process photos from my camera while travelling. I had no idea what to install on it since I didn't really want to spend all the time Gentoo required, and I knew I wouldn't be updating the system regularly, which could result in a lot of pain on Gentoo if you ever needed something new. And I had too many bad experiences with all the other Linux distros I'd tried. So, just for the heck of it, I tried OpenBSD. Ten minutes later I have a working system and GIMP one pkg_add away.

As for the desktop.. well, I didn't switch from Gentoo directly. I had been running Debian for a short while. I can't remember why exactly. Could be that I had a hard drive break and I didn't have the time for Gentoo. Unfortunately Debian had been a pain from the start and one night, in a bad mood I was, for some reason I had to reboot. Which I couldn't, because apparently in some routine round of package updates Debian had messed with the bootloader. By that time I was just so sick of it, and didn't really want to look for yet another distro. I went to bed, and next morning installed OpenBSD, which had already proven painless so far.
I do prefer rebases over merges because they lead to a cleaner history, but when you have a set of features in separate branches that are all dependent, rebasing becomes a pain. I like to have one local branch per CL/pull request. If I have a branch feature1 with commits on top of master, then feature2 with commits on top of feature1, feature3 with commits on top of feature1, and feature4 that merges feature2 and feature3 and then has commits on top of that, that thing is a pain to rebase. (I know about --preserve-merges, but it does not always do the right thing.) The main problem here is that the end result should be feature4 rebased on top of master, but the other branches should also be updated to point to the new commits.
There is no explicit function that decides which organisms are more fit than others. But you are right that there is selection pressure since all organisms have the same lifetime(they are eventually popped from front as newer ones are pushed to back). This means that if they did not produce viable offspring, the genetic information does not stay in the simulation.
Same in France: all the PhD students in computer science I know have finished in 3 years, or 3 years and 6 months (you can request a 6 month extension). You can't carry on after that duration because you have to be funded and be full-time (so no side job).
It's rare to need to develop multiple features as concurrent branches, as long as you can release regularly.

The practice that works really well is: just develop against master while running "git pull --rebase" regularly. Code review and then ship the feature, repeat. Use branches only for rare concurrent development, and only after the need has arisen (Git makes it trivial to move changes into a branch after the fact).
Since having a PhD is not a prerequisite for most jobs, it only makes sense if you are genuinely interested in science. The system is geared to support this.

Unfortunately, the system is also biased for the young and single and child-free. When I tried entering the PhD program, I was ready for significant income drop (I had been a successful software engineer for 10 years before). But I also had a 10-months daughter (she is almost 2 now). And this proved to be incompatible with the requirements of the job. I am not a father who neglects his family needs and focuses on the job. So I moved back to consulting, working from home most of the time.

I don't see an adequate solution for this. Of course, young and single will be preferred to survive the grind, and forcing the employers to do otherwise is unfair to them. Perhaps there is something else I can do to make a difference.
I agree, communication is essential. The most important thing is that the developers agree on how they work with git, and all these branching models are just usable defaults and starting-off points from which you figure out what works for your organization.

But preventing the new guy from pushing straight to master is not that hard. On my current project, a git hook prevents merging commits into the remote master if that commit doesn't already exist in another remote branch. So you have to do your work elsewhere or it won't be accepted.
> requires that Apple write new software it does not currently posses

I'm not American, but how is this different from the demands imposed by CALEA? If the platform did not support wire taps, you would have to put in work on a feature which wasn't there to add wire tap capabilities.
> What's the speed like going out of the country?

Full line rate round the clock.

> Where are the big peering points?

The main local IX is FICIX. The main Swedish IX Netnod in Stockholm is 8 ms away. Netnod is the 10th largest IX in the world. A new direct subsea cable to Germany just got built and it will bring DE-CIX, the largest IX In the world closer.

Russia is also close. Google and Yandex both built datacenters in Finland to serve Russia and Northern Europe. Facebook put theirs in Sweden for the same reason.
I found this with a bit of searching and clicking around on Stackoverflow: https://www.colm.net/open-source/ragel/ (via http://stackoverflow.com/a/15608037).

I didn't look long enough to know if there's an easy way to convert a regular expression to Ragel syntax.
When you think about it's the perfect tax: it's regressive (and the people in power love regressive taxes) and it effects the middle classes (and the people in power don't care one bit about the middle classes, no-one I've heard of has ever said to him: "My ideal in life is to improve the condition of the middle class!" while I've heard of lots of people saying to themselves and others: "I want to eradicate poverty!").

A land tax would be regressive because it would have a bigger effect on middle class people compared to the 1%, because for a person representing the middle class a house purchase (which includes the land the house sits on) it's gonna be the biggest ever purchase from his/her life, while for a hedge-fund manager worth $5+ billion an extra money that he would have to pay on his Hamptons house is a blip in the ocean.

You mentioned a lot of economists, but you left out J.S. Mill, who at some point was strongly in favor of proportionally higher inheritance taxes. That kind of tax wold effect the hedge fund managers a little more, and it sounds fairer to the middle classes.
You'll start with baby steps, but you also need to have a great 1000-mile goal to motivate you. Every step counts.
It sounds bizarre as a starting point, but several years in having still not completed, I decided to adopt this attitude as a way of avoiding the immense stress about the thing taking so long. Forgetting about the timeframe and focusing on doing whatever it took (and persisting as long as necessary) is what got me through. Completing was important enough to me that I wasn't going to give up.
> rebase keeps the history honest

The history is a record of changes. You're suggesting there's a good reason to track timeshifting by implication (you could rebase at multiple points) because...honesty?

I'm not trying to argue about the why. I'm trying to understand the why.

My view is that you merge your change into the head and there's a record. That's the story. The particulars of how a particular commit came to be is irrelevant to the repo and less problematic when it's treated the same as any other commit.
Mostly agreed. I have some notion that a commit "should" be a well-defined change in terms of program behavior, so if I can develop a feature in actual stages, I like to make separate commits. That's often the case with complex features.

Multiple commits can be confusing too, when commit messages aren't good, so I think making coherent changes is a problem beyond commit frequency...
Dr.med. and Dr.jur. are not the equivalents of PhD/DPhil, they are the equivalents of MD and JD degrees, which in terms of research output are also a joke in anglo-saxon countries. In the US, medical doctors who wants to pursue medical research usually do a PhD _on top_ of their MD degree.
Not an Elixir user. I have investigated previously. Decided on Golang. But I have to reconsider Elixir for some cases.
I'm not OP, but the gist of his argument is you cannot be secure against the government if you cannot be secure against Apple first. If Apple continues to force people to trust it, the government will subvert this trust via legal means.

I find the argument quite congent. It's not getting lost in the weeeds, but generalizing the problem; instead of just fixing this bug, why not go ahead and fix the whole class of possible bugs?
With President Bernie Sanders, Bitcoin Will Thrive
> You lose a whole lot of development history information

What information do you lose, and why is that a problem? The feature commit tells you everything you need to know. Beneath those details tend to be irrelevant minutiae.

Let's imagine an editor that made one commit for each key press you type, or every time you save a file. That would be the closest thing to true history. I might accuse your practice of not committing that level of detail with "losing a whole lot of development history", and it would be true but only in a banal sense.

How an author built up their feature commit is almost never (and shouldn't be) relevant to everyone else. What's relevant to others is how they changed the repository and why. A good feature commit or commit series should stand alone.
The whole experience of doing a Ph.D in computer science is so different to doing one in the experimental sciences. My Ph.D was a constant struggle against nature and her desire to keep her secrets. As a general rule you could expect 98% of all your experiments to fail and usually for totally boring reasons like your reagents had died. Getting anywhere was a real struggle.

I loved writing up my papers as this was at least something I had some control over. I do agree that doing a Ph.D is an experience like no other and one I don't regret.
How secure were these devices? How much work was put onto application developers to maintain isolation? I mean it wasn't feasible back then since we didn't have MMUs (ifaik)

This argument is pretty poor, since we've done a lot of things - cooperative multitasking, windows versions which had little to no isolation between the root user and other users, etc. etc. it doesn't mean they are the best approach now, or were even a good idea at the time. Yes we got them to work. Microsoft Bob and Windows ME worked too.

I don't think the javascript PC emulator runs that acceptably fast either. That was more of a toy example, I don't think you'll find many people using that for anything real.

At the kernel level performance/resource usage really does matter. I don't know enough about OCaml to comment on how it performs but especially when you make your argument about how (allegedly) terribly linux performs in certain circumstances, and that's a lot of what the selling point of unikernels are, it doesn't really follow to talk about how 'acceptable' performance is possible from higher level languages.
MSFT did it .. sure .. but my first half-decade of software engineering jobs seem like coffee chats compared to the crap we have today. I think I got my first job after a 45 minute chat (was supposed to be 30 mins but we were having a fun, geeky convo and lost track of time). What's crazy is I would leave with offers in hand. This is until 2004. Google copied and one-uped microsoft. The Googlers went out and replicated their process and suddenly, most decent software engineering jobs require you to bend over.

I had a startup interview last year where they were a well-funded start up full of PhDs. Had a hiring screen (with non-trivial code), a full day of interviews over the phone/etherpad, a conversation + coding interview with the frickin CTO. This was to decide weather to fly me to the Bay are for the actual interview (was on the East coast). I had a full-time, high workload job at the time (constant crunchtime) ... so this was brutal on me. Never doing this again.
While I understand your point, that's not entirely true; Redux itself is just a state management library, and thus _completely_ decoupled from React. You can use it with any other library/framework. In order for Redux to work with React, you need the _connector_ library, "react-redux".

Furthermore, Redux itself is a relatively small library, written in a heavily functional style. True, this may be hard to wrap one's head around for developers new to this, but I can think of no better place to learn due to not only the small size, but a lot of documentation and _very_ active involvement (in GH issues and StackOverflow) by it's author.
Rebasing is safe as long as you only do it to commits you haven't shared yet. Of course the risk is that if rebasing becomes your default, there's a risk you might also do it on a commit you already have shared.

As any time traveler knows, you need to be careful when you rewrite history.
Some people die in that too. People are nuts.
> Look, a PhD is for one thing, and one thing only: Teaching you to be a researcher.

I disagree - there's tons of skills you learn in the process which are useful in other contexts - the most important, in my opinion, is learning how to write well and communicate complicated ideas to others.

If you go into industry, then depending on what you studied and what kind of job you have, the knowledge of a given field (networking, graphics, compilers, computer vision etc) can be extremely helpful.
I quit recently after 5 years. I don't think I regret it - the improvement in my mental health has been dramatic. I found it difficult to trust any of the advice I was getting from supervisors etc. because our interests weren't aligned.

I can say that I'm significantly more highly skilled than when I started though. Knowing that I didn't want to stay in academia, I spent a lot of time working on my transferable skills (i.e. tech).
That's a little unfair to utopians.

I think that what happens is that people only listen to calls for utopia when they are discontent. This discontent is used by ambitious characters to take power, frequently in the name of utopia.

Free market proponents are frequently utopians themselves.
The Book of Humour, Wit & Wisdom.
Seems like all the jokes come from here.
Why not randomize or have an option to dig without hitting the next button?
You can change the offset number in the URL, although that is not what I would call a friendly database interface.
The Web Needs Faster Websites
I accomplish this in Redux with a simple:

componentDidMount() {
item = store.getState().get('item') // Get function from Immutable.js
this.unsubscribe = store.subscribe(() => {
let nowItem = store.getState().get('item');
if (item !== nowItem) {
this.forceUpdate();
item = nowItem;
}
});
}

Someone may have a better solution, but I think this works fine for my needs. The internet is full of people dissuading redux users from subscribing to actions.
Are there any decent opensource projects out there (preferably with Python APIs) that do speaker or "voice recognition" reasonably well? I know this is an area of active research in academia.
I imagine it might turn out something like https://www.youtube.com/watch?v=KyLqUf4cdwc - Which may not be the best. Coding using voice is incredibly tiresome and with the speed most programmers can type is unnecessary.

However, saying that, if you have a voice to text engine that _works_, you could theoretically have some fun with different compiler settings. For example, saying "Go" to continue after breakpoints could be fun, meaning you can just lay back whilst trying to find the issues with your code.
I'm genuinely surprised Microsoft allows disabling of those automatic updates...
I suppose he miss explaining histories around a fire after a day of hunting in the wildness.

There are something alienating in the way we live in big cities. We miss the palaeolithic.
I know the minister for Telecommunications in Somalia. I asked him to do an AMA on hackernews but there was no interest.