> if students are unwilling to learn, or are taking shortcuts, it will ultimately hurt them in the long run

That's a very limited, and dismissive view. If you allow students to use copilot, you're handing out certificates or diplomas to people who can't code. That will very quickly erode the value of your institute's certification, and with it, that of the other students. Otherwise, why not give everyone an MSc in CS? "It'll only hurt themselves in the long run".

> coding clever for-loops to perform algorithmic magic

A for loop for searching or summation is not algorithmic magic.

> maybe we should be measuring based on something else

No, why? Students have to understand the fundamentals. What those fundamentals are depends on the expertise. Once you've shown mastery, you can use more advanced tools. Teaching has always been like this, and for a good reason.

I'll be honest: has anyone here ever looked at a resume with an MSc in CS and said "Yep, I bet this person knows how to write code well"? Surely there are some research level jobs where a PhD in CS is necessary, but for most coding jobs, an MSc is just 2 years of missed experience where you're learning bad habits and antipatterns by never having your code used by other people in any strenuous way.

Certainly there are a lot of pros and cons to getting a BA in CS. But "learning how to write code" is not the major advantage of a university education, nor should it be.

Lets face it: There is so much theory crammed into some CS degrees, bachelor and master degrees, that students do not get to code much. Real coding is often learned by oneself in side projects or on the job. If students do not engage in side projects, how do we expect them to be proficient computer programmers out of university?

However, I see this as a failure of CS education. Our work is with computers. If we do not teach, how to use the tool we work with properly, then we have failed. I know CS is not only developing software, but also a lot about the theory, but it should not exclude practice of working with the most commonly used tool, which graduates will use, the computer.

Often even things are taught wrongly (do not get me started on "every noun is a class" kind of teaching of OOP), by people, who have not developed a single larger code base for decades.

That said, the industry has at least in that regard caught up a bit, and realized, that fresh from university most people do not write good code immediately.

Your argument is akin to saying "there's so much theory crammed into Astronomy that students do not get to look through a telescope much"

CS fundamentally is not about computers. It's about math and the flow of information between theoretical machines. Computers just happen to be a physical implement.

The idea that universities should teach to develop industry-fit individuals is just an extension of commodifying university education. Why not let the industry handle training for what they need their people to do, and let universities focus on their intended goal: create more university professors/researchers.

What about moving the responsibility (and financial risk) off students' backs and to the corporations that want to exploit the knowledge gained in a degree through apprenticeship and learning to code through experience?

We don't do it because it means trade schools for developers. Which, in truth, is exactly what 90% of what we do in the industry needs. But it's not glamorous; it's not a degree. Trade schools are for proles, and we aren't proles, now, how could we possibly be?

