Hacker News new | past | comments | ask | show | jobs | submit login
Kite – Programming Copilot (kite.com)
1138 points by wodow on April 14, 2016 | hide | past | favorite | 232 comments

First of all, this is a cool looking tool. Useful, well-organized, easily-accessed information is always a wonderful thing.

I think a model like Dash would work a lot better: Rather than opting in my code to be sent up to Kite's servers, I opt in to the packages I'm interested in having indexes for. In some cases, as with node, there are ways to see what packages my project depends on and then those bits of indexed data could be sent to me.

My computer has a 512GB SSD. I could devote 10GB to indexes of libraries and my own code without blinking. The argument that it's too much data and therefore belongs in the cloud doesn't seem to hold up.

Also, there are cases where I'm not online... this is one of the great things about Dash. I have fast access to library docs anywhere I happen to be.

Yes but how much CPU and memory are you willing to spare? Parsing is quite CPU-intensive, hence the CPU drag you often see when IDEs start indexing, and type inference involves a lot of unpredictable lookups all over the index, so much of it needs to be in memory to get reasonable performance (yes this is still true if we're talking SSD).

To see why: when you type "x.foo()" we need run type inference on the complete data flow chain that produced the value "x", so that we know which particular "foo" you're using. Throughout this analysis we may also need to know a lot about the python libraries you're using, since you may be passing values into and out of arbitrary third party libraries. If each of the steps in this chain triggered an SSD read then you'd often have a multi-second lag between hitting a key and seeing the result.

My editor had no problem indexing all of Chromium (fairly large project). It also indexed external libraries. It indexes new code as you write it so type a foo function, next time you type foo you get help immediately. It added standard libraries by default and you can add any other library (like I have it indexing Unity3D's mono libraries).

I didn't notice more than a 100-200ms delay in seeing the result (which happened in other threads so no effect on my editing). About the same I'd expect with a round trip over the the internet. It shows both help at the cursor as well as definitions and references in another pane in that time.

It doesn't look as slick as Kite but it also seems to suggest it's possible to do this all locally. If nothing else you at least have some context (the language) so you don't have to search all data, only data relevant to that language. You even know where in the language I am so you know when to search ids and which subset of ids to search.

On top of that you're basically going to have me sending a gig of source to you to index something like Chromium which will take hours on my crappy connection.

Let me be clear, I think kite looks amazing and I'd be happy to pay for it if it was local. Maybe you download the DB to my machine. I'm not nearly as comfortable with you reading my terminal though. I'm sure you can turn that feature off but that's a feature I liked. Turing features off = less interesting

What editor?

I'm not an OP, but Eclipse does quite well indexing fairly large projects.

This argument seems decent enough, but a couple of things come to mind.

1. Wouldn't multiple HTTP requests be just as slow? (especially if you're on a slow cellular connection, which I am at a coffee shop). Are there any benchmark tests you've done?

2. Is there a reason you couldn't select libraries to download at the start of your project? It's not like you switch libraries too much, especially after initial exploration. I don't think it'd break workflow too much to check some boxes or pick a few packages, I do it already in sublime.

3. To allay concerns about storage for some, couldn't you dump the data after some point? It seems like to be useful you'd only need it while someone is coding, and certainly not long term.

Just some thoughts, would love to get a response. Like others have said, I love the idea, but especially at my work, I don't think I could actually get permission, which puts me in a grey area.

In addition to what the others said, I'll note that PyCharm is already doing these things and there isn't a multi-second lag between hitting a key and seeing the completions. It is also doing type inference. And sure, there's a bit of lag when it needs to do a full index, but that shouldn't be often.

All of it. That's why I run an X99 system with 32GB of 3200MHz RAM at home, and a i7-6700 w/ 16GB 2866MHz RAM in my laptop.

Computational power is so insanely cheap these days it doesn't make any sense to not throw the as much power at your programming environment as you can, IMO.

Those aren't insanely cheap computers - those are top-of-the-line machines - so you can't really design an application to require that kind of hardware to work effectively and expect the user response to be good.

But you're right, that kind of computing power is cheap compared to what you can do with it. If the $1000 in lifetime cost that separates your system from a baseline enables you to be a few percent more productive, it will quickly pay for itself.

That hardly seems necessary. Only so many objects have a foo method to find. With free cores, search from both ends and meet in the middle.

> To see why: when you type "x.foo()" we need run type inference on the complete data flow chain that produced the value "x", so that we know which particular "foo" you're using. Throughout this analysis we may also need to know a lot about the python libraries you're using, since you may be passing values into and out of arbitrary third party libraries.

I don't understand. The libraries I'm using need to be on my machine anyway. If you're doing type inference, there's no need to do the whole process each time: you incrementally add type information and keep it in an index in RAM and the disk. Can't there be a hybrid approach, where your servers are contacted only for libraries that are searched over but not imported yet?

> Yes but how much CPU and memory are you willing to spare?

Hell, I'm using 50% of my CPU to have 60 fps animated 3d fractals as my wallpaper. Surely I can spare some to parsing.

I think this really makes a case for this being best as an open source API, i.e. something anyone could access and something to which anyone could contribute.

I'd personally prefer not having to manage the indexes on any of my computers.

Regardless of where the info is stored, it should be possible for the client to run locally, and access your code, but not actually send anything more revealing than what you're already sending to, e.g. Google.

I use Zeal. Local. Opensource. Uses Dash's docsets. Has basic integration with Sublime.

I have a feeling lot of the functionality of Kite will eventually get into Zeal type local tools.

Which component of Zeal allows you to pull in your own local code for completion?

Zeal definitely works great for popular third party library code and integrates with Sublime, but I haven't seen options for it to integrate with your own libraries or third party libraries that aren't quite big enough to be supported by Zeal directly.

100% agree. I don't think this will ever take off, if there isn't an opt-out for local code to be pushed up.

Far too many companies will never allow employees to do this.

Actually kite does not index any directories that you haven't explicitly enabled. So it's really easy to enable it for some but not all of your codebases.

The link to dash: https://kapeli.com/dash

> My computer has a 512GB SSD. I could devote 10GB to indexes of libraries and my own code without blinking

Mine has 128GB, less than 10GB free.

A 512GB ssd costs somewhere around £100.

That puts the cost of 10GB at about £2.

Assuming you're using a MacBook Pro, it's going to cost at least $300 to upgrade to the 512GB SSD. Compared with £100 = $140 for a 2.5" SSD.

Given I don't need that extra storage, the cost for 10GB to me would be $300. Ouch.

One alternative is a Nifty MiniDrive for ~$30 + a MicroSD card. I put m an extra 128 GB in my rMBP that way.


Maybe you should opt for a more serviceable notebook, then?

Rolls eyes. Thanks for the snark - the many iOS and Mac developers on HN

I wasn't being snarky, really. I was suggesting that if upgradeability is in your list of priorities, then you would be better off with another notebook rather than a Macbook.

someone using apples really should complain about prices though. its their choice to pay thrice of the market price.

Well, you bought into Apple's system. They almost always overcharge for hardware.

Did you work as developer and make money with your machine?

That's for 2.5" SATA SSDs. Some people have embedded PCIe drives. And on some macs they are soldered. Regardless, reserving 10GB for offline help isn't that bad.

AFAIK the point about Macs is untrue.

While the RAM in many Macs is soldered into the motherboard, SSDs are not (they are often proprietary, though).

These days they're mostly (possibly always) flash on the motherboard. Afaik, chances are the only way you'll find a removable SSD in a Mac is if its stock spinning-platter drive was replaced.

That's only true for the MacBook, which isn't a suitable development machine anyway. In both the current MacBook Pro and MacBook Air the storage is a PCIe SSD.

I said some Macs (thinking about the 12" retina) but I think that's where they are moving.

Not really willing to change the SSD that came with my 2015 Mac.

Just wait for this summer, 3d nand is shaking things up in ssd world. Platter drives might even become obsolete by next year.

Assuming you use all of the 512GB, if I wasn't needing to use the 10GB free then the 10GB costs $100.

And you are a developer or a consumer?

Developer. I don't care about space because most of my stuff are cloud-based.

Privacy question - what will Kite do with the source code stored in its databases when/if Kite shuts down or is acquired? How will you respect the licenses of the files you upload?

(paraphrased) "You trust Github/Slack, why not also trust us?" Perhaps because Github and Slack's monitization models are well known, and Kite's are not.

It's a great concept for a tool, but I could never get it to fly at work. I couldn't even begin to imagine trying to convince a technically savvy cofounder (let alone their lawyer) with "let me use this tool which uploads all of our code to their server."

Alex from kite here. Re privacy: we totally agree that it's a legit concern. when we started working on this we realized if we wanted to index tens of thousands of libraries, we wouldn't be able to ship the entire index along with the client. Hence the cloud-based architecture. We've thought a lot about privacy and written up our thoughts here: www.kite.com/privacy. The short answer is: we don't index anything on your computer that you don't explicitly ask us to, and our plan is to earn trust the hard (i.e. only) way: transparency, published policies, and a track record of good decision making.

I did read the privacy document, which does not address the acquisition/shutdown aspect, which is fairly important; Oracle (for example) may not have the same views on the privacy of the acquired data as you do.

Also, do you have plans to support deletion of indexed data?

Yeah, this is something we should have put in the privacy doc. We're talking about it now. Definitely want to think properly on this stuff before posting something publicly (as with anything privacy-related) but we'll have an update.

I think this is a great point. Does anyone know if it's possible to bulletproof against what an acquirer might want to do with the data? Is there a way, for instance, to shift the ownership away from the company gathering the data such that if ownerhship of the company changes, ownership of the data does not?

Lawyer here. Not my area of speciality but off the top of my head (and after thinking about it for all of 30 seconds) that strikes me as a surprisingly hard thing to do. Bankruptcy courts have extremely broad powers to administer the assets of debtors including disavowing contracts. There may be some way to do a structure where the data is escrowed with a 3rd party and the subject company is just holding the data as some sort of fiduciary, but I'm not sure anything like that has been tested. I would want to consult a bankruptcy expert to really figure something like this out.

What if Kite can't legally use the data for alternative purposes? I don't think disavowing a contract via a bankruptcy would let a company sell assets they don't own.

So Kite should be able to avoid this fear by asking only for limited license. For example, a license can expire after 1 year, or be untransferable (or perhaps expire at bankruptcy?).

Facebook does this to some extent: "This IP License ends when you delete your IP content or your account unless your content has been shared with others, and they have not deleted it."

Here's what Heroku does: "Heroku claims no ownership or control over any Content or Application. You retain copyright and any other rights you already hold in the Content and/or Application, and you are responsible for protecting those rights, as appropriate. By submitting, posting or displaying the Content on or through the Heroku Services you give Heroku a worldwide, royalty-free, and non-exclusive license to reproduce, adapt, modify, translate, publish, publicly perform, publicly display and distribute such Content for the sole purpose of enabling Heroku to provide you with the Heroku Services. [...]"


Super helpful -- thanks for chiming in. I think its really interesting that this isn't worked out yet. It feels like there should be a way to say to a consumer "I'm just looking after your data -- you still own it, etc. Even if I go bankrupt or get bought, I can't change that and the acquiring company should consider that when valuing me." I mean, banks do it with money (and other assets). One bank buys another and there's no way for it say "Now your money is mine! Muwahaha". Feels like it's a whole missing regulatory / legal area to me.

Disclaimer: I'm not a lawyer, but I did write my company's privacy policy with approval by lawyers.

A lot of companies' privacy policies have a section explicitly dealing with how data is transferred when company ownership changes. Sometimes this just says that all data will be transferred, but sometimes there are stipulations (for instance, my company doesn't sell or rent user data for marketing purposes, and its privacy policy requires that an acquiring company won't do that either).

Of course, there are edge cases (like what happens if the privacy policy changes) that complicate things, but the FTC has a pretty helpful discussion of all of this: https://www.ftc.gov/news-events/blogs/business-blog/2015/03/...

I raised this point with my lawyer recently. His view is that this is essentially impossible - any rules in the company articles can be rewritten or dropped at the whim of the acquirer.

Some technical solutions might be possible, in terms of allowing users provably to withdraw their data, but it would be messy and probably not bulletproof.

How about offering an on-site solution, where the client can deploy the Kite service on their own machines?

I would agree with this. Every client doesn't need this running, but having it running locally would be nice. I imagine, a business with many programmers all using this would get pretty cluttered with constant updates to this, but an onsite installation could easily clean that up.

Even if you have to ship individual backend modules (when more languages get supported). One place might only need the bash/python/js syntax whereas another might need only php, etc.

An on-site installation would also be able to refer to internal documentation, wikis, etc.

It's something we've thought a lot about. For anybody interested in this, shoot us a message at onprem@kite.com

Even though I trust you, there's no way anyone can guarantee that a hacker won't get into your database and get my proprietary source code.

I'm no security expert but one way I can think of is creating an encryption system which works like this: all my source code will be stored encrypted on your (non-ephemeral) databases. The decryption key will be stored on my computer, and it'll be transferred to the server when I run Kite and destroyed as soon as I quit Kite. The key will be stored in your server only in an ephemeral storage (in-memory database etc.)

Except those keys could still easily be vulnerable to Heartbleed style overflow attacks. The only real answer here is hosting your own service behind your firewall the same way people do with Github.

I like that you're planning to earn trust long-term, but, if customers are entrusting their proprietary codebase to you, some more concrete promises will be important, too.

There's a difference between trusting someone not to redistribute your work versus having it in writing. Both are important.


The issue with actual source being uploaded is going to be a deal breaker with a _lot_ of corporations. People will use it for stuff that's already OSS, no problem, but not for the proprietary stuff they may get paid to work on. Is there any possibility of processing the code on the client side so that what you upload is not the source, but just the data structures necessary for the index, such that the code itself could not be reproduced from what you have stored on your servers?

I agree. Why would they even need to upload/store the whole file? It seems like it's basing the suggestions on the line you're typing at that moment, so it doesn't seem that hard to just throw away the history immediately, and only deal with the 1-3 lines you're currently typing.

It indexes your code as well. All your project's libraries for example so it can give you suggestions relevant to your project.

We host GitHub, etc on site. Not because we don't trust them, but they don't have the resources we do to keep bad guys out.

Could you also answer the other part of the question: What is your revenue model?

Can I get an invite now? mariodel [at] gmail

Kite should just ask for a limited license like Heroku does (ideally more limited). Anyone worried about their IP should never use a service like Kite (or Heroku!) without looking at the legal docs — to ensure that they are not giving away their work for another organization to use or sell...

Kite doesn't seem to currently have any legal docs that I can see, but I assume that will rectified soon.

More detail in another comment: https://news.ycombinator.com/item?id=11499670 (Also, hi Adam and Alex! Congrats!)

What about passwords? Either from an ssh prompt, or in a static file like MediaWiki's LocalSettings.php.

They mention terminal passwords on their privacy page (short story, they don't read passwords if they aren't echoed on the terminal)

The ability to exclude files that I know contain sensitive data would be a very nice step. Even better if you explicitly state that retroactively excluding files will result in a deletion of the file from your servers.

It's a great concept for a tool, but I could never get it to fly at work.

Not windy enough for flying a kite? ;)

First, this is amazing. I want.

Second, I do a lot of code readings that include not shareable code, I would imagine a lot of developers from a lot of companies would be in the same position. From https://kite.com/privacy/:

* all the python files in your authorized directories are sent over the network

* everything you type in these files are sent as well

* all the terminal commands you are going to type (ouch ouch)

> Q: How does Kite secure this network traffic?

> A: As you would expect, all traffic goes over https.

Yeah unfortunately that is not enough, a MITM can also use https. How do you authenticate the server? Do you have certificate pinning?

> What information does Kite keep around on its servers?

Pretty much all the info I previously talked about, that you are now worrying about, is kept there, in clear (correct me if I'm wrong).

This is a big no-no at this point.

> Many developers have already chosen to trust their code to services such as Github and Bitbucket

Many developers also do not trust Github/Bitbucket with there code (and they should not) and do not store secrets there. And who would want github to have access all the terminal commands they type? This sounds like a nightmare.

At this point I don't see why anyone would use that, if not in a VM, with extreme care on what commands are typed in the terminal and what code is used with Kite.

I was really excited, then very disappointed to see the code I type is sent to your servers. This immediately prevents it from being used by many businesses, including my employers.

Super bummer :(

Please get the on-prem sorted out pronto!

We want you to be able to use it just as much! : )

There will be an adoption curve from early -> late adopters. Working through this is something we're committed to, and we know it will take time.

We're committed because we think it will be incredibly valuable to our field. We just can't imagine a future 50 years from now where programmers don't benefit from a smart backend helping them work.

So we start with step one today, and here we go : )

I'm not clear on why we need to upload the full codebase.

The Privacy Policy indicates that this is because their index of public code is too large to copy to the client machine. So why can't my machine just send queries as needed, or, even better, download the subset of the index relevant to my project?

Maybe it was easier to ship the "local code" search features by building on top of the existing public code indexing, which is server-side. But, despite the extra engineering work, client-side indexing for local code would definitely make a lot more sense for most customers.

We really did think a lot about this. It turns out that there is no clean separation between "index code" and "query for results". E.g. In Python if you see x.foo() you may need to know a _lot_ about the universe of Python libraries to do the type inference required to figure out what foo is in that particular expression.

I'm not sure that addresses the question; likely I'm missing something. Why does it need to send the user's entire codebase over? If it's a question of needing to analyze a given source file to infer types so query results are relevant, then why not do that inference work client side and ship back just the type information to the server where the query is run?

Even if that is a step too far, you could strip out string literals (e.g. API keys), and obfuscate variable, method, type, and file names while retaining a map on the client side so results line up.

That seems possible with a strongly-typed language, but for something like Python, they'd basically have to recompile the code on every keystroke, right?

Wouldn't they basically need to do this (compile the code) even if they have all of it?

From the privacy page:

Does Kite offer an on-premise option?

Kite does not have any plans to add an on-premise offering at the moment. If you are interested in an on-premise or AWS co-managed installation of Kite servers, please email onprem@kite.com.

nooooo! why does it do this?? It's a cool tool but it'll never fly in industry.

seriously, I don't think anyone is after your code.

I'm not concerned about people stealing my code. I'm concerned about losing my job, which is the consequence of transmitting proprietary code over the network to an unknown 3rd party.

Also plain legal implication. Our code could contain some protected information (transient debugging code mostly) and it is illegal to transmit it to a third party first because of DNA our company has signed, and then with regards to data protection act (credit card information, name, address).

At the very least, the service would need to be validated quite extensively.

Tell that to a tech Fortune 500's legal department.

Not even. I work for a 30 person company and I can't even share my own personal code with third parties.

Wait what

Yep... I'm exaggerating but I did trade some freedom to post whatever code I want wherever for a better salary. It's not uncommon for contracts to give employers ownership of any ideas/code an employee comes up with, or to specifically prohibit freelancing or contribution to open source.

For others reading this thread - there are only 8 states that provide restrictions on what these contracts can say regarding what ideas/code are owned by the company. In the other 42, most contracts won't care if you used company resources, or if your work is in an entirely different industry - the employer will own what you make if they're paying you for the month in which you made it. It's not very nice, but it's not like you're being cheated when you choose to take a salary.


There's plenty wrong about California, but this is one of the nice parts about living here.

I'm in a similar situation - had to have a detailed discussion with the our local legal counsel about what I can/cannot opensource. Long story short, for personal projects: a) I cannot use my company provided laptop. b) It cannot overlap with my employer's current or future business interests.

That sounds absolutely terrible... but to each their own I suppose.

Indeed to the latter bit. I'm completely okay with it; otherwise I wouldn't have signed the contract. Kind of irritating that someone downvoted me too.

Thanks to the good Samaritan who gave my point back :)

