It is interesting that some languages do not use semicolons and braces, even though their predecessors had them. Personally, it makes me nervous to write code in Python because of this. Semicolons are also missing from Google's GO language, although the lexer uses a rule to insert semicolons automatically as it scans.
Why do some languages not use semicolons and braces?
The designers for those languages presumably believe that the braces and semi-colons are needless cruft, when line continuations can (usually) be detected due to a statement not being complete, and blocks can be detected by whitespace.
Personally it makes me nervous too, but then the lack of checked exceptions in C# had the same effect on me for a while... I suspect that when you get used to such a scheme, it can improve readability (which is the point). It does mean you need to be more careful with whitespace, of course.
I really don't understand why you ask. You hate writing Python code? Well, don't! Nobody has canceled C/C++/etc.
You can argue that when you use semicolons and braces, you still indent your code with whitespace and new lines - for readability reasons. Therefore those delimiters can be considered redundant in this sense.
Some people think that semicolons and curly braces are not exactly human-readable text. I personally favor the Pascal-style begin end blocks, it seems more natural and easier to understand in terms of sheer meaning, even for a non-initiate in programming languages: "See, is says begin, then some stuff, then end, so it must be something that begins here and ends over there, some sort of block, huh...". Nevertheless, semicolons and brackets are usually easier to parse, so that's why it's easier to use them instead of indentation or other constructs; designers that consider the language easier to understand without them, but easier to parse with them, apply tricks like the one you mentioned: the lexer uses a rule to insert semicolons automatically as it scans.
Every programming language must have some way of distinguishing the end of a statement, function call parameter lists or a block of code from the next one.
Some languages use ; and {} (C, Java)
Some languages rely on known sizes of parameter lists (x86 assembly code)
Some use parentheses to form s-expression (Lisp, Clojure)
Some use whitespace (Python)
Some use special keywords like begin .... end (Pascal, Delphi)
So basically this is mostly just a language design choice. There is always some equivalent of ; or {}, even if it doesn't look the same at first glance...
Two reasons: There are so many different ways to put braces around code blocks (see indent styles) that reading/parsing code written by others can be quite hard. Python code, on the other hand, always looks similar, and the indentation level gives a very clear visual clue for the structure of the code. As a side effect, it forces you to keep your code structure simple since deep nesting makes your code vanish off the right side of the screen :)
As for the semicolons - I've been bitten often enough by for(i=0;i<=100;i++); errors that I'm glad I'm not falling into the same traps in Python...
We have been using indentation to indicate statement groupings as a readability aid for a long time. This occasionally causes problems when the indentation and the actual statement groupings (indicated by {};, begin/end, whatever) are in conflict; we read one meaning, but the code actually says something else.
Python took the simplifying approach. If we find indentation a help in clarity of expression, why not make it the way the language itself determines groupings. When we write code, we express intent to other readers, so looking at what writing gurus say is often useful:
A sentence should contain no unnecessary words, a paragraph no unnecessary sentences, for the same reason that a drawing should have no unnecessary lines and a machine no unnecessary parts. ~William Strunk, Jr., The Elements of Style, 1918
So, maybe a programming language should have no unnecessary syntax elements...??
Semicolons and {} have semantic meanings (variable lifetime, mostly) as well as just syntax. In C++ I've written code that looked like
{
lua_table tab;
{
lua_string str;
}
}
They were of great use because using the Lua stack from C++ sucks terribly.
For some people, semicolons and braces look like noise that makes difficult reading the 'actual' code.
As you can have parsers to recognize blocks either based on punctuations or in indentation (no technical issue involved) the use of one or the other alternative is just a question of the programmer preference.
My impression is that this preference could be mainly due to the previous programmer background.
Using delimiters like semicolons and braces, or not, is just a matter of taste. In practical terms, compilers can work without them, so, why use them in modern programming languages? As I said, is a matter of taste, and... a long-time established de-facto syntax that ressembles C. It is difficult to fight against that.
There is one field in which braces and semicolons are useful: code generation. When you generate code that is expected to be compiled/interpreted in a kind of reflective behaviour, it is normally more comfortable to write braces (in, say, just one, single line) than to write the structure needed by a programming language such as Python, for example. Think of a function with a couple of unnested loops. You would have to keep track of the number of tabs needed at each line.
Is there any reason why some languages do not use semicolons and braces?
Some designers believe that "syntactic noise" such as semicolons and braces distract the reader from the code. There are various ways to eliminate them:
Python and Haskell use significant indentation.
Clu and Lua use very carefully engineered grammars.
Standard ML uses keywords to introduce each construct plus let-bindings, which eliminate the need for most semicolons while also providing a handy way to declare local variables.
The Bourne shells use significant newlines to eliminate semicolons
Scheme uses an extremely regular syntax which in which the only syntactic markers are parentheses. Longtime Schemers like Olin Shivers claim that after a few weeks, your brain adjusts and you no longer see the parentheses.
The fact that there are so many designs, with so much variation, suggest that many language designers view semicolons and braces as syntactic noise to be eliminated if possible. By eliminating syntactic noise, designers make programs easier to read and understand all at once. and many programmers feel more productive, as if the signal-to-noise ratio has improved and they are channeling their code more clearly. (I won't say they're right and I won't say they're wrong, but I will say that has language-design decisions go, this one is pretty easy to defend.)
So is there a reason why language designers do use semicolons and braces?
Many of the modern semi-colon-and-brace languages are designed explicitly, or in some cases not so explicitly, to appeal to C programmers. After all, if it has semicolons and braces, it must be easy to learn. Right?