loops just changed forever (Again)!

Added: 2026-05-11

[00:00:00]In 1843, Ada Lovelace was translating a paper about Charles Babbage's machine.

[00:00:05]And during that work, she wrote an algorithm intended for a machine. It included repetition and conditional logic, just on paper, for a machine that didn't exist yet. So, at this point, we had the idea of repetition, but not a concrete syntax. However, about 100 years later, in 1957, John Backus and his team at IBM created Fortran, the first high-level language to run on a real computer. And it had a loop called do. It looked like this. However, in 1960, a group of scientists from Europe and the United States, who had first gathered in Zurich in 1958, published a language called Algol 60. And here, for the first time, we see the three-part for loop structure we recognize today: a start, a step, and an end condition.

[00:00:48]This idea would go on to directly influence many languages after it.

[00:00:52]However, in 1969, Ken Thompson and Dennis Ritchie at Bell Labs developed a language called B, a simple and typeless language used for early system tools and a direct predecessor to C. You could write something like this. Still simple, but getting closer to what we recognize today. Then in 1972, Dennis Ritchie and Ken Thompson were building Unix. They needed a language closer to the machine.

[00:01:16]So, Ritchie took B, extended it, and created C. C took the for loop idea from Algol and gave it the exact form we know today. Everything in one line. Flexible, powerful, but not always clear. However, that was a correction for some of the historical misconceptions from the last episode. I hope I didn't miss anything.

[00:01:34]And before I move on, just because I didn't cover the full history of computing, doesn't mean I was lying or misleading anyone. Sometimes, you just want to keep the video short. However, beyond the historical side, there are two more things I need to address: philosophical misconceptions and technical ones. Starting with the philosophical side, some of you said, "Just use the for keyword and remove while and loop keywords entirely." And others said, "Loop is unnecessary. Just use while instead." But, here's how I see it. If you watched the second episode in this series, you'll know I said that syntax is a signal. It carries meaning, and without meaning, syntax is pointless. And if two constructs mean the exact same thing with no difference, that's a problem. But, that's not what's happening in Mine. The for keyword is specifically for iterating over something, a range, an array, a collection. The word itself linguistically needs something to complete it. It's not a standalone loop.

[00:02:28]It has a start, an end, a purpose. It's not infinite, but the loop keyword is the most honest keyword you can write for an infinite loop. No condition, no tricks, just a loop. Also, for the while keyword, the word itself implies a condition. It means as long as. That's a conditional loop, not an infinite one.

[00:02:51]And speaking of that, some of you criticized Mine's compile error for while true. But, I want to clarify, in Mine, you can define your own rules and enforce them on your project. You have full control over syntax-level behavior and certain compile-time decisions related to the developer experience.

[00:03:05]Mine is bigger and deeper than it might seem right now. Anyway, let's talk about a real technical mistake from the last episode. When I showed the for loop on arrays, there was a problem. And honestly, I don't know how I missed it.

[00:03:17]It wasn't ignorance. I literally added those last few minutes to the video hours before publishing because I was trying to hit a time limit. I wasn't expecting it to reach this many people, and I just didn't catch it. But, this is my journey, my language, my channel.

[00:03:31]Even if I make a mistake, I'm not dead yet. I'll learn and keep going. I'm not deleting the channel and disappearing like some of you suggested. The issue was, when I talked about for on arrays, I kept mixing up the index and the value. I kept writing I and calling it index. But, sometimes I meant the value.

[00:03:48]That caused confusion between me and some of you. Maybe I mixed up some of the usage patterns, and honestly, the reason is simple. I was looking at five different languages at the same time, and I unconsciously assumed something like the classic index access. That bled into how I was explaining things, and it caused confusion. So, after thinking it through, here are the changes I made.

[00:04:08]Firstly, when iterating over an array, you have two things available: the value and the index. But, which comes first?

[00:04:15]This might seem like a small decision, but it matters. In Mine, the value comes first, and the reason is simple. In most cases, you don't need the index at all.

[00:04:23]The value is what you're actually there for. The index is extra information. So, the default is just the value, and when you need both, you just ask for them.