Also, it's totally reasonable for some companies to have restrictions like this. At my company, for example, the primary business is some really smart math guys coming up with market models. By programming these models, a programmer will get algorithms and ideas which belong to the company in their mind. Depending on the nature of a personal/open source project, one could even inadvertently use the company's ideas--putting the company's property out in the open and potentially benefiting competitors.

That doesn't change the fact that sending code to a third party is explicitly disallowed by many employers.

The problem is that it is not his code to begin with. So somebody cares: the employer, the owner of the code.

Hi everyone, we couldn't be more excited to tell you about Kite and get your feedback!

We think connecting programming environments to a smart backend will improve programming in a lot of ways, and this is just the first step. We'd love to hear your thoughts on where we should go from here!

This looks great! Loved the left-pad joke in there.

Could you elaborate on when it'll be available? Will you make it or parts open source?

We will begin inviting folks today. We want to control the upramp for two reasons: first, with desktop software, every time you take a step up in user base order-of-magnitude (1 -> 10 -> 100 ...) you see new bugs from odd desktop configurations. For example, we've already had one user whose machine wouldn't resolve "localhost" when docker was running : )

Second, we have to also manage backend scaling. We have some pretty strong systems engineers, but maybe because they're experienced they know what they don't know!

But we want everyone to be using it ASAP also.

