bool ConfigurationReader::parse_generic_options(
         const variables_map& vm,
         const options_description& visible_options
-)
+) const
 {
     if ( vm.count( HelpCmdStr ) )
     {
         const int argc,
         char *argv[],
         variables_map &vm
-)
+) const
 {
     try
     {
         }
 
     }
-    catch ( std::exception &e )
+    catch ( const std::exception &ex )
     {
-        cerr << e.what() << endl;
+        cerr << ex.what() << endl;
         return false;
     }
 
 bool ConfigurationReader::process_configuration_file(
         const string &config_file_name,
         variables_map &vm
-)
+) const
 {
     BOOST_ASSERT( !config_file_name.empty() );
 
 
     bool parse_generic_options(
             const boost::program_options::variables_map &vm,
             const boost::program_options::options_description &visible_options
-    );
+    ) const;
 
     boost::program_options::options_description get_configuration_options() const;
     bool parse_configuration_options(
             const int argc,
             char *argv[],
             boost::program_options::variables_map &vm
-    );
+    ) const;
     bool process_configuration_file(
             boost::program_options::variables_map &vm
     );
     bool process_configuration_file(
             const std::string &config_file_name,
             boost::program_options::variables_map &vm
-    );
+    ) const;
 
 private:
     Configuration Config;
 
 
     try
     {
-        io_service io_service;
-        tcp::resolver resolver( io_service );
+        io_service io_serv;
+        tcp::resolver resolver( io_serv );
         tcp::resolver::query query( tcp::v4(), HostDnsAddress, "" );
         tcp::resolver::iterator it_first = resolver.resolve( query );
         tcp::resolver::iterator it_last = tcp::resolver::iterator();
         while ( it_first != it_last )
         {
-            string ip = (*it_first).endpoint().address().to_string();
+            string dest_ip = (*it_first).endpoint().address().to_string();
 
             HostAddress resolved_host;
-            resolved_host.set_ip( ip );
+            resolved_host.set_ip( dest_ip );
             ResolvedHostAddressList.push_back( resolved_host );
 
-            cerr << ip << endl;
+            cerr << dest_ip << endl;
 
             ++it_first;
         }
     }
-    catch ( boost::system::system_error& ex )
+    catch ( const std::exception &ex )
     {
-        cerr << "Error: host " << HostDnsAddress << " could not be resolved."
-             << endl;
+        cerr << "Error: host " << HostDnsAddress << " could not be resolved. "
+             << ex.what() << endl;
         return false;
     }
 
 /**
  * @return the amount of IPs resolved for the DNS.
  */
-int DnsResolver::get_resolved_ip_count()
+int DnsResolver::get_resolved_ip_count() const
 {
     int resolved_ip_count = ResolvedHostAddressList.size();
 
 
     virtual ~DnsResolver();
 
     bool resolve();
-    int get_resolved_ip_count();
+    int get_resolved_ip_count() const;
     std::string get_next_ip();
 
 private:
 
 {
 public:
     ChecksumCalculator(
-            Iterator body_begin,
-            Iterator body_end
+            const Iterator &body_begin,
+            const Iterator &body_end
     );
 
     uint16_t compute(
 
 template<typename Iterator>
     ChecksumCalculator<Iterator>::ChecksumCalculator(
-            Iterator body_begin,
-            Iterator body_end
+            const Iterator &body_begin,
+            const Iterator &body_end
     ) :
-        BodyBegin(),
-        BodyEnd()
+        BodyBegin( body_begin ),
+        BodyEnd( body_end )
     {
-        this->BodyBegin = body_begin;
-        this->BodyEnd = body_end;
     }
 
 template<typename Iterator>
 
         IcmpHeader::IcmpType type,
         uint16_t identifier,
         uint16_t sequence_number
-)
+) const
 {
     bool type_match = IcmpPayloadHeader.get_type() == type;
     bool identifier_match = IcmpPayloadHeader.get_identifier() == identifier;
 
             IcmpHeader::IcmpType type,
             uint16_t identifier,
             uint16_t sequence_number
-    );
+    ) const;
 
     friend std::istream& operator>>(
             std::istream &is,
 
     bool read_success = config_reader.parse( argc, argv );
     if ( read_success )
     {
-        io_service io_service;
+        io_service io_serv;
 
         Configuration config = config_reader.get_configuration();
 
             int ping_interval_in_sec = (*host).get_interval_in_sec();
             PingSchedulerItem scheduler(
                     new PingScheduler(
-                            io_service,
+                            io_serv,
                             ping_address,
                             ping_interval_in_sec,
                             ping_fail_limit,
         }
 
         // Main loop to handle scheduled ping requests
-        io_service.run();
+        io_serv.run();
     }
 
     return 0;
 
     BOOST_ASSERT( !value.empty() );
     BOOST_ASSERT( !CommandStr.empty() );
 
-    size_t token_begin_pos = CommandStr.find( token );
+    const size_t token_begin_pos = CommandStr.find( token );
     if ( token_begin_pos == string::npos )
     {
         return false; // token string not found!
     return true;
 }
 
-bool StatusNotifierCommand::execute()
+bool StatusNotifierCommand::execute() const
 {
     BOOST_ASSERT( !CommandStr.empty() );
 
 
             const std::string &value
     );
 
-    bool execute();
+    bool execute() const;
 
 private:
     std::string get_application_string() const;
 
 //-----------------------------------------------------------------------------
 
 BoostPinger::BoostPinger(
-        boost::asio::io_service &io_service,
+        boost::asio::io_service &io_serv,
         const int echo_reply_timeout_in_sec
 ) :
-    IoService( io_service ),
-    Resolver( io_service ),
+    IoService( io_serv ),
+    Resolver( io_serv ),
     DestinationEndpoint(),
-    Socket( io_service, icmp::v4() ),
-    Timer( io_service ),
+    Socket( io_serv, icmp::v4() ),
+    Timer( io_serv ),
     SequenceNumber( 0 ),
     TimeSent( microsec_clock::universal_time() ),
     ReplyBuffer(),
 
 {
 public:
     BoostPinger(
-            boost::asio::io_service &io_service,
+            boost::asio::io_service &io_serv,
             const int echo_reply_timeout_in_sec
     );
     virtual ~BoostPinger();
     {
         PingStatus_NotSent,
         PingStatus_SuccessReply,
-        PingStatus_FailureTimeout,
+        PingStatus_FailureTimeout
     };
 
 private:
 
 //-----------------------------------------------------------------------------
 
 PingScheduler::PingScheduler(
-        boost::asio::io_service &io_service,
+        boost::asio::io_service &io_serv,
         const string &ping_address,
         const long ping_interval_in_sec,
         const int ping_fail_percentage_limit,
         shared_ptr<LinkStatusAnalyzer> link_analyzer
 
 ) :
-    IoService( io_service ),
-    Timer( io_service ),
+    IoService( io_serv ),
+    Timer( io_serv ),
     TimeSentLastPing( microsec_clock::universal_time() ),
     PingIntervalInSec( ping_interval_in_sec ),
     IpList( ping_address ),
 
 {
 public:
     PingScheduler(
-            boost::asio::io_service &io_service,
+            boost::asio::io_service &io_serv,
             const std::string &ping_address,
             const long ping_interval_in_sec,
             const int ping_fail_percentage_limit,