Return to Answer

Don't just use the default streams directly. Do you have any simple way of preventing this from happening when you don't actually want to debug your application? Is there any way for you to change the log output target without going over each line and changing it? Are all of the messages you're logging that way actually very serious and require immediate attention in all environments?

You should use a logging framework that abstracts away the actual stream and provides configuration for logging levels.

This way you'll be able to configure just how much information you want. IDEs also allow you to display logs like this in a readable manner and give you filtering capabilities (only showing messages at a certain logging level, text-search, etc.). Just how much support you'll get from an IDE probably depends on the platform you're working on and its specific tooling. For example, LogCat gives you some really nice options for android development. Even if whatever frameworks or servers you're using do not give you this much support, I'd rather get a simple log viewing plugin with colouring and filtering capabilities than use the default stream directly. Or even a standalone tool like BareTail (if you're on Windows). Or even tail -f log_file| grep --line-buffered some_regex_pattern if you're desperate or just want something lightweight and have a Unix terminal.

When managed properly, messages logged by an actual logger can be useful anywhere from development to production.

Just pick log4j, SL4J, Logback or even the classes from java.util.logging

Which one you chose is a wider subject but I find every one of them better than simply using System.err without any layer of abstraction above it.

And for actual debugging, a debugger just works better for me. You don't have to change and recompile the code like you do with those println statements to check the state of variables in scope of the lines being analysed or to inspect a different place. Using it also removes the need for cluttering your code with such statements. They take unnecessary space and, whether you want it or not, you have to visually parse them when trying to understand the logic behind the code.

Don't just use the default streams directly. Do you have any simple way of preventing this from happening when you don't actually want to debug your application? Is there any way for you to change the log output target without going over each line and changing it? Are all of the messages you're logging that way actually very serious and require immediate attention in all environments?

You should use a logging framework that abstracts away the actual stream and provides configuration for logging levels.

This way you'll be able to configure just how much information you want. IDEs also allow you to display logs like this in a readable manner and give you filtering capabilities (only showing messages at a certain logging level, text-search, etc.). Just how much support you'll get from an IDE probably depends on the platform you're working on and its specific tooling. For example, LogCat gives you some really nice options for android development. Even if whatever frameworks or servers you're using do not give you this much support, I'd rather get a simple log viewing plugin with colouring and filtering capabilities than use the default stream directly. Or even a standalone tool like BareTail (if you're on Windows). Or even tail -f log_file| grep --line-buffered some_regex_pattern if you're desperate or just want something lightweight and have a Unix terminal.

When managed properly, messages logged by an actual logger can be useful anywhere from development to production.

Just pick log4j, SL4J, Logback or even the classes from java.util.logging

Which one you chose is a wider subject but I find every one of them better than simply using System.err without any layer of abstraction above it.

And for actual debugging, a debugger just works better for me. You don't have to change and recompile the code like you do with those println statements to check the state of variables in scope of the lines being analysed or to inspect a different place. Using it also removes the need for cluttering your code with such statements. They take unnecessary space and, whether you want it or not, you have to visually parse them when trying to understand the logic behind the code.

Don't just use the default streams directly. Do you have any simple way of preventing this from happening when you don't actually want to debug your application? Is there any way for you to change the log output target without going over each line and changing it? Are all of the messages you're logging that way actually very serious and require immediate attention in all environments?

You should use a logging framework that abstracts away the actual stream and provides configuration for logging levels.

This way you'll be able to configure just how much information you want. IDEs also allow you to display logs like this in a readable manner and give you filtering capabilities (only showing messages at a certain logging level, text-search, etc.). Just how much support you'll get from an IDE probably depends on the platform you're working on and its specific tooling. For example, LogCat gives you some really nice options for android development. Even if whatever frameworks or servers you're using do not give you this much support, I'd rather get a simple log viewing plugin with colouring and filtering capabilities than use the default stream directly. Or even a standalone tool like BareTail. Or even tail -f log_file| grep --line-buffered some_regex_pattern if you're desperate or just want something lightweight.

When managed properly, messages logged by an actual logger can be useful anywhere from development to production.

Just pick log4j, SL4J, Logback or even the classes from java.util.logging

Which one you chose is a wider subject but I find every one of them better than simply using System.err without any layer of abstraction above it.

And for actual debugging, a debugger just works better for me. You don't have to change and recompile the code like you do with those println statements to check the state of variables in scope of the lines being analysed or to inspect a different place. Using it also removes the need for cluttering your code with such statements. They take unnecessary space and, whether you want it or not, you have to visually parse them when trying to understand the logic behind the code.