If taken seriously by universities, this would be a really hypocritical stance (on the universities' part).

CS departments are getting more students and funding in recent years precisely _because_ they are seen to be providing valuable education for would-be programmers and practitioners in the software industry. At the same time, some people like you perpetuate the myth that only the theory matters in a CS degree, and it shouldn't have any bearing at all with the demands of industry.

If what you propose is becomes reality, expect CS departments shrink to 10% of their current size and high school graduates skip university to take on apprenticeships. That's actually fine by me, but I doubt that's actually what you're envisioning.

The fact is that most universities these days _pretend_ that they can prepare somebody to become a software engineer by providing CS courses. That works to some extent, but as you say, the degree is generally more geared towards training researchers and academics. There's no fundamental reason why universities shouldn't provide a more practical-oriented "software engineering" degree of sorts, much like how they provide other engineering degrees (eg. Civil Engineering) as opposed to pure sciences. _Except that they generally aren't capable of doing so_, so they happily accept the sub-optimal arrangement that CS is the de-facto degree for prospective software engineers, while maintaining the whatever perceived high ground where they insist on teaching theoretical, impractical stuff because most of the faculty don't know a thing about developing software in modern environments. Basically they want to have their cake and eat it.

Software engineering has become such an important part of modern society that IMHO it should at least have the recognition and respect as such. Imagine somebody arguing that universities shouldn't provide Civil Engineering courses because, you know, it's just physics and applied maths, and civil engineers should just do a Bachelor of Science in Physics with a theoretical focus, leaving the practical knowledge of how to build a building to apprenticeships, because universities are too busy mentoring the next Einstein. Would you want to live in a society like that?

> Why not let the industry handle training for what they need their people to do, and let universities focus on their intended goal: create more university professors/researchers.

Which would result in universities eventually going out of business. An outcome I'm not opposed to, provided what replaces them functions better at training young people for real life.

> Your argument is akin to saying "there's so much theory crammed into Astronomy that students do not get to look through a telescope much"

I doubt, that a computer with its endless possibilities of using it and programming it, is comparable to a telescope. Also I did make note, that CS is not only about computer programming. So I am fully aware of the following:

> CS fundamentally is not about computers. It's about math and the flow of information between theoretical machines. Computers just happen to be a physical implement.

However, this does not mean, that universities should forego teaching about computer programming properly.

The alternative is, that we acknowledge, that first we study CS, but then employers finance year long computer programming classes for new employees, taught by people, who are actually good at this. The kind of people, who have lots of experience with different systems, programming languages, paradigms and teaching in general. That'll be expensive.

> What about moving the responsibility (and financial risk) off students' backs and to the corporations that want to exploit the knowledge gained in a degree through apprenticeship and learning to code through experience?

Yes indeed, that is one alternative.

I am saying, that employers should not expect and of do not expect good good to come out of people, who recently graduated from university and have their BSc or MSc. I don't think we are in disagreement about that point.

However, realistically this might lead to some employers being to much up in the clouds, only ever accepting employees, who were taught elsewhere and students having a really hard time finding _any_ job at all, because no one is willing to expend the resources to teach them. Furthermore, the teaching will probably be very one-sided, gaered towards what that particular employers uses in their tech stack. It is also highly unlikely, that most employers will have teachers, who are really that good, lets say up to Abelson and Sussman standards, if we may wish for something.

Imagine what happens when that person doesn’t leave academia to have the opportunity to learn to code. They just stay on. And end up teaching coding.

Depends on the school and depends on the person. The same way many companies in the US assume any grad from MIT is a good engineer, there are companies who look at resumes w/ an MSc and bump them up. From personal experience, MScs are particularly well-regarded in Brazil, for instance.

My question wasn't "do companies think that an MSc is good" but rather "Have you, personally, ever noticed that a candidate with an MSc was better than a candidate with equivalent experience without an MSc".

I think we can all agree that whether a company thinks something is good is completely unrelated to whether that thing actually improves your programming ability.

Yes, some times.

I've thought of going back for an MSc because it sounds kinda fun. Although probably in math rather than CS.

I never thought it would be held against me though. Seems weird.

I don't think it would be held against you? Especially if it was "going back" for it.

I think the uncharitable view people take of a Bachelors followed immediately by a masters but with no PhD is that they presumably weren't planning to go for a PhD, and given that, had the choice between a) doing 2 more years of school for very tenuous benefit and b) going directly into a job where entry level pays 1.5x+ the median household income in many states. And they chose a).

So I think the uncharitable interpretation is then that the person was afraid of entering the adult world or felt like they couldn't hack it.

Or that they washed out of a PhD.

> has anyone here ever looked at a resume with an MSc in CS and said "Yep, I bet this person knows how to write code well"

A Masters in CS doesn't tell me the person knows how to code well, but it does tell me that they are _more likely_ to

- Have had experience with a wider variety of algorithms, data structures, and general coding concepts

- Have written code to perform more complex things

- Written code for someone "outside of a classroom"

Certainly the last two are more directly accomplished by actually being in the workforce. However, an educational environment is a far better source for the first one. Now, I'm not saying having a Masters is necessarily _better_ for a developer but

- Given two developers with no work experience, one with a Masters and one with a Bachelors; I would generally assume the one with the Masters is a better developer.

- Given two developers with a similar amount of work experience, one with a Masters and one with a Bachelors; I would generally assume the one with the Masters is a better developer.

- Given two developers, one with a Masters and no work experience, one with a Bachelors a couple years of work experience; I wouldn't make any assumptions about their skill (they're certainly different, but I wouldn't assume one is a better developer than the other).

The same logic holds true for me when people try to convince me that a degree in CSci offers no benefit at all, and that it's better to just self study and start working. There's nothing you can learn during a degree that _can't_ be learned by self study; but there's a lot of things that are much more likely to be learned in an academic environment.

I'll generally rate an MSc lower than BA/BSc. (The exceptions would be if you needed the MSc to meet some visa requirement, or if you had an BSc in some weakly-related field beforehand.)

From downvoters: I would genuinely love to hear a defense of an MSc per se. What university has their shit together enough to actually accelerate/compress 2-4y of work experience into 1-2y years of academic project, which is what's always the claim? If all you're doing is the courses, those are accessible to 4th year undergraduates in every university I know.

To a person, everyone I've interviewed who did an MSc for the coursework had to because they finished their BSc with minimum effort and no one was interested in hiring them. Even worse is when you see 4y BSc, 2y work, 1y MSc.

This just sounds like you’re punishing candidates because you have an inferiority complex.

Many master’s holders started out thinking they might have been interested in research and decided industry was a better fit after seeing how the sausage is made. You’re “rule of thumb” punishes undergrads who were inspired to push the boundaries of knowledge in the field.

Cool personal insult - who has the inferiority complex here?

Your explanation can be reframed as "many MSc holders did not invest any attention to how the academy works during their BSc years" - why should I prefer them? My rule of thumb punishes such people compared to those with a broader view and better self-knowledge, yes.

> holders did not invest any attention to how the academy works during their BSc years" - why should I prefer them?

More inferiority complex. Some people give a shit about research and want to give it a try to see if they can make it work. There is no way you understand the nuances of how NSF or DoD funding works for your specific areas of research until you spend a lot of time in the weeds of grant proposals and reading reviews.

> My rule of thumb punishes such people compared to those with a broader view

This is a joke. Most BScs have no clue at all how academia works because they don’t care. They are absolutely not more enlightened to the nuances of career prospects in research in their areas of interest.

There are wide gulfs in the funding available depending on sub fields of CS. Research security and you’ll have plenty of money and opportunities at national labs, research arms of corporations, and academia. Go the P/L route and it gets dry pretty quickly.

> Cool personal insult - who has the inferiority complex here?

If you’re gonna try to insult, at least get it right. It would be a superiority complex if you wanted to view my post through the lens of pushing “how smart” grad students are. Yours is an inferiority complex because you’re taking out your lack of institutional credentials on anyone who has them with some convoluted logic about how people are stupid if they spend extra time in academia.

Graduate degrees aren’t meant to simulate work experience or take more classes, they’re intended for research. If your MSc lists no research and is applying for some sort of boilerplate frontend job, then I understand the hesitation, but normally one would take that experience into a cutting-edge field which focuses on innovation rather than making web apps as fast as possible. In jobs with an element of R&D, university research experience is very useful.`

I mean that's the theory, and it still seems true for PhD programs. (So I guess I'd include "ABD" as another possible exception if the program also granted an MSc but it feels like this is much less common than it was when I graduated - the many problems of grad school are now better communicated to undergrads.)

But for MScs, nah. The more focused coursework is directly accessible to undergraduates, and the projects are often like "port this 20yo tool to a new kernel version" or "build me a DB schema" or a few other things you'll have also done but 3x over in your first year of a real job.

> (...) the projects are often like (...)

This seems to suggest that asking a candidate with an MSc about their thesis might be useful

For most university CS labs, "research experience" comes down to 1) writing code in an overcomplicated way (because it's theoretically cooler) and 2) with no thought to future maintainability (because once the paper's published, the code gets thrown in the garbage). There are a few CS jobs where those skills come in handy! But in most jobs, even jobs doing "R&D", they're bad habits.

One does not typically return to undergraduate study after gaining a first BS degree. If you have a BS (or in my case a MS as well) in a not-directly related technical field and wish to study CS, you get a graduate degree. This often requires extensive additional coursework, in my case about 12 additional semester hours. Thanks for ranking people like me lower than someone with less education; I doubt I would enjoy working for you anyway.

I described precisely this case even before my edit and said it was an exception.

There are a lot of people coming with 4+1y or 4+2y purely CS/SE. That's who I'm talking about.

I'd quibble with the meaning of weakly related vs. not directly related, but fair enough.

I think an accelerated bs/ms might be another exception you should consider. (This being when a bs student can do another year immediately following to get their ms.) It makes sense on ROI as many companies have HR departments more likely to get you into the interview process, and then it’s often a slightly higher starting role. Also, from a knowledge standpoint, some graduate classes help practical abilities only. A 500-level databases course, for example, isn’t research-oriented. It just teaches more advanced topics that might actually matter in the workplace (an intuitive understanding of how/where to use an index, more complicated examples of projects with database connections, etc.). I fall into the case of your first exception, so I’m not actually sure undergraduate courses don’t teach these things. I’ve had a few 500-level classes that had absolutely no research orientation (“object oriented design and development” is another example of a class where the projects are just super-complicated examples of what you experience in industry). Pursuing an accelerated degree shows that the student wasn’t careless in thinking research was something they wanted to do.

Undergraduates in CS can fill their senior year with 500 level courses easily. Motivated ones also much of their junior year. Why would I take the applicant who did it five over the ones who did it in four? Worrying about the “MSc” label at the end for the same work is just credentialism.

Your confusion in this thread stems from the assumption that there is only actually enough CS to cover 4 years for a good student and 5 for a mediocre bs+ms. This is complete bullshit because the truly motivated undergrad would spend the senior year doing 500s and then the next year doing a bunch more for more breadth.

At any of the large CS universities, there are usually 4+ masters tracks you can go down (security, hpc, p/l, HCI, algorithms, etc).

Someone who quits with just a BS has no interest in going further theoretically. The absolutely did not cover all of the topics available - let alone get into research.

Credentialism is bad, yes. It’s important to get over prejudice that less education is worse, yes. Saying that an ms student with the same gpa (adjusted for graduate grade inflation) from the same university as a rule is worse than a bs is ridiculous. You’ve gotten things twisted past overcoming prejudice. It’s great that programming as an industry has lots of room for people who go without education, but your logic is delusional. Of course a 4 year student who accomplished the same as another who took 5 is better, but that doesn’t justify your statement that started this.

I agree with you on the value of a master's, but not about the some of the assumptions you make about the people who get them.

The most legitimate use of a MS degree is to move from one field to an adjacent field (eg math to CS). You know the basics, and you just need the advanced coursework in the other field.

A lot of people I have seen use a master's as a pure signaling tool, getting a high-profile University on their resume. For example, I have seen a lot of resumes with "BS from Unknown University" and "MS from Stanford/Harvard/MIT." In interviews, these students have not performed nearly as well as students with a BS from Stanford/Harvard/MIT, so I tend to discount the MS if I see this pattern.

Another common reason for the MS that I have seen is as an immigration tool. These people are usually pretty smart.

I got my MS directly after my BS without looking for work. In my case, your claim is that experience was actually detrimental to my knowledge, somehow erasing part of the value of my BS.

Maybe that's why you're getting downvoted. (Not by me, for the record.)

But my options aren't ever "candidate A with BSc" and "candidate A with MSc", it's "candidate A with BSc" and "candidate B with MSc". I don't assign negative value to the MSc per se.

I still don't get it, though. If I'm candidate b with the MS, does candidate a with the BS get preference?

A masters program is generally going to cover deeper theoretical subjects and will also give you stronger mathematical underpinnings in those areas.

If you're just looking for a code monkey to do your e-commerce react website then obviously work experience will always trump academia.

This comment reeks of elitism.

It’s also stating the obvious to some extent. Extrapolating “master’s” to “PhD”: a company designing and selling hardware verification software would be better off hiring someone with an algorithms PhD to work on their SAT solver. Plenty of self-taught folk are better programmers, but experience parsing the academic literature defining cutting edge SAT techniques is valuable here. This isn’t even really an “R&D” role in which the research experience is necessary. If you care about ad hominem aspects of the discussion, I identify as a code monkey.

Boohoo

Those aspects of a MSc are easily accessible to any motivated undergraduate as well.

Would you agree that all of the most important aspects of a bachelors in CS are easily accessible to a motivated non-student?

I'm not the OP, but I find a lot of the time the University program isn't too relevant and it's really the work experience that matters.

For example, I used to work in our IT department that handled the CS/Math departments at our University. We are a fairly well regarded school in the computing fields. However when we did co-op hiring of students for roles we had in the department there was one thing that stood out. People who only had programming experience through the school were not good programmers. It was the people who either had past work experience or had their own side projects who actually knew their stuff well.

At the end of the day I think CS degrees often go heavy on the theoretical and I find much of the theory is not applicable to the majority of CS/SoftEng jobs out there. I feel like someone who is motivated can gain the skills to be hirable in many software companies out there without going to school. I view things like co-pilot not as a problem. This will hopefully force the professors to make assignments that teach people more complex and work applicable content, rather than having them write generic intro to programming style cookie cutter programs.

Yes, and I hire lots of people without CS degrees. But I do see guided study accelerating the process. People who come in with no CS background do need some years to backfill missing knowledge, or they've some years in self-study on top of a 4y degree.

I don't see an MSc accelerating anything; in general one year of MSc seems worse than one year of work experience or one year of motivated self-study, and the students who do it were not the top tier of BSc students.

As my previous reply to your comments says, I disagree here. It depends on the nature of the courses. I think some graduate coursework falls into the category you’ve mentioned of “accelerating learning” of stuff that’s very applicable in industry. Sure, a research-oriented course about neural networks isn’t going to help someone write SQL. You could even say that an academic introduction to AI is a waste of time, but a survey of software engineering methodologies and the resources surrounding them (SWEBOK, CMMI 1.3) is going to help a student in industry over someone who hasn’t invested that time (and being guided in an academic setting is only going to help).

> a survey of software engineering methodologies and the resources surrounding them (SWEBOK, CMMI 1.3) is going to help a student in industry

Yeah, no. This kind of nonsense filling it up is precisely why an MSc in SE is useless.

Nonsense? If you know what distinguishes these things as nonsense, why didn’t they consult you when compiling these sources? Surely you could have helped them produce value. /s

Seriously though, you clearly need a reality check. SWEBOK is by no means necessary; it’s far from it. Saying it’s a complete waste of time shows that you have poor judgement on the subject. To your earlier point, having someone guide you through the poignant aspects of CMMI 1.3 is exactly the kind of value added by paying a teacher (where you would otherwise have to sift through piles of less valuable material). I only preach out of a sense of trying to help you and the others you have influence over. If you’ve actually worked yourself into a position where you hire people, and you’re not just pretending on the internet, you could do yourself a favor by being a little more open minded. Maybe consider that your original reply has been downvoted on a forum with “hacker” in its name.

Yes (in the field of CS, in other fields it might vary). That said, for me the most important difference was a thing around expectations: I felt fine to spend all the time I wished on the thing that became my thesis, to the exclusion of everything else, while at the same time not feeling the obligation to do so.

Libraries have always existed, yes.

> If you allow students to use copilot, you're handing out certificates or diplomas to people who can't code. That will very quickly erode the value of your institute's certification, and with it, that of the other students.

Very true. Like it or not, the reputation of educational institutions plays a significant role in candidate selection processes at many companies. If a company brings in 10 graduates from a local college and discovers that 7/10 of them can’t actually write basic code, they’re going to become more hesitant to bring in other graduates from that college. Meanwhile, someone who has Stanford or Harvard on their resume is virtually guaranteed an interview. Reputation matters far more than I ever thought it would.

>Meanwhile, someone who has Stanford or Harvard on their resume is virtually guaranteed an interview.

The funny thing is though - the CS programs at Stanford or Harvard are more research based than anything and hardly teach students to code. You are forced to take maybe 1 or 2 "learn to code" courses and everything else is just math/theory or assumes you can code anyways. And that shouldn't be a surprise; it doesn't take 4 years to learn to code; there are plenty of 15 year olds who can pass leetcode style interviews. Everything else you learn is far more valuable (although it's not a given that you will get a chance to apply it).

> there are plenty of 15 year olds who can pass leetcode style interviews

Are you sure?

Given the month of preparation that normal candidates do? Sure. That’s basically what they do every time they have to take a test about a subject that doesn’t interest them.

I've interviewed lots of new grads, and also observed my own classmates.

Most institutions have been granting CS diplomas to people that cannot code for decades.

Those people tend not to find long-lasting programming jobs.

Computer science is to programming what materials science is to construction. It produces really interesting new building blocks that actual practitioners can put to amazing uses.

But research scientists aren't necessarily great engineers, and engineers aren't necessarily great research scientists. That's OK though, it's why we have separate disciplines.

The CS program at my university, and most people I've spoken too, wasn't research oriented. At least not until the graduate level. Maybe at really respected places like MIT. Yes there were algorithms classes and such, but it was more about memorization than actually studying how they were made or how you would make a novel one. Final projects were always about building a real-world-ish application on a team.

But I'd say about 20% of the students that graduated still didn't understand things like references very well. They'd write their code with "foo.bar" and when it didn't compile they'd randomly change "." to "->" or add random asterisks around until it compiled.

(Classes were primarily in C++. We did some classes Java as well, and in my 3rd year Microsoft came in with a big sponsorship to change all the Java classes to C# classes.)

I mean, it's more like "woodworker" vs "carpenter." We don't ask people framing houses to plane their own wood. Most practitioners in our industry don't apply much fundamental CS knowledge.

After graduating most CS grads seem to forget foundational CS stuff anyways.

I never got a CS degree. So I trained myself. While working and also a lot of a year when I was unemployed during the .com crash.

Which only made me more frustrated to find that most jobs are just "you nail these two boards together" and most programmers are clueless about things like what the "relation" in "relational DBMS" means.

Your woodworker analogy needs a bit of work 8)

In construction - in the UK - there are first and second fix "chippies". First fix do the big stuff and second fix do everything after the plaster is dry(ish).

There are also cabinet makers and furniture makers, turners and several more wood related trades. Here, woodworker is a synonym for carpenter and carpenter is rarely used as a job title. Generally a specialisation is used.

I happen to own an IT firm and I prefer to see engineering qualifications on CVs (resumes). I'm a rather shabby Civ. Eng myself! I graduated just before the shit hit the fan in the UK in 1991 - recession, >10% unemployment (in Devon and Cornwall) etc. Can't recall what inflation was up to at the time but I think it was worse than now.

... So I ended up in IT

> If you allow students to use copilot, you're handing out certificates or diplomas to people who can't code.

I've given a couple hundred technical interviews over the last 10 years. This has been the case for a long, long time—even from fancy colleges.

While it would likely be prohibitively expensive, I really wish there was an independent board that would certify software engineering as a certification and required an oral defense in the same style as a PhD.

I recognize that it's kind of gatekeeping but it feels like more and more diploma mills are just hanging out degrees, not to mention all the coding camps out there.

As someone who has excelled in non credentialled industries and seen enough credentialed proffessionals coast by, I much prefer that companies do their diligence in hiring and firing, rather than ousourcing it to central regulatory body destined to ossify.

That's how it works in italy. The bad side is that to be an engineer you have to pay a yearly fee as well :D

Being an actual engineer (software) is different to just being a software engineer, and the former is very commonly highly regulated.

Being an actual engineer myself, I discovered that an official Professional Engineer license has little correlation with competence.

I don't really doubt that, and that's why I'm glad software in general places much less emphasis on licensing than other industries.

In italy software engineers are actual engineers.

I hope, for the sake of your software industry, that this only relates to calling yourself an engineer, and not to the general practice of software development. If you have to be a licensed engineer to work in software in Italy then that'd be a colossal drag on anything interesting happening in that industry.

No, that's not mandatory. Actually, only the big, shitty, consultancy shops (Accenture, Deloitte, etc) look stricly for licensed engineers, mostly because, funnily enough, they're usually hired for much less than the average SWEs. Actually there's kind of a shared feeling in the industry that licensed software engineers are dumbasses.

They want licensed engineers so they hire them as consultants and pay no sick leave and vacations.

Becoming licensed is mostly needed if you want to work on your own. You pay less taxes but have ZERO safety, so in theory you should earn much more and work for many customers. But those shitty consultancy companies hire consultants and pay them very little.

That's actually really amusing. Thanks for the insight!

Just raise the bar, rather than getting students to reverse an array, get them to do something more complex that is difficult even with the use of modern AI tools. We currently hand out degrees to people who couldn't write a program in raw assembly but it doesn't matter anymore. The world has moved on from that being a required skill.

Seriously. Take an rfc, change some of the clauses, and make them implement it.

I’ve used copilot to turn an rfc into code. It wasn’t perfect the code did need to be changed a bit but it was surprisingly close. And I ended only rewriting 4-5 lines that were totally wrong and 3-4 just for clarity. Out of like 40 lines of generated code.

Great. If an undergrad can find and rewrite those 10% of lines that are wrong, this is exactly what I care about to be an effective programmer. Especially since a good chunk of programming is reading code by former programmer (including self()) and interpreting and debugging. If they can use copilot with confidence to be more productive in getting to that point even more bonus points if I were a manager.

tbf I dropped out of a CE degree (and college) because I couldn't pass discrete math so I might not be the best logic programmer... I doubt I could pass leetcode interviews, I mostly work on the fringes of software dev.

I have never taken a job where I had to do a leetcode interview. My best job experience was one where I had no technical interview at all.

A lot of CS education is limited by students' ability to code.

If everyone was great at coding after a year or two, you could do a lot more algorithm analysis,theory, engineering principles, mathematics and other sciences, etc.

I don't think copilot is to the point where this is true.

Copilot mostly helps write boiler plate. It can also do a good job with adding correct comments to that boiler plate.

It's a tool that saves time and repetition. It's not a tool that's writing algorithms or solving problems for you.

Most people I meet with CS degrees cannot code. Not anything. Some can’t declare variables or get a file to compile.

Your actual problem is that you are stressing people out so badly that they cannot think, then asking things of them while expecting them to fail

I let people use their own computers, own IDEs, own programming language, own testing framework.

A CS degree is worth nothing. A masters is worth even less.

If you forget the basics of your favorite programming language under stress, you might not be suited for a programming job.

"you're handing out certificates or diplomas to people who can't code"

The diploma is not issued after only the 101 course.

So people who couldn't find a max value in an array will somehow excel at advanced concepts later?

You seem to have missed the point of this thread.

The problem an earlier comment expressed is that the student will sabotage themselves.

What else did you think that means besides exactly what you just said?

They sail through the beginning and splat in the middle, because they didn't have to learn anything in the beginning.

My comment is reponding to one that says the problem is that students get diplomas witbout learning.

I am saying that diplomas and certs are not a problem, not that there is no problem. The problem is what the earlier comment said in the first place.

Actually I'm not even sure that's a problem either in the long term, but it is the immediate problem. It may just be during a transition period while schools have not yet adapted to reality and are still worried about calculators in math classes. But at this moment, it's a problem.

Tools of abstraction like Copilot raise the threshold for what can be considered "fundamentals." Yes, knowing how to add, subtract, multiply, and divide is important. However, now that calculators exist, we can teach people to do so much more than simple arithmetic. So, too, with Copilot.

> Tools of abstraction

Isn't it a bit leaky to be called that?

> If you allow students to use copilot, you're handing out certificates or diplomas to people who can't code.

Many would argue that this is already happening. Moreover, we have no plan to stop it, so it's no good saying that we should not lose progress toward that goal.

This is why CS and coding are barely related.

Software engineering experience can be gained at a code school, or by working on open source projects, if you already know some coding from one of the many free online resources.

Copilot doesn't change the fact that trivial questions (such as 'write a Fibonacci function') can already be googled.

What I don't know (I can't try the 'free' Copilot without providing a credit card), is how well it understands unusual constraints and separate pieces of C++ classes that make the real programs we write.

For instance, a simple test would be: "write a fibonacci function but skip the number 5". Does it do the right thing?

Another challenge would be a C++ class with several fields. That's what our real programs look like: composite data objects, mixing several different algorithms together to implement complex behavior.

Maybe my data structure has a hash table of items, as well as a direct link to the largest item. When I say: "write the function to insert a new item in the list, and remember to update the largest item if it is larger than the current one", would Copilot do the right thing? Each step is easy in itself (adding an element to a hash, comparing an item to another one).

> Maybe my data structure has a hash table of items, as well as a direct link to the largest item. When I say: "write the function to insert a new item in the list, and remember to update the largest item if it is larger than the current one", would Copilot do the right thing? Each step is easy in itself (adding an element to a hash, comparing an item to another one).

In general it won't solve all your problems, but it's helpful for automating simple things like this (but you still need to test edge cases). With this prompt in Python (which I'm more familiar with):

  from dataclasses import dataclass
  from typing import TypeVar
  
  T = TypeVar('T')
  
  @dataclass
  class MaxDict:
      items: dict[T, float]
      max_value_item: T

      def add_item(

It completed:

    def add_item(self, item: T, value: float):
        if value > self.items[self.max_value_item]:
            self.max_value_item = item
        self.items[item] = value

This was my second attempt; first I called it `max_item` and the completion did something about comparing the key.

I (surprisingly) could not get it to generate a Fibonacci function that skips 5.

As a human, I’m having trouble understanding the problem description. What does it mean to “skip 5”? I’ve always understood the definition of a Fibonacci sequence to be, starting with 2 numbers (usually 1 and 1) the next number in the sequence is the sum of the previous 2.

So starting with 1 and 1, we get 2. 2 and 1 is three. 3 and 2 is five. What do we do from here? Do I not add 5 and 3? If not, then what do I add? 3 and 2 again? Do I repeat 3 and get 6? What does it mean to “skip 5”?

You compute the Fibonacci sequence first. Then you use that as the input for another function that produces the modified sequence by dropping 5.

I understood it to mean don’t print “5” but keep computing as if 5 were in it.

With the prompt

  // Print the fibonnaci sequence, except the number 5.
  int main() {

I got the result:

    int a = 0;
    int b = 1;
    int c = 0;
    while (c < 100) {
        c = a + b;
        a = b;
        b = c;
        if (c != 5) {
            cout << c << endl;
        }
    }
    return 0;

I've been writing code for nearly as long and man, you have to try it. It's more like autocomplete on roids than something that generates Fibonacci methods automagically.

I will try it at some point, but I have... feelings... about its abuse of open source licenses software as a learning set.

Also I work in Rust these days, and use CLion. Not sure if it would be much help in that environment.

It works fine in clion with rust.

The completions are often more “similar to stuff I’ve typed before” rather than “generate this working function”, and it’s not an order of magnitude improvement over just regular intellij completion.

…but I find it’s generally better.

Up to you if you consider it worth the cost of paying for it, and the macro completion is so-so, but “its rust so copilot can’t do it” isn’t really true.

I guess any "abuse" is the fact that any code reproduced verbatim doesn't carry the license under which it was originally published. But the reality is that what Copilot is most useful for is (semi) intelligent autocomplete, and generating functions that almost certainly exist as StackOverflow answers. It won't do any thinking for you when it comes to the bigger picture.

I left GitHub on the spot, and moved to Source Hut the day Copilot released.

someone can still mirror your stuff on github. I wonder if they should make a special open source license, that disallows use of the source code for the purpose of training something like Copilot.

> I wonder if they should make a special open source license, that disallows use of the source code for the purpose of training something like Copilot.

Since Microsoft uses material for copilot outside of licensing on the basis that it is Fair Use, that would probably have no effect in practice on whether or not the material is used in training something like Copilot. For that to matter, you’d first have to win a lawsuit on the basis that training something like Copilot requires permission of the copyright owner of the training material, to invalidate the premise of Microsoft’s action.

I don't care about all the handwaving here, it comes down to this.

The moment a fragment of code from a GPL'd or AGPL'd project shows up almost verbatim in someone's closed source or non-copylefted, etc. project, and someone proves it, sparks are going to fly.

And it's probably already happening, just people haven't discovered it yet.

How many years did the Oracle/Google lawsuit go on for? And in the end about a handful of a lines of code only tangentially related to the issue at hand?

Part of the lesson from that must be: employers should be telling their workers to say TF away from Copilot or things like it. And be careful in general when browsing source. License literacy is critical.

I don't touch it because I need to feed my kids. I don't need my career exploded. Overcautious? Maybe. I'll let someone else find out. I make a living in and around open source software.

> The moment a fragment of code from a GPL'd or AGPL'd project shows up almost verbatim in someone's closed source or non-copylefted, etc. project, and someone proves it, sparks are going to fly.

I'm hoarding popcorn and can't wait for that, honestly.

> License literacy is critical.

It's beyond critical, but most people I have talked says that they see the right to copy and use any code they see online. They don't care.

Building this open source corpus was not easy, and we need to defend it too. This is a culture.

Didn't it already happen that it spat out a function from Quake? And they then dealt with that by banning the particular function.

ISTR that Amazon's version of copilot has licensing info output too.

> Since Microsoft uses material for copilot outside of licensing on the basis that it is Fair Use, that would probably have no effect in practice

i think that any formal violation of an open source license would be very bad in terms of public relations - even if they can claim fair use.

Of note, a non-human cannot hold a copyright.

Anything generated by copilot, which if it is a derivative work, is not something that copilot can hold the copyright on.

From the auditor's perspective it doesn't matter if you copied it out of stack overflow, from some GitHub search, or copilot. You, the human, didn't check the license / plagiarism detecter. It is you, the human, claiming copyright on the work you are creating which may incorporate material from other sources.

Copilot isn't claiming fair use.

You could argue that the model that copilot runs from is a derivative work (and this is going to be interesting when it gets to the courts, because, frankly no one will come out the 'winner' on this when trying to explain it to a judge) - but that's not the code that a human is claiming to be their creative work and is ultimately the license violation.

Personally, I (not a lawyer), believe that copilot is on ok ground - but anyone using it needs to do their due diligence in verifying that the code that they've incorporated is licensed appropriately - just as if they've copied something from Stack Overflow - who knows where that copied was copied from.

I have less concerns with identifiable code from copilot than humans not caring about the licenses of their source material in creating human generated content.

They got it covered. Passed the responsibility to user in their official documentation.

It's not really an issue when you're a large software corporation; you already have mechanisms in place to check for license compliance in everything that ships, including F/OSS plagiarism checks.

I think that's the part that people who don't think it's worth the money aren't getting. This kind of system is godsend for the likes of Infosys, TCS etc. So the immediate threat is to the jobs there - but the side effect is that it'll make it all even cheaper, so we'll see more "outsourcing to the cloud", so to speak. Often to the obvious detriment of quality, but that doesn't seem to matter in this market.

> Someone can still mirror your stuff on github.

It is the nature of the beast, however I make my stance clear and stand by my principles. It is equally important for me.

If it's your creation you can make your own license. Copy and paste a license you like and add a few lines.

This fact solves many "we need this lib but it's too open" problems. The author can make a special license just for you if they want.

As in this example: https://web.archive.org/web/20130203112329/http://dev.hasenj...

How is it abusive?

There is a common trend of devs on HN getting angry that their work has been "stolen" to train copilot, While none of them raised the same concerns when everything else like art, music, literature, etc was used to train other models. Now that it affects them its a real issue.

Yes. It's especially amusing given that much of the other things you note are actually intended for commercial use (i.e. sales) from the start, unlike open source software.

I just don't understand the OSS community sometimes. "Software should be open and free (libre) for me to study and modify" includes what Github did for copilot. If you don't want your software to be free (in either sense), don't host it on an open source platform, especially one that makes it available gratis to the public.

There's possibly a valid argument that any private repo code that was used for copilot doesn't fit the proper definition of "open" (or gratis). But I haven't actually read the Github license around this, so I don't know.

Your argument fails to distinguish between "open source" and "free software".

Copyleft, free software, GPL style licenses do not have their source open purely for the purpose of studying and modifying. Their licenses also require that derivative works also be free and that such modifications be distributed.

Copilot does not comply with this. And so violates the spirit of those licenses, and probably also the letter of the law.

Open source is usually referring to the OSI definition which is essentially identical to the FSF “free software” term.

And by that logic, gpt3 and dall-e are also copyright violations. Except this has never been proven to be the case.

I literally use “libre” and “gratis” to make that precise distinction.

And it’s at best questionable whether copilot is derivative of the code it is trained on.

It's not about the distinction between “libre” and “gratis”, but about the distinction between copyleft and permissive.

All the software I write is Open Source, and I'm happy to have anyone use it for any purpose.

It was trained using source code whose licenses don't permit such usage.

In what sense? Copilot isn’t a derivative work in the sense these licenses usually are understood to mean. And given that they’re open source code bases I expect licenses to explicitly disallow things, and consider anything not explicitly disallowed as permitted.

> Copilot isn’t a derivative work in the sense these licenses usually are understood to mean

The phrase “derived work” is, IIUC, a phrase from copyright law. And you’d have a hard time convincing me that Copilot-generated code is not a derived work from its training data.

> And given that they’re open source code bases I expect licenses to explicitly disallow things, and consider anything not explicitly disallowed as permitted.

That is very much not how copyright and licences work. Copyright law gives the copyright holder the exclusive right to make copies of the work, making derived works, (and to do some other related things, like making a public performance of it, etc.), so to do any of those things, you need explicit permission, i.e. a license from the copyright holder to do it. A license is not a list of things you are forbidden to do; on the contrary, it is a list of things you are permitted to do, which you would not otherwise be legally allowed to do according to copyright law.

Sure, but there are things you can do without a license because they're not copyright violations. You can read the work, learn from it, and sometimes make quotations under fair use.

This is a novel scenario. It seems unclear how the courts will interpret it? Never mind what we think, will they decide it's a derivative work, or is it a transformative use?

https://en.m.wikipedia.org/wiki/Transformative_use

“Fair use” is, technically, not actually permitted by copyright law. ISTR that “fair use” is only a defense you can use when you are being sued for copyright violation.

Suppose we create a new AI image generator, and use as training input every image ever made of a Disney character (official images by Disney, that is, no fan art), including every frame of every Disney movie. Could we just use the output images of that AI however we wanted to? (Not withstanding trademarks.)

Looks like there is case law that fictional characters are protected if they are "sufficiently delineated." I don't see how that applies to code, though.

https://en.m.wikipedia.org/wiki/Copyright_protection_for_fic...

I guess we’ll find out.

This is unclear. I have never seen an open source license that was explicit about this. Seems like a grey area.

It's not even clear how often training machine learning algorithms on code results in copyright violations. CoPilot does have a setting to detect and disallow direct copying, but how well does it work?

This legal uncertainty is enough that I wouldn't advise using it, but maybe people who use it will be fine?

It's messy enough it's likely to end up a Supreme Court case in US (and I wouldn't want to be a party to it).

Europeans will probably preempt that with legislation.

I found carefully reviewing the suggestions it gave me more work than actually writing the code myself. Granted, I only used it for a day, but many of the suggestions were subtly wrong, needless inefficient, or used outdated/deprecated paradigms/standard library stuff.

I only used it for a language I'm very familiar with. I'd be a lot more hesitant using it for a language I'm less familiar with because I won't be able to spot the problems so easily.

I’ve really found no use for it at all. It doesn’t understand the codebase it’s being used in. I can’t tell it to write a service that gets data from another internal microservice, oh and make sure you do it in the same way the other services are implemented so that this passes code review… it can cough up slightly wrong answers to leetcode problems, but who has a job where that’s useful?

I've found it extremely helpful in writing highly repetitive code that's too complicated for a Regex find/replace. For example, I used it when writing a recursive descent parser in Rust for a hobby project.

I wrote the grammar in a comment at the top of the file, wrote and imported the AST enum, and wrote the first production. After that, I just prompted Copilot and it worked its way down the grammar, producing the parser functions one at a time. The CLion integration was able to consider the imported data structures as part of the prompt, so it even stored everything in the correct AST nodes.

For something like that, it's easy to verify that it did it correctly (through visual inspection and testing), and it allowed me to write the entire parser in about 2-3 seconds per rule.

Why not just use a parser generator?

I've used Copilot for a little while. I'm away from my computer at the moment but I'm very confident it would generate Fibonacci methods.

I don’t think they mean that it can’t, just that the better way to think about the advantages it gives an experienced engineer is more along the lines of “autocomplete v2”, i.e. a keystroke-saver.

Is it a keystroke saver if you need to review every line it proposes to you?

Yes because often times while I'm unable to recall the exact idiosyncratic keywords incantation that I need, copilot will retrieve them automatically. This saves me a context switch to MSDN docs or stack overflow.

It automates a great deal of boilerplate crap that you have to do especially in web frameworks such as angular.

Yes. For my part, it's a very obvious boost in exactly that sort of keystroke-saving way.

Here's an example I just now tried in the codebase I had open. I literally typed in the following Go in a function:

  mean := geom.Vec3D{}
  for 

Copilot then autocompleted this, me pressing tab to accept each line, to:

  mean := geom.Vec3D{}
  for _, detection := range filtered {
    mean.X += detection.X
    mean.Y += detection.Y
    mean.Z += detection.Z
  }
  mean.X /= float64(len(filtered))
  mean.Y /= float64(len(filtered))
  mean.Z /= float64(len(filtered))

It's not a perfect platform by any means, but it's also pretty useful for this sort of autocompletion.

I can picture autogen boilerplate being collected and distributed in versioned "community expansion packs" to popular languages, and I'm not looking for fragmentation like that in my tools. I really don't want my IDE involved like this.

I'd rather see Copilot used to expand existing libraries. Pulling potential additions to your own library off of Copilot would be an interesting twist on the situation. A hacktoberfest-alike based off this would be weird.

Nobody is forcing you to use it... Others like myself find it useful and to be a huge timesaver. If it doesn't benefit you, then just don't use it. Why must people be so vocal about not liking something? I get that you don't think it would be useful for yourself, but it sounds like you've never used it, yet are against it enough to come bash on it in a thread.

I think you should give it a try and see what you think about it. I was hesitant about it at first but was very surprised at how much time it could save me from having to look up things on Google. I've found it especially useful when I'm switching to a language I may be less familiar with. I can understand the basic logic of what I want to do, but would have to spend time looking up how to do it in this specific language. Orrr... I just have copilot help me out and generate such a solution.

It's obviously not going to be a tool that is applicable to everyone. Just like how many manual labour oriented contractors have a bunch of tools, each of them may have their own set of tools that slightly differs from the other person. That is okay, and there would be no need to try and bring someone else down for their choice to use a certain tool.

No, I think it's amazing. My point is why not write its suggestions down somewhere and cut out the middle man.

My concern is that I'd get locked into a specific IDE.

This is a good example of why I dread Copilot: even if Go specifically couldn't express this any more concisely, there is a language that can and Copilot's very existence makes it less likely for that other language to be used as much as it deserves.

Besides, the generated example seems to be missing code to gracefully handle the case where len(filtered) is zero. Maybe there's a precondition that prevents that from happening or maybe a division by zero is exactly what you'd want, but at face value it looks like the bot did a rush job.

Zero is gracefully handled; the mean of a zero-sized set is best represented by NaN, and this would be idiomatic in most languages' IEEE754-style handling.

Saturation is not. This is what really bugs me: If I'm going to drag in a billion GPUs of external computation (or a dependency, which is basically the same thing but with human brains), I want it to provide the hard algorithm I can't write, not the easy one I can. I am not limited by typing speed.

I also wonder what a "detection" is.

Agreed about saturation and the choice of variable name, but the code would trigger a division by zero and not result in NaN: https://go.dev/play/p/vYm4tSNEJ7M

(Also, in--say--Ruby and JavaScript 1.0/0.0 is Infinity and not NaN.)

Your playground link shows a build error. 0.0/0.0 at runtime will be NaN. And in basically every language, 1.0/0.0 is Infinity. But we're talking about 0.0/0.0.

Both good examples of coding where you should be thinking instead, though.

I think if anything there is far too much thinking going on here, for the tiny example I copied from the window I literally already had open with the function I was working on.

For what it's worth, Copilot (correctly) inferred a loop variable called "detection", I imagine based on similar usage earlier in the function. And there is already a conditional in place to prevent invalid operations; if I remove it I see a new suggestion:

  if len(filtered) > 0 {

This tool is far from perfect, but it very much sounds like you folks haven't used it. If that's the case, I would encourage you to research it like all tooling and draw some informed conclusions about it's applicability instead of making assumptions.

Not until there's a setting that can guarantee the automcomplete is based on verifiably license-unencumbered source that is automatically tracked in some kind of sourcemap that tells me which parts of "the code I didn't write" comes from which other project and file inside that project.

Until then, copilot is a giant liability that ensures I can't use it for code that my company ends up owning, nor can I contribute code I write with it to literally any open source project because in a very real sense: I didn't write it. I just assembled it from parts unknown, and those parts may end up being lawsuits.

As a hypothetical, what would that case actually look like? I'm suing you because I have a strong belief that part of the codebase of your personal project was assembled from code I wrote and didn't license permissively, so now I'm claiming ownership?

Obviously IANAL so this is largely conjecture, but until we _actually_ see how this would play out in court, I'm leaning towards this being less of a legal issue than folks here act like. For personal projects, I'd say the likelihood of some other engineer reading your code, noticing a similarity or duplication, and dragging you to court for it is near 0.

As hypetheticals:

- "you were hired to write code for us, not to use an autocomplete service that makes us liable for both copyright and patent lawsuits, I hope you like getting fired."

- "as per this project's license, we can only take code on board that you contributed under our license, but an audit shows that your PR/MRs contain tons of GPL/MIT/Whatever licensed code instead. We're going to have to back all of that out, and we're going to revoke your contributor status"

- etc.

If you don't know where the code in your autocomplete comes from (and copilot can autocomplete large swathes of code) then literally anything that comes out of "you didn't write this code" may apply. From fraud (depending on what contract you signed) to trademark infringement, to license violations, to even just simply misrepresenting your skills to an employer. As with all things, it's a sliding scale, but just because the majority of incidents will be on the bening part of the spectrum doesn't mean the litigating part doesn't exist, and that's what your legal department plans for.

Work for a big company? Good bet you're not allowed to use copilot. And depending on the company, not even "for your personal projects" because you might accidentally read someone else's license encumbered code that you would not have come up with yourself and may now open your employer up to "you stole our ideas instead of properly crediting/paying for licenses".

Copilot is a legal nightmare.

I would also be comfortable with a service that was willing to broadly indemnify me as the customer from copyright and patent claims arising from code generated by their service. I doubt that will ever happen either.

Yup exactly, and the ability to basically be fluent in any language.

RTFA :)

The grind you have to go through in a "google style" interview has nothing to do with the actual work you normally do. It's done to show 1) you will do large amounts of boring work without questioning the need for it 2) you got the fundamentals and you know what's there / when using something you can grok what's going on under the covers. Nobody needs to implement a sorting algorithm until they do - the risk of NIH and reinventing the wheel is high. When you do you need to have a good understanding of why

Nobody at Google wants you to do boring work without questioning the need for it. That would be a waste of money and time.

Hard interview questions are asked for the same reason hard questions are asked in SAT tests. The assumption is that if you can do a hard thing in the interview (implement a mutex using a semaphore or whatever) then you can probably write simple code too.

A few years ago I was working somewhere that had a low hiring bar. We were using an opensource graphql library to interact with some service. The graphql library didn’t expose some queries we needed, so I forked the library and added those queries.

After I left I heard through the grapevine that they were very unhappy with my work. They didn’t have anyone on the team who was skilled enough to maintain the code I wrote, so I left them in a bad place.

In retrospect I’m still not sure what else I could have done to solve the team’s graphql problems. Not that, but what?

I’ve seen many instances where a low-skill programming place either lives with a bug, or alternatively, adopts a solution that involves meticulously copy&pasting a workaround into 300 places.

Having said that, I know great, intelligent programmers, sone of who worked on compilers, who are simply bad in a whiteboard setting. Having a filter is necessary, I’m just not convinced a Google-style interview filters exactly the right thing.

The google-style interviews are certainly filtering for something though. An unfounded theory of mine is that the unfortunate eagerness of Google to sunset their products [1] might be a side effect of hiring for people that rather want to solve exciting coding problems and furthering their career by using X new language/framework, than maintaining legacy systems and keeping backwards compatibility, which might not sound so exciting.

[1] https://killedbygoogle.com/

Aren't all FAANG using these style of coding interviews? And if you look at Amazon, they have almost the opposite problem of pushing out too many (AWS) products.

They do build a lot of stuff. And don't have the muscle to keep it around and maintain it. That's not whay softwarr developers do, right?

I'm going respectfully disagree with you on the first point. Do you really need a Phd to maintain an internal javascript framework with a handful of users? (True story). A lot of the hires are made to starve the competition of good people.

The low hiring bar is relative. If all you do is put together crud apps and it's mostly stitching things together you might not even need a formal CS education. In fact a lot of people I know are wildly successful because they found their niche. They would have an exceptional bad time in a whiteboard setting.

Leetcode interviews have maybe just become an example for https://en.wikipedia.org/wiki/Goodhart%27s_law - as long as people aren't aware, it's a great signal, but after people catch onto it, it becomes a measure of something else

> After 30 years, actually writing code is perhaps the easiest part of my job. The mechanics is the easy part. The big picture thinking and figuring how to get it all together into a system is the hard part

This is the thing that you won't be learning about in a bootcamp. Coding is easy. Knowing what to code is hard, sometimes very hard. As is keeping it simple.

I code for a living and Copilot can't do the least part of my job, though it is possible it could find uses here and there around the fringes (perhaps not even then).

I'm coding audio DSP along the lines (real example here) of, "Given that the Dolby noise reduction system is deeply part of the sound of classic seventies and eighties recording, what parts of it can be generalized to make DSP processing producing the same general effects on the sound, and having done so, how should this be tweaked and adjusted to optimize for pleasurable results?"

This doesn't exist on Copilot. Damn near nothing I do for work exists on Copilot, and even if it (being an MIT-licensed public code library) gets slurped up into Copilot, Copilot has absolutely no way to determine whether a 0.8273 in the algorithm should be leaning towards 0.83 to brighten the sound of something happening, that it would do this, or why you'd want brighter rather than darker, or whether you are right in wanting this or would do better to go darker knowing that other things will happen to the listening experience.

Copilot's inability to do these things is much like Dall-E's inability to do art. There is much visualization and a striking absence of purpose or intention. With Copilot, it will do all the boring or common stuff for you. If that's your job, maybe you're not aiming at the strengths of humans, rather you are aiming at things too easy to automate…

> the hypothesis (propagated mostly by the Google-style job interview) that intensely coding clever for-loops to perform algorithmic magic (for things usually already in the standard library) is the best measure of the competence of a software developer

I think the hypothesis is, rather, that people who can successfully run that gauntlet are smart and motivated. The details of the problems they’re solving along the way are almost incidental.

In my master program in CS there was a guy unfamiliar with the concept of "find the minimum number in an array". Turns out he just had paid someone to do all of his assignment in the bachelor.

> using the standard library

This is why I care more that you can tell me about the algorithm at a high level, and reasons to use it. I don't care about you writing code outside of a computer. I don't write code on paper and then write it in my editor. I open up my browser, look up the documentation and refresh my understanding of the algorithm to make sure I am not overlooking anything. I do some research to figure out if I even need it, maybe there's some even superior way to do what I'm trying to do in my programming language at that moment.

This happened in mathematics about a decade ago when Wolfram Alpha came out. Lecturers started complaining that Wolfram Alpha could solve assignment problems with worked steps.

In both cases I think this is a real opportunity; we can let students get more quickly to bigger problems and systems thinking by leveraging these tools. It requires professors to start thinking innovatively about how to teach and assess these subjects.

And it does. Kids use wolfram alpha for a lot of the first and second year math courses in college now.

> After 30 years, actually writing code is perhaps the easiest part of my job. The mechanics is the easy part.

Actually Copilot can really help people like you.

Even if the mechanics is the easy part, knowing how to touch type and knowing an editor like vim, can help you get your thoughts from your mind into code faster.

Copilot can do the same thing. It can act as a super powerful text editor augmentor to get your thoughts into code faster.

Just because the straight ways of a racing course aren’t the most challenging, doesn’t mean that going faster on them won’t improve your racing performance.

I had a C class in my first year of bachelor and the exam was a paper exam where we had to write code by hand. I thought that was dumb but now it sorts of makes sense.

> Especially since this kind of thing is best done on the job by looking in a good textbook or using the standard library.

The way that job interviews continue to fixate on having a huge amount of information stored in your head, rather than your ability to be resourceful, is so frustrating. Oh well, maybe it's about time I go back to Leetcode and see how quickly I can grind out a recursive DFS algorithm...

I was skeptical of copilot, but since trying it for two months, I'm really impressed. It's a smarter auto complete. For $10/month it pays for itself in one day.

You have to be careful with the output it produces, as it often looks sensible but is wrong. Especially if it contains numeric constants. But on the whole it speeds things up, the same way good code auto complete does.

There is a copilot for that. I think you’re making programming seem more intricate than it is. It can build a crud app. It can build distributed systems. It can write web3 contracts. There’s not a whole lot besides that except maybe rare structural projects that don’t happen very often.

> I doubt I'm its intended audience. After 30 years, actually writing code is perhaps the easiest part of my job.

I think that’s exactly the intended audience. Copilot just cannot write code for me, but it’s really good at inferring patterns and giving me the next step.

All the boring repetitive coding has disappeared.

"our profession is in trouble"

Or the world will shudder at the Byzantine monters we can pump out day after day

I was not sure about copilot but it's amazing. You can put your pseudo code up in comments and it fills out the boiler plate. For things like plumbing info from the db to the front end it's amazing how much time it saves.

If you’re writing code you are the audience for copilot. Just try it

This sounds kind of creepy culty. I think it's the pushing "just try it" vs merely reporting "I like it".

It's not even free. I have to put in the credit card number to just try it.

It saves me more time than the monthly cost of the service. I've never tried things like Jedi or copilot before - I definitely enjoy it more than I thought I would.

If you're into being hydrated, water is great. Just try it

Exactly. Since it was so great, I didn't need to be told to try it, and what's it to you if I do or don't?

And if you were given an IDE from a young age with copilot you also wouldn't be told you needed to try it...

I’m tired of people saying things like that when they haven’t tried copilot. So now I’m just saying “try it, we’ll see how you feel after that”