Real quick question about the "break"

Submitted ⁨⁨5⁩ ⁨months⁩ ago⁩ by ⁨UnRelatedBurner@sh.itjust.works⁩ to ⁨programming@programming.dev⁩

I’m studying programming, and I don’t agree woth my teacher. She basically said that if we use break (and continue too maybe) our test is an instant fail. She’s reasoning is that it makes the code harder to read, and breaks the flow of it or something. (I didn’t get her yapping tbh)

I can’t understand why break would do anything of the sorts. I asked around and noone agreed with the teacher. So I came here. Is there a benefit to not using breaks or continues? And if you think she’s wrong, please explain why, briefly even. We do enough down talking on almost all teachers she doesn’t need more online.

source

Comments

Sort:hotnew top

BrianTheeBiscuiteer@lemmy.world ⁨5⁩ ⁨months⁩ ago
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).

source
- UnRelatedBurner@sh.itjust.works ⁨5⁩ ⁨months⁩ ago
  As I said to xmonk: “u make me not wanna be a software engineer with this talk…”.
  
  This is a good mindset to be in however, thanks
  
  source
  - MajorHavoc@lemmy.world ⁨5⁩ ⁨months⁩ ago
    
    As I said to xmonk: “u make me not wanna be a software engineer with this talk…”.
    
    Yeah, and it gets worse before it gets better… youtu.be/BKorP55Aqvg
    
    source
mcforest@kbin.social ⁨5⁩ ⁨months⁩ ago
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.

source
ptz@dubvee.org ⁨5⁩ ⁨months⁩ ago

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.

source
- xmunk@sh.itjust.works ⁨5⁩ ⁨months⁩ ago
  Oh yea, definitely just follow the arbitrary preference. It’s actually pretty good practice for your professional life to learn to follow the occasional arbitrary bullshit… you’ll need to obey a depressing amount of it in most large companies (especially a shitshow like Google).
  
  source
  - UnRelatedBurner@sh.itjust.works ⁨5⁩ ⁨months⁩ ago
    u make me not wanna be a software engineer with this talk…
    
    source
    -> View More Comments
- UnRelatedBurner@sh.itjust.works ⁨5⁩ ⁨months⁩ ago
  You might be right, problem is that I’m already appeasing her by not writing in a language that I know, but in one that she knows. However I’m enlightened by your correction, might explain things.
  
  source
  - CookieOfFortune@lemmy.world ⁨5⁩ ⁨months⁩ ago
    It’s very rare in the industry for you to start something and have the flexibility to pick the language. You’re much more likely to be working on an existing system or expected to work with whatever the company uses.
    
    That said, there’s plenty of opportunity to make your own decisions. Having to follow arbitrary style rules is hardly a consideration (actually you’ll find it’s hard enough just to have consistent arbitrary rules within a company).
    
    source
Redkey@programming.dev ⁨5⁩ ⁨months⁩ ago
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.

source
- gazter@aussie.zone ⁨5⁩ ⁨months⁩ ago
  It’s a very good lesson- to the point where I wouldn’t be surprised if the teacher is deliberately putting an arbitrary restriction on the assignment.
  
  If you want to have a career, the people that pay you are going to make you do things that you consider to be ridiculous. That’s work, that’s life. You’ve got three options- Just smile and nod and do it their way, get huffy and tell them that you don’t like their yapping and you’ll do their project your own way, or politely suggest there may be an alternative way, and ask if they are willing to be flexible with some requirements.
  
  source
  - ck_@discuss.tchncs.de ⁨5⁩ ⁨months⁩ ago
    
    It’s a very good lesson- to the point where I wouldn’t be surprised if the teacher is deliberately putting an arbitrary restriction on the assignment.
    
    It’s not arbitrary. When you start out on a profession, the first thing a good instructor does is make you unlearn the things you already think you know before teaching you the things you need to know. Think of it this way: When you pick up a golf club and start hitting the ball, you’ll drive it left and right. First thing you’ll be taught is to only hit straight. Even if you think you should try to drive a curve ball, a good teacher will not allow you. Only when you have mastered the basics will he teach you to drive curved balls. So ignore your teachers advice at your own peril, but it will most likely set you up for an expert beginners career.
    
    As a closer, I can tell you this much: I received the same advice almost 20 years ago and now, after being a professional developer for two decades, I can not recall more than five times when a break statement actually made more sense than to rethink the algorithm.
    
    source
    -> View More Comments
  - UnRelatedBurner@sh.itjust.works ⁨5⁩ ⁨months⁩ ago
    I’ve never considered that she might just be very smart. You’re very optimistic. Filled me with hope out of nothing. Thanks!
    
    source
