public class FileRead {
    static void printFile(String filename) {
        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(
                    new FileInputStream(new File(filename))));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (FileNotFoundException e) {
            System.err.printf("No such file found: %s\n", filename);
        } catch (IOException e) {
            System.err.println("Error reading from file.");
        }
    }

    public static void main(String[] args) {
        if (args.length == 1)
            printFile(args[0]);
    }

}

File file = new File(filename);
if ( !file.exists() ) // ...

filename = ARGV[0]
open(filename).each_line { |line| print line }

filename = ARGV[0] or raise ArgumentError.new("No filename provided")

begin
  open(filename).each_line { |line|
    print line
  }
rescue Errno::ENOENT
  $stderr.puts("No such file: #{filename}")
end

from sys import argv

if len( argv ) == 2:
    try:
        file = open( argv[1] )
        for line in file.readlines():
            print line,
    except IOError:
        print "Error reading from the file."
else:
    print "No file specified."

Comments

1. Michel Parisien said:
   

   I came to the same conclusion over the summer about Java. To be fair, Java is a great teaching tool for a lot of software engineering principles, but it is fairly impractical. What Java has going for it is the community and their appreciation for developing software right more than the language itself.

2. Stuart said:
   

   Keep in mind that Java is also a great language for people who just won’t ever be super bright. That anal-retentedness keeps idjits in line.

3. FiG said:
   

   Stuart has a point, but it’s more than that. Java is limiting itself in its own “Object Oriented” blinders. The only reason that certain types arn’t full fledged Objects in Java is probably because they tried it, and it was the most ridiculous thing ever.

   Just like everything in the world, as soon as you’re a fanatic about something (such as religion, programming, japanese culture (YES, I’m point at you skrud!), you stop thinking in rational terms.

   I’m not saying the people who designed Java weren’t rational, it’s just that they let they’re love of a SYMBOL overshadow the fact that it could be done better.

4. Skrud said:
   

   I’m pretty sure the reason Java still has primitive types was more for performance reasons than anything else. It is totally not the silliest thing ever, and it makes languages like Python and Ruby so much easier to work with and more flexible. (C# also follows the everything-is-an-object-no-primitive-types thing).

   Java is a testament to over-engineering.

5. Edward said:
   

   Dear Skrud,

   I concur. Java has a lot going for it except for its overly verbose syntax. Java with Ruby’s syntax and philosophy would have been beautiful. Oh well.

   I saw this today:

   * Perl : #*@%-ed
   * Python : Simple, Fun and Indented!
   * Ruby : Ruby is Perl's younger, prettier sister.
   

   Please fill in an entry for Java.

6. Iouri Goussev said:
   

   IMHO Simple examples are stupid.

   Anyway few remarks

   1) You can use something like BufferedReader(new FileReader(args[0]));

   2) You don’t have to create a static function, and you can add a throw exception to your main method. That will make java code smaller.

   3) No matter how good the language it is still easy to write bad code, for example http://dev.rubyonrails.org/svn/rails/trunk/actionwebservice/lib/actionwebservice/dispatcher/actioncontrollerdispatcher.rb

   4) Why won’t you just write function printFile(file) and make your life happy? Language designers can’t anticipate all the possible uses of their language, for java console I/O never was a priority; notice the absence of printf till java5!

