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.
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.
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
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.
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.
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.
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?
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'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 have a feeling lot of the functionality of Kite will eventually get into Zeal type local tools.
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.
Far too many companies will never allow employees to do this.
Mine has 128GB, less than 10GB free.
That puts the cost of 10GB at about £2.
Given I don't need that extra storage, the cost for 10GB to me would be $300. Ouch.
While the RAM in many Macs is soldered into the motherboard, SSDs are not (they are often proprietary, though).
(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."
Also, do you have plans to support deletion of indexed data?
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. [...]"
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.
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.
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.)
There's a difference between trusting someone not to redistribute your work versus having it in writing. Both are important.
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!)
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.
Not windy enough for flying a kite? ;)
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.
Super bummer :(
Please get the on-prem sorted out pronto!
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 : )
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.
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.
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 firstname.lastname@example.org.
At the very least, the service would need to be validated quite extensively.
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.
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!
Could you elaborate on when it'll be available? Will you make it or parts open source?
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. : )
* 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
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 can certainly see some degree of overlap, but they seem like quite different programs.
"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."
What platforms does Kite run on?
For now, Kite only works on OS X, but we'll support Linux and Windows soon, too.
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).
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.
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.
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.
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.
2. I love Rust. We will get to it even though it's (sadly) not at the top of our list right now.
"from left_pad import left_pad"
I guess a super autosense along with Copilot would make for more exact coding.
Don't want to be rude but it doesn't seem like this tool may currently enhance my productivity.
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.
They seem to have a similar offering with an on-premise version, though lacking the smooth editor integration.
Am I just really ignorant, or is this satire?
The authors make a few other witty jokes in the video as well.
Well, I could. But then I probably wouldn't be at work much longer. ;-)
If you implemented such functionality the suggestion experience could be more seamless for myself and those with similar workflows.
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.
"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?
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?
That might be worse.
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.
Also, there seems to be no confirmation email.
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 really only spoon feeding.
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?
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.
Super 1337 bro
And certainly Kite could be a keylogger. So you're right that using it requires a lot of trust.
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.
Or Zest (http://zestdocs.org)
Disclaimer: I'm (co-)author of both, and to be honest, Zest sadly isn't really maintained now.
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.
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.
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'm still eager to try it out!
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.
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).
This will make things so much easier. Reminds me of how2
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?
Couldn't this data just be deleted once the lookup has run?
So no questions asked on IRC?
It would be cool if they also open sourced it