Membandingkan Perintah Bash Go Ruby dan Python

• Sintaks elegan yang mudah dibaca dan ditulis.
• Kemampuan kuat untuk metaprogramming dan membangun DSL.

• Kinerja bisa menjadi masalah, mirip dengan Python.
• Ekosistem lebih kecil dibandingkan dengan Python.

numbers = [1, 2, 3, 4, 5]
doubled_numbers = numbers.map { |number| number * 2 }
puts doubled_numbers

Go Lang

package main

import (
    "fmt"
    "net/http"
    "sync"
)

func fetch(url string, wg *sync.WaitGroup) {
    defer wg.Done()
    res, err := http.Get(url)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("Status Code for", url, ":", res.StatusCode)
}

func main() {
    var wg sync.WaitGroup
    urls := []string{"http://example.com", "http://example.org"}
    for _, url := range urls {
        wg.Add(1)
        go fetch(url, &wg)
    }
    wg.Wait()
}

$ echo "Hello, world!" > file.txt

with open('file.txt', 'w') as file:
    file.write("Hello, world!")

File.open('file.txt', 'w') { |file| file.puts "Hello, world!" }

(curl -s -o /dev/null -w "%{http_code}" http://example.com &)
(curl -s -o /dev/null -w "%{http_code}" http://example.org &)
wait

import requests
from concurrent.futures import ThreadPoolExecutor

def fetch_url(url):
    response = requests.get(url)
    print(response.status_code)

urls = ["http://example.com", "http://example.org"]

with ThreadPoolExecutor(max_workers=2) as executor:
    executor.map(fetch_url, urls)

require 'net/http'
require 'uri'
threads = []

urls = ["http://example.com", "http://example.org"]
urls.each do |url|
    threads << Thread.new {
        uri = URI(url)
        response = Net::HTTP.get_response(uri)
        puts response.code
    }
end
threads.each(&:join)

package main

import (
    "fmt"
    "net/http"
    "sync"
)

func fetch(url string, wg *sync.WaitGroup) {
    defer wg.Done()
    res, err := http.Get(url)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("Status Code for", url, ":", res.StatusCode)
}

func main() {


    var wg sync.WaitGroup
    urls := []string{"http://example.com", "http://example.org"}
    wg.Add(len(urls))
    for _, url := range urls {
        go fetch(url, &wg)
    }
    wg.Wait()
}

# Hypothetical example using a simplified setup
watch -n 5 'cat data_source.txt | awk "{sum += \$1; n++} END {if (n > 0) print sum / n}"'

import numpy as np
import time

def get_data():
    # Simulate fetching real-time data
    return np.random.random(10)

def compute_average():
    data = []
    while True:
        data.extend(get_data())
        if len(data) > 1000:
            data = data[-1000:]  # keep only the most recent 1000 entries
        print(f"Current average: {

np.mean(data):.2f}")
        time.sleep(5)  # simulate real-time delay

compute_average()

require 'time'

def fetch_data
  # Simulate fetching real-time data
  Array.new(10) { rand }
end

def process_data
  data = []
  loop do
    data.concat(fetch_data)
    data.shift if data.size > 1000  # maintain only the latest 1000 records
    avg = data.reduce(:+) / data.size.to_f
    puts "Current Average: #{avg.round(2)}"
    sleep 5  # simulate real-time delay
  end
end

process_data

package main

import (
    "fmt"
    "math/rand"
    "sync"
    "time"
)

func fetchData(c chan float64) {
    for {
        c <- rand.Float64()  // Send random data to the channel
        time.Sleep(time.Second * 1)  // Simulate real-time data fetching every second
    }
}

func computeAverage(c chan float64) {
    var data []float64
    for value := range c {
        data = append(data, value)
        if len(data) > 1000 {
            data = data[1:]  // Keep only the last 1000 records
        }
        sum := 0.0
        for _, v := range data {
            sum += v
        }
        fmt.Printf("Current average: %.2f\n", sum/float64(len(data)))
    }
}

func main() {
    c := make(chan float64)
    var wg sync.WaitGroup
    wg.Add(2)
    go fetchData(c)
    go computeAverage(c)
    wg.Wait()
}

$ curl -s https://api.example.com/data | jq '.items[] | select(.price > 20)'

import requests
import json

def fetch_and_process(url):
    response = requests.get(url)
    data = json.loads(response.text)
    processed_data = [item for item in data['items'] if item['price'] > 20]
    return processed_data

data = fetch_and_process('https://api.example.com/data')
print(data)

require 'net/http'
require 'json'

uri = URI('https://api.example.com/data')
response = Net::HTTP.get(uri)
data = JSON.parse(response)
filtered_data = data['items'].select { |item| item['price'] > 20 }

puts filtered_data

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "io/ioutil"
)

type Item struct {
    Price int `json:"price"`
}

type ApiResponse struct {
    Items []Item `json:"items"`
}

func fetchData(url string) []Item {
    resp, err := http.Get(url)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }
    var apiResponse ApiResponse
    json.Unmarshal(body, &apiResponse)
    var filteredItems []Item
    for _, item := range apiResponse.Items {
        if item.Price > 20 {
            filteredItems = append(filteredItems, item)
        }
    }
    return filteredItems
}

func main() {
    items := fetchData("https://api.example.com/data")
    fmt.Println(items)
}