RE open source, today we open sourced our client plugins (http://github.com/kiteco/plugins), and published instructions for writing your own. If you use an editor that isn't supported, it's about a 2-3 day project to create a plugin for a new editor. : )

Someone I know can only ping localhost as root on his Mac. Still haven't figured that one out hah

Also the hostname of "TayandYou".

And the Batman v Superman. lol

And the icons on the desktop.

And the rm -rf / joke ;)

I have a question that is not answered on your /privacy page. Do you anonymise the data you collect? I'm curious about terminal commands in particular, but I don't care so much if the usage information can be linked back to me.

I hate to say it but my first thought was "Hey it is Clippy[1] for developers"! But after reading on I think it is a really great idea and looks nice. I will certainly give it a try.

[1] https://en.wikipedia.org/wiki/Office_Assistant

One of the best demo videos I've seen

Are you open to new clients being written in addition to editor plug-ins to the existing client? For example would you be open to a client interface directly from Atom or the terminal instead of a side by side window experience?

Fantastic idea. Disappointed I can't use it now! I'll be waiting for use with Swift.

Thanks! FYI: if you sign up at kite.com then you'll get to enter the language you use, so we can get in touch when we get to swift.

While I really like the idea, there's a couple of no gos here:

    * Only supports python (as of now, I know you said you'll do others)
    * No Linux support (yet)
    * Uploads code to your servers
    * Wants me to sign up to a crappy newsletter
Really liked all the jokes in the video though. But I'm not convinced (yet), sorry.

And there's the issue that's I'd want to test it before recommending buying it to my employer. But I don't do enterprise Java for fun, so there's completely different languages and libraries between the open source projects where I could upload the code (but don't want to because fuck everything cloud, also I won't pay for it, because I'm not making any money) and the for work projects (where I personally don't give a shit, but all the libraries/frameworks the we/the customer bought are proprietary). And maybe even the customer wouldn't like his code being uploaded somewhere, but they usually don't really care about the code.

I don't want undermine the value of this product, but this seems like something that I've (and many others) sort of already solved by using products like Dash [1] and Alfred [2] together. You can easily and quickly find all info on docs while working right in Sublime Text, or while also using an IDE to read into functions throughout your project. And maybe I'm missing more what this product does, but that's just what I noticed based on the video.

[1] https://kapeli.com/dash [2] https://www.alfredapp.com/

I use Dash everyday and I think it would be disingenuous to say that it solves the same 'problem' that Kite looks like it's trying to solve.

I can certainly see some degree of overlap, but they seem like quite different programs.

Interesting. How are you connecting Dash and Alfred to arrive at something similar?

I have used both the Alfred workflow https://github.com/Kapeli/Dash-Alfred-Workflow and the Vim connection https://github.com/rizzatti/dash.vim in the past. They are useful and provide very fast symbol lookup.

Or, if you use SublimeText then DashDoc comes really handy.

[1] https://github.com/farcaller/DashDoc

So if there was an open source version of this, I'd use it. I would never trust it otherwise. Large corps will never trust it either, IT sec policies would roast you for using this. Instead I see an opportunity for IDE's to step up this space and provide this built in, without copying and keeping your source code.

"What information does Kite keep around on its servers? Usage information about which results you click on in the sidebar. Contents of all Python files in enabled directories."

Exactly, I really don't want to have to tie myself to a single company for my tools, and I definitely don't want to be handing over all the code I type to that same company. Having a company sponsored key logger just to remove googling for documentation/basic autocomplete is not something I'm interested in doing.

How does Kite protect against accidental API keys and passwords in source code (copy/paste) being shipped to them?

I was about to ask some questions about exactly what gets sent to Kite and what you do with it. Your privacy page[0] answered my thoughts and concerns quite nicely.

[0] https://kite.com/privacy

I was exited until:

    What platforms does Kite run on?

    For now, Kite only works on OS X, but we'll support Linux and Windows soon, too.
bummer :(

I started slinging code in Visual Basic 5 back in the day, and ran Windows until recently. I hope to be able to jump into building the Windows client soon : )

Fortunately all of our UI is html and javascript, so no windows controls needed : )

