Repository: GuillaumeGomez/sysinfo
Pull request #513 (2021-06-14 18:31:37)

Rename methods to remove 'get_' prefix for more idiomatic code


Patch:
diff --git a/README.md b/README.md
index 0416b2b..d76f0a3 100644
--- a/README.md
+++ b/README.md
@@ -63,42 +63,42 @@ let mut sys = System::new_all();
 
 // We display the disks:
 println!("=> disk list:");
-for disk in sys.get_disks() {
+for disk in sys.disks() {
     println!("{:?}", disk);
 }
 
 // Network data:
-for (interface_name, data) in sys.get_networks() {
-    println!("{}: {}/{} B", interface_name, data.get_received(), data.get_transmitted());
+for (interface_name, data) in sys.networks() {
+    println!("{}: {}/{} B", interface_name, data.received(), data.transmitted());
 }
 
 // Components temperature:
-for component in sys.get_components() {
+for component in sys.components() {
     println!("{:?}", component);
 }
 
 // Memory information:
-println!("total memory: {} KB", sys.get_total_memory());
-println!("used memory : {} KB", sys.get_used_memory());
-println!("total swap  : {} KB", sys.get_total_swap());
-println!("used swap   : {} KB", sys.get_used_swap());
+println!("total memory: {} KB", sys.total_memory());
+println!("used memory : {} KB", sys.used_memory());
+println!("total swap  : {} KB", sys.total_swap());
+println!("used swap   : {} KB", sys.used_swap());
 
 // Number of processors
-println!("NB processors: {}", sys.get_processors().len());
+println!("NB processors: {}", sys.processors().len());
 
 // To refresh all system information:
 sys.refresh_all();
 
 // We show the processes and some of their information:
-for (pid, process) in sys.get_processes() {
+for (pid, process) in sys.processes() {
     println!("[{}] {} {:?}", pid, process.name(), process.disk_usage());
 }
 
 // Display system information:
-println!("System name:             {:?}", sys.get_name());
-println!("System kernel version:   {:?}", sys.get_kernel_version());
-println!("System OS version:       {:?}", sys.get_os_version());
-println!("System host name:        {:?}", sys.get_host_name());
+println!("System name:             {:?}", sys.name());
+println!("System kernel version:   {:?}", sys.kernel_version());
+println!("System OS version:       {:?}", sys.os_version());
+println!("System host name:        {:?}", sys.host_name());
 ```
 
 By default, `sysinfo` uses multiple threads. However, this can increase the memory usage on some platforms (macOS for example).
diff --git a/benches/basic.rs b/benches/basic.rs
index f825be6..7c6e545 100644
--- a/benches/basic.rs
+++ b/benches/basic.rs
@@ -62,7 +62,7 @@ fn bench_refresh_process(b: &mut test::Bencher) {
 fn bench_refresh_disk(b: &mut test::Bencher) {
     let mut s = sysinfo::System::new_all();
 
-    let disks = s.get_disks_mut();
+    let disks = s.disks_mut();
     let disk = &mut disks[0];
     b.iter(move || {
         disk.refresh();
diff --git a/examples/simple.rs b/examples/simple.rs
index 92e8998..7d8e1ac 100644
--- a/examples/simple.rs
+++ b/examples/simple.rs
@@ -169,44 +169,28 @@ fn interpret_input(input: &str, sys: &mut System) -> bool {
             writeln!(
                 &mut io::stdout(),
                 "number of physical cores: {}",
-                sys.get_physical_core_count()
+                sys.physical_core_count()
                     .map(|c| c.to_string())
                     .unwrap_or_else(|| "Unknown".to_owned()),
             );
             writeln!(
                 &mut io::stdout(),
                 "total process usage: {}%",
-                sys.get_global_processor_info().get_cpu_usage()
+                sys.global_processor_info().cpu_usage()
             );
-            for proc_ in sys.get_processors() {
+            for proc_ in sys.processors() {
                 writeln!(&mut io::stdout(), "{:?}", proc_);
             }
         }
         "memory" => {
-            writeln!(
-                &mut io::stdout(),
-                "total memory: {} KB",
-                sys.get_total_memory()
-            );
-            writeln!(
-                &mut io::stdout(),
-                "used memory : {} KB",
-                sys.get_used_memory()
-            );
-            writeln!(
-                &mut io::stdout(),
-                "total swap  : {} KB",
-                sys.get_total_swap()
-            );
-            writeln!(
-                &mut io::stdout(),
-                "used swap   : {} KB",
-                sys.get_used_swap()
-            );
+            writeln!(&mut io::stdout(), "total memory: {} KB", sys.total_memory());
+            writeln!(&mut io::stdout(), "used memory : {} KB", sys.used_memory());
+            writeln!(&mut io::stdout(), "total swap  : {} KB", sys.total_swap());
+            writeln!(&mut io::stdout(), "used swap   : {} KB", sys.used_swap());
         }
         "quit" | "exit" => return true,
         "all" => {
-            for (pid, proc_) in sys.get_processes() {
+            for (pid, proc_) in sys.processes() {
                 writeln!(
                     &mut io::stdout(),
                     "{}:{} status={:?}",
@@ -217,28 +201,20 @@ fn interpret_input(input: &str, sys: &mut System) -> bool {
             }
         }
         "frequency" => {
-            writeln!(
-                &mut io::stdout(),
-                "{} MHz",
-                sys.get_processors()[0].get_frequency()
-            );
+            writeln!(&mut io::stdout(), "{} MHz", sys.processors()[0].frequency());
         }
         "vendor_id" => {
             writeln!(
                 &mut io::stdout(),
                 "vendor ID: {}",
-                sys.get_processors()[0].get_vendor_id()
+                sys.processors()[0].vendor_id()
             );
         }
         "brand" => {
-            writeln!(
-                &mut io::stdout(),
-                "brand: {}",
-                sys.get_processors()[0].get_brand()
-            );
+            writeln!(&mut io::stdout(), "brand: {}", sys.processors()[0].brand());
         }
         "load_avg" => {
-            let load_avg = sys.get_load_average();
+            let load_avg = sys.load_average();
             writeln!(&mut io::stdout(), "one minute     : {}%", load_avg.one);
             writeln!(&mut io::stdout(), "five minutes   : {}%", load_avg.five);
             writeln!(&mut io::stdout(), "fifteen minutes: {}%", load_avg.fifteen);
@@ -253,33 +229,33 @@ fn interpret_input(input: &str, sys: &mut System) -> bool {
                 );
                 writeln!(&mut io::stdout(), "example: show 1254");
             } else if let Ok(pid) = Pid::from_str(tmp[1]) {
-                match sys.get_process(pid) {
+                match sys.process(pid) {
                     Some(p) => writeln!(&mut io::stdout(), "{:?}", *p),
                     None => writeln!(&mut io::stdout(), "pid \"{:?}\" not found", pid),
                 };
             } else {
                 let proc_name = tmp[1];
-                for proc_ in sys.get_process_by_name(proc_name) {
+                for proc_ in sys.process_by_name(proc_name) {
                     writeln!(&mut io::stdout(), "==== {} ====", proc_.name());
                     writeln!(&mut io::stdout(), "{:?}", proc_);
                 }
             }
         }
         "temperature" => {
-            for component in sys.get_components() {
+            for component in sys.components() {
                 writeln!(&mut io::stdout(), "{:?}", component);
             }
         }
         "network" => {
-            for (interface_name, data) in sys.get_networks().iter() {
+            for (interface_name, data) in sys.networks().iter() {
                 writeln!(
                     &mut io::stdout(),
                     "{}:\n  input data  (new / total): {} / {} B\n  output data (new / total): {} / {} B",
                     interface_name,
-                    data.get_received(),
-                    data.get_total_received(),
-                    data.get_transmitted(),
-                    data.get_total_transmitted(),
+                    data.received(),
+                    data.total_received(),
+                    data.transmitted(),
+                    data.total_transmitted(),
                 );
             }
         }
@@ -309,7 +285,7 @@ fn interpret_input(input: &str, sys: &mut System) -> bool {
                          signals command"
                     );
                 } else {
-                    match sys.get_process(pid) {
+                    match sys.process(pid) {
                         Some(p) => {
                             writeln!(
                                 &mut io::stdout(),
@@ -325,21 +301,21 @@ fn interpret_input(input: &str, sys: &mut System) -> bool {
             }
         }
         "disks" => {
-            for disk in sys.get_disks() {
+            for disk in sys.disks() {
                 writeln!(&mut io::stdout(), "{:?}", disk);
             }
         }
         "users" => {
-            for user in sys.get_users() {
-                writeln!(&mut io::stdout(), "{:?}", user.get_name());
+            for user in sys.users() {
+                writeln!(&mut io::stdout(), "{:?}", user.name());
             }
         }
         "boot_time" => {
-            writeln!(&mut io::stdout(), "{} seconds", sys.get_boot_time());
+            writeln!(&mut io::stdout(), "{} seconds", sys.boot_time());
         }
         "uptime" => {
-            let up = sys.get_uptime();
-            let mut uptime = sys.get_uptime();
+            let up = sys.uptime();
+            let mut uptime = sys.uptime();
             let days = uptime / 86400;
             uptime -= days * 86400;
             let hours = uptime / 3600;
@@ -402,13 +378,11 @@ fn interpret_input(input: &str, sys: &mut System) -> bool {
                 System kernel version: {}\n\
                 System OS version:     {}\n\
                 System host name:      {}",
-                sys.get_name().unwrap_or_else(|| "<unknown>".to_owned()),
-                sys.get_kernel_version()
-                    .unwrap_or_else(|| "<unknown>".to_owned()),
-                sys.get_os_version()
-                    .unwrap_or_else(|| "<unknown>".to_owned()),
-                sys.get_host_name()
+                sys.name().unwrap_or_else(|| "<unknown>".to_owned()),
+                sys.kernel_version()
                     .unwrap_or_else(|| "<unknown>".to_owned()),
+                sys.os_version().unwrap_or_else(|| "<unknown>".to_owned()),
+                sys.host_name().unwrap_or_else(|| "<unknown>".to_owned()),
             );
         }
         e => {
diff --git a/src/apple/disk.rs b/src/apple/disk.rs
index f36aeaf..5b65138 100644
--- a/src/apple/disk.rs
+++ b/src/apple/disk.rs
@@ -26,27 +26,27 @@ pub struct Disk {
 }
 
 impl DiskExt for Disk {
-    fn get_type(&self) -> DiskType {
+    fn type_(&self) -> DiskType {
         self.type_
     }
 
-    fn get_name(&self) -> &OsStr {
+    fn name(&self) -> &OsStr {
         &self.name
     }
 
-    fn get_file_system(&self) -> &[u8] {
+    fn file_system(&self) -> &[u8] {
         &self.file_system
     }
 
-    fn get_mount_point(&self) -> &Path {
+    fn mount_point(&self) -> &Path {
         &self.mount_point
     }
 
-    fn get_total_space(&self) -> u64 {
+    fn total_space(&self) -> u64 {
         self.total_space
     }
 
-    fn get_available_space(&self) -> u64 {
+    fn available_space(&self) -> u64 {
         self.available_space
     }
 
diff --git a/src/apple/ios/component.rs b/src/apple/ios/component.rs
index e0e18ad..16333a2 100644
--- a/src/apple/ios/component.rs
+++ b/src/apple/ios/component.rs
@@ -11,19 +11,19 @@ use crate::ComponentExt;
 pub struct Component {}
 
 impl ComponentExt for Component {
-    fn get_temperature(&self) -> f32 {
+    fn temperature(&self) -> f32 {
         0.0
     }
 
-    fn get_max(&self) -> f32 {
+    fn max(&self) -> f32 {
         0.0
     }
 
-    fn get_critical(&self) -> Option<f32> {
+    fn critical(&self) -> Option<f32> {
         None
     }
 
-    fn get_label(&self) -> &str {
+    fn label(&self) -> &str {
         ""
     }
 
diff --git a/src/apple/macos/component.rs b/src/apple/macos/component.rs
index f33288e..71b0518 100644
--- a/src/apple/macos/component.rs
+++ b/src/apple/macos/component.rs
@@ -37,7 +37,7 @@ impl ComponentFFI {
             })
     }
 
-    fn get_temperature(&self, con: ffi::io_connect_t) -> Option<f32> {
+    fn temperature(&self, con: ffi::io_connect_t) -> Option<f32> {
         get_temperature_inner(con, &self.input_structure, &self.val)
     }
 }
@@ -63,7 +63,7 @@ impl Component {
     ) -> Option<Component> {
         let ffi_part = ComponentFFI::new(key, connection)?;
         ffi_part
-            .get_temperature(connection)
+            .temperature(connection)
             .map(|temperature| Component {
                 temperature,
                 label,
@@ -76,24 +76,24 @@ impl Component {
 }
 
 impl ComponentExt for Component {
-    fn get_temperature(&self) -> f32 {
+    fn temperature(&self) -> f32 {
         self.temperature
     }
 
-    fn get_max(&self) -> f32 {
+    fn max(&self) -> f32 {
         self.max
     }
 
-    fn get_critical(&self) -> Option<f32> {
+    fn critical(&self) -> Option<f32> {
         self.critical
     }
 
-    fn get_label(&self) -> &str {
+    fn label(&self) -> &str {
         &self.label
     }
 
     fn refresh(&mut self) {
-        if let Some(temp) = self.ffi_part.get_temperature(self.connection) {
+        if let Some(temp) = self.ffi_part.temperature(self.connection) {
             self.temperature = temp;
             if self.temperature > self.max {
                 self.max = self.temperature;
diff --git a/src/apple/network.rs b/src/apple/network.rs
index 40d63a3..e7992b7 100644
--- a/src/apple/network.rs
+++ b/src/apple/network.rs
@@ -26,7 +26,7 @@ macro_rules! old_and_new {
 /// use sysinfo::{NetworksExt, System, SystemExt};
 ///
 /// let s = System::new_all();
-/// let networks = s.get_networks();
+/// let networks = s.networks();
 /// ```
 pub struct Networks {
     interfaces: HashMap<String, NetworkData>,
@@ -195,51 +195,51 @@ pub struct NetworkData {
 }
 
 impl NetworkExt for NetworkData {
-    fn get_received(&self) -> u64 {
+    fn received(&self) -> u64 {
         self.current_in.saturating_sub(self.old_in)
     }
 
-    fn get_total_received(&self) -> u64 {
+    fn total_received(&self) -> u64 {
         self.current_in
     }
 
-    fn get_transmitted(&self) -> u64 {
+    fn transmitted(&self) -> u64 {
         self.current_out.saturating_sub(self.old_out)
     }
 
-    fn get_total_transmitted(&self) -> u64 {
+    fn total_transmitted(&self) -> u64 {
         self.current_out
     }
 
-    fn get_packets_received(&self) -> u64 {
+    fn packets_received(&self) -> u64 {
         self.packets_in.saturating_sub(self.old_packets_in)
     }
 
-    fn get_total_packets_received(&self) -> u64 {
+    fn total_packets_received(&self) -> u64 {
         self.packets_in
     }
 
-    fn get_packets_transmitted(&self) -> u64 {
+    fn packets_transmitted(&self) -> u64 {
         self.packets_out.saturating_sub(self.old_packets_out)
     }
 
-    fn get_total_packets_transmitted(&self) -> u64 {
+    fn total_packets_transmitted(&self) -> u64 {
         self.packets_out
     }
 
-    fn get_errors_on_received(&self) -> u64 {
+    fn errors_on_received(&self) -> u64 {
         self.errors_in.saturating_sub(self.old_errors_in)
     }
 
-    fn get_total_errors_on_received(&self) -> u64 {
+    fn total_errors_on_received(&self) -> u64 {
         self.errors_in
     }
 
-    fn get_errors_on_transmitted(&self) -> u64 {
+    fn errors_on_transmitted(&self) -> u64 {
         self.errors_out.saturating_sub(self.old_errors_out)
     }
 
-    fn get_total_errors_on_transmitted(&self) -> u64 {
+    fn total_errors_on_transmitted(&self) -> u64 {
         self.errors_out
     }
 }
diff --git a/src/apple/processor.rs b/src/apple/processor.rs
index c06b12b..514951f 100644
--- a/src/apple/processor.rs
+++ b/src/apple/processor.rs
@@ -90,30 +90,30 @@ impl Processor {
         self.processor_data = processor_data;
     }
 
-    pub(crate) fn get_data(&self) -> Arc<ProcessorData> {
+    pub(crate) fn data(&self) -> Arc<ProcessorData> {
         Arc::clone(&self.processor_data)
     }
 }
 
 impl ProcessorExt for Processor {
-    fn get_cpu_usage(&self) -> f32 {
+    fn cpu_usage(&self) -> f32 {
         self.cpu_usage
     }
 
-    fn get_name(&self) -> &str {
+    fn name(&self) -> &str {
         &self.name
     }
 
     /// Returns the processor frequency in MHz.
-    fn get_frequency(&self) -> u64 {
+    fn frequency(&self) -> u64 {
         self.frequency
     }
 
-    fn get_vendor_id(&self) -> &str {
+    fn vendor_id(&self) -> &str {
         &self.vendor_id
     }
 
-    fn get_brand(&self) -> &str {
+    fn brand(&self) -> &str {
         &self.brand
     }
 }
@@ -185,7 +185,7 @@ pub fn init_processors(port: libc::mach_port_t) -> (Processor, Vec<Processor>) {
                     + *cpu_info
                         .offset((libc::CPU_STATE_MAX * i) as isize + libc::CPU_STATE_IDLE as isize);
                 p.set_cpu_usage(in_use as f32 / total as f32 * 100.);
-                pourcent += p.get_cpu_usage();
+                pourcent += p.cpu_usage();
                 processors.push(p);
             }
         }
@@ -267,18 +267,18 @@ mod test {
         let stdout = String::from_utf8(child.stdout).expect("Not valid UTF8");
 
         let sys = System::new();
-        let processors = sys.get_processors();
+        let processors = sys.processors();
         assert!(!processors.is_empty(), "no processor found");
         if let Some(line) = stdout.lines().find(|l| l.contains("machdep.cpu.vendor")) {
             let sysctl_value = line.split(":").skip(1).next().unwrap();
-            assert_eq!(processors[0].get_vendor_id(), sysctl_value.trim());
+            assert_eq!(processors[0].vendor_id(), sysctl_value.trim());
         }
         if let Some(line) = stdout
             .lines()
             .find(|l| l.contains("machdep.cpu.brand_string"))
         {
             let sysctl_value = line.split(":").skip(1).next().unwrap();
-            assert_eq!(processors[0].get_brand(), sysctl_value.trim());
+            assert_eq!(processors[0].brand(), sysctl_value.trim());
         }
     }
 }
diff --git a/src/apple/system.rs b/src/apple/system.rs
index f173b8d..862780b 100644
--- a/src/apple/system.rs
+++ b/src/apple/system.rs
@@ -255,7 +255,7 @@ impl SystemExt for System {
                 let proc_data = Arc::new(ProcessorData::new(cpu_info, num_cpu_info));
                 let mut add = 0;
                 for proc_ in self.processors.iter_mut() {
-                    let old_proc_data = &*proc_.get_data();
+                    let old_proc_data = &*proc_.data();
                     let in_use = (*cpu_info.offset(add as isize + libc::CPU_STATE_USER as isize)
                         - *old_proc_data
                             .cpu_info
@@ -274,7 +274,7 @@ impl SystemExt for System {
                                 .cpu_info
                                 .offset(add as isize + libc::CPU_STATE_IDLE as isize));
                     proc_.update(in_use as f32 / total as f32 * 100., Arc::clone(&proc_data));
-                    pourcent += proc_.get_cpu_usage();
+                    pourcent += proc_.cpu_usage();
 
                     add += libc::CPU_STATE_MAX;
                 }
@@ -363,23 +363,23 @@ impl SystemExt for System {
     //
     // Need to be moved into a "common" file to avoid duplication.
 
-    fn get_processes(&self) -> &HashMap<Pid, Process> {
+    fn processes(&self) -> &HashMap<Pid, Process> {
         &self.process_list
     }
 
-    fn get_process(&self, pid: Pid) -> Option<&Process> {
+    fn process(&self, pid: Pid) -> Option<&Process> {
         self.process_list.get(&pid)
     }
 
-    fn get_global_processor_info(&self) -> &Processor {
+    fn global_processor_info(&self) -> &Processor {
         &self.global_processor
     }
 
-    fn get_processors(&self) -> &[Processor] {
+    fn processors(&self) -> &[Processor] {
         &self.processors
     }
 
-    fn get_physical_core_count(&self) -> Option<usize> {
+    fn physical_core_count(&self) -> Option<usize> {
         let mut physical_core_count = 0;
 
         if unsafe {
@@ -395,66 +395,66 @@ impl SystemExt for System {
         }
     }
 
-    fn get_networks(&self) -> &Networks {
+    fn networks(&self) -> &Networks {
         &self.networks
     }
 
-    fn get_networks_mut(&mut self) -> &mut Networks {
+    fn networks_mut(&mut self) -> &mut Networks {
         &mut self.networks
     }
 
-    fn get_total_memory(&self) -> u64 {
+    fn total_memory(&self) -> u64 {
         self.mem_total
     }
 
-    fn get_free_memory(&self) -> u64 {
+    fn free_memory(&self) -> u64 {
         self.mem_free
     }
 
-    fn get_available_memory(&self) -> u64 {
+    fn available_memory(&self) -> u64 {
         self.mem_available
     }
 
-    fn get_used_memory(&self) -> u64 {
+    fn used_memory(&self) -> u64 {
         self.mem_total - self.mem_free
     }
 
-    fn get_total_swap(&self) -> u64 {
+    fn total_swap(&self) -> u64 {
         self.swap_total
     }
 
-    fn get_free_swap(&self) -> u64 {
+    fn free_swap(&self) -> u64 {
         self.swap_free
     }
 
     // need to be checked
-    fn get_used_swap(&self) -> u64 {
+    fn used_swap(&self) -> u64 {
         self.swap_total - self.swap_free
     }
 
-    fn get_components(&self) -> &[Component] {
+    fn components(&self) -> &[Component] {
         &self.components
     }
 
-    fn get_components_mut(&mut self) -> &mut [Component] {
+    fn components_mut(&mut self) -> &mut [Component] {
         &mut self.components
     }
 
-    fn get_disks(&self) -> &[Disk] {
+    fn disks(&self) -> &[Disk] {
         &self.disks
     }
 
-    fn get_disks_mut(&mut self) -> &mut [Disk] {
+    fn disks_mut(&mut self) -> &mut [Disk] {
         &mut self.disks
     }
 
-    fn get_uptime(&self) -> u64 {
+    fn uptime(&self) -> u64 {
         let csec = unsafe { libc::time(::std::ptr::null_mut()) };
 
         unsafe { libc::difftime(csec, self.boot_time as _) as u64 }
     }
 
-    fn get_load_average(&self) -> LoadAvg {
+    fn load_average(&self) -> LoadAvg {
         let mut loads = vec![0f64; 3];
         unsafe {
             libc::getloadavg(loads.as_mut_ptr(), 3);
@@ -466,21 +466,21 @@ impl SystemExt for System {
         }
     }
 
-    fn get_users(&self) -> &[User] {
+    fn users(&self) -> &[User] {
         &self.users
     }
 
-    fn get_boot_time(&self) -> u64 {
+    fn boot_time(&self) -> u64 {
         self.boot_time
     }
 
-    fn get_name(&self) -> Option<String> {
+    fn name(&self) -> Option<String> {
         get_system_info(libc::KERN_OSTYPE, Some("Darwin"))
     }
 
-    fn get_long_os_version(&self) -> Option<String> {
+    fn long_os_version(&self) -> Option<String> {
         #[cfg(target_os = "macos")]
-        let friendly_name = match self.get_os_version().unwrap_or_default() {
+        let friendly_name = match self.os_version().unwrap_or_default() {
             f_n if f_n.starts_with("10.16")
                 | f_n.starts_with("11.0")
                 | f_n.starts_with("11.1")
@@ -510,25 +510,25 @@ impl SystemExt for System {
         #[cfg(target_os = "macos")]
         let long_name = Some(format!(
             "MacOS {} {}",
-            self.get_os_version().unwrap_or_default(),
+            self.os_version().unwrap_or_default(),
             friendly_name
         ));
 
         #[cfg(target_os = "ios")]
-        let long_name = Some(format!("iOS {}", self.get_os_version().unwrap_or_default()));
+        let long_name = Some(format!("iOS {}", self.os_version().unwrap_or_default()));
 
         long_name
     }
 
-    fn get_host_name(&self) -> Option<String> {
+    fn host_name(&self) -> Option<String> {
         get_system_info(libc::KERN_HOSTNAME, None)
     }
 
-    fn get_kernel_version(&self) -> Option<String> {
+    fn kernel_version(&self) -> Option<String> {
         get_system_info(libc::KERN_OSRELEASE, None)
     }
 
-    fn get_os_version(&self) -> Option<String> {
+    fn os_version(&self) -> Option<String> {
         unsafe {
             // get the size for the buffer first
             let mut size = 0;
diff --git a/src/c_interface.rs b/src/c_interface.rs
index 2f8ed95..cfce3df 100644
--- a/src/c_interface.rs
+++ b/src/c_interface.rs
@@ -15,7 +15,7 @@ pub type CSystem = *mut c_void;
 pub type CProcess = *const c_void;
 /// C string returned from `CString::into_raw`.
 pub type RString = *const c_char;
-/// Callback used by [`get_processes`][crate::System#method.get_processes].
+/// Callback used by [`get_processes`][crate::System#method.processes].
 pub type ProcessLoop = extern "C" fn(pid: pid_t, process: CProcess, data: *mut c_void) -> bool;
 
 /// Equivalent of [`System::new()`][crate::System#method.new].
@@ -143,95 +143,95 @@ pub extern "C" fn sysinfo_refresh_disks_list(system: CSystem) {
     Box::into_raw(system);
 }
 
-/// Equivalent of [`System::get_total_memory()`][crate::System#method.get_total_memory].
+/// Equivalent of [`System::get_total_memory()`][crate::System#method.total_memory].
 #[no_mangle]
 pub extern "C" fn sysinfo_get_total_memory(system: CSystem) -> size_t {
     assert!(!system.is_null());
     let system: Box<System> = unsafe { Box::from_raw(system as *mut System) };
-    let ret = system.get_total_memory() as size_t;
+    let ret = system.total_memory() as size_t;
     Box::into_raw(system);
     ret
 }
 
-/// Equivalent of [`System::get_free_memory()`][crate::System#method.get_free_memory].
+/// Equivalent of [`System::get_free_memory()`][crate::System#method.free_memory].
 #[no_mangle]
 pub extern "C" fn sysinfo_get_free_memory(system: CSystem) -> size_t {
     assert!(!system.is_null());
     let system: Box<System> = unsafe { Box::from_raw(system as *mut System) };
-    let ret = system.get_free_memory() as size_t;
+    let ret = system.free_memory() as size_t;
     Box::into_raw(system);
     ret
 }
 
-/// Equivalent of [`System::get_used_memory()`][crate::System#method.get_used_memory].
+/// Equivalent of [`System::get_used_memory()`][crate::System#method.used_memory].
 #[no_mangle]
 pub extern "C" fn sysinfo_get_used_memory(system: CSystem) -> size_t {
     assert!(!system.is_null());
     let system: Box<System> = unsafe { Box::from_raw(system as *mut System) };
-    let ret = system.get_used_memory() as size_t;
+    let ret = system.used_memory() as size_t;
     Box::into_raw(system);
     ret
 }
 
-/// Equivalent of [`System::get_total_swap()`][crate::System#method.get_total_swap].
+/// Equivalent of [`System::get_total_swap()`][crate::System#method.total_swap].
 #[no_mangle]
 pub extern "C" fn sysinfo_get_total_swap(system: CSystem) -> size_t {
     assert!(!system.is_null());
     let system: Box<System> = unsafe { Box::from_raw(system as *mut System) };
-    let ret = system.get_total_swap() as size_t;
+    let ret = system.total_swap() as size_t;
     Box::into_raw(system);
     ret
 }
 
-/// Equivalent of [`System::get_free_swap()`][crate::System#method.get_free_swap].
+/// Equivalent of [`System::get_free_swap()`][crate::System#method.free_swap].
 #[no_mangle]
 pub extern "C" fn sysinfo_get_free_swap(system: CSystem) -> size_t {
     assert!(!system.is_null());
     let system: Box<System> = unsafe { Box::from_raw(system as *mut System) };
-    let ret = system.get_free_swap() as size_t;
+    let ret = system.free_swap() as size_t;
     Box::into_raw(system);
     ret
 }
 
-/// Equivalent of [`System::get_used_swap()`][crate::System#method.get_used_swap].
+/// Equivalent of [`System::get_used_swap()`][crate::System#method.used_swap].
 #[no_mangle]
 pub extern "C" fn sysinfo_get_used_swap(system: CSystem) -> size_t {
     assert!(!system.is_null());
     let system: Box<System> = unsafe { Box::from_raw(system as *mut System) };
-    let ret = system.get_used_swap() as size_t;
+    let ret = system.used_swap() as size_t;
     Box::into_raw(system);
     ret
 }
 
 /// Equivalent of
-/// `system::get_networks().iter().fold(0, |acc, (_, data)| acc + data.get_received() as size_t)`.
+/// `system::get_networks().iter().fold(0, |acc, (_, data)| acc + data.received() as size_t)`.
 #[no_mangle]
 pub extern "C" fn sysinfo_get_networks_received(system: CSystem) -> size_t {
     assert!(!system.is_null());
     let system: Box<System> = unsafe { Box::from_raw(system as *mut System) };
     let ret = system
-        .get_networks()
+        .networks()
         .iter()
-        .fold(0, |acc, (_, data)| acc + data.get_received() as size_t);
+        .fold(0, |acc, (_, data)| acc + data.received() as size_t);
     Box::into_raw(system);
     ret
 }
 
 /// Equivalent of
-/// `system::get_networks().iter().fold(0, |acc, (_, data)| acc + data.get_transmitted() as size_t)`.
+/// `system::get_networks().iter().fold(0, |acc, (_, data)| acc + data.transmitted() as size_t)`.
 #[no_mangle]
 pub extern "C" fn sysinfo_get_networks_transmitted(system: CSystem) -> size_t {
     assert!(!system.is_null());
     let system: Box<System> = unsafe { Box::from_raw(system as *mut System) };
     let ret = system
-        .get_networks()
+        .networks()
         .iter()
-        .fold(0, |acc, (_, data)| acc + data.get_transmitted() as size_t);
+        .fold(0, |acc, (_, data)| acc + data.transmitted() as size_t);
     Box::into_raw(system);
     ret
 }
 
-/// Equivalent of [`System::get_processors_usage()`][crate::System#method.get_processors_usage].
+/// Equivalent of [`System::get_processors_usage()`][crate::System#method.processors_usage].
 ///
 /// * `length` will contain the number of cpu usage added into `procs`.
 /// * `procs` will be allocated if it's null and will contain of cpu usage.
@@ -247,14 +247,14 @@ pub extern "C" fn sysinfo_get_processors_usage(
     }
     let system: Box<System> = unsafe { Box::from_raw(system as *mut System) };
     {
-        let processors = system.get_processors();
+        let processors = system.processors();
         unsafe {
             if (*procs).is_null() {
                 (*procs) = libc::malloc(::std::mem::size_of::<c_float>() * processors.len())
                     as *mut c_float;
             }
             for (pos, processor) in processors.iter().skip(1).enumerate() {
-                (*(*procs).offset(pos as isize)) = processor.get_cpu_usage();
+                (*(*procs).offset(pos as isize)) = processor.cpu_usage();
             }
             *length = processors.len() as c_uint - 1;
         }
@@ -262,7 +262,7 @@ pub extern "C" fn sysinfo_get_processors_usage(
     Box::into_raw(system);
 }
 
-/// Equivalent of [`System::get_processes()`][crate::System#method.get_processes]. Returns an
+/// Equivalent of [`System::get_processes()`][crate::System#method.processes]. Returns an
 /// array ended by a null pointer. Must be freed.
 ///
 /// # /!\ WARNING /!\
@@ -278,7 +278,7 @@ pub extern "C" fn sysinfo_get_processes(
     if let Some(fn_pointer) = fn_pointer {
         let system: Box<System> = unsafe { Box::from_raw(system as *mut System) };
         let len = {
-            let entries = system.get_processes();
+            let entries = system.processes();
             for (pid, process) in entries {
                 if !fn_pointer(*pid, process as *const Process as CProcess, data) {
                     break;
@@ -293,7 +293,7 @@ pub extern "C" fn sysinfo_get_processes(
     }
 }
 
-/// Equivalent of [`System::get_process()`][crate::System#method.get_process].
+/// Equivalent of [`System::get_process()`][crate::System#method.process].
 ///
 /// # /!\ WARNING /!\
 ///
@@ -303,7 +303,7 @@ pub extern "C" fn sysinfo_get_processes(
 pub extern "C" fn sysinfo_get_process_by_pid(system: CSystem, pid: pid_t) -> CProcess {
     assert!(!system.is_null());
     let system: Box<System> = unsafe { Box::from_raw(system as *mut System) };
-    let ret = if let Some(process) = system.get_process(pid) {
+    let ret = if let Some(process) = system.process(pid) {
         process as *const Process as CProcess
     } else {
         std::ptr::null()
diff --git a/src/common.rs b/src/common.rs
index 5e6b9a1..df1f800 100644
--- a/src/common.rs
+++ b/src/common.rs
@@ -104,9 +104,9 @@ assert_eq!(r.", stringify!($name), "(), false);
 /// // We want everything except disks.
 /// let mut system = System::new_with_specifics(RefreshKind::everything().without_disks_list());
 ///
-/// assert_eq!(system.get_disks().len(), 0);
+/// assert_eq!(system.disks().len(), 0);
 /// # if System::IS_SUPPORTED {
-/// assert!(system.get_processes().len() > 0);
+/// assert!(system.processes().len() > 0);
 /// # }
 /// ```
 ///
@@ -205,7 +205,7 @@ impl RefreshKind {
 /// use sysinfo::{System, SystemExt, NetworksExt};
 ///
 /// let system = System::new_all();
-/// let networks_iter = system.get_networks().iter();
+/// let networks_iter = system.networks().iter();
 /// ```
 pub struct NetworksIter<'a> {
     inner: std::collections::hash_map::Iter<'a, String, NetworkData>,
@@ -236,14 +236,14 @@ impl<'a> IntoIterator for &'a Networks {
 
 /// Enum containing the different supported disks types.
 ///
-/// This type is returned by [`Disk::get_type`][crate::Disk#method.get_type].
+/// This type is returned by [`Disk::get_type`][crate::Disk#method.type].
 ///
 /// ```no_run
 /// use sysinfo::{System, SystemExt, DiskExt};
 ///
 /// let system = System::new_all();
-/// for disk in system.get_disks() {
-///     println!("{:?}: {:?}", disk.get_name(), disk.get_type());
+/// for disk in system.disks() {
+///     println!("{:?}: {:?}", disk.name(), disk.type_());
 /// }
 /// ```
 #[derive(Debug, PartialEq, Clone, Copy)]
@@ -340,7 +340,7 @@ pub enum Signal {
 /// use sysinfo::{System, SystemExt};
 ///
 /// let s = System::new_all();
-/// let load_avg = s.get_load_average();
+/// let load_avg = s.load_average();
 /// println!(
 ///     "one minute: {}%, five minutes: {}%, fifteen minutes: {}%",
 ///     load_avg.one,
@@ -411,7 +411,7 @@ xid!(
 /// use sysinfo::{System, SystemExt};
 ///
 /// let s = System::new_all();
-/// println!("users: {:?}", s.get_users());
+/// println!("users: {:?}", s.users());
 /// ```
 #[derive(PartialEq, Eq, PartialOrd, Ord, Debug)]
 pub struct User {
@@ -422,19 +422,19 @@ pub struct User {
 }
 
 impl UserExt for User {
-    fn get_uid(&self) -> Uid {
+    fn uid(&self) -> Uid {
         self.uid
     }
 
-    fn get_gid(&self) -> Gid {
+    fn gid(&self) -> Gid {
         self.gid
     }
 
-    fn get_name(&self) -> &str {
+    fn name(&self) -> &str {
         &self.name
     }
 
-    fn get_groups(&self) -> &[String] {
+    fn groups(&self) -> &[String] {
         &self.groups
     }
 }
@@ -447,7 +447,7 @@ impl UserExt for User {
 /// use sysinfo::{ProcessExt, System, SystemExt};
 ///
 /// let s = System::new_all();
-/// for (pid, process) in s.get_processes() {
+/// for (pid, process) in s.processes() {
 ///     let disk_usage = process.disk_usage();
 ///     println!("[{}] read bytes   : new/total => {}/{} B",
 ///         pid,
diff --git a/src/debug.rs b/src/debug.rs
index af9d73c..23a533c 100644
--- a/src/debug.rs
+++ b/src/debug.rs
@@ -14,8 +14,8 @@ use std::fmt;
 impl fmt::Debug for Processor {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Processor")
-            .field("name", &self.get_name())
-            .field("CPU usage", &self.get_cpu_usage())
+            .field("name", &self.name())
+            .field("CPU usage", &self.cpu_usage())
             .finish()
     }
 }
@@ -25,18 +25,18 @@ impl fmt::Debug for System {
         f.debug_struct("System")
             .field(
                 "global CPU usage",
-                &self.get_global_processor_info().get_cpu_usage(),
+                &self.global_processor_info().cpu_usage(),
             )
-            .field("load average", &self.get_load_average())
-            .field("total memory", &self.get_total_memory())
-            .field("free memory", &self.get_free_memory())
-            .field("total swap", &self.get_total_swap())
-            .field("free swap", &self.get_free_swap())
-            .field("nb CPUs", &self.get_processors().len())
-            .field("nb network interfaces", &self.get_networks().iter().count())
-            .field("nb processes", &self.get_processes().len())
-            .field("nb disks", &self.get_disks().len())
-            .field("nb components", &self.get_components().len())
+            .field("load average", &self.load_average())
+            .field("total memory", &self.total_memory())
+            .field("free memory", &self.free_memory())
+            .field("total swap", &self.total_swap())
+            .field("free swap", &self.free_swap())
+            .field("nb CPUs", &self.processors().len())
+            .field("nb network interfaces", &self.networks().iter().count())
+            .field("nb processes", &self.processes().len())
+            .field("nb disks", &self.disks().len())
+            .field("nb components", &self.components().len())
             .finish()
     }
 }
@@ -46,15 +46,15 @@ impl fmt::Debug for Disk {
         write!(
             fmt,
             "Disk({:?})[FS: {:?}][Type: {:?}] mounted on {:?}: {}/{} B",
-            self.get_name(),
-            self.get_file_system()
+            self.name(),
+            self.file_system()
                 .iter()
                 .map(|c| *c as char)
                 .collect::<Vec<_>>(),
-            self.get_type(),
-            self.get_mount_point(),
-            self.get_available_space(),
-            self.get_total_space()
+            self.type_(),
+            self.mount_point(),
+            self.available_space(),
+            self.total_space()
         )
     }
 }
@@ -81,22 +81,22 @@ impl fmt::Debug for Process {
 
 impl fmt::Debug for Component {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if let Some(critical) = self.get_critical() {
+        if let Some(critical) = self.critical() {
             write!(
                 f,
                 "{}: {}°C (max: {}°C / critical: {}°C)",
-                self.get_label(),
-                self.get_temperature(),
-                self.get_max(),
+                self.label(),
+                self.temperature(),
+                self.max(),
                 critical
             )
         } else {
             write!(
                 f,
                 "{}: {}°C (max: {}°C)",
-                self.get_label(),
-                self.get_temperature(),
-                self.get_max()
+                self.label(),
+                self.temperature(),
+                self.max()
             )
         }
     }
@@ -118,24 +118,18 @@ impl fmt::Debug for Networks {
 impl fmt::Debug for NetworkData {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("NetworkData")
-            .field("income", &self.get_received())
-            .field("total income", &self.get_total_received())
-            .field("outcome", &self.get_transmitted())
-            .field("total outcome", &self.get_total_transmitted())
-            .field("packets income", &self.get_packets_received())
-            .field("total packets income", &self.get_total_packets_received())
-            .field("packets outcome", &self.get_packets_transmitted())
-            .field(
-                "total packets outcome",
-                &self.get_total_packets_transmitted(),
-            )
-            .field("errors income", &self.get_errors_on_received())
-            .field("total errors income", &self.get_total_errors_on_received())
-            .field("errors outcome", &self.get_errors_on_transmitted())
-            .field(
-                "total errors outcome",
-                &self.get_total_errors_on_transmitted(),
-            )
+            .field("income", &self.received())
+            .field("total income", &self.total_received())
+            .field("outcome", &self.transmitted())
+            .field("total outcome", &self.total_transmitted())
+            .field("packets income", &self.packets_received())
+            .field("total packets income", &self.total_packets_received())
+            .field("packets outcome", &self.packets_transmitted())
+            .field("total packets outcome", &self.total_packets_transmitted())
+            .field("errors income", &self.errors_on_received())
+            .field("total errors income", &self.total_errors_on_received())
+            .field("errors outcome", &self.errors_on_transmitted())
+            .field("total errors outcome", &self.total_errors_on_transmitted())
             .finish()
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index f6538e3..cb5b09c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -39,31 +39,31 @@
 //! system.refresh_all();
 //!
 //! // Now let's print every process' id and name:
-//! for (pid, proc_) in system.get_processes() {
+//! for (pid, proc_) in system.processes() {
 //!     println!("{}:{} => status: {:?}", pid, proc_.name(), proc_.status());
 //! }
 //!
 //! // Then let's print the temperature of the different components:
-//! for component in system.get_components() {
+//! for component in system.components() {
 //!     println!("{:?}", component);
 //! }
 //!
 //! // And then all disks' information:
-//! for disk in system.get_disks() {
+//! for disk in system.disks() {
 //!     println!("{:?}", disk);
 //! }
 //!
 //! // And finally the RAM and SWAP information:
-//! println!("total memory: {} KB", system.get_total_memory());
-//! println!("used memory : {} KB", system.get_used_memory());
-//! println!("total swap  : {} KB", system.get_total_swap());
-//! println!("used swap   : {} KB", system.get_used_swap());
+//! println!("total memory: {} KB", system.total_memory());
+//! println!("used memory : {} KB", system.used_memory());
+//! println!("total swap  : {} KB", system.total_swap());
+//! println!("used swap   : {} KB", system.used_swap());
 //!
 //! // Display system information:
-//! println!("System name:             {:?}", system.get_name());
-//! println!("System kernel version:   {:?}", system.get_kernel_version());
-//! println!("System OS version:       {:?}", system.get_os_version());
-//! println!("System host name:        {:?}", system.get_host_name());
+//! println!("System name:             {:?}", system.name());
+//! println!("System kernel version:   {:?}", system.kernel_version());
+//! println!("System OS version:       {:?}", system.os_version());
+//! println!("System host name:        {:?}", system.host_name());
 //! ```
 
 #![crate_name = "sysinfo"]
@@ -205,9 +205,7 @@ mod test {
             let mut s = System::new();
             s.refresh_all();
             assert_eq!(
-                s.get_processes()
-                    .iter()
-                    .all(|(_, proc_)| proc_.memory() == 0),
+                s.processes().iter().all(|(_, proc_)| proc_.memory() == 0),
                 false
             );
         }
@@ -221,7 +219,7 @@ mod test {
         s.refresh_all();
         // All CPU usage will start at zero until the second refresh
         assert_eq!(
-            s.get_processes()
+            s.processes()
                 .iter()
                 .all(|(_, proc_)| proc_.cpu_usage() == 0.0),
             true
@@ -231,10 +229,10 @@ mod test {
         std::thread::sleep(std::time::Duration::from_millis(100));
         s.refresh_all();
         assert_eq!(
-            s.get_processes()
+            s.processes()
                 .iter()
                 .all(|(_, proc_)| proc_.cpu_usage() >= 0.0
-                    && proc_.cpu_usage() <= (s.get_processors().len() as f32) * 100.0),
+                    && proc_.cpu_usage() <= (s.processors().len() as f32) * 100.0),
             true
         );
     }
@@ -242,37 +240,37 @@ mod test {
     #[test]
     fn check_users() {
         let mut s = System::new();
-        assert!(s.get_users().is_empty());
+        assert!(s.users().is_empty());
         s.refresh_users_list();
-        assert!(s.get_users().len() >= MIN_USERS);
+        assert!(s.users().len() >= MIN_USERS);
 
         let mut s = System::new();
-        assert!(s.get_users().is_empty());
+        assert!(s.users().is_empty());
         s.refresh_all();
-        assert!(s.get_users().is_empty());
+        assert!(s.users().is_empty());
 
         let s = System::new_all();
-        assert!(s.get_users().len() >= MIN_USERS);
+        assert!(s.users().len() >= MIN_USERS);
     }
 
     #[test]
     fn check_uid_gid() {
         let mut s = System::new();
-        assert!(s.get_users().is_empty());
+        assert!(s.users().is_empty());
         s.refresh_users_list();
-        let users = s.get_users();
+        let users = s.users();
         assert!(users.len() >= MIN_USERS);
 
         for user in users {
-            match user.get_name() {
+            match user.name() {
                 "root" => {
-                    assert_eq!(*user.get_uid(), 0);
-                    assert_eq!(*user.get_gid(), 0);
+                    assert_eq!(*user.uid(), 0);
+                    assert_eq!(*user.gid(), 0);
                 }
                 _ => {
-                    assert!(*user.get_uid() > 0);
+                    assert!(*user.uid() > 0);
                     #[cfg(not(target_os = "windows"))]
-                    assert!(*user.get_gid() > 0);
+                    assert!(*user.gid() > 0);
                 }
             }
         }
@@ -283,20 +281,17 @@ mod test {
         // We don't want to test on unsupported systems.
         if System::IS_SUPPORTED {
             let s = System::new();
-            assert!(!s.get_name().expect("Failed to get system name").is_empty());
+            assert!(!s.name().expect("Failed to get system name").is_empty());
 
             assert!(!s
-                .get_kernel_version()
+                .kernel_version()
                 .expect("Failed to get kernel version")
                 .is_empty());
 
-            assert!(!s
-                .get_os_version()
-                .expect("Failed to get os version")
-                .is_empty());
+            assert!(!s.os_version().expect("Failed to get os version").is_empty());
 
             assert!(!s
-                .get_long_os_version()
+                .long_os_version()
                 .expect("Failed to get long OS version")
                 .is_empty());
         }
@@ -307,10 +302,7 @@ mod test {
         // We don't want to test on unsupported systems.
         if System::IS_SUPPORTED {
             let s = System::new();
-            assert!(!s
-                .get_host_name()
-                .expect("Failed to get host name")
-                .is_empty());
+            assert!(!s.host_name().expect("Failed to get host name").is_empty());
         }
     }
 
@@ -342,15 +334,15 @@ mod test {
         let s = System::new();
 
         if System::IS_SUPPORTED {
-            assert!(!s.get_processors().is_empty());
+            assert!(!s.processors().is_empty());
             let physical_cores_count = s
-                .get_physical_core_count()
+                .physical_core_count()
                 .expect("failed to get number of physical cores");
             assert!(physical_cores_count > 0);
-            assert!(physical_cores_count <= s.get_processors().len());
+            assert!(physical_cores_count <= s.processors().len());
         } else {
-            assert!(s.get_processors().is_empty());
-            assert_eq!(s.get_physical_core_count(), None);
+            assert!(s.processors().is_empty());
+            assert_eq!(s.physical_core_count(), None);
         }
     }
 }
diff --git a/src/linux/component.rs b/src/linux/component.rs
index 78f8384..f5a7ff4 100644
--- a/src/linux/component.rs
+++ b/src/linux/component.rs
@@ -138,19 +138,19 @@ impl Component {
 }
 
 impl ComponentExt for Component {
-    fn get_temperature(&self) -> f32 {
+    fn temperature(&self) -> f32 {
         self.temperature
     }
 
-    fn get_max(&self) -> f32 {
+    fn max(&self) -> f32 {
         self.max
     }
 
-    fn get_critical(&self) -> Option<f32> {
+    fn critical(&self) -> Option<f32> {
         self.critical
     }
 
-    fn get_label(&self) -> &str {
+    fn label(&self) -> &str {
         &self.label
     }
 
diff --git a/src/linux/disk.rs b/src/linux/disk.rs
index c725d7d..988b607 100644
--- a/src/linux/disk.rs
+++ b/src/linux/disk.rs
@@ -32,27 +32,27 @@ pub struct Disk {
 }
 
 impl DiskExt for Disk {
-    fn get_type(&self) -> DiskType {
+    fn type_(&self) -> DiskType {
         self.type_
     }
 
-    fn get_name(&self) -> &OsStr {
+    fn name(&self) -> &OsStr {
         &self.name
     }
 
-    fn get_file_system(&self) -> &[u8] {
+    fn file_system(&self) -> &[u8] {
         &self.file_system
     }
 
-    fn get_mount_point(&self) -> &Path {
+    fn mount_point(&self) -> &Path {
         &self.mount_point
     }
 
-    fn get_total_space(&self) -> u64 {
+    fn total_space(&self) -> u64 {
         self.total_space
     }
 
-    fn get_available_space(&self) -> u64 {
+    fn available_space(&self) -> u64 {
         self.available_space
     }
 
diff --git a/src/linux/network.rs b/src/linux/network.rs
index c3df908..3cdd67f 100644
--- a/src/linux/network.rs
+++ b/src/linux/network.rs
@@ -17,7 +17,7 @@ use std::collections::{hash_map, HashMap};
 /// use sysinfo::{NetworksExt, System, SystemExt};
 ///
 /// let s = System::new_all();
-/// let networks = s.get_networks();
+/// let networks = s.networks();
 /// ```
 pub struct Networks {
     interfaces: HashMap<String, NetworkData>,
@@ -226,51 +226,51 @@ impl NetworkData {
 }
 
 impl NetworkExt for NetworkData {
-    fn get_received(&self) -> u64 {
+    fn received(&self) -> u64 {
         self.rx_bytes.saturating_sub(self.old_rx_bytes)
     }
 
-    fn get_total_received(&self) -> u64 {
+    fn total_received(&self) -> u64 {
         self.rx_bytes
     }
 
-    fn get_transmitted(&self) -> u64 {
+    fn transmitted(&self) -> u64 {
         self.tx_bytes.saturating_sub(self.old_tx_bytes)
     }
 
-    fn get_total_transmitted(&self) -> u64 {
+    fn total_transmitted(&self) -> u64 {
         self.tx_bytes
     }
 
-    fn get_packets_received(&self) -> u64 {
+    fn packets_received(&self) -> u64 {
         self.rx_packets.saturating_sub(self.old_rx_packets)
     }
 
-    fn get_total_packets_received(&self) -> u64 {
+    fn total_packets_received(&self) -> u64 {
         self.rx_packets
     }
 
-    fn get_packets_transmitted(&self) -> u64 {
+    fn packets_transmitted(&self) -> u64 {
         self.tx_packets.saturating_sub(self.old_tx_packets)
     }
 
-    fn get_total_packets_transmitted(&self) -> u64 {
+    fn total_packets_transmitted(&self) -> u64 {
         self.tx_packets
     }
 
-    fn get_errors_on_received(&self) -> u64 {
+    fn errors_on_received(&self) -> u64 {
         self.rx_errors.saturating_sub(self.old_rx_errors)
     }
 
-    fn get_total_errors_on_received(&self) -> u64 {
+    fn total_errors_on_received(&self) -> u64 {
         self.rx_errors
     }
 
-    fn get_errors_on_transmitted(&self) -> u64 {
+    fn errors_on_transmitted(&self) -> u64 {
         self.tx_errors.saturating_sub(self.old_tx_errors)
     }
 
-    fn get_total_errors_on_transmitted(&self) -> u64 {
+    fn total_errors_on_transmitted(&self) -> u64 {
         self.tx_errors
     }
 }
diff --git a/src/linux/processor.rs b/src/linux/processor.rs
index b201786..01457a0 100644
--- a/src/linux/processor.rs
+++ b/src/linux/processor.rs
@@ -199,24 +199,24 @@ impl Processor {
 }
 
 impl ProcessorExt for Processor {
-    fn get_cpu_usage(&self) -> f32 {
+    fn cpu_usage(&self) -> f32 {
         self.cpu_usage
     }
 
-    fn get_name(&self) -> &str {
+    fn name(&self) -> &str {
         &self.name
     }
 
     /// Returns the CPU frequency in MHz.
-    fn get_frequency(&self) -> u64 {
+    fn frequency(&self) -> u64 {
         self.frequency
     }
 
-    fn get_vendor_id(&self) -> &str {
+    fn vendor_id(&self) -> &str {
         &self.vendor_id
     }
 
-    fn get_brand(&self) -> &str {
+    fn brand(&self) -> &str {
         &self.brand
     }
 }
diff --git a/src/linux/system.rs b/src/linux/system.rs
index 55aba79..469a7eb 100644
--- a/src/linux/system.rs
+++ b/src/linux/system.rs
@@ -318,7 +318,7 @@ impl SystemExt for System {
     }
 
     fn refresh_processes(&mut self) {
-        let uptime = self.get_uptime();
+        let uptime = self.uptime();
         if refresh_procs(
             &mut self.process_list,
             Path::new("/proc"),
@@ -332,7 +332,7 @@ impl SystemExt for System {
     }
 
     fn refresh_process(&mut self, pid: Pid) -> bool {
-        let uptime = self.get_uptime();
+        let uptime = self.uptime();
         let found = match _get_process_data(
             &Path::new("/proc/").join(pid.to_string()),
             &mut self.process_list,
@@ -372,47 +372,47 @@ impl SystemExt for System {
     //
     // Need to be moved into a "common" file to avoid duplication.
 
-    fn get_processes(&self) -> &HashMap<Pid, Process> {
+    fn processes(&self) -> &HashMap<Pid, Process> {
         &self.process_list.tasks
     }
 
-    fn get_process(&self, pid: Pid) -> Option<&Process> {
+    fn process(&self, pid: Pid) -> Option<&Process> {
         self.process_list.tasks.get(&pid)
     }
 
-    fn get_networks(&self) -> &Networks {
+    fn networks(&self) -> &Networks {
         &self.networks
     }
 
-    fn get_networks_mut(&mut self) -> &mut Networks {
+    fn networks_mut(&mut self) -> &mut Networks {
         &mut self.networks
     }
 
-    fn get_global_processor_info(&self) -> &Processor {
+    fn global_processor_info(&self) -> &Processor {
         &self.global_processor
     }
 
-    fn get_processors(&self) -> &[Processor] {
+    fn processors(&self) -> &[Processor] {
         &self.processors
     }
 
-    fn get_physical_core_count(&self) -> Option<usize> {
+    fn physical_core_count(&self) -> Option<usize> {
         get_physical_core_count()
     }
 
-    fn get_total_memory(&self) -> u64 {
+    fn total_memory(&self) -> u64 {
         self.mem_total
     }
 
-    fn get_free_memory(&self) -> u64 {
+    fn free_memory(&self) -> u64 {
         self.mem_free
     }
 
-    fn get_available_memory(&self) -> u64 {
+    fn available_memory(&self) -> u64 {
         self.mem_available
     }
 
-    fn get_used_memory(&self) -> u64 {
+    fn used_memory(&self) -> u64 {
         self.mem_total
             - self.mem_free
             - self.mem_buffers
@@ -420,36 +420,36 @@ impl SystemExt for System {
             - self.mem_slab_reclaimable
     }
 
-    fn get_total_swap(&self) -> u64 {
+    fn total_swap(&self) -> u64 {
         self.swap_total
     }
 
-    fn get_free_swap(&self) -> u64 {
+    fn free_swap(&self) -> u64 {
         self.swap_free
     }
 
     // need to be checked
-    fn get_used_swap(&self) -> u64 {
+    fn used_swap(&self) -> u64 {
         self.swap_total - self.swap_free
     }
 
-    fn get_components(&self) -> &[Component] {
+    fn components(&self) -> &[Component] {
         &self.components
     }
 
-    fn get_components_mut(&mut self) -> &mut [Component] {
+    fn components_mut(&mut self) -> &mut [Component] {
         &mut self.components
     }
 
-    fn get_disks(&self) -> &[Disk] {
+    fn disks(&self) -> &[Disk] {
         &self.disks
     }
 
-    fn get_disks_mut(&mut self) -> &mut [Disk] {
+    fn disks_mut(&mut self) -> &mut [Disk] {
         &mut self.disks
     }
 
-    fn get_uptime(&self) -> u64 {
+    fn uptime(&self) -> u64 {
         let content = get_all_data("/proc/uptime", 50).unwrap_or_default();
         content
             .split('.')
@@ -458,11 +458,11 @@ impl SystemExt for System {
             .unwrap_or_default()
     }
 
-    fn get_boot_time(&self) -> u64 {
+    fn boot_time(&self) -> u64 {
         self.boot_time
     }
 
-    fn get_load_average(&self) -> LoadAvg {
+    fn load_average(&self) -> LoadAvg {
         let mut s = String::new();
         if File::open("/proc/loadavg")
             .and_then(|mut f| f.read_to_string(&mut s))
@@ -483,12 +483,12 @@ impl SystemExt for System {
         }
     }
 
-    fn get_users(&self) -> &[User] {
+    fn users(&self) -> &[User] {
         &self.users
     }
 
     #[cfg(not(target_os = "android"))]
-    fn get_name(&self) -> Option<String> {
+    fn name(&self) -> Option<String> {
         get_system_info_linux(
             InfoType::Name,
             Path::new("/etc/os-release"),
@@ -497,11 +497,11 @@ impl SystemExt for System {
     }
 
     #[cfg(target_os = "android")]
-    fn get_name(&self) -> Option<String> {
+    fn name(&self) -> Option<String> {
         get_system_info_android(InfoType::Name)
     }
 
-    fn get_long_os_version(&self) -> Option<String> {
+    fn long_os_version(&self) -> Option<String> {
         #[cfg(target_os = "android")]
         let system_name = "Android";
 
@@ -511,12 +511,12 @@ impl SystemExt for System {
         Some(format!(
             "{} {} {}",
             system_name,
-            self.get_os_version().unwrap_or_default(),
-            self.get_name().unwrap_or_default()
+            self.os_version().unwrap_or_default(),
+            self.name().unwrap_or_default()
         ))
     }
 
-    fn get_host_name(&self) -> Option<String> {
+    fn host_name(&self) -> Option<String> {
         let hostname_max = unsafe { sysconf(_SC_HOST_NAME_MAX) };
         let mut buffer = vec![0_u8; hostname_max as usize];
         if unsafe { libc::gethostname(buffer.as_mut_ptr() as *mut c_char, buffer.len()) } == 0 {
@@ -531,7 +531,7 @@ impl SystemExt for System {
         }
     }
 
-    fn get_kernel_version(&self) -> Option<String> {
+    fn kernel_version(&self) -> Option<String> {
         let mut raw = std::mem::MaybeUninit::<libc::utsname>::zeroed();
 
         if unsafe { libc::uname(raw.as_mut_ptr()) } == 0 {
@@ -551,7 +551,7 @@ impl SystemExt for System {
     }
 
     #[cfg(not(target_os = "android"))]
-    fn get_os_version(&self) -> Option<String> {
+    fn os_version(&self) -> Option<String> {
         get_system_info_linux(
             InfoType::OsVersion,
             Path::new("/etc/os-release"),
@@ -560,7 +560,7 @@ impl SystemExt for System {
     }
 
     #[cfg(target_os = "android")]
-    fn get_os_version(&self) -> Option<String> {
+    fn os_version(&self) -> Option<String> {
         get_system_info_android(InfoType::OsVersion)
     }
 }
diff --git a/src/system.rs b/src/system.rs
index c8ddd09..23cddc0 100644
--- a/src/system.rs
+++ b/src/system.rs
@@ -17,20 +17,17 @@ mod tests {
         sys.refresh_system();
         // We don't want to test on unsupported systems.
         if System::IS_SUPPORTED {
-            assert!(sys.get_total_memory() != 0);
-            assert!(sys.get_free_memory() != 0);
+            assert!(sys.total_memory() != 0);
+            assert!(sys.free_memory() != 0);
         }
-        assert!(sys.get_total_memory() >= sys.get_free_memory());
-        assert!(sys.get_total_swap() >= sys.get_free_swap());
+        assert!(sys.total_memory() >= sys.free_memory());
+        assert!(sys.total_swap() >= sys.free_swap());
     }
 
     #[test]
     fn test_refresh_process() {
         let mut sys = System::new();
-        assert!(
-            sys.get_processes().is_empty(),
-            "no process should be listed!"
-        );
+        assert!(sys.processes().is_empty(), "no process should be listed!");
         sys.refresh_processes();
         // We don't want to test on unsupported systems.
         if System::IS_SUPPORTED {
@@ -45,9 +42,7 @@ mod tests {
     fn test_get_process() {
         let mut sys = System::new();
         sys.refresh_processes();
-        if let Some(p) =
-            sys.get_process(utils::get_current_pid().expect("failed to get current pid"))
-        {
+        if let Some(p) = sys.process(utils::get_current_pid().expect("failed to get current pid")) {
             assert!(p.memory() > 0);
         } else {
             assert!(!System::IS_SUPPORTED);
@@ -69,9 +64,7 @@ mod tests {
 
         let mut sys = System::new();
         sys.refresh_processes();
-        if let Some(p) =
-            sys.get_process(utils::get_current_pid().expect("failed to get current pid"))
-        {
+        if let Some(p) = sys.process(utils::get_current_pid().expect("failed to get current pid")) {
             p.foo(); // If this doesn't compile, it'll simply mean that the Process type
                      // doesn't implement the Send trait.
             p.bar(); // If this doesn't compile, it'll simply mean that the Process type
@@ -85,7 +78,7 @@ mod tests {
     fn check_hostname_has_no_nuls() {
         let sys = System::new();
 
-        if let Some(hostname) = sys.get_host_name() {
+        if let Some(hostname) = sys.host_name() {
             assert!(!hostname.contains('\u{0}'))
         }
     }
@@ -93,10 +86,10 @@ mod tests {
     #[test]
     fn check_uptime() {
         let sys = System::new();
-        let uptime = sys.get_uptime();
+        let uptime = sys.uptime();
         if System::IS_SUPPORTED {
             std::thread::sleep(std::time::Duration::from_millis(1000));
-            let new_uptime = sys.get_uptime();
+            let new_uptime = sys.uptime();
             assert!(uptime < new_uptime);
         }
     }
diff --git a/src/traits.rs b/src/traits.rs
index e846d85..eb3f052 100644
--- a/src/traits.rs
+++ b/src/traits.rs
@@ -23,8 +23,8 @@ use std::path::Path;
 /// use sysinfo::{DiskExt, System, SystemExt};
 ///
 /// let s = System::new();
-/// for disk in s.get_disks() {
-///     println!("{:?}: {:?}", disk.get_name(), disk.get_type());
+/// for disk in s.disks() {
+///     println!("{:?}: {:?}", disk.name(), disk.type_());
 /// }
 /// ```
 pub trait DiskExt: Debug {
@@ -34,11 +34,11 @@ pub trait DiskExt: Debug {
     /// use sysinfo::{DiskExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// for disk in s.get_disks() {
-    ///     println!("{:?}", disk.get_type());
+    /// for disk in s.disks() {
+    ///     println!("{:?}", disk.type_());
     /// }
     /// ```
-    fn get_type(&self) -> DiskType;
+    fn type_(&self) -> DiskType;
 
     /// Returns the disk name.
     ///
@@ -46,11 +46,11 @@ pub trait DiskExt: Debug {
     /// use sysinfo::{DiskExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// for disk in s.get_disks() {
-    ///     println!("{:?}", disk.get_name());
+    /// for disk in s.disks() {
+    ///     println!("{:?}", disk.name());
     /// }
     /// ```
-    fn get_name(&self) -> &OsStr;
+    fn name(&self) -> &OsStr;
 
     /// Returns the file system used on this disk (so for example: `EXT4`, `NTFS`, etc...).
     ///
@@ -58,11 +58,11 @@ pub trait DiskExt: Debug {
     /// use sysinfo::{DiskExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// for disk in s.get_disks() {
-    ///     println!("{:?}", disk.get_file_system());
+    /// for disk in s.disks() {
+    ///     println!("{:?}", disk.file_system());
     /// }
     /// ```
-    fn get_file_system(&self) -> &[u8];
+    fn file_system(&self) -> &[u8];
 
     /// Returns the mount point of the disk (`/` for example).
     ///
@@ -70,11 +70,11 @@ pub trait DiskExt: Debug {
     /// use sysinfo::{DiskExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// for disk in s.get_disks() {
-    ///     println!("{:?}", disk.get_mount_point());
+    /// for disk in s.disks() {
+    ///     println!("{:?}", disk.mount_point());
     /// }
     /// ```
-    fn get_mount_point(&self) -> &Path;
+    fn mount_point(&self) -> &Path;
 
     /// Returns the total disk size, in bytes.
     ///
@@ -82,11 +82,11 @@ pub trait DiskExt: Debug {
     /// use sysinfo::{DiskExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// for disk in s.get_disks() {
-    ///     println!("{}", disk.get_total_space());
+    /// for disk in s.disks() {
+    ///     println!("{}", disk.total_space());
     /// }
     /// ```
-    fn get_total_space(&self) -> u64;
+    fn total_space(&self) -> u64;
 
     /// Returns the available disk size, in bytes.
     ///
@@ -94,11 +94,11 @@ pub trait DiskExt: Debug {
     /// use sysinfo::{DiskExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// for disk in s.get_disks() {
-    ///     println!("{}", disk.get_available_space());
+    /// for disk in s.disks() {
+    ///     println!("{}", disk.available_space());
     /// }
     /// ```
-    fn get_available_space(&self) -> u64;
+    fn available_space(&self) -> u64;
 
     /// Updates the disk' information.
     ///
@@ -106,7 +106,7 @@ pub trait DiskExt: Debug {
     /// use sysinfo::{DiskExt, System, SystemExt};
     ///
     /// let mut s = System::new_all();
-    /// for disk in s.get_disks_mut() {
+    /// for disk in s.disks_mut() {
     ///     disk.refresh();
     /// }
     /// ```
@@ -127,7 +127,7 @@ pub trait ProcessExt: Debug {
     /// use sysinfo::{ProcessExt, Signal, System, SystemExt};
     ///
     /// let s = System::new();
-    /// if let Some(process) = s.get_process(1337) {
+    /// if let Some(process) = s.process(1337) {
     ///     process.kill(Signal::Kill);
     /// }
     /// ```
@@ -148,7 +148,7 @@ pub trait ProcessExt: Debug {
     /// use sysinfo::{ProcessExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// if let Some(process) = s.get_process(1337) {
+    /// if let Some(process) = s.process(1337) {
     ///     println!("{}", process.name());
     /// }
     /// ```
@@ -160,7 +160,7 @@ pub trait ProcessExt: Debug {
     /// use sysinfo::{ProcessExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// if let Some(process) = s.get_process(1337) {
+    /// if let Some(process) = s.process(1337) {
     ///     println!("{:?}", process.cmd());
     /// }
     /// ```
@@ -172,7 +172,7 @@ pub trait ProcessExt: Debug {
     /// use sysinfo::{ProcessExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// if let Some(process) = s.get_process(1337) {
+    /// if let Some(process) = s.process(1337) {
     ///     println!("{}", process.exe().display());
     /// }
     /// ```
@@ -184,7 +184,7 @@ pub trait ProcessExt: Debug {
     /// use sysinfo::{ProcessExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// if let Some(process) = s.get_process(1337) {
+    /// if let Some(process) = s.process(1337) {
     ///     println!("{}", process.pid());
     /// }
     /// ```
@@ -198,7 +198,7 @@ pub trait ProcessExt: Debug {
     /// use sysinfo::{ProcessExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// if let Some(process) = s.get_process(1337) {
+    /// if let Some(process) = s.process(1337) {
     ///     println!("{:?}", process.environ());
     /// }
     /// ```
@@ -212,7 +212,7 @@ pub trait ProcessExt: Debug {
     /// use sysinfo::{ProcessExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// if let Some(process) = s.get_process(1337) {
+    /// if let Some(process) = s.process(1337) {
     ///     println!("{}", process.cwd().display());
     /// }
     /// ```
@@ -226,32 +226,32 @@ pub trait ProcessExt: Debug {
     /// use sysinfo::{ProcessExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// if let Some(process) = s.get_process(1337) {
+    /// if let Some(process) = s.process(1337) {
     ///     println!("{}", process.root().display());
     /// }
     /// ```
     fn root(&self) -> &Path;
 
-    /// Returns the memory usage (in kB).
+    /// Returns the memory usage (in KB).
     ///
     /// ```no_run
     /// use sysinfo::{ProcessExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// if let Some(process) = s.get_process(1337) {
-    ///     println!("{} kB", process.memory());
+    /// if let Some(process) = s.process(1337) {
+    ///     println!("{} KB", process.memory());
     /// }
     /// ```
     fn memory(&self) -> u64;
 
-    /// Returns the virtual memory usage (in kB).
+    /// Returns the virtual memory usage (in KB).
     ///
     /// ```no_run
     /// use sysinfo::{ProcessExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// if let Some(process) = s.get_process(1337) {
-    ///     println!("{} kB", process.virtual_memory());
+    /// if let Some(process) = s.process(1337) {
+    ///     println!("{} KB", process.virtual_memory());
     /// }
     /// ```
     fn virtual_memory(&self) -> u64;
@@ -262,7 +262,7 @@ pub trait ProcessExt: Debug {
     /// use sysinfo::{ProcessExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// if let Some(process) = s.get_process(1337) {
+    /// if let Some(process) = s.process(1337) {
     ///     println!("{:?}", process.parent());
     /// }
     /// ```
@@ -274,7 +274,7 @@ pub trait ProcessExt: Debug {
     /// use sysinfo::{ProcessExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// if let Some(process) = s.get_process(1337) {
+    /// if let Some(process) = s.process(1337) {
     ///     println!("{:?}", process.status());
     /// }
     /// ```
@@ -286,7 +286,7 @@ pub trait ProcessExt: Debug {
     /// use sysinfo::{ProcessExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// if let Some(process) = s.get_process(1337) {
+    /// if let Some(process) = s.process(1337) {
     ///     println!("Running since {} seconds", process.start_time());
     /// }
     /// ```
@@ -305,7 +305,7 @@ pub trait ProcessExt: Debug {
     /// use sysinfo::{ProcessExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// if let Some(process) = s.get_process(1337) {
+    /// if let Some(process) = s.process(1337) {
     ///     println!("{}%", process.cpu_usage());
     /// }
     /// ```
@@ -319,7 +319,7 @@ pub trait ProcessExt: Debug {
     /// use sysinfo::{ProcessExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// if let Some(process) = s.get_process(1337) {
+    /// if let Some(process) = s.process(1337) {
     ///     let disk_usage = process.disk_usage();
     ///     println!("read bytes   : new/total => {}/{}",
     ///         disk_usage.read_bytes,
@@ -345,11 +345,11 @@ pub trait ProcessorExt: Debug {
     /// use sysinfo::{ProcessorExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// for processor in s.get_processors() {
-    ///     println!("{}%", processor.get_cpu_usage());
+    /// for processor in s.processors() {
+    ///     println!("{}%", processor.cpu_usage());
     /// }
     /// ```
-    fn get_cpu_usage(&self) -> f32;
+    fn cpu_usage(&self) -> f32;
 
     /// Returns this processor's name.
     ///
@@ -357,11 +357,11 @@ pub trait ProcessorExt: Debug {
     /// use sysinfo::{ProcessorExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// for processor in s.get_processors() {
-    ///     println!("{}", processor.get_name());
+    /// for processor in s.processors() {
+    ///     println!("{}", processor.name());
     /// }
     /// ```
-    fn get_name(&self) -> &str;
+    fn name(&self) -> &str;
 
     /// Returns the processor's vendor id.
     ///
@@ -369,11 +369,11 @@ pub trait ProcessorExt: Debug {
     /// use sysinfo::{ProcessorExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// for processor in s.get_processors() {
-    ///     println!("{}", processor.get_vendor_id());
+    /// for processor in s.processors() {
+    ///     println!("{}", processor.vendor_id());
     /// }
     /// ```
-    fn get_vendor_id(&self) -> &str;
+    fn vendor_id(&self) -> &str;
 
     /// Returns the processor's brand.
     ///
@@ -381,11 +381,11 @@ pub trait ProcessorExt: Debug {
     /// use sysinfo::{ProcessorExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// for processor in s.get_processors() {
-    ///     println!("{}", processor.get_brand());
+    /// for processor in s.processors() {
+    ///     println!("{}", processor.brand());
     /// }
     /// ```
-    fn get_brand(&self) -> &str;
+    fn brand(&self) -> &str;
 
     /// Returns the processor's frequency.
     ///
@@ -393,11 +393,11 @@ pub trait ProcessorExt: Debug {
     /// use sysinfo::{ProcessorExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// for processor in s.get_processors() {
-    ///     println!("{}", processor.get_frequency());
+    /// for processor in s.processors() {
+    ///     println!("{}", processor.frequency());
     /// }
     /// ```
-    fn get_frequency(&self) -> u64;
+    fn frequency(&self) -> u64;
 }
 
 /// Contains all the methods of the [`System`][crate::System] type.
@@ -461,15 +461,15 @@ pub trait SystemExt: Sized + Debug + Default {
     /// // We want everything except disks.
     /// let mut system = System::new_with_specifics(RefreshKind::everything().without_disks_list());
     ///
-    /// assert_eq!(system.get_disks().len(), 0);
+    /// assert_eq!(system.disks().len(), 0);
     /// # if System::IS_SUPPORTED {
-    /// assert!(system.get_processes().len() > 0);
+    /// assert!(system.processes().len() > 0);
     /// # }
     ///
     /// // If you want the disks list afterwards, just call the corresponding
     /// // "refresh_disks_list":
     /// system.refresh_disks_list();
-    /// let disks = system.get_disks();
+    /// let disks = system.disks();
     /// ```
     fn new_with_specifics(refreshes: RefreshKind) -> Self;
 
@@ -564,7 +564,7 @@ pub trait SystemExt: Sized + Debug + Default {
     /// s.refresh_components();
     /// ```
     fn refresh_components(&mut self) {
-        for component in self.get_components_mut() {
+        for component in self.components_mut() {
             component.refresh();
         }
     }
@@ -609,7 +609,7 @@ pub trait SystemExt: Sized + Debug + Default {
     /// s.refresh_disks();
     /// ```
     fn refresh_disks(&mut self) {
-        for disk in self.get_disks_mut() {
+        for disk in self.disks_mut() {
             disk.refresh();
         }
     }
@@ -649,11 +649,11 @@ pub trait SystemExt: Sized + Debug + Default {
     /// use sysinfo::{NetworksExt, System, SystemExt};
     ///
     /// let mut s = System::new_all();
-    /// let networks = s.get_networks_mut();
+    /// let networks = s.networks_mut();
     /// networks.refresh();
     /// ```
     fn refresh_networks(&mut self) {
-        self.get_networks_mut().refresh();
+        self.networks_mut().refresh();
     }
 
     /// The network list will be updated: removing not existing anymore interfaces and adding new
@@ -672,11 +672,11 @@ pub trait SystemExt: Sized + Debug + Default {
     /// use sysinfo::{NetworksExt, System, SystemExt};
     ///
     /// let mut s = System::new_all();
-    /// let networks = s.get_networks_mut();
+    /// let networks = s.networks_mut();
     /// networks.refresh_networks_list();
     /// ```
     fn refresh_networks_list(&mut self) {
-        self.get_networks_mut().refresh_networks_list();
+        self.networks_mut().refresh_networks_list();
     }
 
     /// Refreshes all system, processes, disks and network interfaces information.
@@ -703,11 +703,11 @@ pub trait SystemExt: Sized + Debug + Default {
     /// use sysinfo::{ProcessExt, System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// for (pid, process) in s.get_processes() {
+    /// for (pid, process) in s.processes() {
     ///     println!("{} {}", pid, process.name());
     /// }
     /// ```
-    fn get_processes(&self) -> &HashMap<Pid, Process>;
+    fn processes(&self) -> &HashMap<Pid, Process>;
 
     /// Returns the process corresponding to the given pid or `None` if no such process exists.
     ///
@@ -715,11 +715,11 @@ pub trait SystemExt: Sized + Debug + Default {
     /// use sysinfo::{ProcessExt, System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// if let Some(process) = s.get_process(1337) {
+    /// if let Some(process) = s.process(1337) {
     ///     println!("{}", process.name());
     /// }
     /// ```
-    fn get_process(&self, pid: Pid) -> Option<&Process>;
+    fn process(&self, pid: Pid) -> Option<&Process>;
 
     /// Returns a list of process containing the given `name`.
     ///
@@ -727,13 +727,13 @@ pub trait SystemExt: Sized + Debug + Default {
     /// use sysinfo::{ProcessExt, System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// for process in s.get_process_by_name("htop") {
+    /// for process in s.process_by_name("htop") {
     ///     println!("{} {}", process.pid(), process.name());
     /// }
     /// ```
-    fn get_process_by_name(&self, name: &str) -> Vec<&Process> {
+    fn process_by_name(&self, name: &str) -> Vec<&Process> {
         let mut ret = vec![];
-        for val in self.get_processes().values() {
+        for val in self.processes().values() {
             if val.name().contains(name) {
                 ret.push(val);
             }
@@ -747,9 +747,9 @@ pub trait SystemExt: Sized + Debug + Default {
     /// use sysinfo::{ProcessorExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// println!("{}%", s.get_global_processor_info().get_cpu_usage());
+    /// println!("{}%", s.global_processor_info().cpu_usage());
     /// ```
-    fn get_global_processor_info(&self) -> &Processor;
+    fn global_processor_info(&self) -> &Processor;
 
     /// Returns the list of the processors.
     ///
@@ -757,11 +757,11 @@ pub trait SystemExt: Sized + Debug + Default {
     /// use sysinfo::{ProcessorExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// for processor in s.get_processors() {
-    ///     println!("{}%", processor.get_cpu_usage());
+    /// for processor in s.processors() {
+    ///     println!("{}%", processor.cpu_usage());
     /// }
     /// ```
-    fn get_processors(&self) -> &[Processor];
+    fn processors(&self) -> &[Processor];
 
     /// Returns the number of physical cores on the processor or `None` if it couldn't get it.
     ///
@@ -773,91 +773,91 @@ pub trait SystemExt: Sized + Debug + Default {
     /// use sysinfo::{ProcessorExt, System, SystemExt};
     ///
     /// let s = System::new();
-    /// println!("{:?}", s.get_physical_core_count());
+    /// println!("{:?}", s.physical_core_count());
     /// ```
-    fn get_physical_core_count(&self) -> Option<usize>;
+    fn physical_core_count(&self) -> Option<usize>;
 
-    /// Returns the RAM size in kB.
+    /// Returns the RAM size in KB.
     ///
     /// ```no_run
     /// use sysinfo::{System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// println!("{} kB", s.get_total_memory());
+    /// println!("{} KB", s.total_memory());
     /// ```
-    fn get_total_memory(&self) -> u64;
+    fn total_memory(&self) -> u64;
 
-    /// Returns the amount of free RAM in kB.
+    /// Returns the amount of free RAM in KB.
     ///
     /// Generally, "free" memory refers to unallocated memory whereas "available" memory refers to
     /// memory that is available for (re)use.
     ///
     /// Side note: Windows doesn't report "free" memory so this method returns the same value
-    /// as [`get_available_memory`](#tymethod.get_available_memory).
+    /// as [`get_available_memory`](#tymethod.available_memory).
     ///
     /// ```no_run
     /// use sysinfo::{System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// println!("{} kB", s.get_free_memory());
+    /// println!("{} KB", s.free_memory());
     /// ```
-    fn get_free_memory(&self) -> u64;
+    fn free_memory(&self) -> u64;
 
-    /// Returns the amount of available RAM in kB.
+    /// Returns the amount of available RAM in KB.
     ///
     /// Generally, "free" memory refers to unallocated memory whereas "available" memory refers to
     /// memory that is available for (re)use.
     ///
     /// Side note: Windows doesn't report "free" memory so
-    /// [`get_free_memory`](#tymethod.get_free_memory) returns the same value as this method.
+    /// [`get_free_memory`](#tymethod.free_memory) returns the same value as this method.
     ///
     /// ```no_run
     /// use sysinfo::{System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// println!("{} kB", s.get_available_memory());
+    /// println!("{} KB", s.available_memory());
     /// ```
-    fn get_available_memory(&self) -> u64;
+    fn available_memory(&self) -> u64;
 
-    /// Returns the amound of used RAM in kB.
+    /// Returns the amound of used RAM in KB.
     ///
     /// ```no_run
     /// use sysinfo::{System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// println!("{} kB", s.get_used_memory());
+    /// println!("{} KB", s.used_memory());
     /// ```
-    fn get_used_memory(&self) -> u64;
+    fn used_memory(&self) -> u64;
 
-    /// Returns the SWAP size in kB.
+    /// Returns the SWAP size in KB.
     ///
     /// ```no_run
     /// use sysinfo::{System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// println!("{} kB", s.get_total_swap());
+    /// println!("{} KB", s.total_swap());
     /// ```
-    fn get_total_swap(&self) -> u64;
+    fn total_swap(&self) -> u64;
 
-    /// Returns the amount of free SWAP in kB.
+    /// Returns the amount of free SWAP in KB.
     ///
     /// ```no_run
     /// use sysinfo::{System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// println!("{} kB", s.get_free_swap());
+    /// println!("{} KB", s.free_swap());
     /// ```
-    fn get_free_swap(&self) -> u64;
+    fn free_swap(&self) -> u64;
 
-    /// Returns the amount of used SWAP in kB.
+    /// Returns the amount of used SWAP in KB.
     ///
     /// ```no_run
     /// use sysinfo::{System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// println!("{} kB", s.get_used_swap());
+    /// println!("{} KB", s.used_swap());
     /// ```
-    fn get_used_swap(&self) -> u64;
+    fn used_swap(&self) -> u64;
 
     /// Returns the components list.
     ///
@@ -865,11 +865,11 @@ pub trait SystemExt: Sized + Debug + Default {
     /// use sysinfo::{ComponentExt, System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// for component in s.get_components() {
-    ///     println!("{}: {}°C", component.get_label(), component.get_temperature());
+    /// for component in s.components() {
+    ///     println!("{}: {}°C", component.label(), component.temperature());
     /// }
     /// ```
-    fn get_components(&self) -> &[Component];
+    fn components(&self) -> &[Component];
 
     /// Returns a mutable components list.
     ///
@@ -877,11 +877,11 @@ pub trait SystemExt: Sized + Debug + Default {
     /// use sysinfo::{ComponentExt, System, SystemExt};
     ///
     /// let mut s = System::new_all();
-    /// for component in s.get_components_mut() {
+    /// for component in s.components_mut() {
     ///     component.refresh();
     /// }
     /// ```
-    fn get_components_mut(&mut self) -> &mut [Component];
+    fn components_mut(&mut self) -> &mut [Component];
 
     /// Returns the disks list.
     ///
@@ -889,11 +889,11 @@ pub trait SystemExt: Sized + Debug + Default {
     /// use sysinfo::{DiskExt, System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// for disk in s.get_disks() {
-    ///     println!("{:?}", disk.get_name());
+    /// for disk in s.disks() {
+    ///     println!("{:?}", disk.name());
     /// }
     /// ```
-    fn get_disks(&self) -> &[Disk];
+    fn disks(&self) -> &[Disk];
 
     /// Returns the users list.
     ///
@@ -901,11 +901,11 @@ pub trait SystemExt: Sized + Debug + Default {
     /// use sysinfo::{System, SystemExt, UserExt};
     ///
     /// let mut s = System::new_all();
-    /// for user in s.get_users() {
-    ///     println!("{} is in {} groups", user.get_name(), user.get_groups().len());
+    /// for user in s.users() {
+    ///     println!("{} is in {} groups", user.name(), user.groups().len());
     /// }
     /// ```
-    fn get_users(&self) -> &[User];
+    fn users(&self) -> &[User];
 
     /// Returns the disks list.
     ///
@@ -913,11 +913,11 @@ pub trait SystemExt: Sized + Debug + Default {
     /// use sysinfo::{DiskExt, System, SystemExt};
     ///
     /// let mut s = System::new_all();
-    /// for disk in s.get_disks_mut() {
+    /// for disk in s.disks_mut() {
     ///     disk.refresh();
     /// }
     /// ```
-    fn get_disks_mut(&mut self) -> &mut [Disk];
+    fn disks_mut(&mut self) -> &mut [Disk];
 
     /// Returns the network interfaces object.
     ///
@@ -925,17 +925,17 @@ pub trait SystemExt: Sized + Debug + Default {
     /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// let networks = s.get_networks();
+    /// let networks = s.networks();
     /// for (interface_name, data) in networks {
     ///     println!(
     ///         "[{}] in: {}, out: {}",
     ///         interface_name,
-    ///         data.get_received(),
-    ///         data.get_transmitted(),
+    ///         data.received(),
+    ///         data.transmitted(),
     ///     );
     /// }
     /// ```
-    fn get_networks(&self) -> &Networks;
+    fn networks(&self) -> &Networks;
 
     /// Returns a mutable access to network interfaces.
     ///
@@ -943,10 +943,10 @@ pub trait SystemExt: Sized + Debug + Default {
     /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt};
     ///
     /// let mut s = System::new_all();
-    /// let networks = s.get_networks_mut();
+    /// let networks = s.networks_mut();
     /// networks.refresh_networks_list();
     /// ```
-    fn get_networks_mut(&mut self) -> &mut Networks;
+    fn networks_mut(&mut self) -> &mut Networks;
 
     /// Returns system uptime (in seconds).
     ///
@@ -954,9 +954,9 @@ pub trait SystemExt: Sized + Debug + Default {
     /// use sysinfo::{System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// println!("System running since {} seconds", s.get_uptime());
+    /// println!("System running since {} seconds", s.uptime());
     /// ```
-    fn get_uptime(&self) -> u64;
+    fn uptime(&self) -> u64;
 
     /// Returns the time (in seconds) when the system booted since UNIX epoch.
     ///
@@ -964,9 +964,9 @@ pub trait SystemExt: Sized + Debug + Default {
     /// use sysinfo::{System, SystemExt};
     ///
     /// let s = System::new();
-    /// println!("System booted at {} seconds", s.get_boot_time());
+    /// println!("System booted at {} seconds", s.boot_time());
     /// ```
-    fn get_boot_time(&self) -> u64;
+    fn boot_time(&self) -> u64;
 
     /// Returns the system load average value.
     ///
@@ -974,7 +974,7 @@ pub trait SystemExt: Sized + Debug + Default {
     /// use sysinfo::{System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// let load_avg = s.get_load_average();
+    /// let load_avg = s.load_average();
     /// println!(
     ///     "one minute: {}%, five minutes: {}%, fifteen minutes: {}%",
     ///     load_avg.one,
@@ -982,7 +982,7 @@ pub trait SystemExt: Sized + Debug + Default {
     ///     load_avg.fifteen,
     /// );
     /// ```
-    fn get_load_average(&self) -> LoadAvg;
+    fn load_average(&self) -> LoadAvg;
 
     /// Returns the system name.
     ///
@@ -992,9 +992,9 @@ pub trait SystemExt: Sized + Debug + Default {
     /// use sysinfo::{System, SystemExt};
     ///
     /// let s = System::new();
-    /// println!("OS: {:?}", s.get_name());
+    /// println!("OS: {:?}", s.name());
     /// ```
-    fn get_name(&self) -> Option<String>;
+    fn name(&self) -> Option<String>;
 
     /// Returns the system's kernel version.
     ///
@@ -1004,9 +1004,9 @@ pub trait SystemExt: Sized + Debug + Default {
     /// use sysinfo::{System, SystemExt};
     ///
     /// let s = System::new();
-    /// println!("kernel version: {:?}", s.get_kernel_version());
+    /// println!("kernel version: {:?}", s.kernel_version());
     /// ```
-    fn get_kernel_version(&self) -> Option<String>;
+    fn kernel_version(&self) -> Option<String>;
 
     /// Returns the system version (e.g. for MacOS this will return 11.1 rather than the kernel version).
     ///
@@ -1016,9 +1016,9 @@ pub trait SystemExt: Sized + Debug + Default {
     /// use sysinfo::{System, SystemExt};
     ///
     /// let s = System::new();
-    /// println!("OS version: {:?}", s.get_os_version());
+    /// println!("OS version: {:?}", s.os_version());
     /// ```
-    fn get_os_version(&self) -> Option<String>;
+    fn os_version(&self) -> Option<String>;
 
     /// Returns the system long os version (e.g "MacOS 11.2 BigSur").
     ///
@@ -1028,9 +1028,9 @@ pub trait SystemExt: Sized + Debug + Default {
     /// use sysinfo::{System, SystemExt};
     ///
     /// let s = System::new();
-    /// println!("Long OS Version: {:?}", s.get_long_os_version());
+    /// println!("Long OS Version: {:?}", s.long_os_version());
     /// ```
-    fn get_long_os_version(&self) -> Option<String>;
+    fn long_os_version(&self) -> Option<String>;
 
     /// Returns the system hostname based off DNS
     ///
@@ -1040,9 +1040,9 @@ pub trait SystemExt: Sized + Debug + Default {
     /// use sysinfo::{System, SystemExt};
     ///
     /// let s = System::new();
-    /// println!("Hostname: {:?}", s.get_host_name());
+    /// println!("Hostname: {:?}", s.host_name());
     /// ```
-    fn get_host_name(&self) -> Option<String>;
+    fn host_name(&self) -> Option<String>;
 }
 
 /// Getting volume of received and transmitted data.
@@ -1053,12 +1053,12 @@ pub trait NetworkExt: Debug {
     /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// let networks = s.get_networks();
+    /// let networks = s.networks();
     /// for (interface_name, network) in networks {
-    ///     println!("in: {} B", network.get_received());
+    ///     println!("in: {} B", network.received());
     /// }
     /// ```
-    fn get_received(&self) -> u64;
+    fn received(&self) -> u64;
 
     /// Returns the total number of received bytes.
     ///
@@ -1066,12 +1066,12 @@ pub trait NetworkExt: Debug {
     /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// let networks = s.get_networks();
+    /// let networks = s.networks();
     /// for (interface_name, network) in networks {
-    ///     println!("in: {} B", network.get_total_received());
+    ///     println!("in: {} B", network.total_received());
     /// }
     /// ```
-    fn get_total_received(&self) -> u64;
+    fn total_received(&self) -> u64;
 
     /// Returns the number of transmitted bytes since the last refresh.
     ///
@@ -1079,12 +1079,12 @@ pub trait NetworkExt: Debug {
     /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// let networks = s.get_networks();
+    /// let networks = s.networks();
     /// for (interface_name, network) in networks {
-    ///     println!("out: {} B", network.get_transmitted());
+    ///     println!("out: {} B", network.transmitted());
     /// }
     /// ```
-    fn get_transmitted(&self) -> u64;
+    fn transmitted(&self) -> u64;
 
     /// Returns the total number of transmitted bytes.
     ///
@@ -1092,12 +1092,12 @@ pub trait NetworkExt: Debug {
     /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// let networks = s.get_networks();
+    /// let networks = s.networks();
     /// for (interface_name, network) in networks {
-    ///     println!("out: {} B", network.get_total_transmitted());
+    ///     println!("out: {} B", network.total_transmitted());
     /// }
     /// ```
-    fn get_total_transmitted(&self) -> u64;
+    fn total_transmitted(&self) -> u64;
 
     /// Returns the number of incoming packets since the last refresh.
     ///
@@ -1105,12 +1105,12 @@ pub trait NetworkExt: Debug {
     /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// let networks = s.get_networks();
+    /// let networks = s.networks();
     /// for (interface_name, network) in networks {
-    ///     println!("in: {}", network.get_packets_received());
+    ///     println!("in: {}", network.packets_received());
     /// }
     /// ```
-    fn get_packets_received(&self) -> u64;
+    fn packets_received(&self) -> u64;
 
     /// Returns the total number of incoming packets.
     ///
@@ -1118,12 +1118,12 @@ pub trait NetworkExt: Debug {
     /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// let networks = s.get_networks();
+    /// let networks = s.networks();
     /// for (interface_name, network) in networks {
-    ///     println!("in: {}", network.get_total_packets_received());
+    ///     println!("in: {}", network.total_packets_received());
     /// }
     /// ```
-    fn get_total_packets_received(&self) -> u64;
+    fn total_packets_received(&self) -> u64;
 
     /// Returns the number of outcoming packets since the last refresh.
     ///
@@ -1131,12 +1131,12 @@ pub trait NetworkExt: Debug {
     /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// let networks = s.get_networks();
+    /// let networks = s.networks();
     /// for (interface_name, network) in networks {
-    ///     println!("out: {}", network.get_packets_transmitted());
+    ///     println!("out: {}", network.packets_transmitted());
     /// }
     /// ```
-    fn get_packets_transmitted(&self) -> u64;
+    fn packets_transmitted(&self) -> u64;
 
     /// Returns the total number of outcoming packets.
     ///
@@ -1144,12 +1144,12 @@ pub trait NetworkExt: Debug {
     /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// let networks = s.get_networks();
+    /// let networks = s.networks();
     /// for (interface_name, network) in networks {
-    ///     println!("out: {}", network.get_total_packets_transmitted());
+    ///     println!("out: {}", network.total_packets_transmitted());
     /// }
     /// ```
-    fn get_total_packets_transmitted(&self) -> u64;
+    fn total_packets_transmitted(&self) -> u64;
 
     /// Returns the number of incoming errors since the last refresh.
     ///
@@ -1157,12 +1157,12 @@ pub trait NetworkExt: Debug {
     /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// let networks = s.get_networks();
+    /// let networks = s.networks();
     /// for (interface_name, network) in networks {
-    ///     println!("in: {}", network.get_errors_on_received());
+    ///     println!("in: {}", network.errors_on_received());
     /// }
     /// ```
-    fn get_errors_on_received(&self) -> u64;
+    fn errors_on_received(&self) -> u64;
 
     /// Returns the total number of incoming errors.
     ///
@@ -1170,12 +1170,12 @@ pub trait NetworkExt: Debug {
     /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// let networks = s.get_networks();
+    /// let networks = s.networks();
     /// for (interface_name, network) in networks {
-    ///     println!("in: {}", network.get_total_errors_on_received());
+    ///     println!("in: {}", network.total_errors_on_received());
     /// }
     /// ```
-    fn get_total_errors_on_received(&self) -> u64;
+    fn total_errors_on_received(&self) -> u64;
 
     /// Returns the number of outcoming errors since the last refresh.
     ///
@@ -1183,12 +1183,12 @@ pub trait NetworkExt: Debug {
     /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// let networks = s.get_networks();
+    /// let networks = s.networks();
     /// for (interface_name, network) in networks {
-    ///     println!("out: {}", network.get_errors_on_transmitted());
+    ///     println!("out: {}", network.errors_on_transmitted());
     /// }
     /// ```
-    fn get_errors_on_transmitted(&self) -> u64;
+    fn errors_on_transmitted(&self) -> u64;
 
     /// Returns the total number of outcoming errors.
     ///
@@ -1196,12 +1196,12 @@ pub trait NetworkExt: Debug {
     /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// let networks = s.get_networks();
+    /// let networks = s.networks();
     /// for (interface_name, network) in networks {
-    ///     println!("out: {}", network.get_total_errors_on_transmitted());
+    ///     println!("out: {}", network.total_errors_on_transmitted());
     /// }
     /// ```
-    fn get_total_errors_on_transmitted(&self) -> u64;
+    fn total_errors_on_transmitted(&self) -> u64;
 }
 
 /// Interacting with network interfaces.
@@ -1212,9 +1212,9 @@ pub trait NetworksExt: Debug {
     /// use sysinfo::{NetworkExt, NetworksExt, System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// let networks = s.get_networks();
+    /// let networks = s.networks();
     /// for (interface_name, network) in networks {
-    ///     println!("in: {} B", network.get_received());
+    ///     println!("in: {} B", network.received());
     /// }
     /// ```
     fn iter(&self) -> NetworksIter;
@@ -1225,7 +1225,7 @@ pub trait NetworksExt: Debug {
     /// use sysinfo::{NetworksExt, System, SystemExt};
     ///
     /// let mut s = System::new_all();
-    /// let networks = s.get_networks_mut();
+    /// let networks = s.networks_mut();
     /// networks.refresh_networks_list();
     /// ```
     fn refresh_networks_list(&mut self);
@@ -1236,7 +1236,7 @@ pub trait NetworksExt: Debug {
     /// use sysinfo::{NetworksExt, System, SystemExt};
     ///
     /// let mut s = System::new_all();
-    /// let networks = s.get_networks_mut();
+    /// let networks = s.networks_mut();
     /// networks.refresh();
     /// ```
     fn refresh(&mut self);
@@ -1250,11 +1250,11 @@ pub trait ComponentExt: Debug {
     /// use sysinfo::{ComponentExt, System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// for component in s.get_components() {
-    ///     println!("{}°C", component.get_temperature());
+    /// for component in s.components() {
+    ///     println!("{}°C", component.temperature());
     /// }
     /// ```
-    fn get_temperature(&self) -> f32;
+    fn temperature(&self) -> f32;
 
     /// Returns the maximum temperature of the component (in celsius degree).
     ///
@@ -1262,11 +1262,11 @@ pub trait ComponentExt: Debug {
     /// use sysinfo::{ComponentExt, System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// for component in s.get_components() {
-    ///     println!("{}°C", component.get_max());
+    /// for component in s.components() {
+    ///     println!("{}°C", component.max());
     /// }
     /// ```
-    fn get_max(&self) -> f32;
+    fn max(&self) -> f32;
 
     /// Returns the highest temperature before the component halts (in celsius degree).
     ///
@@ -1274,11 +1274,11 @@ pub trait ComponentExt: Debug {
     /// use sysinfo::{ComponentExt, System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// for component in s.get_components() {
-    ///     println!("{:?}°C", component.get_critical());
+    /// for component in s.components() {
+    ///     println!("{:?}°C", component.critical());
     /// }
     /// ```
-    fn get_critical(&self) -> Option<f32>;
+    fn critical(&self) -> Option<f32>;
 
     /// Returns the label of the component.
     ///
@@ -1286,11 +1286,11 @@ pub trait ComponentExt: Debug {
     /// use sysinfo::{ComponentExt, System, SystemExt};
     ///
     /// let s = System::new_all();
-    /// for component in s.get_components() {
-    ///     println!("{}", component.get_label());
+    /// for component in s.components() {
+    ///     println!("{}", component.label());
     /// }
     /// ```
-    fn get_label(&self) -> &str;
+    fn label(&self) -> &str;
 
     /// Refreshes component.
     ///
@@ -1298,7 +1298,7 @@ pub trait ComponentExt: Debug {
     /// use sysinfo::{ComponentExt, System, SystemExt};
     ///
     /// let mut s = System::new_all();
-    /// for component in s.get_components_mut() {
+    /// for component in s.components_mut() {
     ///     component.refresh();
     /// }
     /// ```
@@ -1313,8 +1313,8 @@ pub trait ComponentExt: Debug {
 /// use sysinfo::{System, SystemExt, UserExt};
 ///
 /// let mut s = System::new_all();
-/// for user in s.get_users() {
-///     println!("{} is in {} groups", user.get_name(), user.get_groups().len());
+/// for user in s.users() {
+///     println!("{} is in {} groups", user.name(), user.groups().len());
 /// }
 /// ```
 pub trait UserExt: Debug {
@@ -1324,11 +1324,11 @@ pub trait UserExt: Debug {
     /// use sysinfo::{System, SystemExt, UserExt};
     ///
     /// let mut s = System::new_all();
-    /// for user in s.get_users() {
-    ///     println!("{}", *user.get_uid());
+    /// for user in s.users() {
+    ///     println!("{}", *user.uid());
     /// }
     /// ```
-    fn get_uid(&self) -> Uid;
+    fn uid(&self) -> Uid;
 
     /// Return the group id of the user.
     ///
@@ -1341,11 +1341,11 @@ pub trait UserExt: Debug {
     /// use sysinfo::{System, SystemExt, UserExt};
     ///
     /// let mut s = System::new_all();
-    /// for user in s.get_users() {
-    ///     println!("{}", *user.get_gid());
+    /// for user in s.users() {
+    ///     println!("{}", *user.gid());
     /// }
     /// ```
-    fn get_gid(&self) -> Gid;
+    fn gid(&self) -> Gid;
 
     /// Returns the name of the user.
     ///
@@ -1353,11 +1353,11 @@ pub trait UserExt: Debug {
     /// use sysinfo::{System, SystemExt, UserExt};
     ///
     /// let mut s = System::new_all();
-    /// for user in s.get_users() {
-    ///     println!("{}", user.get_name());
+    /// for user in s.users() {
+    ///     println!("{}", user.name());
     /// }
     /// ```
-    fn get_name(&self) -> &str;
+    fn name(&self) -> &str;
 
     /// Returns the groups of the user.
     ///
@@ -1365,9 +1365,9 @@ pub trait UserExt: Debug {
     /// use sysinfo::{System, SystemExt, UserExt};
     ///
     /// let mut s = System::new_all();
-    /// for user in s.get_users() {
-    ///     println!("{} is in {:?}", user.get_name(), user.get_groups());
+    /// for user in s.users() {
+    ///     println!("{} is in {:?}", user.name(), user.groups());
     /// }
     /// ```
-    fn get_groups(&self) -> &[String];
+    fn groups(&self) -> &[String];
 }
diff --git a/src/unknown/component.rs b/src/unknown/component.rs
index 98c659e..0f5f009 100644
--- a/src/unknown/component.rs
+++ b/src/unknown/component.rs
@@ -10,19 +10,19 @@ use crate::ComponentExt;
 pub struct Component {}
 
 impl ComponentExt for Component {
-    fn get_temperature(&self) -> f32 {
+    fn temperature(&self) -> f32 {
         0.0
     }
 
-    fn get_max(&self) -> f32 {
+    fn max(&self) -> f32 {
         0.0
     }
 
-    fn get_critical(&self) -> Option<f32> {
+    fn critical(&self) -> Option<f32> {
         None
     }
 
-    fn get_label(&self) -> &str {
+    fn label(&self) -> &str {
         ""
     }
 
diff --git a/src/unknown/disk.rs b/src/unknown/disk.rs
index 7e1bd64..f7cbadb 100644
--- a/src/unknown/disk.rs
+++ b/src/unknown/disk.rs
@@ -12,27 +12,27 @@ use std::{ffi::OsStr, path::Path};
 pub struct Disk {}
 
 impl DiskExt for Disk {
-    fn get_type(&self) -> DiskType {
+    fn type_(&self) -> DiskType {
         unreachable!()
     }
 
-    fn get_name(&self) -> &OsStr {
+    fn name(&self) -> &OsStr {
         unreachable!()
     }
 
-    fn get_file_system(&self) -> &[u8] {
+    fn file_system(&self) -> &[u8] {
         &[]
     }
 
-    fn get_mount_point(&self) -> &Path {
+    fn mount_point(&self) -> &Path {
         Path::new("")
     }
 
-    fn get_total_space(&self) -> u64 {
+    fn total_space(&self) -> u64 {
         0
     }
 
-    fn get_available_space(&self) -> u64 {
+    fn available_space(&self) -> u64 {
         0
     }
 
diff --git a/src/unknown/network.rs b/src/unknown/network.rs
index c522876..aaa632e 100644
--- a/src/unknown/network.rs
+++ b/src/unknown/network.rs
@@ -14,7 +14,7 @@ use crate::{NetworkExt, NetworksExt, NetworksIter};
 /// use sysinfo::{NetworksExt, System, SystemExt};
 ///
 /// let s = System::new_all();
-/// let networks = s.get_networks();
+/// let networks = s.networks();
 /// ```
 pub struct Networks {
     interfaces: HashMap<String, NetworkData>,
@@ -42,51 +42,51 @@ impl NetworksExt for Networks {
 pub struct NetworkData;
 
 impl NetworkExt for NetworkData {
-    fn get_received(&self) -> u64 {
+    fn received(&self) -> u64 {
         0
     }
 
-    fn get_total_received(&self) -> u64 {
+    fn total_received(&self) -> u64 {
         0
     }
 
-    fn get_transmitted(&self) -> u64 {
+    fn transmitted(&self) -> u64 {
         0
     }
 
-    fn get_total_transmitted(&self) -> u64 {
+    fn total_transmitted(&self) -> u64 {
         0
     }
 
-    fn get_packets_received(&self) -> u64 {
+    fn packets_received(&self) -> u64 {
         0
     }
 
-    fn get_total_packets_received(&self) -> u64 {
+    fn total_packets_received(&self) -> u64 {
         0
     }
 
-    fn get_packets_transmitted(&self) -> u64 {
+    fn packets_transmitted(&self) -> u64 {
         0
     }
 
-    fn get_total_packets_transmitted(&self) -> u64 {
+    fn total_packets_transmitted(&self) -> u64 {
         0
     }
 
-    fn get_errors_on_received(&self) -> u64 {
+    fn errors_on_received(&self) -> u64 {
         0
     }
 
-    fn get_total_errors_on_received(&self) -> u64 {
+    fn total_errors_on_received(&self) -> u64 {
         0
     }
 
-    fn get_errors_on_transmitted(&self) -> u64 {
+    fn errors_on_transmitted(&self) -> u64 {
         0
     }
 
-    fn get_total_errors_on_transmitted(&self) -> u64 {
+    fn total_errors_on_transmitted(&self) -> u64 {
         0
     }
 }
diff --git a/src/unknown/processor.rs b/src/unknown/processor.rs
index 33fc29d..9d6484f 100644
--- a/src/unknown/processor.rs
+++ b/src/unknown/processor.rs
@@ -16,23 +16,23 @@ impl Processor {
 }
 
 impl ProcessorExt for Processor {
-    fn get_cpu_usage(&self) -> f32 {
+    fn cpu_usage(&self) -> f32 {
         0.0
     }
 
-    fn get_name(&self) -> &str {
+    fn name(&self) -> &str {
         ""
     }
 
-    fn get_frequency(&self) -> u64 {
+    fn frequency(&self) -> u64 {
         0
     }
 
-    fn get_vendor_id(&self) -> &str {
+    fn vendor_id(&self) -> &str {
         ""
     }
 
-    fn get_brand(&self) -> &str {
+    fn brand(&self) -> &str {
         ""
     }
 }
diff --git a/src/unknown/system.rs b/src/unknown/system.rs
index 3ab3239..9617968 100644
--- a/src/unknown/system.rs
+++ b/src/unknown/system.rs
@@ -49,87 +49,87 @@ impl SystemExt for System {
     //
     // Need to be moved into a "common" file to avoid duplication.
 
-    fn get_processes(&self) -> &HashMap<Pid, Process> {
+    fn processes(&self) -> &HashMap<Pid, Process> {
         &self.processes_list
     }
 
-    fn get_process(&self, _pid: Pid) -> Option<&Process> {
+    fn process(&self, _pid: Pid) -> Option<&Process> {
         None
     }
 
-    fn get_networks(&self) -> &Networks {
+    fn networks(&self) -> &Networks {
         &self.networks
     }
 
-    fn get_networks_mut(&mut self) -> &mut Networks {
+    fn networks_mut(&mut self) -> &mut Networks {
         &mut self.networks
     }
 
-    fn get_global_processor_info(&self) -> &Processor {
+    fn global_processor_info(&self) -> &Processor {
         &self.global_processor
     }
 
-    fn get_processors(&self) -> &[Processor] {
+    fn processors(&self) -> &[Processor] {
         &[]
     }
 
-    fn get_physical_core_count(&self) -> Option<usize> {
+    fn physical_core_count(&self) -> Option<usize> {
         None
     }
 
-    fn get_total_memory(&self) -> u64 {
+    fn total_memory(&self) -> u64 {
         0
     }
 
-    fn get_free_memory(&self) -> u64 {
+    fn free_memory(&self) -> u64 {
         0
     }
 
-    fn get_available_memory(&self) -> u64 {
+    fn available_memory(&self) -> u64 {
         0
     }
 
-    fn get_used_memory(&self) -> u64 {
+    fn used_memory(&self) -> u64 {
         0
     }
 
-    fn get_total_swap(&self) -> u64 {
+    fn total_swap(&self) -> u64 {
         0
     }
 
-    fn get_free_swap(&self) -> u64 {
+    fn free_swap(&self) -> u64 {
         0
     }
 
-    fn get_used_swap(&self) -> u64 {
+    fn used_swap(&self) -> u64 {
         0
     }
 
-    fn get_components(&self) -> &[Component] {
+    fn components(&self) -> &[Component] {
         &[]
     }
 
-    fn get_components_mut(&mut self) -> &mut [Component] {
+    fn components_mut(&mut self) -> &mut [Component] {
         &mut []
     }
 
-    fn get_disks(&self) -> &[Disk] {
+    fn disks(&self) -> &[Disk] {
         &[]
     }
 
-    fn get_disks_mut(&mut self) -> &mut [Disk] {
+    fn disks_mut(&mut self) -> &mut [Disk] {
         &mut []
     }
 
-    fn get_uptime(&self) -> u64 {
+    fn uptime(&self) -> u64 {
         0
     }
 
-    fn get_boot_time(&self) -> u64 {
+    fn boot_time(&self) -> u64 {
         0
     }
 
-    fn get_load_average(&self) -> LoadAvg {
+    fn load_average(&self) -> LoadAvg {
         LoadAvg {
             one: 0.,
             five: 0.,
@@ -137,27 +137,27 @@ impl SystemExt for System {
         }
     }
 
-    fn get_users(&self) -> &[User] {
+    fn users(&self) -> &[User] {
         &[]
     }
 
-    fn get_name(&self) -> Option<String> {
+    fn name(&self) -> Option<String> {
         None
     }
 
-    fn get_long_os_version(&self) -> Option<String> {
+    fn long_os_version(&self) -> Option<String> {
         None
     }
 
-    fn get_kernel_version(&self) -> Option<String> {
+    fn kernel_version(&self) -> Option<String> {
         None
     }
 
-    fn get_os_version(&self) -> Option<String> {
+    fn os_version(&self) -> Option<String> {
         None
     }
 
-    fn get_host_name(&self) -> Option<String> {
+    fn host_name(&self) -> Option<String> {
         None
     }
 }
diff --git a/src/windows/component.rs b/src/windows/component.rs
index 6607f8b..05ddea6 100644
--- a/src/windows/component.rs
+++ b/src/windows/component.rs
@@ -47,7 +47,7 @@ impl Component {
             .and_then(|x| x.set_proxy_blanket())
             .and_then(|x| x.exec_query())?;
 
-        c.get_temperature(true)
+        c.temperature(true)
             .map(|(temperature, critical)| Component {
                 temperature,
                 label: "Computer".to_owned(),
@@ -59,19 +59,19 @@ impl Component {
 }
 
 impl ComponentExt for Component {
-    fn get_temperature(&self) -> f32 {
+    fn temperature(&self) -> f32 {
         self.temperature
     }
 
-    fn get_max(&self) -> f32 {
+    fn max(&self) -> f32 {
         self.max
     }
 
-    fn get_critical(&self) -> Option<f32> {
+    fn critical(&self) -> Option<f32> {
         self.critical
     }
 
-    fn get_label(&self) -> &str {
+    fn label(&self) -> &str {
         &self.label
     }
 
@@ -89,7 +89,7 @@ impl ComponentExt for Component {
             None
         };
         if let Some(ref mut connection) = self.connection {
-            if let Some((temperature, _)) = connection.get_temperature(false) {
+            if let Some((temperature, _)) = connection.temperature(false) {
                 self.temperature = temperature;
                 if self.temperature > self.max {
                     self.max = self.temperature;
@@ -294,7 +294,7 @@ impl Connection {
         Some(self)
     }
 
-    fn get_temperature(&mut self, get_critical: bool) -> Option<(f32, Option<f32>)> {
+    fn temperature(&mut self, get_critical: bool) -> Option<(f32, Option<f32>)> {
         let p_enum = match self.enumerator.take() {
             Some(x) => x,
             None => {
diff --git a/src/windows/disk.rs b/src/windows/disk.rs
index 5465902..7c9d2f7 100644
--- a/src/windows/disk.rs
+++ b/src/windows/disk.rs
@@ -47,27 +47,27 @@ pub struct Disk {
 }
 
 impl DiskExt for Disk {
-    fn get_type(&self) -> DiskType {
+    fn type_(&self) -> DiskType {
         self.type_
     }
 
-    fn get_name(&self) -> &OsStr {
+    fn name(&self) -> &OsStr {
         &self.name
     }
 
-    fn get_file_system(&self) -> &[u8] {
+    fn file_system(&self) -> &[u8] {
         &self.file_system
     }
 
-    fn get_mount_point(&self) -> &Path {
+    fn mount_point(&self) -> &Path {
         Path::new(&self.s_mount_point)
     }
 
-    fn get_total_space(&self) -> u64 {
+    fn total_space(&self) -> u64 {
         self.total_space
     }
 
-    fn get_available_space(&self) -> u64 {
+    fn available_space(&self) -> u64 {
         self.available_space
     }
 
diff --git a/src/windows/network.rs b/src/windows/network.rs
index 4fc2584..1cbe16a 100644
--- a/src/windows/network.rs
+++ b/src/windows/network.rs
@@ -27,7 +27,7 @@ macro_rules! old_and_new {
 /// use sysinfo::{NetworksExt, System, SystemExt};
 ///
 /// let s = System::new_all();
-/// let networks = s.get_networks();
+/// let networks = s.networks();
 /// ```
 pub struct Networks {
     interfaces: HashMap<String, NetworkData>,
@@ -206,51 +206,51 @@ pub struct NetworkData {
 }
 
 impl NetworkExt for NetworkData {
-    fn get_received(&self) -> u64 {
+    fn received(&self) -> u64 {
         self.current_in.saturating_sub(self.old_in)
     }
 
-    fn get_total_received(&self) -> u64 {
+    fn total_received(&self) -> u64 {
         self.current_in
     }
 
-    fn get_transmitted(&self) -> u64 {
+    fn transmitted(&self) -> u64 {
         self.current_out.saturating_sub(self.old_out)
     }
 
-    fn get_total_transmitted(&self) -> u64 {
+    fn total_transmitted(&self) -> u64 {
         self.current_out
     }
 
-    fn get_packets_received(&self) -> u64 {
+    fn packets_received(&self) -> u64 {
         self.packets_in.saturating_sub(self.old_packets_in)
     }
 
-    fn get_total_packets_received(&self) -> u64 {
+    fn total_packets_received(&self) -> u64 {
         self.packets_in
     }
 
-    fn get_packets_transmitted(&self) -> u64 {
+    fn packets_transmitted(&self) -> u64 {
         self.packets_out.saturating_sub(self.old_packets_out)
     }
 
-    fn get_total_packets_transmitted(&self) -> u64 {
+    fn total_packets_transmitted(&self) -> u64 {
         self.packets_out
     }
 
-    fn get_errors_on_received(&self) -> u64 {
+    fn errors_on_received(&self) -> u64 {
         self.errors_in.saturating_sub(self.old_errors_in)
     }
 
-    fn get_total_errors_on_received(&self) -> u64 {
+    fn total_errors_on_received(&self) -> u64 {
         self.errors_in
     }
 
-    fn get_errors_on_transmitted(&self) -> u64 {
+    fn errors_on_transmitted(&self) -> u64 {
         self.errors_out.saturating_sub(self.old_errors_out)
     }
 
-    fn get_total_errors_on_transmitted(&self) -> u64 {
+    fn total_errors_on_transmitted(&self) -> u64 {
         self.errors_out
     }
 }
diff --git a/src/windows/processor.rs b/src/windows/processor.rs
index d0b5958..57301a0 100644
--- a/src/windows/processor.rs
+++ b/src/windows/processor.rs
@@ -243,23 +243,23 @@ pub struct Processor {
 }
 
 impl ProcessorExt for Processor {
-    fn get_cpu_usage(&self) -> f32 {
+    fn cpu_usage(&self) -> f32 {
         self.cpu_usage
     }
 
-    fn get_name(&self) -> &str {
+    fn name(&self) -> &str {
         &self.name
     }
 
-    fn get_frequency(&self) -> u64 {
+    fn frequency(&self) -> u64 {
         self.frequency
     }
 
-    fn get_vendor_id(&self) -> &str {
+    fn vendor_id(&self) -> &str {
         &self.vendor_id
     }
 
-    fn get_brand(&self) -> &str {
+    fn brand(&self) -> &str {
         &self.brand
     }
 }
diff --git a/src/windows/system.rs b/src/windows/system.rs
index 1d2df1d..b510495 100644
--- a/src/windows/system.rs
+++ b/src/windows/system.rs
@@ -311,100 +311,100 @@ impl SystemExt for System {
         self.users = unsafe { get_users() };
     }
 
-    fn get_processes(&self) -> &HashMap<Pid, Process> {
+    fn processes(&self) -> &HashMap<Pid, Process> {
         &self.process_list
     }
 
-    fn get_process(&self, pid: Pid) -> Option<&Process> {
+    fn process(&self, pid: Pid) -> Option<&Process> {
         self.process_list.get(&(pid as usize))
     }
 
-    fn get_global_processor_info(&self) -> &Processor {
+    fn global_processor_info(&self) -> &Processor {
         &self.global_processor
     }
 
-    fn get_processors(&self) -> &[Processor] {
+    fn processors(&self) -> &[Processor] {
         &self.processors
     }
 
-    fn get_physical_core_count(&self) -> Option<usize> {
+    fn physical_core_count(&self) -> Option<usize> {
         get_physical_core_count()
     }
 
-    fn get_total_memory(&self) -> u64 {
+    fn total_memory(&self) -> u64 {
         self.mem_total
     }
 
-    fn get_free_memory(&self) -> u64 {
+    fn free_memory(&self) -> u64 {
         // MEMORYSTATUSEX doesn't report free memory
         self.mem_available
     }
 
-    fn get_available_memory(&self) -> u64 {
+    fn available_memory(&self) -> u64 {
         self.mem_available
     }
 
-    fn get_used_memory(&self) -> u64 {
+    fn used_memory(&self) -> u64 {
         self.mem_total - self.mem_available
     }
 
-    fn get_total_swap(&self) -> u64 {
+    fn total_swap(&self) -> u64 {
         self.swap_total
     }
 
-    fn get_free_swap(&self) -> u64 {
+    fn free_swap(&self) -> u64 {
         self.swap_free
     }
 
-    fn get_used_swap(&self) -> u64 {
+    fn used_swap(&self) -> u64 {
         self.swap_total - self.swap_free
     }
 
-    fn get_components(&self) -> &[Component] {
+    fn components(&self) -> &[Component] {
         &self.components
     }
 
-    fn get_components_mut(&mut self) -> &mut [Component] {
+    fn components_mut(&mut self) -> &mut [Component] {
         &mut self.components
     }
 
-    fn get_disks(&self) -> &[Disk] {
+    fn disks(&self) -> &[Disk] {
         &self.disks
     }
 
-    fn get_disks_mut(&mut self) -> &mut [Disk] {
+    fn disks_mut(&mut self) -> &mut [Disk] {
         &mut self.disks
     }
 
-    fn get_users(&self) -> &[User] {
+    fn users(&self) -> &[User] {
         &self.users
     }
 
-    fn get_networks(&self) -> &Networks {
+    fn networks(&self) -> &Networks {
         &self.networks
     }
 
-    fn get_networks_mut(&mut self) -> &mut Networks {
+    fn networks_mut(&mut self) -> &mut Networks {
         &mut self.networks
     }
 
-    fn get_uptime(&self) -> u64 {
+    fn uptime(&self) -> u64 {
         unsafe { GetTickCount64() / 1000 }
     }
 
-    fn get_boot_time(&self) -> u64 {
+    fn boot_time(&self) -> u64 {
         self.boot_time
     }
 
-    fn get_load_average(&self) -> LoadAvg {
+    fn load_average(&self) -> LoadAvg {
         get_load_average()
     }
 
-    fn get_name(&self) -> Option<String> {
+    fn name(&self) -> Option<String> {
         Some("Windows".to_owned())
     }
 
-    fn get_long_os_version(&self) -> Option<String> {
+    fn long_os_version(&self) -> Option<String> {
         get_reg_string_value(
             HKEY_LOCAL_MACHINE,
             "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion",
@@ -412,11 +412,11 @@ impl SystemExt for System {
         )
     }
 
-    fn get_host_name(&self) -> Option<String> {
+    fn host_name(&self) -> Option<String> {
         get_dns_hostname()
     }
 
-    fn get_kernel_version(&self) -> Option<String> {
+    fn kernel_version(&self) -> Option<String> {
         get_reg_string_value(
             HKEY_LOCAL_MACHINE,
             "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion",
@@ -424,7 +424,7 @@ impl SystemExt for System {
         )
     }
 
-    fn get_os_version(&self) -> Option<String> {
+    fn os_version(&self) -> Option<String> {
         let major = get_reg_value_u32(
             HKEY_LOCAL_MACHINE,
             "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion",


Test patch:
diff --git a/tests/disk_list.rs b/tests/disk_list.rs
index 959c858..716349f 100644
--- a/tests/disk_list.rs
+++ b/tests/disk_list.rs
@@ -10,6 +10,6 @@ fn test_disks() {
 
     if sysinfo::System::IS_SUPPORTED {
         let s = sysinfo::System::new_all();
-        assert!(!s.get_disks().is_empty());
+        assert!(!s.disks().is_empty());
     }
 }
diff --git a/tests/network.rs b/tests/network.rs
index b62dccf..3974e5a 100644
--- a/tests/network.rs
+++ b/tests/network.rs
@@ -13,8 +13,8 @@ fn test_processor() {
 
     if sysinfo::System::IS_SUPPORTED {
         let s = sysinfo::System::new();
-        assert_eq!(s.get_networks().iter().count(), 0);
+        assert_eq!(s.networks().iter().count(), 0);
         let s = sysinfo::System::new_all();
-        assert!(s.get_networks().iter().count() > 0);
+        assert!(s.networks().iter().count() > 0);
     }
 }
diff --git a/tests/process.rs b/tests/process.rs
index b65f328..f30047c 100644
--- a/tests/process.rs
+++ b/tests/process.rs
@@ -10,15 +10,15 @@ use sysinfo::SystemExt;
 #[test]
 fn test_process() {
     let mut s = sysinfo::System::new();
-    assert_eq!(s.get_processes().len(), 0);
+    assert_eq!(s.processes().len(), 0);
     s.refresh_processes();
     if !sysinfo::System::IS_SUPPORTED {
         return;
     }
-    assert!(!s.get_processes().is_empty());
+    assert!(!s.processes().is_empty());
     #[cfg(not(windows))]
     assert!(s
-        .get_processes()
+        .processes()
         .values()
         .any(|p| !p.exe().to_str().unwrap_or("").is_empty()));
 }
@@ -26,14 +26,14 @@ fn test_process() {
 #[test]
 fn test_process_refresh() {
     let mut s = sysinfo::System::new();
-    assert_eq!(s.get_processes().len(), 0);
+    assert_eq!(s.processes().len(), 0);
 
     if !sysinfo::System::IS_SUPPORTED {
         return;
     }
     s.refresh_process(sysinfo::get_current_pid().expect("failed to get current pid"));
     assert!(s
-        .get_process(sysinfo::get_current_pid().expect("failed to get current pid"))
+        .process(sysinfo::get_current_pid().expect("failed to get current pid"))
         .is_some(),);
 }
 
@@ -46,10 +46,10 @@ fn test_get_cmd_line() {
         .spawn()
         .unwrap();
     let mut s = sysinfo::System::new();
-    assert!(s.get_processes().is_empty());
+    assert!(s.processes().is_empty());
     s.refresh_processes();
-    assert!(!s.get_processes().is_empty());
-    if let Some(process) = s.get_process(p.id() as sysinfo::Pid) {
+    assert!(!s.processes().is_empty());
+    if let Some(process) = s.process(p.id() as sysinfo::Pid) {
         assert_eq!(process.cmd(), &["timeout", "/t", "3"]);
     } else {
         // We're very likely on a "linux-like" shell so let's try some unix command...
@@ -75,10 +75,10 @@ fn unix_like_cmd() {
     // To ensure that the system data are filled correctly...
     thread::sleep(time::Duration::from_millis(250));
     let mut s = sysinfo::System::new();
-    assert!(s.get_processes().is_empty());
+    assert!(s.processes().is_empty());
     s.refresh_processes();
-    assert!(!s.get_processes().is_empty());
-    let process = s.get_process(p.id() as sysinfo::Pid).unwrap();
+    assert!(!s.processes().is_empty());
+    let process = s.process(p.id() as sysinfo::Pid).unwrap();
     if process.cmd() != &["sleep", "3"] {
         panic!("cmd not equivalent to`[sleep, 3]`: {:?}", process);
     }
@@ -102,11 +102,11 @@ fn test_process_disk_usage() {
     }
     fs::remove_file("test.txt").ok();
     let mut system = sysinfo::System::new();
-    assert!(system.get_processes().is_empty());
+    assert!(system.processes().is_empty());
     system.refresh_processes();
-    assert!(!system.get_processes().is_empty());
+    assert!(!system.processes().is_empty());
     let p = system
-        .get_process(get_current_pid().expect("Failed retrieving current pid."))
+        .process(get_current_pid().expect("Failed retrieving current pid."))
         .expect("failed to get process");
 
     assert!(
@@ -131,7 +131,7 @@ fn cpu_usage_is_not_nan() {
     }
 
     let first_pids = system
-        .get_processes()
+        .processes()
         .iter()
         .take(10)
         .map(|(&pid, _)| pid)
@@ -140,7 +140,7 @@ fn cpu_usage_is_not_nan() {
 
     first_pids.into_iter().for_each(|pid| {
         system.refresh_process(pid);
-        if let Some(p) = system.get_process(pid) {
+        if let Some(p) = system.process(pid) {
             assert!(!p.cpu_usage().is_nan());
             checked += 1;
         }
diff --git a/tests/processor.rs b/tests/processor.rs
index 2d74539..1f9a783 100644
--- a/tests/processor.rs
+++ b/tests/processor.rs
@@ -13,12 +13,12 @@ fn test_processor() {
 
     if sysinfo::System::IS_SUPPORTED {
         let s = sysinfo::System::new();
-        assert!(!s.get_processors().is_empty());
+        assert!(!s.processors().is_empty());
         let s = sysinfo::System::new_all();
-        assert!(!s.get_processors().is_empty());
+        assert!(!s.processors().is_empty());
 
-        assert!(s.get_processors()[0]
-            .get_brand()
+        assert!(s.processors()[0]
+            .brand()
             .chars()
             .find(|c| *c == '\0')
             .is_none())
@@ -31,7 +31,7 @@ fn test_physical_core_numbers() {
 
     if sysinfo::System::IS_SUPPORTED {
         let s = sysinfo::System::new();
-        let count = s.get_physical_core_count();
+        let count = s.physical_core_count();
         assert_ne!(count, None);
         assert!(count.unwrap() > 0);
     }
diff --git a/tests/uptime.rs b/tests/uptime.rs
index 5f92a1a..e5b7d61 100644
--- a/tests/uptime.rs
+++ b/tests/uptime.rs
@@ -11,6 +11,6 @@ fn test_uptime() {
     if sysinfo::System::IS_SUPPORTED {
         let mut s = sysinfo::System::new();
         s.refresh_all();
-        assert!(s.get_uptime() != 0);
+        assert!(s.uptime() != 0);
     }
 }