- UnRelatedBurner@sh.itjust.works ⁨5⁩ ⁨months⁩ ago
  last part gave me something of a mindset change, for the better. I’ll try being a little less of an idiot then c: Thanks!
  
  source
litchralee@sh.itjust.works ⁨5⁩ ⁨months⁩ ago
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.

source
- UnRelatedBurner@sh.itjust.works ⁨5⁩ ⁨months⁩ ago
  This rule will apply for C# only I think (I hope). I also like your optimistic points, thanks.
  
  source
samus7070@programming.dev ⁨5⁩ ⁨months⁩ ago
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.

source
- RustySharp@programming.dev ⁨5⁩ ⁨months⁩ ago
  
  break and continue are just goto in disguise … use return instead of break
  
  An if statement is goto in disguise. So is a return.
  
  Some would argue having 10x 4-line functions are worse for readability and debugging than a single 40-liner, because to actually understand the code you have to jump around all over the page (another disguised goto - for your eyes!)
  
  source
- dgriffith@aussie.zone ⁨5⁩ ⁨months⁩ ago
  
  you’ll see that he doesn’t like functions to be very long. I think his rule is no more than 4 lines.
  
  Four line functions? Sounds like a codebase adhering to that rule would end up as a nice thick function soup. It feels like… I dunno, those database programmers that like normalising databases to the Nth degree.
  
  If you put your loops into functions then you can just use return instead of break.
  
  And that just sounds like abusing the concept of functions to replace standard flow control that your language provides.
  
  But hey, I use C and on the rare occasion I sneak a goto in there, so I’m not qualified to pass too much judgement.
  
  source
  - samus7070@programming.dev ⁨5⁩ ⁨months⁩ ago
    Yeah, it’s a bit on the extreme side for me. 10-20 is what I prefer. I find that if I follow that rule the code is easy to come back to later because the things a function does are more clearly defined. I can look at a higher level function and it’s filled with function calls like readX, createY and doThis. I don’t have to look at as many blocks of code and try to remember what the intent was.
    
    source
- arisunz@lemmy.blahaj.zone ⁨5⁩ ⁨months⁩ ago
  I wish people stopped praising a book that has been repeatedly debunked as dogmatic, outdated, nonsensical garbage.
  
  No, do not bother with Clean Code. Been there thinking it was some bastion of truth that just went over my head. It’s not. Fuck uncle bob.
  
  source
  - UnRelatedBurner@sh.itjust.works ⁨5⁩ ⁨months⁩ ago
    I don’t know your or his source, but warning me before I read it deserves a thank, so thanks for saving me time.
    
    source
    -> View More Comments
- UnRelatedBurner@sh.itjust.works ⁨5⁩ ⁨months⁩ ago
  
  If you put your loops into functions then you can just use return instead of break.
  
  I wonder if I can bypass her rule with this, thanks.
  
  source
m_r_butts@kbin.social ⁨5⁩ ⁨months⁩ ago
I suspect/hope she's not "against" using break and continue as much as trying to teach your brain to solve the type of problem at hand without relying on breaks.

Like this

const int JUST_THE_WORST_NUMBER = 13; for (int i = 0; i < 100; i++) { if (i % 2 == 0) continue; if (i >= JUST_THE_WORST_NUMBER) break; Console.WriteLine(i); }

could effectively be rewritten like this, which I think actually is clearer in a way:

const int JUST_THE_WORST_NUMBER = 13; foreach (int i in Enumerable.Range(0, 100).Where(i => i % 2 != 0).TakeWhile(i => i < JUST_THE_WORST_NUMBER)) { Console.WriteLine(i); }