+1 for Electron sounds like you have a knowledge gap and are missing an easy cross platform opportunity.


It's good to polish it first for one OS. Honestly, I would have been disappointed with them if it were otherwise.

This looks very slick. However, as others have said, uploading all source code to your servers is a pretty serious issue when working on anything other than open source projects.

Also, when asking about editors while signing up, you listed "XCode". That's not the correct spelling, it should be "Xcode" (lowercase c). Also, you should allow for selecting multiple languages/editors. I selected Swift/Xcode because that's my day job, but I also use Swift/Vim in some cases, and I use Vim for languages other than Swift/Obj-C. In fact, I'm guessing Kite won't be nearly as useful for Swift/Xcode as it would be for other languages, because Xcode already provides a lot of this functionality (e.g. intelligent code completion and quick help for any API).

I wouldn't say Xcode is providing this... kite looks to be going much further in providing examples, alternatives, etc with a diff screen real estate philosophy. I welcome it.

Yeah Xcode doesn't do everything Kite does, but it does enough that Kite isn't nearly so compelling there. And Xcode has the benefit of being 100% accurate with its code completion and quick help, whereas it remains to be seen how accurate Kite will be on that front.

This is a great idea. I particularly think the trade-off between a separate tile vs. a traditional overlay is interesting.

While we lose things like auto complete, it might be less intrusive for the times when we don't need help. It will be interesting to see if we see a new generation of smart IDEs.

