
Show HN: Better code review for GitHub - timr
https://www.omniref.com/code_review
======
mullr
"Code reviews become annotations" \- cool feature, and it identifies a real
problem. I don't think it solves it though.

We've learned many times that your source code and its history are _the_ thing
you care about. Spreading closely related information across different systems
is dicey at best. It never seems to follow the same branching structure as the
source code, and external systems come and go. Even for issue trackers, one of
the most obviously useful tools we have for software development, it's not
obviously a good idea to refer to issue ids from source code comments.

That is to say: if you believe that code reviews are an important part of the
code, or at least sometime can be, then you should be getting that information
back into the code itself. Show me a way to turn code review into a code
comment from the review interface, _that_ would be cool.

~~~
justinsb
I agree with this, and recently learned about [https://github.com/google/git-
appraise](https://github.com/google/git-appraise) which I believe stores the
code reviews in the repo itself.

~~~
timr
Hi there, author of Omniref here.

There's a substantial difference between what we're doing, and what git-
appraise is doing. Git appraise is solving the problem of decentralized code
review, but it doesn't solve the problem of making code reviews _discoverable_
, after you've done them: having a directory full of JSON files doesn't make
it easy to go from a line of code to the review that created it.

In other words: we're trying to make it possible to look at your code, and see
every bit of historical information, in context, that made it as good (or bad)
as it is at that moment.

That said, having the ability to export our annotations to a directory full of
JSON files is high on the to-do list. You should absolutely be able to work
with your own data.

------
allanderek
This is beautiful and clearly very useful. Some thoughts:

* Business-wise, your main risk is that GitHub agrees how useful this is and builds much of the same features. In a sense, GitHub can improve in this manner, by taking the best features of external services and implementing them directly.

* The killer app here would be if you can integrate this into an IDE. In other words, the annotations are great for code-review, but not _just_ code-review. In general they are essentially _better_ comments. Wouldn't it be great if I saw those annotations whilst coding? I understand that it's not as if you personally could create plug-ins for all existing IDEs. But could you have an API to make that possible for third-parties to author said plug-ins?

* Integrated with code-analysis software could make for a very pleasing automated-code-review service. For example, with Python you could annotate the source with the output of pylint. Obviously, I'm not suggesting that this replaces manual code-review, just that it would be a nice addition. I mean you already have the automated annotations highlighting where a line was affected by a pull-request.

* The tour was really nice, but whenever I was asked to "go ahead and click on the annotation" this did not really work, mostly it just advanced the tour. On that note, it would be good if the tour suggested how far was to go.

~~~
timr
Hi, glad you like it!

Yes, an API is coming very soon. And hopefully soon after that, some open-
source editor integrations based on that API. Do you have an editor/IDE you
prefer?

Integrated code-analysis would be cool, but it gets into a messy, language
specific area that I'd like to avoid for the time being (these tools can
be...flaky...when run at at scale, on lots of strange repos). But I'd like to
find a solution -- either, again, via API, or possibly by some sort of
jenkins-like service that allows you to run any particular tool you want, and
attach the output to the code as annotations. I'd like Omniref to _really_ be
a "universal reference" for your code -- not just code review comments, but
any sort of information that is relevant to lines of code.

Regarding the tour bug: could you send me an email (tim@omniref.com) with a
screenshot of what you saw before/after clicking the annotation button? It
might be a client-specific bug.

------
webo
We currently use Reviewable.io. It has a lot of features that I expect from a
code review tool, but the UI is just very bad and slow on so many levels.

Will give omniref a try.

@timr, I think you should charge per user, not per repository + per user. In
today's micro-service/library/containers age, there a lot of small
repositories within companies. Your pricing suggests there's a 2:1 repos to
users ratio. Our team, for example, easily has 10:1 repos to users ratio.

~~~
piotrkaminski
Hi there, Reviewable founder here. Can you elaborate on "very bad and slow"
please? The UI can be polarizing but I'm always open to simplifications /
alternatives. As for performance, I'm not aware of any regressions at the
moment as long as you're running Chrome 49+ or Firefox 46+ on a decent machine
(Safari and Edge have... issues), but again I'm happy to investigate every
report.

~~~
larsberg
I'd like to echo this comment. Piotr has been amazingly responsive to problems
with bugs or performance issues that we have hit (the Mozilla Servo team).

Apart from the UI, Reviewable also handles many of the really ugly "they did
an over-under rebase, force-pushed, did another, then flipped back" cases that
come up with longer-lived PRs and manages to keep the review state reasonable
better than any other tool I've seen. And we've tried quite a few of them :-)

------
lobster_johnson
Here are two things I'd want from code reviews:

* Editor integration. Let the comments show up in Atom or whatever as inline editor annotations (assuming they're on the right HEAD).

* Inline editing while reviewing. Very often I have to comment on a bit of code with " _this_ is how you should write it". When code reviews are just comments, I have to write that as Markdown, and I often have to copy/paste a chunk of the original code, and it's up to the reader to mentally diff what I changed. I'd rather edit the wrong code directly, and the target user should see it as a third diff pane.

~~~
timr
Hi, author here.

Editor integration: Agreed. An API is soming soon, which will make it possible
for anyone to write an editor integration. Because there are A Lot of Editors.

Inline editing: _interesting_. I'd have to think about how to do that one, but
it's a cool idea. Thanks!

------
pbowyer
Oh. My. Word. This is awesome - both the UI and how it works/what it does.
Well done!

Having this embedded inside JetBrains IDEs would be fab (no idea if possible
via a plugin).

And a slightly-jealous programmer Q about step 10 of the tour ('Reviews stay
“stuck” to their line!'): how did you make that work, when GitHub can't?

~~~
timr
Thanks!

The smart annotations literally require computing a revision history for every
line in the code. Essentially, a signature that uniquely identifies the line
in time and location. It's a non-trivial thing to compute, and there are a lot
of edge cases, so I can understand why GitHub hasn't done it. ;-)

Editor integrations are a super-common request, but because there are as many
editors as programmers (it seems), we'll probably start with an API, and then
move to creating open-source extensions for the most common editors. But your
vote for JetBrains is recorded!

------
timr
Hi everyone, Omniref author here.

Just want to let you know that our repo importing processes are currently
being hugged to death. Oops. I'm spinning up more workers now, but we're about
100 repos behind at the moment.

------
levemi
protip: make your free option a bit of text with a link instead of
highlighting it on an equal basis with your paid plan. People who want a free
option will find it while people who are willing to pay you $50 wont think
about the free option as much. Also those red buttons are very angry looking.
Maybe make them green instead. I don't like clicking red buttons, red buttons
usually do dangerous things like delete accounts and launch stuff in
production. Green buttons are click magnets on the other hand.

It looks like a really nice tool though.

Good luck!

------
reustle
I feel like this could all be done with a polished up chrome extension. I
don't see what I'd be paying $50/mo for, which is double what I pay for my
company's GitHub account itself.

~~~
jorams
It's a bit non-obvious, but there are some smaller plans. You have to click
the arrows on the sides of the box to see them.

~~~
timr
I updated the page to make those arrows more visible for now. But it looks
like I'll have to re-think this bit of "clever" UI.

------
great_kraken
What happened to omniref for Ruby's source code? I can't seem to navigate to
it from the main site anymore, I can only find it via Google search linking
into the site.

~~~
timr
It's still there, just on a subdomain:

[https://docs.omniref.com](https://docs.omniref.com)

I'll add a link back to the homepage.

~~~
great_kraken
Awesome! The interface is great, I always found it the best option for looking
into ruby source code. Wishing you guys success with your endeavors.

~~~
timr
Thanks for the kind words!

------
tdrd
This appears to hammer GitHub's API pretty aggressively. I attempted to import
[https://github.com/cockroachdb/cockroach](https://github.com/cockroachdb/cockroach)
and a few hours later my API limit is exceeded.

Seems bad.

~~~
timr
It's pretty conservative with the API usage, but if you have thousands of pull
requests, issues and branches, it will probably hit the limit of 5k requests
an hour on first import. After initial import, API usage is very light.

You're the first person to have this problem, but I'll add some logic to
throttle the request rate before we run through your allocation. The trade-off
is that it will slow down import of pull requests and issues.

------
sedeki
I would be interested in seeing some screenshots and preferably more details.
Looks promising, though. Good work!

~~~
timr
Don't know if you saw it, but there's a tour that walks you through the major
features:

[https://www.omniref.com/code_review/tour](https://www.omniref.com/code_review/tour)

~~~
sedeki
Hmm. I'm on mobile right now, maybe it is hidden?

Anyway, thanks!

~~~
timr
Oh, yeah. It's way too much UI information to work well on a mobile device. I
hid it to prevent eyeball bleeding from cellphone users. You'll see it on a
larger screen.

I'll have to add some screenshots, but it's just a hard thing to make obvious
on a small screen. Thanks for the feedback!

~~~
pbnjay
You definitely need some screenshots at least on mobile. I skimmed the page
and left cause I didn't see anything. Glad I read the comments to see why it
was upvoted, now I at least know to check it out later on my main machine. If
this weren't HN you'd have lost me though!

~~~
timr
Yeah, I try to be aware of users browsing on phones, but I slip up sometimes,
since, for obvious reasons, I mainly use Omniref on a desktop.

This was a forehead-slapper, though. :-/

------
mholt
Is there anyone using this already for a public project that I could take a
look at?

~~~
Blahah
Yes, the entire Ruby language.

[https://docs.omniref.com/ruby/2.2.3/](https://docs.omniref.com/ruby/2.2.3/)

example annotation:
[https://docs.omniref.com/ruby/2.2.3/symbols/Class?#annotatio...](https://docs.omniref.com/ruby/2.2.3/symbols/Class?#annotation=4032498&line=511)

~~~
timr
Hi, Omniref author here. Thanks for posting those links! Technically, this is
an older version of the same software, but it does get the idea across.

The "new" Omniref does a lot of things correctly that the "old" Omniref
wouldn't (like working with programming languages other than Ruby...heh.)

~~~
Blahah
Great! We're exploring using it for the BioJulia project as a result of this
HN post. Thanks for all your hard work.

~~~
timr
Awesome. I am an ex-computational biologist, myself.

If you have any trouble just send me an email: tim@omniref.com

------
jbrooksuk
I can't see any reason why Null would break for a surname. You're expecting a
string, not a null value. What's hat about?

