Jaki język, żeby odpocząć od głównego?

Jeśli chcesz czegoś nowego, to mam kilka propozycji, nastawionych głównie na poszerzenie horyzontów:

• Haskell — jako wstęp do programowania funkcyjnego i nauka doceniania statycznego typowania. Wcale nie jest taki trudny jak się zdaje, choć wymaga trochę czasu żeby zmienić sposób myślenia, ale w tym właśnie jest wartość i zabawa.
• Lisp (sam używam Common Lispa, ale podejrzewam, że w innych dialektach jest podobnie) — rodzaj oświecenia programisty, które wynika z bardzo potężnych mechanizmów metaprogramowania, praktycznie nieograniczonych możliwości manipulowania składnią i implementowania nowych paradygmatów. Dodatkowo, Lisp jest językiem zorientowanym na REPL, ma system obsługi błędów zorientowany na interakcję. Pełna moc języka w runtime'ie, możliwość podmienienia nowej wersji aplikacji w locie i takie tam…
• Prolog — raczej niszowy język, ale reprezentuje bardzo egzotyczne podejście (programowanie w logice) i jest to raczej leciutka opcja na nie bardzo długi czas.
• Rust — bardzo ciekawy język, który ma najlepsze cechy Haskella (rozbudowany system typów) i Lispu (rozbudowane wparcie dla metaprogramowania). Dodatkowo implementuje nowatorski sposób zarządzania pamięcią w czasie kompilacji (wymaga to pewnej dyscypliny i to też jest ciekawe). Długi czas trzymałem się C jako języka niskopoziomowego, ale Rust miażdży C, jeśli chodzi o bezpieczeństwo i możliwości abstrakcji.
• R — to jeśli interesuje cię Data Science, Machine Learning, statystyka itp. Trochę chaotyczny, ale robi robotę

@szafran98:

ale co można w nim optymalnie zrobić oprócz cruda?

• komunikacja (patrz np. ejabberd)
• bazy danych (RabbitMQ)
• background processing (https://github.com/sorentwo/oban)
• machine learning (patrz)
• realtime networking (https://github.com/supabase/realtime)
• multimedia processing (https://membrane.stream)
• gry sieciowe (https://github.com/oestrich/ex_venture)

Nigdy nie miałem problemu z wydajnością i nie wiem jaki projekt musiałbym wymyślić, żeby pobawić się współbieżnością.

Głównym zastosowaniem procesów w Eliksirze nie jest współbieżność, a izolacja błędów. Dzięki temu (cytując Joe Armstronga) nie mamy serwera TCP obsługującego N zapytań, a mamy N serwerów TCP obsługujących jedno zapytanie. Przykładowo kod w Eliksirze:

defmodule Foo do
  def run do
    spawn(&Foo.loop/0)
    Process.sleep(1000)
    spawn(&Foo.failing/0)

    :ok
  end

  def loop do
    IO.puts("I am still there #{inspect(self())}")
    Process.sleep(500)
    loop()
  end

  def failing do
    IO.puts("I will fail #{inspect(self())}")
    raise "whoops"
  end
end

Foo.run()

W tym kodzie mamy błąd (oczywisty), ale nie ubije nam to całego systemu, a nawet inne procesy nie zostaną dotknięte tym błędem, a jedynie proces, w którym się zdarzył błąd. Ma to olbrzymią ilość zalet w przypadku oprogramowania sieciowego, które ma "zawsze działać". Po prostu zakładamy, że błędy są rzadkie i "a próbował Pan wyłączyć i włączyć" rozwiązuje większość z nich.

Ja proponuje jezyk przeciwstawny do srodowiska na codzien. Jesli jestem programista mulowatego JVM to warto pojsc w Rust/GO. C/C++ to juz trup. Natomiast rozwiazania native beda zyskiwac na popularnosci. Dobra inwestycja jest tez dobra znajomisc Pythona ktora usprawnia analizy.