While I realise that this could be helpful with editors.I do not see much use with IDEs.and when it comes to languages like Android/iOS/WebApps ?People tend to use IDEs.(I am not making my opinion the general opinion here). And when people google things,Documentations are often the last resort.You tend to google the exception or the specific condition and end up on StackOverflow where some one facing a similar problem solved it by using something which was mentioned somewhere deep in the documentation. Also if documentation and a few examples could work in most real world apps,then we really wouldn't need sites like Stack Overflow.

Simple use case: the `man` and `help` command are useful when you have not been able to solve for your particular use case.Else I would still prefer doing a google search which would tell me how to scp a file with the syntax and placeholders instead of reading the documentation.

The examples would help in this regard.But then again I am not sure how much.Normally documentation list pretty straight forward examples which any editor/IDE with intellisense (even Sublime provides a bit of prediction with plugins) ,should be able to provide.

This also goes against the tendency of comparing.Normally while trying to solve a problem,I tend to open 2~3 similar 'answers' which help me drill down to my particular problem.Whereas here I would be restricted to only a single solution.I love the idea for the technology involved.But I am not completely convinced with the help that it could provide.

This looks really interesting. One question I have is how will you handle hotkeys? If I'm focused in my editor, I don't really want to have to move my mouse to select options suggested by Kite.

Excellent demo. Concise, simple overview of features but with enough little details (loved that rm -rf warning!) to keep me interested, and really well-edited.

I certainly hope there is a way to use Kite comfortably with minimal/no mouse usage.

Hi, Jay from Kite here. Agreed. We are definitely heading in the direction of keyboard shortcuts to access key features in Kite. For example, we have Cmd+; for switching between your editor and Kite. And more are coming up. We want you to get the most relevant info without leaving your keyboard!

The plugin API doesn't make it look likely.

