When it comes to programming you’ll find there’s rarely a right and wrong, it’s usually a question of “meets requirements” or not. She’s your customer and she says not to use breaks or it doesn’t meet the spec (be thankful that customers in the business world are rarely this specific).

I want to add that you should consider that your teacher is teaching you fundamentals of programming. break and continue are often options to use, but you shouldn’t try to solve everything with them. You are probably writing pretty basic functions in class right now where it doesn’t really matter, but with more complex problems break and continue constructions might easily get pretty messy.

Also your teacher has a plan what to teach you over the whole semester. If recursion is part of this plan it’s valid she wants you to understand the basics of calling functions first. This might be overkill for easy problems but it could help you to be a better programmer in the future.

She’s reasoning is that it makes the code harder [for her] to read, and breaks the flow of it or something. (I didn’t get her yapping tbh)

Fixed it for you. She’s imposing her preferences on the class. Unfortunately, it’s easiest to just suck it up and appease her than to fight it. Just my two cents.

Assuming C/C++, dare we even ask what this teacher uses instead of switch statements? Or are her switch statements unreadable rat’s nests of extra conditions?

This is a good life lesson. We’re all idiots about certain things. Your teacher, me, and even you. It’s even possible to be a recognized expert in a field yet still be an idiot about some particular thing in that field.

Just because some people use a screwdriver as a hammer and risk injuring themselves and damaging their work, that’s not a good reason to insist that no-one should ever use a screwdriver under any circumstances, is it?

Use break statements when they’re appropriate. Don’t use them when they’re not. Learn the difference from code that many other people recommend, like popular open-source libraries and tutorials. If there’s a preponderance of break statements in your code, you may be using a suboptimal approach.

But unfortunately, for this course, your best bet is to nod, smile, and not use any break statements. Look at it as a personal learning experience; by forcing yourself sit down and reason out how you can do something without using break statements, you might find some situations where they weren’t actually the best solution. And when you can honestly look back and say that the solution with break statements is objectively better, you’ll be able to use that approach with greater confidence in the future.

There is a school of thought that break and continue are just goto in disguise. It helps that these two are more limited in scope than goto and can be considered less evil. If you read the book Clean Code by Robert Martin (it should be required reading for all developers), you’ll see that he doesn’t like functions to be very long. I think his rule is no more than 4 lines. I try to keep mine around 10 or less with a hard stop at 20 unless it can’t be avoided because I’m switching over a large enum or something. If you put your loops into functions then you can just use return instead of break.

I did have a discussion with a teacher once about my use of early returns. This was when I had returned to school after many years as a professional programmer. I pointed out that my code has far less indentation than theirs and was simpler because of it and that it is common in the world outside of education. I got all of my points back he has deducted.

You’re going to hear some good and bad advice from your teachers. Once you have a job check out what the good developers are doing and just follow them.

deleted by creator

No, there is no benefit. Actually avoiding continue or break like statements makes code overly complicated.

Maybe she made a mental short circuit with constructs like set_jump and long_jump (which are evil).

I’ve 30+ years of C in my portfolio, with >1000 programs small and big, with millions of LOC, and I’d say her stand on break and continue is utterly stupid.

There will always be some instructors that are more dogmatic than pragmatic. All the same, there will be instructors that have pearls of wisdom to offer. Regarding the “break” and “continue” keywords, this lays somewhere in the middle.

One of the purposes of higher-level programming language is to remove from the low-level, machine-specific language of assembly, by offering other, more descriptive constructs, like “while”, “for”, and “switch”. In the C language, “break” is almost mandatory in a “switch” statement but only occasionally shows up in a “for” loop, excepting drivers. In Python, “break” only exists in loops, but there are lots of loops which can be replaced more efficiently with comprehensions, so “break” can be a sign of poorly organized logic.

If you can specify which programming language you’re learning, it would help to understand what your instructor might have meant to teach.

Using breaks is completely standard in some situations. Using breaks and continues can be very useful and still end in clearly understood code in some other situations. It is however, very easy to end up with nonsense code using both, and if its an introductory course just telling you to ignore them isn’t that crazy an idea.

Okay, I want to clarify two different but highly similar syntaxes: break; and break 3;. The latter syntax of break #number is fucking awful and you should never use it. In most languages it’ll only count loops and not conditionals so it can be extremely hard to tell how many levels of indentation you’re unrolling and it’s probably a code smell about having an overly complex function anyway.

However, good old single level break and continue are awesome and useful for making it really clear what preconditions exist in complex situations when looping. It’s much easier to read a series of elementary if break statements than one single gigantic if statement with half a dozen conditions.

Most tools in our toolbox are useful… oh, except goto (unless you’re programming in assembly language). Fuck goto.

I can understand telling you not to use break and continue if the point is to teach you to think about different ways to solve problems, but saying it’s because “it makes the code harder to read” is bullshit. Readable code flow is important, but if using those makes your code too hard to read, your problem is most likely that you’ve just written shitty code.

To get really into the technical weeds, what break and continue boil down to in the compiled machine code is a non-conditional branch instruction. This is just going to move the execution pointer to a different location in memory. Other keywords, such as if, elif, and else, will compile down to conditional branch instructions. Basically the same thing, but they have the added cost of having to evaluate some data to see if the branch should happen at all. You can achieve the same things with both, but the high level code might need to look different.

For instance, if you’re in a loop, continue will let you skip the rest of the code in the loop to get to the next iteration. Not a huge deal to instead make the entire code block conditional to skip it. However, the break keyword will let you exit the loop at any point, which is more complicated to deal with. You would have to conditionalize your code block and force the looping condition to something that would stop it on the next iteration. If you ask me, that has the potential to be much more complicated than necessary.

Also, good luck using switch without any breaks, but I’m guessing that’s not quite what your teacher had in mind.

In short, just go with it for now. Be creative and find a way to make it work to your teacher’s liking, but always try to be aware of different ways you can accomplish a task. Also, I don’t know what language you’re using, but if you’re in C/C++ or C# and you feel like getting really cheeky, it doesn’t sound like she disallowed the use of goto. It’s kinda like break with fewer safeguards, so it’s super easy to write broken code with it.

Well, sometimes it is possible to write a loop with break or without it, and in such cases solution without break is better readable. But if you don’t see a simple way to avoid using break, use it. It is very common, as well as having multiple return statements in function. Even goto can be a good solution sometimes if it points to label located below and not very far.

However you should avoid some antipatterns. If you write an infinite loop that is interrupted only by break, it is highly likely that you are doing something wrong. Nested loops with multiple breaks or gotos are very hard to read and debug. Such code usually can and should be rewritten for better readability and to avoid possible errors (occasional hangs, for instance).

When I need a break I make use of a break

A blanket rule against certain keywords sounds pretty silly to me. Break and continue are useful tools in the right situation. Sounds like it’s her preference that she’s decided to impose on the rest of you.

You could ask her what she expects as an alternative. You could show her code that uses it and ask how she expects you to rewrite it to satisfy her standards. Ask nicely because unfortunately just being right isn’t enough for some teachers, they have to like you too.

If she has a good answer, then do it that way as long as you’re in her class. If not well… sorry that’s just a terrible teacher.

This is too unspecific, not a focused question. Yes, break and continue break directed program flow. Like early returns do too. That doesn’t make them bad tools though. Use them where they make sense.