[00:04:32]The value comes first, because that's what you care about. But, what if you need the index but not the value? You could ask for the value and the index, but never use the value. That's noise, and Mine doesn't like it. So, instead, you use underscore as a placeholder. It tells the compiler explicitly, "I see this position, but I'm choosing to ignore it." Clean, honest, and no confusion. Also, when iterating over an array, the value by default gives you a read-only copy of the value. But, if you need to modify the original array, you ask for its pointer instead. This gives you a pointer to the element, and this is how you dereference it to read or write the actual value. But, this only works on non-constant arrays. If you try to ask for a pointer on a constant array, Mine will give you a compile-time error. You asked for a mutable pointer to something immutable. That's not allowed. However, there were a lot of repeated comments about ranges, and honestly, after thinking about it more, I decided to redesign the syntax.

[00:05:27]Because while the old version technically worked, it clearly wasn't intuitive for everyone. And if people consistently misunderstand something, that usually means the design itself can be improved. Originally, Mine used this, very similar to Rust. But, after reading the feedback, I realized something. The equal sign adds visual noise, especially for something that should feel simple and natural. So, I redesigned the system around a much cleaner idea. The range will be inclusive by default, meaning a range from 0 to 10 includes both 0 and 10. That's 11 iterations, not 10. And if you want to stop before the end, you add a less than before the end value, like telling it stop before you get there.

[00:06:05]But for reversed ranges, in the inclusive case, you simply flip the numbers. The loop starts at 10 and goes all the way down to 0. Still 11 iterations. And if we want an exclusive reversed range, we simply add greater than instead of less than. I think that makes the whole thing more logical, readable, and easier to understand at a glance. However, a lot of you asked about the steps in the comments, and honestly, I like the idea, so I decided to add it. But instead of using step keyword, I went with the by keyword. Two letters, just like the in keyword. The value is always a positive integer. No negative numbers. Mine determines the direction from the range itself. If the start is less than the end, it goes forward. If the start is greater, it goes backward. The by value stays positive either way. And of course, it is optional, so if you do not write it, mine will automatically set it to one.

[00:06:54]Also, some of you asked about the runtime values in ranges. Is it safe?

[00:06:58]Simply, yes. At the end, these are just numbers. Mine can handle it, at least theoretically. However, others asked about negative numbers in range values.

[00:07:07]And the answer is same. These are just integers. What matters is that there's a start point and an end point, and mine can iterate between them. Whether the values are positive or negative, as long as they're whole numbers, the range works. However, some of you asked about character literals in ranges, like when I used A and Z instead of numbers. In mine, a character literal is just an integer under the hood. The size depends on the character. For ASCII characters like A, it's stored as unsigned 8-bit integer. And for Unicode characters like this emoji, it's stored as unsigned 21-bit integer. So, it can store more than 1 million values. However, this range is literally just 97 and 122, a range of integers, nothing special. And yes, the unsigned 21-bit ranges work, too. In mine, all integer ranges work, no exceptions. But is iterating over emojis a common use case? Probably not.

[00:08:01]But the rule is consistent, and consistency matters more than covering only the common cases. However, some of you asked about the nested loops.

[00:08:10]Sometimes you're inside multiple loops, and you want to break out of all of them at once. The regular break only exits the innermost loop. So, how does mine handle that? In mine, we use labeled loops. You label the loop you want to break out of, and then tell break which one. Clean, explicit, and no confusion.

[00:08:25]And if you don't want to name your loop, you can use break with underscore instead of the label. Anyway, I know I couldn't answer every question, and that's simply because there were too many. As I said, I wasn't expecting this kind of reach. Some people saw the video as AI slop. Others used aggressive language and personal attacks, and honestly, none of that matters.

[00:08:46]These people have literally turned into something strange. Any normal human mistake, and they say, "That's AI." So, fine, the video was AI. This one is AI, too. And I'm personally a robot, not a human. Feeling better now?

[00:08:58]Anyway, I want to say thank you to everyone who waited for this video. Your presence genuinely means the world to me. If you have a question I missed, feel free to write it in the comments.

[00:09:08]As you know, this was day six of building my own programming language from scratch. Thanks for watching, and see you next time.