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
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.
> 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?
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.
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.
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.
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.
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.
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.
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).
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.
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.
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.
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.
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.
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.
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?
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.
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.
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.
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.
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.
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!
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. : )
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.
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?
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.
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.
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.
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 : )
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.
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!
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.
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.
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.
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.
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?
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!
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.
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!
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.
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 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.
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).
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.
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 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.
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.
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.
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.
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.
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.
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?
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.
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.
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.
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.
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.