Don't just use the default streams directly. Do you have any simple way of preventing this from happening when you don't actually want to debug your application? Is there any way for you to change the log output target without going over each line and changing it? Are all of the messages you're logging that way actually very serious and require immediate attention in all environments?

You should use a logging framework that abstracts away the actual stream and provides configuration for logging levels.

This way you'll be able to configure just how much information you want. IDEs also allow you to display logs like this in a readable manner and give you filtering capabilities (only showing messages at a certain logging level, text-search, etc.). Just how much support you'll get from an IDE probably depends on the platform you're working on and its specific tooling. For example, LogCat gives you some really nice options for android development. Even if whatever frameworks or servers you're using do not give you this much support, I'd rather get a simple log viewing plugin with colouring and filtering capabilities than use the default stream directly. Or even a standalone tool like BareTail (if you're on Windows). Or even tail -f log_file| grep --line-buffered some_regex_pattern if you're desperate or just want something lightweight and have a Unix terminal.

When managed properly, messages logged by an actual logger can be useful anywhere from development to production.

Just pick log4j, SL4J, Logback or even the classes from java.util.logging

Which one you chose is a wider subject but I find every one of them better than simply using System.err without any layer of abstraction above it.

And for actual debugging, a debugger just works better for me. You don't have to change and recompile the code like you do with those println statements to check the state of variables in scope of the lines being analysed or to inspect a different place. Using it also removes the need for cluttering your code with such statements. They take unnecessary space and, whether you want it or not, you have to visually parse them when trying to understand the logic behind the code.

Don't just use the default streams directly. Do you have any simple way of preventing this from happening when you don't actually want to debug your application? Is there any way for you to change the log output target without going over each line and changing it? Are all of the messages you're logging that way actually very serious and require immediate attention in all environments?

You should use a logging framework that abstracts away the actual stream and provides configuration for logging levels.

This way you'll be able to configure just how much information you want. IDEs also allow you to display logs like this in a readable manner and give you filtering capabilities (only showing messages at a certain logging level, text-search, etc.). Just how much support you'll get from an IDE probably depends on the platform you're working on and its specific tooling. For example, LogCat gives you some really nice options for android development. Even if whatever frameworks or servers you're using do not give you this much support, I'd rather get a simple log viewing plugin with colouring and filtering capabilities than use the default stream directly.

When managed properly, messages logged by an actual logger can be useful anywhere from development to production.

Just pick log4j, SL4J, Logback or even the classes from java.util.logging

Which one you chose is a wider subject but I find every one of them better than simply using System.err without any layer of abstraction above it.

And for actual debugging, a debugger just works better for me. You don't have to change and recompile the code like you do with those println statements to check the state of variables in scope of the lines being analysed or to inspect a different place. Using it also removes the need for cluttering your code with such statements. They take unnecessary space and, whether you want it or not, you have to visually parse them when trying to understand the logic behind the code.

Don't just use the default streams directly. Do you have any simple way of preventing this from happening when you don't actually want to debug your application? Is there any way for you to change the log output target without going over each line and changing it? Are all of the messages you're logging that way actually very serious and require immediate attention in all environments?

You should use a logging framework that abstracts away the actual stream and provides configuration for logging levels.

This way you'll be able to configure just how much information you want. IDEs also allow you to display logs like this in a readable manner and give you filtering capabilities (only showing messages at a certain logging level, text-search, etc.). Just how much support you'll get from an IDE probably depends on the platform you're working on and its specific tooling. For example, LogCat gives you some really nice options for android development. Even if whatever frameworks or servers you're using do not give you this much support, I'd rather get a simple log viewing plugin with colouring and filtering capabilities than use the default stream directly. Or even a standalone tool like BareTail. Or even tail -f log_file| grep --line-buffered some_regex_pattern if you're desperate or just want something lightweight.

When managed properly, messages logged by an actual logger can be useful anywhere from development to production.

Just pick log4j, SL4J, Logback or even the classes from java.util.logging

Which one you chose is a wider subject but I find every one of them better than simply using System.err without any layer of abstraction above it.

And for actual debugging, a debugger just works better for me. You don't have to change and recompile the code like you do with those println statements to check the state of variables in scope of the lines being analysed or to inspect a different place. Using it also removes the need for cluttering your code with such statements. They take unnecessary space and, whether you want it or not, you have to visually parse them when trying to understand the logic behind the code.