diff --git a/tools/chunks/catchunks/discover-version.hpp b/tools/chunks/catchunks/discover-version.hpp
index 6a05727..3f6620e 100644
--- a/tools/chunks/catchunks/discover-version.hpp
+++ b/tools/chunks/catchunks/discover-version.hpp
@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2016-2022, Regents of the University of California,
+ * Copyright (c) 2016-2023, Regents of the University of California,
  *                          Colorado State University,
  *                          University Pierre & Marie Curie, Sorbonne University.
  *
@@ -51,12 +51,12 @@
   /**
    * @brief Signal emitted when the versioned name of Data is found.
    */
-  util::Signal<DiscoverVersion, Name> onDiscoverySuccess;
+  signal::Signal<DiscoverVersion, Name> onDiscoverySuccess;
 
   /**
    * @brief Signal emitted when a failure occurs.
    */
-  util::Signal<DiscoverVersion, std::string> onDiscoveryFailure;
+  signal::Signal<DiscoverVersion, std::string> onDiscoveryFailure;
 
   void
   run();
diff --git a/tools/chunks/catchunks/pipeline-interests-adaptive.hpp b/tools/chunks/catchunks/pipeline-interests-adaptive.hpp
index 7b7aad8..28e6207 100644
--- a/tools/chunks/catchunks/pipeline-interests-adaptive.hpp
+++ b/tools/chunks/catchunks/pipeline-interests-adaptive.hpp
@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2016-2022, Regents of the University of California,
+ * Copyright (c) 2016-2023, Regents of the University of California,
  *                          Colorado State University,
  *                          University Pierre & Marie Curie, Sorbonne University.
  *
@@ -94,7 +94,7 @@
    * The callback function should be: `void(nanoseconds age, double cwnd)`, where `age` is the
    * time since the pipeline started and `cwnd` is the new congestion window size (in segments).
    */
-  util::Signal<PipelineInterestsAdaptive, time::nanoseconds, double> afterCwndChange;
+  signal::Signal<PipelineInterestsAdaptive, time::nanoseconds, double> afterCwndChange;
 
   struct RttSample
   {
@@ -108,7 +108,7 @@
   /**
    * @brief Signals when a new RTT sample has been taken.
    */
-  util::Signal<PipelineInterestsAdaptive, RttSample> afterRttMeasurement;
+  signal::Signal<PipelineInterestsAdaptive, RttSample> afterRttMeasurement;
 
 protected:
   DECLARE_SIGNAL_EMIT(afterCwndChange)
diff --git a/tools/chunks/putchunks/producer.cpp b/tools/chunks/putchunks/producer.cpp
index 6b305cd..ab07517 100644
--- a/tools/chunks/putchunks/producer.cpp
+++ b/tools/chunks/putchunks/producer.cpp
@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2016-2022, Regents of the University of California,
+ * Copyright (c) 2016-2023, Regents of the University of California,
  *                          Colorado State University,
  *                          University Pierre & Marie Curie, Sorbonne University.
  *
@@ -53,7 +53,7 @@
   if (!m_options.isQuiet) {
     std::cerr << "Loading input ...\n";
   }
-  util::Segmenter segmenter(m_keyChain, m_options.signingInfo);
+  Segmenter segmenter(m_keyChain, m_options.signingInfo);
   m_store = segmenter.segment(is, m_versionedPrefix, m_options.maxSegmentSize, m_options.freshnessPeriod);
 
   // register m_prefix without Interest handler
diff --git a/tools/ping/client/ping.hpp b/tools/ping/client/ping.hpp
index f78d761..b2e4bfd 100644
--- a/tools/ping/client/ping.hpp
+++ b/tools/ping/client/ping.hpp
@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2015-2022,  Arizona Board of Regents.
+ * Copyright (c) 2015-2023,  Arizona Board of Regents.
  *
  * This file is part of ndn-tools (Named Data Networking Essential Tools).
  * See AUTHORS.md for complete list of ndn-tools authors and contributors.
@@ -62,7 +62,7 @@
    * @param seq ping sequence number
    * @param rtt round trip time
    */
-  util::Signal<Ping, uint64_t, Rtt> afterData;
+  signal::Signal<Ping, uint64_t, Rtt> afterData;
 
   /**
    * @brief Signals on the return of a Nack
@@ -71,19 +71,19 @@
    * @param rtt round trip time
    * @param header the received Network NACK header
    */
-  util::Signal<Ping, uint64_t, Rtt, lp::NackHeader> afterNack;
+  signal::Signal<Ping, uint64_t, Rtt, lp::NackHeader> afterNack;
 
   /**
    * @brief Signals on timeout of a packet
    *
    * @param seq ping sequence number
    */
-  util::Signal<Ping, uint64_t> afterTimeout;
+  signal::Signal<Ping, uint64_t> afterTimeout;
 
   /**
    * @brief Signals when finished pinging
    */
-  util::Signal<Ping> afterFinish;
+  signal::Signal<Ping> afterFinish;
 
   /**
    * @brief Start sending ping interests
diff --git a/tools/ping/server/ping-server.hpp b/tools/ping/server/ping-server.hpp
index e9127c0..0289da2 100644
--- a/tools/ping/server/ping-server.hpp
+++ b/tools/ping/server/ping-server.hpp
@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2015-2022,  Arizona Board of Regents.
+ * Copyright (c) 2015-2023,  Arizona Board of Regents.
  *
  * This file is part of ndn-tools (Named Data Networking Essential Tools).
  * See AUTHORS.md for complete list of ndn-tools authors and contributors.
@@ -55,12 +55,12 @@
    *
    * @param name incoming interest name
    */
-  util::Signal<PingServer, Name> afterReceive;
+  signal::Signal<PingServer, Name> afterReceive;
 
   /**
    * @brief Signals when finished pinging
    */
-  util::Signal<PingServer> afterFinish;
+  signal::Signal<PingServer> afterFinish;
 
   /** @brief starts ping server
    *