7. Skrud said:
   

   Well, if we’re throwing error handling out the window, then it becomes

   public class FileRead {
      public static void main(String[] args) throws IOException {
            BufferedReader reader = new BufferedReader(new FileReader(args[0]));
            String line;
            while( (line = reader.readLine()) != null ) {
               System.out.println(line);
            }
         }
   }
   

   versus

   import sys.argv
   for line in open(sys.argv[1]).readlines(): print line,
   

   or

   open(ARGV[0]).each_line { |line| print line }
   

   And it’s not Java’s Console IO that I’m referring to here, but it’s File IO. Console IO in Java is a whole other peeve of mine. I think it’s just plain foolish to try to ignore something so basic for so long. As if they decided “oh, people don’t write console programs anymore, so we don’t have to think abou those.” (Meanwhile even Microsoft goes and adds a new and improved shell to their next OS).

   Obviously no language can prevent you from writing buggy, messy code … but the less code you have to write the less things can go wrong. That’s just statistics. Take a discussion on Java foreach loops as an example. They say:

   “The iterator is just clutter. Furthermore, it is an opportunity for error. The iterator variable occurs three times in each loop: that is two chances to get it wrong. The for-each construct gets rid of the clutter and the opportunity for error.”

   The point is, more code = more chances to mess something up. Less code = fewer chances to mess something up. Foreach loops let you get away with writing less code, and reducing your chances for fuckups. A language that isn’t Java lets you do the same.

   And I held back on posthing this in the article, but since we’re tossing error handling to the wind:

   #include<unistd.h>
   #include<fcntl.h>
   #define BUFLEN 1024
   
   int main( int argc, char ** argv ) {
       int fd, nread;
       char buffer[BUFLEN];
   
       fd = open( argv[0], O_RDONLY );
       while( (nread = read( fd, buffer, BUFLEN - 1 )) > 0 ) {
          write( STDOUT_FILENO, buffer, nread );
       }
   }
   

   I like that even better than the Java version because again because basically it says open, read, and write. Other than the fact that you have to create a buffer yourself, I think it’s much better at saying what you mean.

8. Iouri Goussev said:
   

   I don’t think that more code result in more errors, notice that the blog software that you are using, is written in the language you like and still author managed to introduce a bug in post parsing (notice italic in the URL in my previous post), and it did not save my second post (I did not bother to re-post).

   So I don’t think that language with verbose syntax is more mistake prone. COBOL is a good example “add one to counter ;-)” yet anyone can learn it fast and write reasonably complex applications.

   On the other hand Perl allows you to write complex code in just few lines and yet make it very complex;

   I think errors that matter are logical errors, and I can make them in any language.

   C is nice but I think it is not a right level of abstractions for most applications.

   COBOL <—-> Java <—-> Ruby <—-> Perl Choose your poison.

9. Mia said:
   

   Still wishing 248/249 was C++…

10. Iouri Goussev said:
    

    I think this is as small and nice as java allows:

    BufferedReader reader = new BufferedReader(new FileReader(args[0])); while (reader.ready()) { System.out.println(reader.readLine()); } reader.close();

    BTW Skrud, in your code samples you always forget to close file descriptor.

11. Skrud said:
    

    ^^ I’m just being lazy. My program exits immediately after so there’s no reason to bother.

12. ahmed said:
    

    good points in general, but wouldn’t what you are asking for basicaly be SimpleJava, which is simply a Java language the generalizes some aspects in Java?

    also note: (checking that the files exists, and then reading from it does NOT garantee that the file STILL exists; the action is far from atomic, expecialy given the while loop/buffering/different statements)

    Cheers

13. Skrud said:
    

    I never heard of SimpleJava… But I’ll Google it, thanks!

    And you’re right about the file not found thing, I didn’t think of that. But the FileNotFoundException is thrown only from the FileInputStream/FileReader constructor – not from the loop. (The loop can throw an IOException if there’s an error reading).

    I do like the idea of Jython, though. Which is a Python interpreter written in Java that has the added benefits of letting you call Java library classes from Python.

14. FiG said:
    

    I think it’s just a matter of finding the right tool for the job. If you want to do simple IO and command-line functions, then a scripting language is the way to go. If you want to design complex systems, then java (or one of the other highly stuctured languages) is the way to go!

    I think this whole discussion started because you wanted to swat a fly with a bazooka!

15. ahmed said:
    

    lol, No, SimpleJava doesn’t exists :P

    My point is, SimpleJava would be an abstraction of Java. Allowing ppl to assume a whole bunch of things when they want, and still be able to use Java when they want more control.

    Which shouldn’t be hard to do, you can define your own grammer, and abstractions, and then simply expand that code to normal java code. (that would be a neet Compiler Class project)

16. Skrud said:
    

    SimpleJava does exist, and it _is_ a neat Compiler class project: http://www.cs.usfca.edu/galles/compilerdesign/simplejava/sjavaex.html

17. ahmed said:
    

    hahahaha

    i’ll make sure not to MAKE up things that already exist!

    Thats crazy

Leave a Response