Treat it as a thought exercise and just do it her way. Like someone else said, it's also good practice at unhappily conforming to your organization's standards and practices.
source
- xmunk@sh.itjust.works ⁨5⁩ ⁨months⁩ ago
  It might just be an insufficient amount of whitespace, but your second example seems much harder to parse. As someone who regularly writes extremely dense functional paradigm code - you can always use more newlines.
  
  source
  - m_r_butts@kbin.social ⁨5⁩ ⁨months⁩ ago
    Fine:
    
    var enumerable = Enumerable.Range(0, 100) .Where(i => i % 2 != 0) .TakeWhile(i => i < JUST_THE_WORST_NUMBER); foreach (int i in enumerable) { Console.WriteLine(i); }
    
    source
    -> View More Comments
- UnRelatedBurner@sh.itjust.works ⁨5⁩ ⁨months⁩ ago
  Yeah, thanks. I think I will do that. Thanks for the example.
  
  source
Treczoks@kbin.social ⁨5⁩ ⁨months⁩ ago
No, there is no benefit. Actually avoiding continue or break like statements make 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.

source
zib@kbin.social ⁨5⁩ ⁨months⁩ ago
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.

source
- TerrorBite@meow.social ⁨5⁩ ⁨months⁩ ago
  Also, good luck using switch without any breaks, but I'm guessing that's not quite what your teacher had in mind.
  The teacher, probably: “You must always put a switch in its own function! Then use return at the end of each case.”
  @zib @UnRelatedBurner @programming
  source
  - zib@kbin.social ⁨5⁩ ⁨months⁩ ago
    Good point, that is a valid way to do it sometimes, but it's extremely situational and trying to do that for everything would be absolute nonsense.
    
    source
    -> View More Comments
- UnRelatedBurner@sh.itjust.works ⁨5⁩ ⁨months⁩ ago
  thanks for the breakdown, I don’t know if my grade would be too high of a sacrifice to try goto, but I’ll have it in mind. thanks.
  
  source
blargerer@kbin.social ⁨5⁩ ⁨months⁩ ago
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.

source
- pixeltree@lemmy.blahaj.zone ⁨5⁩ ⁨months⁩ ago
  I seriously think that if you’re using a continue, at best it’s just a bit less clear way to structure something, and at worst the codes a kludged together nightmare. There’s definitely good uses for break, but if you think you need a continue you should take a step back and reevaluate what you’re writing.
  
  source
  - UnRelatedBurner@sh.itjust.works ⁨5⁩ ⁨months⁩ ago
    You’re the closest to agreeing so far, thanks for the comment.
    
    source
Excrubulent@slrpnk.net ⁨5⁩ ⁨months⁩ ago
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 juat 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.

source
- autokludge@programming.dev ⁨5⁩ ⁨months⁩ ago
  
  Replace break with goto 😈
  
  source