This looks really cool. Bothers me having my code sent over, because i can't use it for a variety of use cases, but for my personal work i may give it a try. I've got two main desires though:

1. In editor pane. I use Vim in a full screen term, and really want want to deal with managing OS windows to allow a Kite window side by side with iTerm2. Perhaps an overlay would be solve this? That way it works for bash/etc?

2. Rust support. I'm learning rust lately, and this sort of tool could really benefit me with a learner-error-prone language like Rust. Based on the signup form though, Rust does not appear available.

1. Yeah, I agree. It's hard, and it's something we continue to iterate on. How would you feel about a global keyboard shortcut that would show/hide the overlay that was a separate application?

2. I love Rust. We will get to it even though it's (sadly) not at the top of our list right now.

Probably not the problem you're trying to solve but I'd like a better typing assistant as well as a co-pilot. For example, on the first line, I'd like to type "r" then be prompted for "import requests" Anywhere where the video had to be sped up is ripe for an advanced typing assistant. Typing entire lines like this seem unnecessary:

"from left_pad import left_pad"

I guess a super autosense along with Copilot would make for more exact coding.

Absolutely. We're going to be working on this for many years, and this is the kind of thing we're aiming at.

All "my BigTech Co won't let me use this at work" and other privacy concerns aside, this is an amazing tool for budding programmers or experienced ones using an unfamiliar language. Can't wait to try it out!

Well, definitely this is a great project but at the moment, for what i was able to see in the demo video, the main features are very similar to code completion and API exploring as i can currently perform with my ide (i develop mainly java based app so IntellijIdea or Eclipse give me quite the same help).

Don't want to be rude but it doesn't seem like this tool may currently enhance my productivity.

The main difference versus IDEs is that everything we show is informed by all the public code we've collected from the web. So e.g. there are a ton of arguments to matplotlib.plot and IDEs can show you them all ranked alphabetically, whereas we can show you common patterns of how people actually use matplotlib.plot in practice, which is often far more useful. (We'll show you the docs, too.)

Another example is if you type "load('abc.json')" without having imported json: there are hundreds of python packages that define a function called "load", but "json" and "simplejson" are by _far_ the most widely used, so we can suggest that you "from json import load". That's something you can't do unless you have a good model of a lot of real-world code.

Any comments on how your product and plans compare to https://sourcegraph.com/?

They seem to have a similar offering with an on-premise version, though lacking the smooth editor integration.

Definitely agree with you. Clearly, this is a tool that has the potential to make Python programming easier by adding functionality similar to what you can inherently get out of the box with a statically typed language + a good IDE. On the other hand, it also underscores Python's deficiencies as a language. I used to love Python, and still do, but I would never use it for a large project of any substantial complexity since I've seen how tremendously useful static typing is both for writing code and, arguably more importantly, reading and analyzing existing code. A couple of huge advantages are very robust auto-completion, the ability to quickly and immediately jump to the source code of a given type, and finding references to a given type across the codebase without ambiguity. Kite gets you part of the way, but the nature of Python means it'll never beat Java in these aspects.

Agreed that this looks awesome. Seeing code completion and context sensitive help for running terminal commands (e.g. netstat), not just programming languages, was what made me hit the sign up button.

You might want to check out the Fish shell. I've been using it for about a year and it supports completion for most commands by parsing their man pages. It's pretty nice.

I tried Fish a while back, and liked it very much. Trouble is, I can't roll Fish out across a work server estate.

Well, I could. But then I probably wouldn't be at work much longer. ;-)

> Left padding is so complicated that I've pulled it out into its own file, as you can see here.

Am I just really ignorant, or is this satire?

Its satire directed towards the recent npm package fiasco (there was a 'leftpad' library by the original author who pulled his packages)[0].

The authors make a few other witty jokes in the video as well.


Definitely satire.

Often I work in a full screen editor environment like terminal Vim with Tmux. Are you considering support for a command line client that could run in a split pane or window alongside my terminal editor?

If you implemented such functionality the suggestion experience could be more seamless for myself and those with similar workflows.

Supporting the variety of dev setups will definitely be one of our challenges. We've tried to start addressing this with 2 column mode (not shown in the demo video, but happens when Kite is in landscape mode; good for multimon), snapping to the side of your screen, and left/right-handed orientations.

This will be a long term effort. We have a lot more work to do here, along the lines of assisting with Z-index management, attaching to windows, etc.

Overall there's a lot to do! We will get there and are signed up for the long term.

This is similar to the Developer Assistant plugin for Visual Studio made by Microsoft: https://blogs.msdn.microsoft.com/onecode/p/devassistant/

(scribbles with mouse, clicks on things)

"When I open my terminal...."

I am evidently not the target market.

Do professionals actually identify with this stuff? Am I really that out of touch when I think that that much mousing around is CRAZY slow? And who switches back and forth from GUI editors to a terminal?

Noah from Kite here. We're prototyping various keyboard shortcut schemes; we're excited to ship whatever we settle on.

Slower for me, i use a laptop and trackpad. "Mouse" for me is very slow by comparison to keys.

The title is a bit misleading. This only works for Python and OSX.

Jay from Kite here. We're on our way to supporting more languages and operating systems. Stay tuned! Pro tip: when you sign up on our website, you can also specify which language you use so we can keep you in the loop when we get to it!

You folks have a big team, and have been working on this for two years now. Promising another language in the future doesn't mean the title is right.

It can't be used right now anyways, so if it currently doesn't support your favorite language, what does it matter? Who knows what it will support once we get an alpha/beta/release version?

Do you also tell the people that show you a prototype of their product that they are misleading you, because they claim to build an extended product out of that prototype?

