• C is a quick hack of a compiled language that has grown exponentially by adding crap to it, and has standards with ANSI in front of it to make the language sound legitimate, has anal case sensitivity that people never need, and is generally fast.
  :-( :-( :-|

• Perl is a quick hack of a shell scripting language that has grown exponentially by adding crap to it, and has lots of crap available for quick hacks.
  :-( :-|

• Java is a structured OO language with tons of libraries, that requires massive CPU power to do anything useful, tons of typing to do simple things (much more than Pascal or C), a VM engine (interpretter). But nothing available for quick hacks, and the interpretter is written in C.
  :) :-| :-(

• Delphi is a properly structured language with many libraries, OO available at your side, requires no massive CPU power to do anything useful, and no VM engine, geared toward MS Windows but has Kylix. But the compiler is written in C.
  :) :-| :-(

• FreePascal is a properly structured language with many libraries, OO available at your side, requires no massive CPU power to do anything useful, and no hotspot VM engine, with QuikPas compilers and interpretters available for quick hacks. And the compiler/interpretters are written in Pascal.
  :) :) :)

Some say it sucks because of "verboseness" such as begin/end. 

 Comment:
  On the screen, begin/end help you locate code blocks much easier. Especially high 
  resolution monitors. In other languages, parenthesis code markers (such as in C) 
  are very hard to see on a monitor. They can mix in with regular brackets and even
  pipe characters. Even if your syntax editor bolds them for you.

  If you are angry about begin/end and function/procedure tokens in the syntax being
  verbose, take a look at QuikPas. Then you have no excuses, because QuikPas is not
  a new language, but a compatible Pascal counterpart.  

Some say it sucks because there aren't enough code libraries

 Comment:
  Pascal is in in fact much better in this area than several other languages, and 
  more libraries are being added daily. For example, Torry.net, Pascal Server Pages, 
  Regular Expression units, FreePascal contributed units section, string units, 
  sockets units, GUI graphics library, are being worked on and updated every day by 
  several Pascal folks.  

Some say it sucks because you have to compile Pascal.
  
 Comment:
  The Pascal compiler can compile a PascalScript and QuikPas interpreter. Just that 
  no one has used PascalScript or QuikPas in great quantity yet. That doesn't mean
  that you "have to compile Pascal". Far from the truth. This is not to say that we 
  aren't going to make PascalScript and/or QuikPas popular and change this situation. 
  Therefore, no, you do not have to compile Pascal if you do not want to.

Some say it sucks because it is a bondage and discipline language.

 Comment:
  There is a difference between bondage versus common sense. Case sensitivity is 
  anal. Case sensitivity is bondage and discipline. Leaving your room messy when 
  someone has offered you to clean it for you automatically, is lacking common sense.
  Stating that you have an integer you are working with beforehand, is not
  bondage and discipline. 

Some say it sucks because it can't be used on the web.

 Comment:
  So CGI is nice, but maybe that's not what you wanted to hear. Take look at Pascal 
  Server Pages, and in the future, PascalScript. 

Some say it sucks because you have to declare things, type verbose tokens, and you 
end up spending more time on typing.

 Comment:
  You end up commenting your code extra amounts when you use loose typing. These
  comments in your code end up costing you the same time it would have just to
  tell the person in the syntax, while keeping the code neater. And if you 
  don't comment your loose typing, the code becomes unreadable. Commenting your loose
  code takes more time.  Also see QuikPas, if you are so worried that extra
  typing time. And in some cases typing time does matter, we agree, like in a regex 
  for example. Quick on the fly hacks.

Some say it sucks because it is a teaching language
  
 Comment:
  Java and C are the teaching languages. That's what people learn in university. 
  If teaching languages suck, surely Java and C suck.  Hockey is a nice sport to
  teach a kid.  What's your point? 

Some say it sucks because Brian Kerinighan said so.

 Comment:
  Brian K also wrote books on Pascal and sells them still today. He profits on 
  Pascal. Profit and sell something to people you do not believe in? Look on Amazon 
  for his Pascal books he is still prostituting today. If he is selling people bad 
  apples, that is dishonest and disrespectful.  
  See Pargence.
  

Some say it sucks because it doesn't have a pre-processor.

 Comment:
  Yes it does. Take a look at {$DEFINE}. The reason a pre-processor is not
  encouraged, and IS available and recommended as an option to you, is because we 
  think it's a feature, but not an essential part of the language.  Even C 
  programmers always admit that preprocessor can be abused easily, even if they 
  didn't intend it to. It is then wise, for a language to not encourage the 
  preprocessor, but offer it as an option. What is possibly wrong with this logic, 
  something that for example Pascal has recommended?


Some, even still, after we already politely explained, say it sucks because of tokens 
like:

 if, then, and, end, begin, to, until, repeat, while:

 Comment:
  When a human being is proto-typing code, at some point along the line, he must
  go through in his brain what sort of action is going to be happening when his code
  follows through. He must prototype his code inside his head before he writes it
  down. 

  Let's say the programmer is just working on other things and doesn't have
  time to implement the code yet. He writes down the following prototypes just for
  temporary, since he wants to move on to more important code.

      procedure Main.HideConsole;
      begin
        showmessage('STILL TODO!');
        // TODO: hide the console only if shown
        // if console is showing ... then
        // begin
        // end
      end;
  
      procedure Main.ShowConsole;
      begin
        showmessage('STILL TODO!');
        // TODO: show the console only if hidden
        // if console is hidden... then
        // begin
        // end
      end;

  Could it be any more OBVIOUS and READABLE than that? Is there an advantage to NOT 
  being obvious and NOT being readable?

  As you can see, his prototype here is in English, i.e. source code comments.
  He ends up stating that "if console is hidden.. then". These are the words that he 
  comes up with when cycling through his thoughts. He does NOT come up with the 
  following thoughts while he is thinking:
  
     // TODO: show the console only if hidden
      # bin/bash/asslanguage
      if cs1 |\hhdn *(^&(  {  # <-- this ugly crap here makes the console hide
      }                       # <-- this thing here happens to end the statement
                              # <-- I spent so much time commenting the ugly code,
                              #     and converting the symbols into english, that I 
                              #     could have just done it properly in the first 
                              #     place with a real programming language.
  

  The coder now decides it is time to write and complete the code, so here he goes:

      // show the console only if hidden
         if console.hidden then
         begin
             console.show;
         end;

  In the above snippet, the comment "show console only if hidden" can even be 
  completely removed from the file, because the code is so obvious and sensible.
  If you see disadvantages in being obvious and sensible: go away, now.  We don't 
  tolerate people who aren't sensible on this page. 

  As you can see, he just shortened his prototype English thoughts into dot-notation
  syntax. Being TOO verbose would be using actual English paragraphs for his code. 
  Being TOO terse would be using perl, C, PHP, TCL, etc. Being somewhere between, 
  within perfect readability and while still saving screen space, without being 
  direct and actual English, would be Pascal.

  The time you spend converting thoughts into symbols or other bizarre concoctions 
  is pure waste. You might as well just ring it out loud, say it out loud, pronounce
  it out loud. 

   If my code is going to work then 
   begin 
     coding, 
   end. 

   If my console is showing then 
   begin 
    hiding the console,
   end. 

  Shortening the above two sentences is fine, but converting them into bizarre   
  symbols, while not even saving much or any screen space at all, is stupid. 

  Understand that yes, in some cases symbolic code is nice such as in throw away 
  short term situations (regular expressions). But symbolic concoctions are not 
  something you want to be constantly converting and running to the manual for, 
  in everyday, all day long coding.