- UnRelatedBurner@sh.itjust.works ⁨5⁩ ⁨months⁩ ago
  Yeah, that conversation is probably unavoidable. Let’s hope for a good answer. (also I heard that maybe I won’t be studying under her, rumors only, but we’ll see. Thanks.
  
  source
xmunk@sh.itjust.works ⁨5⁩ ⁨months⁩ ago
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.

source
- UnRelatedBurner@sh.itjust.works ⁨5⁩ ⁨months⁩ ago
  haha I personally like both gotos and multi layered breaks, I know it’s bad practice, and I avoid them, but it’s fun.
  
  That aside, you summed up what we are thinking pretty accurately.
  
  source
pixeltree@lemmy.blahaj.zone ⁨5⁩ ⁨months⁩ ago
The only time I’ve used break outside of switch statements is to break out of for each loops early, when I’m checking to see if at least one element in a collection meets a condition. I really don’t think there’s ever a good time to use continue, to be honest. And if you use a labeled break statement, that’s a problem.

source
- yoevli@lemmy.world ⁨5⁩ ⁨months⁩ ago
  continue is useful as a loop analog to early return in a function context, which helps keep indentation/nested conditionals under control and in turn improves code readability.
  
  source
Kissaki@feddit.de ⁨5⁩ ⁨months⁩ ago
When I need a break I make use of a break

source
- UnRelatedBurner@sh.itjust.works ⁨5⁩ ⁨months⁩ ago
  heh, nice one
  
  source
Kissaki@feddit.de ⁨5⁩ ⁨months⁩ ago
This is too unspecific, not a focused question. Yes break and come tinue break directed program flow. Like early returns do too. That doesn’t make them bad tools though. Use them where they make sense.

source
amio@kbin.social ⁨5⁩ ⁨months⁩ ago
Ignore it. A lot of people somehow in charge of teaching coding couldn't code their way out of a wet paper bag.

They are in a ton of languages in all kinds of different families for a reason: they are a logical and fairly consistent expression of two fairly consistently logical ways to deal with control flow in the specific case of a loop - exiting an iteration early, either terminating the whole loop or continuing from the next one. Also there's the switch-case case in C-style languages.

Now, there are legitimate arguments for avoiding tons of of exotic control flow shenanigans, but if someone doesn't understand break/continue, then the problem is 100% theirs and nobody should take their advice on anything much, let alone relating to programming.

source
- m_r_butts@kbin.social ⁨5⁩ ⁨months⁩ ago
  OP said ignoring the rule is an instant fail. They don't have that option.
  
  source
  - amio@kbin.social ⁨5⁩ ⁨months⁩ ago
    Yeah, no shit. I sort of assumed the question was about the actual concepts as they relate to actual programming.
    
    source
crashfrog@lemm.ee ⁨5⁩ ⁨months⁩ ago
I suspect “you’ll fail the test if you use break” is more of a joke by your teacher than an actual grading rubric, although if you used it more than twice in the same test I wouldn’t award you better than a B.

Is there a benefit to not using breaks or continues?

The benefit is that you learn to write non-branching code. That’s important for beginners, who tend to write very complicated and complex code with lots of branching, which they then discover they’re not able to test and debug. Barring you from using break and continue forces you to write more abstract code to achieve the same level of function with less complexity, and that’s how programmers advance in skill - simpler, more abstract code.

Ultimately it’s an effort to kick a crutch out from under you. Whether you think that’s appropriate for a teacher is up to you, I guess - I’m inclined to think it is, but many students don’t respond well to being challenged.

source
- UnRelatedBurner@sh.itjust.works ⁨5⁩ ⁨months⁩ ago
  well, It’s not a joke. But the rest is way to optimistic. You aren’t the first to say that my teacher is just way smarter.then I give credit for but the thing is, noone (in my class) that I tried to share this idea with believed this to be the case. I’ll stay optimistic, and see what’ll happen.
  
  Thanks for the warning about overly braching code, I’ll keep that in mind. (however, I don’t get why more loops and ifs makes a function harder to test, I’m just going to trust you and that I’ll find out later.
  
  source
  - crashfrog@lemm.ee ⁨5⁩ ⁨months⁩ ago
    
    (however, I don’t get why more loops and ifs makes a function harder to test, I’m just going to trust you and that I’ll find out later.
    
    Well, it’s fairly easy to explain - each branching statement in your function doubles the number of discrete paths through the code. If there’s one if statement, there’s two paths through the code. (The one where the if predicate is True, and the one where it isn’t.) If there’s two if statements, there’s four paths through the code. If there’s three if statements, there’s eight paths through the code.
    
    In order to test a function completely, you have to test every possible path through the code. If you used three if statements, that means you have to devise and write eight tests just for the different code paths, plus testing various exceptional cases of the function’s input (“what if all inputs are 0”, “what if all inputs are null”, “what if the integer is a string”, etc.) That’s a lot of tests! You might even have to write tests for exceptional cases combined with different code paths, so now you’re writing eight times the number of tests you otherwise would have had to.
    
    Whereas if your function doesn’t branch at all, there’s only one path through the code to have to test. That’s a lot fewer tests which means you’ll probably actually write them instead of saying “well, it looks like it works, I won’t spend the time on tests right now.” Which is how bugs make it all the way through to the end of the project.
    
    source
    -> View More Comments
Solemarc@lemmy.world ⁨5⁩ ⁨months⁩ ago
Well if you can’t break out of anything then I guess you will just have to return instead. I’m sure this will result in code that is much easier to read.

source
- UnRelatedBurner@sh.itjust.works ⁨5⁩ ⁨months⁩ ago
  Not a bad idea, thx
  
  source
sour@kbin.social ⁨5⁩ ⁨months⁩ ago
you can use break in while true loop when condition is met

source