Hmmm. Regarding one member of their team: "Prior to Kite, he was a tech lead at Homejoy, driving customer acquisition and retention." Not to spread tooooo much guilt by association, but didn't Homejoy just get roasted around here not too long ago for what thy did with the data on their servers? [1] Doesn't really make me feel the warm fuzzies for what they might do with all that data if they shut down.

[1] https://medium.com/@johnsalzarulo/didn-t-homejoy-shut-down-e...

So it's watching my bash terminal? Does it send my passwords on over to your servers when I ssh somewhere without keys?

No! If you can't see it (as visible chars) on your terminal then Kite is not seeing it.

It sees all the visible chars? Not just what I type? So every time I ls all of my filenames and dirs get sent?

That might be worse.

This seems dubious. Does that mean key loggers can't see it?

Is it really a launch if very few people have access to it in a private beta?

All this noise on Twitter/FB/HN/etc. doesn't help when we don't get a chance to play around with it. Just saying.

I thought I was signing up for Kite not for Kite's email list. Pretty misleading copy. Nowhere does it say "Coming soon" or anything to that effect.

Also, there seems to be no confirmation email.

Sorry if there was any confusion, but just FYI we're sending out the first invites today, so we're definitely "in motion".

I dream about a tool like this every time I need to look something up, which only happens about a hundred times every day. I NEED THIS IN MY LIFE.

But reading the kite.com/privacy doc is absolutely gutting. They copy and keep all your code, permanently. That's fine for an open-source project, but it's a deal breaker for anything else. So thanks for the brilliant idea, but I'll wait for it to be implemented in a way compatible with my everyday workflow.

This is awesome! I was going to build something similar, just for the terminal, but extending it to code editors as well makes total sense. And what an all-star team!

Nice tool, very nice demo video.

Unusable since I won't let my code be indexed by a third party. Also unusable since I won't let a third party have access to my shell. Imagine having your bash history stored centrally - a prime target for LEO/security services/black hats/data mining.

However - the code assistant is nice and I would love to have it running locally with a shared intelligent index - OSS based.

Do you support code linting or code smells in addition to completions?

Wow, this looks pretty amazing - well done with the demo. I'm super excited to try it out, how soon will it be ready?

We have some folks outside of the company using Kite already, and will be scaling that up as quickly as we can!

So, this looks pretty damn awesome, and I want to try it out yesterday! Seems like a lot of people are worried about privacy, and I guess I understand that. But I want this for when I'm learning a new language, and I honestly don't much care what happens with that code.

Also I think people are way too worried about their code. It's vanishingly rare that _the code_ is where the value in a business is. "But if I had Google's source code, I could run my own search engine and put them out of business!" Really? Could you? Because last I checked, Google has more engineers working on search than any other company on the planet. The stuff they do next week is probably going to improve their code more than what you would do by yourself for the entire year. And that's just the code, there's far more to search than algorithms.

>Also I think people are way too worried about their code.

I don't think anyone in this thread is worried about their code. The problem is that most of us work somewhere where we write code that isn't ours, and as such continued employment is contingent on us following the policies of the company. This generally include not sharing proprietary code.

I don't know everyone in the thread, so I can't comment specifically to them. You're right that getting fired over using this thing would be suboptimal. :)

I'm still eager to try it out!

I have long wished nodejs provides such helpful info, e.g. when I use the nodejs APIs I can get hints on the syntax and even some concise demo for usage, instead of opening a webpage and read online each time. Both python and PHP provide man pages for all their APIs etc, but no such thing for nodejs yet.

This looks fantastic. It would be great to get this working in Light Table.

Another commenter asked about hotkeys and I'd like to pile on to that sentiment – I've recently started using Vim (and Vimium) and it's really disappointing not being able to navigate by keyboard.

I think this looks great, but it reminded me of Lightable. Also rather than using Sublime text as a comparison, isn't PyCharm a better comparison. In my opinion Pycharm already provides a subset of functionality, in addition to several other features.

Great video :-) Loved the left pad joke and duly noted down your panama account information.

Autocomplete on steroids. This looks very cool and the demo vid was very well done!

Ok, this convinced me. At first I was skeptical, but looking at how it works compared to existing methods that need a ton of configuration, I believe it is at least worth a try.

More importantly, I believe it appeals to newcomers. We are getting into a world where learning the proper way of coding requires a lot more than the famous 10.000 hours, mostly because there are hundreds of standards. This tool might become a much nicer introduction for newbies, compared to digging through pages of documentations in search for the one example that satisfy your use-case (I'm talking to you, Python requests).

Looks great!

The only thing is I don't like the thought of having to share my screen real estate. Would it be possible to have some kind of navigable popup box within the editor?

Yeah this is something we're still iterating on. Though it wasn't in the demo video, there is actually a global keyboard shortcut to show/hide the sidebar without defocussing your editor. We're going to be experimenting more.

Looks like an amazing tool. Have to use it before i can tell more. Showing the documentation and example is cool and all, a very useful feature would be the search and analysis of the error messages upon program compilation/run. Most likely from stackOverflow.

This will make things so much easier. Reminds me of how2 https://github.com/santinic/how2

Great idea! But doesn't it work by intercepting keystrokes? What prevents Kite from reading keystrokes in other applications like a browser?

Super cool concept. One thought: when I'm using my laptop I have limited screen space. It would be awesome to be able to use Kite on my phone's screen, with my phone clipped to my laptop using something like this: https://tenonedesign.com/mountie.php

I don't understand why this needs to store all the typed code on their server.

Couldn't this data just be deleted once the lookup has run?

I imagine they're using all the code they get to update their 'what is popular' examples for all the subsequent lookups; or that's what they want to be able to do.

Of course it could be. They want to monetize it somehow.

left_pad.py - lol

This is amazing. Documentation pages that list methods alphabetically, or by some other random order, drive me crazy! Just being able to show me function calls by frequency and relevance would make Kite worth it. And there's so much more! Very excited about this.

This is really cool. It reminds me of OmniSharp which provides Intellisense to any IDE. It just runs as a background process listening on HTTP so adding intelligent autocompletion to a text editor is fairly easy. I like this approach a lot.

This is nice. Could we get a general description of what tech it is built on top of?

For the early sign up it be cool if you could specify that you write in multiple languages and across multiple platforms to get invites as soon as possible. This looks like an amazing tool for a more hands off teaching style.

What about support for VS Code?

Yes hopefully there will be integration for VS Code and Visual Studio. Though Microsoft already has a similar plugin, but this is purdier.

You might like ReSharper from JetBrains. I think it's the best I ever used.

Many organizations already upload their source code to GitHub. I could get behind a tool like this that could scan GitHub repositories and build an on-premise index.

Could I suggest some kind of per directory .kiteignore file?

Who wants to build an open-source cross-platform clone ?

The juxtaposition between seeing this on the frontpage today, and the VIM 8.0 announcement on the frontpage yesterday, is hilarious.

What's with the invite? Is this a service or something? What about this requires it to be proprietary and hosted elsewhere?

Justin kan mentioned the upcoming launch of this on snapchat the other day and I was intrigued. This does look awesome!

Maybe I'm behind the curve, but I still use TextMate, is there any chance a plug-in is in the works for it?

That's great, very exciting to have it internet based and to have it become smarter and smarter over time.

Does it search Stack overflow along?

Hopefully there will be a bit less traffic on Stackoverflow after using that. :-)

