[HN Gopher] Quantifying GitHub Copilot's impact on developer pro...
___________________________________________________________________
Quantifying GitHub Copilot's impact on developer productivity and
happiness
Author : idan
Score : 64 points
Date : 2022-09-07 17:01 UTC (5 hours ago)
(HTM) web link (github.blog)
(TXT) w3m dump (github.blog)
| gamegoblin wrote:
| The place where Copilot shines most for me is boilerplate like:
| up = foo.north() right =
|
| and then it will correctly suggest up =
| foo.north() right = foo.east() down = foo.south()
| left = foo.west()
|
| This requires a kind of linguistic understanding that is beyond
| basic intellisense. If you are just wanting it for basic
| intellisense autocomplete, it's not much better than JetBrains
| stuff. But for things that require linguistic comprehension, it's
| incredibly useful.
|
| For example, if I have a `Point` object with `x` and `y` fields,
| and I make a function called `lowest_point`, it knows I want to
| the point with the minimum `y` value. Because it knows the name
| `y` is most typically used for vertical direction, and the word
| `lowest` also implies vertical direction. This is kind of a
| linguistic/semantic knowledge that is not found in just the type
| system.
| madeofpalk wrote:
| What's funny is that i often see Copilot give you code that
| Intellisense/a type system will tell you is obviously wrong. I
| wish Copilot was more integrated with type systems.
| phire wrote:
| What's worse, is that if you make a mistake in the code
| leading up to it's completion (even one picked up by
| Intellisense), Copilot will now assume that you actually
| wanted the mistakes, and it's autocompletion will give you
| even more mistakes.
| gamegoblin wrote:
| Right now Copilot is just given the surrounding code, which
| is obviously limited. I suspect the next big jump will be a
| model that is given:
|
| 1. The surrounding code
|
| 2. The type/intellisense information of all the identifiers
| in the surrounding code
|
| 3. The class/function definition of any identifiers in the
| surrounding code
|
| I think #3 will be huge. There is a huge difference in
| Copilot's performance when dealing with types defined right
| above where you are writing code, and types defined in some
| far-away module or library. Right now if you use a class you
| defined in another file or adjacent project, Copilot can't
| see it. But your IDE has jump-to-definition functionality
| that could trivially be wired in to something like Copilot.
|
| The team behind Stable Diffusion (the image synthesis model
| that's been all over HN recently) have said they are working
| on stuff like Copilot as well, so I expect we will see a huge
| transformation in this space in the next year or two.
| neoberg wrote:
| It produces very good results with typescript. When there is
| an interface and I'm creating an object that implements the
| interface; it produces a result that fits into that type.
| madeofpalk wrote:
| This has not been my experience with Copilot and
| Typescript.
| baby wrote:
| Same with Rust. Sometimes I just have to write a comment
| saying "display implementation for X" and it will
| autocomplete with the trait implementation. This is extra
| magical because I don't need to remember the exact detail
| of the trait.
| dgunay wrote:
| It is definitely hit or miss, but I don't find it too
| annoying to just clean up the small mismatches that crop up
| sometimes.
| onemiketwelve wrote:
| Especially boilerplate in a language or framework you don't
| usually use. It's such a time saver.
| jlarocco wrote:
| I've never used Copilot, but are you worried it will only
| spit out: up = foo.north() right =
| foo.east() down = foo.south()
|
| And you won't notice?
| Gigachad wrote:
| This is why I stopped using copilot. It was very good at
| spitting out code that looked correct enough that I didn't
| spot the mistakes. And they were mistakes I'd never make
| myself if I wrote it manually.
| baby wrote:
| You have to think about it like auto complete. You don't
| blindly accept what auto complete tells you, your code
| would never compile otherwise, you read what it proposes to
| you and you modify what you don't like.
| antihero wrote:
| Not really no
| richbell wrote:
| Why not?
|
| From what I've seen GTP3 works exceptionally well until
| it doesn't, which can be easily missed.
| chrisseaton wrote:
| But I read the code, and I run tests.
| blibble wrote:
| does the bot write most of the tests too?
| chrisseaton wrote:
| Do you use it to write anything you want - even works on
| READMEs and comments! But like any good test - test it in
| a different way to how to implement it.
| simonw wrote:
| My rule using copilot is to use it as a fancy typing
| assistant which will frequently make mistakes - so you
| need to read everything it writes for you, and have solid
| test coverage too in order to avoid accidentally
| accepting a dumb mistake.
| Gigachad wrote:
| This made it useless for me because writing code is
| easier and faster than reviewing someone else's code. And
| less error prone.
| throwaway675309 wrote:
| No more worried than in the past if I made the same mistake
| myself by manually typing it or by copying / pasting and
| leaving something off.
|
| As with everything I always do visual sanity checks.
| baby wrote:
| I've been writing a compiler, and I guess enough people have
| because it always knows exactly what my enums should be, what
| the name of my types should be, what I should parse next, etc.
| croes wrote:
| >This requires a kind of linguistic understanding that is
| beyond basic intellisense
|
| Are you sure? If you would look at the statistics what comes
| after up = foo.north() right =
|
| I bet most of the time it's up = foo.north()
| right = foo.east() down = foo.south() left =
| foo.west()
| elcomet wrote:
| but it contextualizes it with adapted variable names, case
| and everything. That's very hard to do with only statistical
| analysis.
| gamegoblin wrote:
| Exactly, for example if I give it:
| hn_example_up = foo.north_garbage_jlakd()
| hn_example_right =
|
| it correctly spits out hn_example_up =
| foo.north_garbage_jlakd() hn_example_right =
| foo.east_garbage_jlakd() hn_example_down =
| foo.south_garbage_jlakd() hn_example_left =
| foo.west_garbage_jlakd()
|
| Even though those identifiers including random letters are
| certainly not in the training data. It can do surprisingly
| good basic reasoning.
|
| Here is another example. I give it:
| hn_example_up = foo.x_0_y_1() hn_example_left =
| foo.x_neg_1_y_0()
|
| So my function names are like referring to unit distances
| on the x/y axes. Copilot correctly figures out what I'm
| doing and completes: hn_example_up =
| foo.x_0_y_1() hn_example_left = foo.x_neg_1_y_0()
| hn_example_down = foo.x_0_y_neg_1()
| hn_example_right = foo.x_1_y_0()
|
| A few weeks ago I coded a rubik's cube solver that involved
| some very nuanced and weird spatial reasoning and was blown
| away by Copilot's ability demonstrate it "understood"
| concepts such as turning the right side down is identical
| to turning the left side up when viewed from the back of
| the cube, or stuff like that.
| phire wrote:
| Yes, ultimately it's just a really good statistical model.
|
| But it does a really good job, and it's not just matching
| code it's seen before. You can use any variable name. You can
| do this in a weird programming language which uses weird
| symbols for assignment and calls. copilot will probably see
| though it and give you a good prediction.
|
| You can probably even swap west for not_east in code
| elsewhere in the file, and it will manage to predict that you
| also want not_east here. And I guaranteed nobody has written
| code like that before.
| fferen wrote:
| > For example, if I have a `Point` object with `x` and `y`
| fields, and I make a function called `lowest_point`, it knows I
| want to the point with the minimum `y` value. Because it knows
| the name `y` is most typically used for vertical direction, and
| the word `lowest` also implies vertical direction.
|
| Unless, as in many systems, y=0 is the top and y increases
| downward.
| gamegoblin wrote:
| The magical thing is once shown examples of this in your
| code, or a comment saying as much, Copilot will adapt.
|
| For example, I just gave Copilot: # The
| screen is inverted, so bigger y values are lower def
| lowest_point(points):
|
| and it completed: # The screen is inverted,
| so bigger y values are lower def
| lowest_point(points): lowest = points[0]
| for point in points: if point.y > lowest.y:
| lowest = point return lowest
|
| Even if you write some code that _implies_ that bigger y is
| lower, Copilot will pick up on it.
| jollybean wrote:
| Yes, but no.
|
| It feels like magic because it really does get some things
| right.
|
| But I find that in most cases, because it's often wrong, you
| have to deal with wrong suggestions, and be _very careful_
| about what you accept.
|
| I feel that for most coding scenarios, it doesn't actually, in
| most cases, do that much but save a few strokes.
|
| I suggest that if there is 'high boilerplate' - then maybe
| there's upside.
|
| But for most things, it really doesn't help, despite how in
| some cases it's really magical.
|
| I turned it off and don't miss it.
|
| What I would however prefer is merely 'much better
| autocomplete'.
|
| Somewhere between 'ok autocomplete' and 'code suggestions' is
| the sweet spot for dev. that's not boilerplate.
| joshstrange wrote:
| Yep, for the boilerplate alone it's worth the cost for me. Oh
| you need to create a DTO from an internal object/class? Define
| the fields, write your `populateFromX()` function signature,
| maybe you have to type `$this->id = $input->id` and then
| CoPilot does the rest. And that's only one feature that I love,
| it does an excellent job most of the time writing the
| boilerplate for loops and the like based on my function names.
| Often I have to make few or no changes to it's code.
|
| At a worst it provides a great starting point to jump off from,
| at best it writes it for me just like I would have (matching
| style/variable naming/etc).
| gamegoblin wrote:
| One of the biggest boilerplate time savers for me is I have a
| service that maps HTTP requests to some specific class. I can
| paste an example HTTP request into a comment like:
| /* <http request here> The well-type
| class representation of this is: */
|
| And then it spits out a totally sane and reasonable class. In
| this file I already have 10+ classes already defined and
| manually touched up by me to rename some things, remove some
| fields, etc. So every time I add a new one, Copilot takes
| into account the previous examples and each addition requires
| less or no manual tweaking.
| joshstrange wrote:
| 100%. Most of my calls to the backend literally only need
| me to type the function name `fetchItems()` and CoPilot
| correctly uses my axios instance, set the return type to be
| my base API response wrapper, sets the generic in my base
| wrapper to be `IItemDTO[]` (it guesses this correctly
| probably 90%+ of the time), and even shoves the response
| into a Vuex store just like I would have done (same deal,
| guesses right about 90%+).
|
| It's not like it's a ton of work to do that myself but
| normally the way I would accomplish it is to copy an
| existing function, change the return type, change the url,
| change the Vuex store it puts the data into but with
| CoPilot it handles that perfectly for me the vast majority
| of the time. And if I'm doing CRUD endpoint I don't even
| have to write the other function names, it will
| autocomplete the "RUD" part after I write the "C" (and by
| write I mean I put `createItem(payload: ICreateItemDTO)` or
| similar and it writes the body of the first function as
| well).
|
| For me it's the perfect blend of "generated code" and
| "human tending" to get exactly what I need without having
| to do the repetitive/boring parts. It's been a joy to work
| with.
| DethNinja wrote:
| There is a real need for offline co-pilot alternative.
|
| Privacy concerns due to copilot makes it unusable for companies
| with closed source code.
|
| I'm hoping that eventually there will be a stable diffusion level
| solution in this field.
| wilg wrote:
| I use Copilot constantly and it's one of my favorite developer
| tools ever.
| davidkuennen wrote:
| Same here. It's such a great tool and productivity boost. Don't
| want to miss it anymore.
| _____s wrote:
| I really love Copilot. I had a trial, let it expire because I
| thought I wouldn't really need it, and then ended up paying for
| it. It's apparently got even better. For me, at least, it gets
| most things very right and takes a lot of mundanity out of day to
| day development!
| xwolfi wrote:
| I work in Finance, if I type a certain client name out in
| public, I can be fired for it. Can copilot work without the
| internet and within only a corporate network ?
| speedgoose wrote:
| No, you can already use offline alternatives like tabnine but
| it's not as good. But I guess better opensource models and
| tools will be available eventually.
| skneko wrote:
| You might be interested in IntelliCode from Visual Studio.
| It's an AI-guided autocompletion tool, like Copilot, although
| dumber and less powerful. It can run in local mode [0],
| looking at your existing codebase (opened solution) to feed
| future suggestions.
|
| [0]: https://docs.microsoft.com/en-
| us/visualstudio/intellicode/ov...
| avg_dev wrote:
| Not presently per their FAQ.
|
| > [...] The GitHub Copilot extension sends your comments and
| code to the GitHub Copilot service, and it relies on context,
| as described in Privacy below - i.e., file content both in
| the file you are editing, as well as neighboring or related
| files within a project. It may also collect the URLs of
| repositories or file paths to identify relevant context. The
| comments and code along with context are then used by OpenAI
| Codex to synthesize and suggest individual lines and whole
| functions.
|
| - from https://github.com/features/copilot/#faq - see "How
| does GitHub Copilot work?"
| j-sizz wrote:
| Wish the auth was better
| adamddev1 wrote:
| I mostly enjoyed my Copilot trial but one thing that really
| annoyed me was that it would often make suggestions for
| strings/keys that would be decent guesses by the AI but would be
| obvious type errors in TypeScript. Then it seemed a bit tricky to
| fight through the incorrect suggestion and get the old TypeScript
| Intellisense which was of course correct and what I wanted. Other
| suggestions by Copilot were awesome but when there was an obvious
| job for TypeScript it would be nice if Copilot would step back.
| For example I would often type:
|
| if (myTypedVar === "" <--
|
| Back off Copilot, let TypeScript Intellisense give me the correct
| suggestions. Or at least run the Copilot suggestions through TS
| first and make sure it doesn't suggest type errors.
| capableweb wrote:
| Sounds like it was your Copilot integration with whatever
| editor you used that was bad, not Copilot itself.
|
| The neovim integration worked very well, at least when I used
| it with Clojure and associated tooling. Could move seamlessly
| between what my Clojure tooling provides me with, and what
| Copilot did.
| matthewmacleod wrote:
| Indeed this is one of the more annoying features of the
| integrations I've seen.
|
| Running through the type-checker is an interesting idea - even
| if you didn't reject suggestions outright (which seems like it
| could frequently reject suggestions you actually wanted) it may
| be a useful weighting function.
|
| Similarly, running through eslint (or whatever linting system
| is appropriate) to avoid introducing obvious fixable formatting
| errors, like incorrect quotes, would be wonderful.
| NoraCodes wrote:
| I'll tell you right now, having my GPL-licensed code stolen has a
| pretty negative impact on my happiness.
| elcomet wrote:
| What if I read your code? Now I have memory of it in my brain
| and it will influence my next projects. Is it stealing?
| JamesBarney wrote:
| What snippets were stolen from your code and how has it
| affected your happiness?
| baby wrote:
| "wants to participate in and use open source, but is not happy
| when others use their code"
| bastardoperator wrote:
| Maybe you should switch to the Unlicense. I'm so much happier
| not giving a damn or punishing my users with pettiness.
| sergnio wrote:
| "The GPL is a free software license, and therefore it permits
| people to use and even redistribute the software without being
| required to pay anyone a fee for doing so."
|
| How is GHC breaking this license?
| NoraCodes wrote:
| GPL requires that derivative works - which, I argue, Copilot
| is - also be distributed under the GPL. Microsoft disagrees
| with my interpretation, and wins by default because I can't
| afford to sue them.
| mtlynch wrote:
| The GPL has requirements, and Copilot fails to adhere to
| those requirements. Here's an important one:
|
| > _You may convey verbatim copies of the Program 's source
| code as you receive it, in any medium, provided that you
| conspicuously and appropriately publish on each copy an
| appropriate copyright notice_
| blowski wrote:
| Say I drew a lovely picture and hung it outside my house for
| passers by to look at. I say "sure you can take a copy, no
| problem", they then sell a billion prints, and don't credit
| me at all.
|
| Legally, not stealing. Ethically? I'd call that stealing.
| tducasse wrote:
| Except that's not exactly what they are doing, is it?
| Following on your example, it'd be like selling the advice
| of someone who has seen a lot of these pictures passing by
| windows, with a very good memory and understanding of
| pictures.
|
| Github Copilot is not spitting out code verbatim, it's
| learning what code is, what shape it usually has, and
| trying to retrofit your own code onto the shape it thinks
| code should have.
|
| It's not like it's doing a query like `SELECT * FROM
| COPIED_CODE WHERE CODE STARTS_WITH "def my_func("`.
| JohnHaugeland wrote:
| Legally that actually is stealing. They must have
| documented reproduction rights. Misunderstanding a verbal
| comment will not fly in a court.
| jacobsenscott wrote:
| This is as credible as Ford doing a survey and finding out people
| got way more done with Ford trucks.
|
| I found copilot to be nothing but a hinderance and additional
| cognitive load. Not only do you need to think about the code you
| want, you need to review the (usually wrong) code copilot
| produces and either reject it or edit it to make it right. This
| is a lot more mental overhead than just writing the code.
| epolanski wrote:
| I donk't like copilot. I don't like sending MS my code, I don't
| trust it to not violate copyright, and from what I used it, it
| feels like using dall-e trying to phrase what I expect.
|
| Moreover writing boilerplate is rarely my daily activity, when
| it is, it's faster to copy paste from a similar file.
|
| On the other hand, few exceptional devs I know, the kind of
| rockstar 10x engineer, insanely productive and very smart about
| product and business, not just great coders, people that were
| leads in faang 15 years ago already and are responsible for
| high impact quality sooftware, speak very highly of it and how
| better it makes them, which crushes my doubts about copilot.
| jacobsenscott wrote:
| As a 10x engineer with 24 years of experience, I stand by my
| opinion that it is meh at best.
| valenterry wrote:
| How's Copilot with really good statically typed languages like
| Haskell? I haven't tried it out because most comments say it
| doens't even work well with typescript yet...
| speedgoose wrote:
| I use it almost daily with typescript and it works well. It
| will guess wrong some types once in a while but it's still a
| very nice help.
| siraben wrote:
| It is not even remotely usable with languages like Haskell, the
| code it generates almost never typechecks, IME. I think the
| primary reasons being lack of training data (there is far more
| Python code on GitHub than the entirety of Hackage) and that
| Copilot is essentially a language model that does not consider
| AST and type information at all.
| noizz wrote:
| I spent most of the trial hating Copilot and the way takes over
| my Tab key in Jetbrains software. It got in the way a bit too
| much. Every time I tried to use emmet shortcuts, live template
| triggers or anything muscle memory related, it would bring
| something else, so I had to undo, press Esc a couple of times and
| then continue with whatever I actually wanted.
|
| However, every now and then, there came a typed object or
| something mundane and Copilot exceled at it, so I decided that I
| want to find a way for it to coexist in a way that's as easy to
| use as pressing Tab to expand it. Lo and behold - I found an
| unused key below Tab (AKA caps lock), remapped it and now it
| doesn't get in the way and I can use Copilot's help only when I
| want.
| abdusco wrote:
| I liked using it. Though, most of the time, it was limited, in
| the sense that it could only offer completions using the code
| before the cursor as the context.
|
| I found it most helpful in setting up boilerplate in when writing
| tests. It could offer testing some edge cases before I could
| think of them.
| jeffbee wrote:
| "and timed how long it took them to write an HTTP server in
| JavaScript"
|
| OK ... interesting choice. This could mean almost anything. I can
| "write a web server" in a python 1-liner in about 2 seconds
| (ctrl-r SimpleHttpServer, enter).
| idan wrote:
| We'll be sharing some more about how we conducted this in an
| upcoming post! But no, the task was actually to write a little
| engine to process a limited subset of HTTP requests and return
| a valid response or relevant error.
| verdverm wrote:
| Would you pit it against my non-ai solution for the same
| problem? As a baseline to measure against? It would seem
| prudent to compare against other tools trying to alleviate
| the same problem, rather than just humans writing the code by
| hand
|
| https://github.com/hofstadter-io/demos/tree/main/full-
| stack-...
|
| I've since shortened that demo to be even faster for a user
| to complete
| mcluck wrote:
| Based on this task, I could write a snippet that would beat
| Copilot every single time.
| blibble wrote:
| it's a profoundly stupid task to measure to measure developer
| productivity too
|
| the hard bit of being a developer is deciding in precise,
| pedantic, utterly exact detail on what needs building to solve
| the business problem
|
| not bashing out the code in the editor
|
| now if they had given out a vague problem that ended up with
| the dev eventually producing a webserver in Javascript, then
| fine
|
| but then the difference copilot makes would be a much smaller
| percentage of the development effort
|
| I swear we're going back to the age of "lines of code written
| per hour", just now with arTiFiCiAL InTellIgEncE
| mgkimsal wrote:
| > the hard bit of being a developer is deciding in precise,
| pedantic, utterly exact detail on what needs building to
| solve the business problem
|
| The process seemed to involve have a test suite to write
| against. So, essentially, you had some/most of your "business
| problem" defined by acceptance tests (produce these outputs
| given these inputs). Some of that process may normally
| stretch out for days or weeks during meetings - condensed
| down, provided for you ahead of time takes some of that
| variability out.
|
| I was possibly a bit more surprised that less than 80%
| finished. Did they not commit code? Did they submit code but
| it didn't pass? Did they take too long? Was the 'did not
| finish' an explicit call on the dev side ("I'm done") or did
| they just stop taking input after X days?
| mgkimsal wrote:
| There was a test suite to work against, so some standard notion
| of things that needed to be in place to be 'working'.
| siraben wrote:
| I'm doubtful that the results from the experimental process can
| be used to draw such generalizing conclusions about the utility
| of Copilot. The task (implementing a HTTP web server in JS) is
| already something that would be over-represented in public
| codebases, this is like asking participants to implement two sum
| or a sudoku solver, of course the language model would have
| essentially memorized these types of problems.
| avg_dev wrote:
| I read the article and I have some skepticism. I think my
| skepticism is well-founded but it may well be the case that a
| machine will one day do my job. I don't believe that time is at
| hand, though.
|
| First off, I don't see a link to the "HTTP server in JavaScript"
| task. It's really hard for me to place much faith in their
| conclusions when it's not even clear what the problem definition
| was.
|
| Second, I believe that a lot of more senior developers and
| development managers who take secure development practices
| somewhat seriously will not be able or willing to use Copilot in
| any sort of proprietary setting. Here is a quote from the Copilot
| FAQ:
|
| > [...] The GitHub Copilot extension sends your comments and code
| to the GitHub Copilot service, and it relies on context, as
| described in Privacy below - i.e., file content both in the file
| you are editing, as well as neighboring or related files within a
| project. It may also collect the URLs of repositories or file
| paths to identify relevant context. The comments and code along
| with context are then used by OpenAI Codex to synthesize and
| suggest individual lines and whole functions.
|
| - from https://github.com/features/copilot/#faq - see "How does
| GitHub Copilot work?"
|
| I believe this makes it simply a nonstarter in a lot of
| environments. I am wondering if there are a number of places that
| have restrictions on sharing their code with a third-party but
| don't know or don't care and so end up using Copilot anyway. I
| believe that short-sighted thinking like this is more prevalent
| in shops that have low-quality code, and I believe that the
| higher-quality the code, the less likely someone is to use
| Copilot, simply for the "I can't share my code, even if I use the
| most restrictive no-telemetry settings" reason. Give me a self-
| hosted Copilot, and I may try it out in anger.
|
| Finally, I based some of my thinking on a recent Reddit
| /r/programming discussion of Copilot:
| https://old.reddit.com/r/programming/comments/wsnend/since_g...
|
| After reading those posts, and internalizing them with my own
| view of coding, I believe Copilot is not ready for my personal
| use. Again: licensing considerations aside (if you actually can
| feel comfortable putting them aside, see NoraCodes comment in
| this HN thread e.g.), it is simply a non-starter for anything
| proprietary in nature. I am also of the mind that any code that
| is of necessity very tedious to write is in dire need of real
| attention, most likely in the form of tests and quite possibly
| refactoring to reduce the boilerplate if at all possible. I
| believe in the value of linters and automated code analysis tools
| and in continuous integration that runs after every commit. Give
| me a self-hosted Copilot, and we'll have a real chance to see how
| it works out - until then it's not going to be a boon to
| programmers.
| avg_dev wrote:
| Replying to myself to add some things I think _are_ real boons
| to development:
|
| - https://pvs-studio.com/en/blog/posts/ - I don't code in C or
| C++ but I love to read these posts with the limited
| understanding that I possess
|
| - GitHub has another product which is good
| https://github.com/dependabot - similar in nature to Snyk,
| Renovate, etc.
|
| - there was an HN thread yesterday about govulncheck which
| looks pretty nice as a Go-known-vulnerability-in-your-
| dependencies checker
|
| - code review is invaluable
|
| - continuous integration and a build that passes and expands to
| cover new bug cases is really helpful
| chank wrote:
| I ended up disabling it in the beta. It ended up getting in the
| way more often than not.
| cesarvarela wrote:
| Same. Felt like pairing with a drunk programmer.
| verdverm wrote:
| Did it ever repeat "developers!" loudly?
| AzzieElbab wrote:
| Out of curiosity, what programming language you use, and what
| type of code you write?
| mcluck wrote:
| Not OP but I did the same thing. I build web apps using some
| combination of TypeScript, C#, F#, HTML, and CSS (or CSS-
| style languages). I spent about as much time correcting what
| it wrote as if I had written it myself. As someone else
| mentioned, it also interfered with proper inference given by
| the type system. Any time I wrote a more complicated
| algorithm (I work with a lot of graphs) I couldn't trust what
| it gave me. It's far easier to just gloss over some incorrect
| detail when the "shape" of the code is correct.
| nprateem wrote:
| I turned it off after it kept outputting go that looked
| feasible but wasn't valid because of the libraries I was or
| wasn't using. I only turn it on if I'm doing something
| mundane that it might be able to handle. The fact it
| overrides intellij's autocompletion was too annoying
___________________________________________________________________
(page generated 2022-09-07 23:01 UTC)