This looks great - can't wait to try it. Can I beg for an invite here?

No nerds were harmed in the making of this product.

So no questions asked on IRC?

At age 13, I completed my PhD at Google while having an internship at MIT, Stanford, and Berkeley. By age 15 I won the Nobel Prize while working at my tenth SV startup. My name is Franklin, and I drink wine on the weekends.

Very interesting. But closed. Not open.

Loved the humor in the intro video :D

This isn't that big a deal IMO. For a start, any non-trivial complex problem will probably not be included in kite, and the trivial stuff is generally memorised or easily googled.

This is really only spoon feeding.

I guess it depends on what a 'big deal' is exactly, but if it saves me all the Googling I do now then it'll be really useful (to me).

I don't expect them to really provide an intelligent artificial pair programmer, so you're right that this won't help with "any non-trivial complex problem", but that's okay with me.

I don't mind being spoon fed stuff I'm not interested in acquiring 'the hard way'. Do you also disdain autocompletion in your code editors?

Funnily enough, I've never used auto-completion. I've even gone through the trouble of deactivating it in Atom, but disdain is a strong word.

Also, it just occurred to me that Kite is basically a keylogger. Every keystroke is sent to their servers. That requires a lot of trust.

> Funnily enough, I've never used auto-completion. I've even gone through the trouble of deactivating it in Atom,

Super 1337 bro

Fair enough.

And certainly Kite could be a keylogger. So you're right that using it requires a lot of trust.

One thing I will say though. Is that I greatly respect 'the hard way'.

Meh – https://xkcd.com/378/

I certainly understand why it's enjoyable, and useful, to setup artificial challenges, but I have way too many projects I'd like to work on, and complete, to want to make programming generally harder.

I often Google for trivial syntax when switching back and forth between programming languages. A quick reminder without having to leave the editor window would be great. Also, typos.

Look into Dash. Even if you don't want to pay for the application (or can't run it on your platform), the docsets are free and ISTR there are some editor integrations for them that don't involve the paid app.

Or navigate to http://devdocs.io/

Or Zeal (http://zealdocs.org)

Or Zest (http://zestdocs.org)

Disclaimer: I'm (co-)author of both, and to be honest, Zest sadly isn't really maintained now.

I hope it supports TextMate...

I'm very impressed!

awesome. intellisense on steroids.

He should've put left_pad.py in a folder with an __init__.py to make it a proper package ;)

This is really cool, and I wish you luck. It has great potential for educational purposes as well! I'd like to download it and try it when it's launched for my personal projects; however, I won't be able to use this at work (no way I'd get buy in to upload our source code lol). It'd be great to see local indexing on the roadmap for the future.

This would be even more amazing if it was free or cheap.

It would be cool if they also open sourced it

What we be really cool is if you wrote an open source version. I'm sure if you started it, you'd find people to help once you reach minimal functionality.

I'm sure it will be one of many of the same kind of tool come time enough. I hope the team makes tons and tons of $$$. Also I can't wait to try it out!

This kind of tool destroys ones ability to program long sustainable production code. For a novice programmer this has tremendous negative effect on the learning curve. For an experienced programmer this tool is useless, because an experienced programmer will NEVER rely on "popularity" of some code-snippet out there in the wild. Programming is a very intense and deep practice and it is certainly not crafted using this kind of tools. This tool helps people write poor quality code for customers. Makes me wonder, what Knuth would say on this?

What about experts who are transitioning new languages or technologies? I'd say this tool has tremendous value for them. Also, as long as novice programmers understand the fundamentals (DS, algorithms) something like this won't have a 'tremendous negative effect' on their learning curve.

In my opinion Kite is promoting "coding by gluing" which certainly gets the job done in our economy but it is not yielding long sustainable code.

IntelliJ already has most of what this tool offers (but for java as opposed to python). It has auto-complete, quick access to documentation, quick fix suggestions (such as missing imports, etc.) and many many others not available in Kite at the moment. You wouldn't say IntelliJ "destroys ones ability to program long sustainable production code" would you? Because if you would, you'd be absolutely wrong.

IntelliJ certainly doesn't do this. IntelliJ and Kite have functionalities in common, which are fine. The other parts of Kite that IntelliJ hasn't, are problematic.

Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact