Ruby vs Elm

Ruby is one of the most popular languages for developing web sites. As a result, there's an abundant amount of documentation, sample code, and libraries available for learning the language and getting your project up and running. The most popular features are just 'gem install' away. Additionally, it is easier to find Ruby jobs because of this.

Ruby has a very clean syntax that makes code easier to both read and write than more traditional Object Oriented languages, such as Java. For beginning programmers, this means the focus is on the meaning of the program, where it should be, rather than trying to figure out the meaning of obscure characters.

presidents = ["Ford", "Carter", "Reagan", "Bush1", "Clinton", "Bush2"]
for ss in 0...presidents.length
    print ss, ": ", presidents[presidents.length - ss - 1], "\n";
end

Ruby has a large ecosystem of tools and libraries for just about every use. Such as ORMs (Active Record, DatabMapper), Web Application Frameworks(Rails, Sinatra, Volt), Virtualization Orchestration(docker-api, drelict), CLI tools(Thor, Commando), GUI Frameworks(Shoes, FXRuby) and the list goes on. If you can think of it, there is probably a gem for that ( and if not you can create your own and share with the community).

The Ruby language is equipped with the necessary features to learn the essence of algorithms.

In online playground environments like ideone.com, measures have been taken to prevent beginners from going astray by restricting the use of external libraries such as Python's NumPy and SymPy.
Even in such constrained Ruby execution environments, the required features for learning algorithms are fully available.

Many of the algorithms that should be learned are documented in the book "Hello Ruby: Adventures in Coding." For example, the cake serving problem in the book leads to topological sorting, which is a graph theory concept useful in project management for creating Gantt charts.

To evaluate the effectiveness of algorithms with a level of complexity comparable to topological sorting,
it is necessary to be able to solve mathematical computation problems up to the high school level easily.
As shown in the table below, using only Ruby's standard library, it is possible to solve high school-level math problems effortlessly.
However, other programming languages may not be able to perform such computations in online playground environments.

To experience the superior performance of algorithms, it is important to challenge oneself by reimplementing good algorithms. Ruby's standard library includes implementations of excellent algorithms. For instance, the algorithm for solving linear equations, which has been widely known since the era of Fortran, is used within the code of SolvingLinearEquations through the "/" operator. Reimplementing code from Ruby's standard library serves as an excellent learning resource with high reusability and efficiency.

The SolvingLinearEquations function mentioned above demonstrates the benefits of duck typing and forced type conversion between objects of different types in arithmetic operations. While Rust also has features like duck typing, the implementation of "forced type conversion" is still far from being realized.

# Title: "(1) Cake Serving Procedure Problem"
require 'tsort'

class Hash
  include TSort
  alias tsort_each_node each_key
  def tsort_each_child(node, &block)
    fetch(node).each(&block)
  end
end

puts 'Tasks'
task_names = {
  'A' => 'Arrange the plates.',
  'B' => 'Set the spoons.',
  'C' => 'Place the birthday cake on the table.',
  'D' => 'Spread the tablecloth.'
}
p task_names

puts 'Preceding Tasks'
preceding_tasks = {
  'A' => ['D'],
  'B' => ['C', 'A'],
  'C' => ['A', 'D'],
  'D' => []
}

steps = preceding_tasks.strongly_connected_components
puts 'The appropriate steps are as follows:'
steps.each do |task_candidates|
  p task_candidates.map { |task| [task, task_names[task]] }
end

p "#(2) Equation Solving Rule"
def SolvingLinearEquations(y, a, b)
   x = (y - b) / a
end

p "(2-1) Real Solution", SolvingLinearEquations(1.0, 5, 0.5)
# => 0.1

p "(2-2) Fraction Solution", SolvingLinearEquations(Rational(1, 1), Rational(5, 1), Rational(1, 2))
# =>  (1/10)

p "(2-3) Imaginary Solution", SolvingLinearEquations(1 + 1i, 5, 1.0 / (2 + 2i))
# => (0.15+0.25i)

p "(2-4) Complex & Fraction Solution", SolvingLinearEquations(Rational(1 + 1i, 1), Rational(5, 1), Rational(1, 2 + 2i))
# => ((3/20)+(1/4)*i)

p "(2-5) Matrix Solution with Large Integers", 
   SolvingLinearEquations(Matrix[[Rational(1234567890123456789890, 1), Rational(0, 1)]],
                                                Matrix[[Rational(1234567890123456789890, 1), Rational(1234567890123456789890 * 2, 1)],
                                                             [Rational(1234567890123456789890, 1), Rational(1234567890123456789890 * 3, 1)]],
                                                Matrix[[Rational(1234567890, 1), Rational(123456789, 1)]] )
# => Matrix[[(3703703670366790122789/1234567890123456789890), (-2469135780244567900789/1234567890123456789890)]]

p "(2-7) Matrix Solution with Large Integers, Complex Numbers, and Fractions", 
     SolvingLinearEquations(Matrix[[Rational(1234567890123456789890, 1i), Rational(0, 1)]],
                                                 Matrix[[Rational(1234567890123456789890, 1), Rational(1234567890123456789890 * 2, 1i)],
                                                               [Rational(1234567890123456789890, 1), Rational(1234567890123456789890 * 3, 1i)]],
                                                Matrix[[1234567890, 0 + 1i]] )
# => Matrix[[((-3703703671/1234567890123456789890)-(3/1)*i), ((2469135781/1234567890123456789890)+(2/1)*i)]]

Lays out an easy to follow and opinionated MVC pattern that teaches best practices through necessity.

It's the fore-runner and trend setter for TDD.

Object oriented programming is one of the most important concepts in programming.

Meta-programming provides efficiency and freedom.

No indentation increase development efficiency.

Lack of run-time exceptions makes it easy to produce large swathes of reliable front-end code without drowning in tests.

ML static typing is great because it's always there, you just choose how explicit you want to be and how much you want the compiler to do.

In no other language you can refactor so easy without any worries, since the compiler will guide you through. It is like TDD but than compiler-error driven.

As Elm was designed as a front-end langauge, it has out of the box support for things like DOM-element creation, letting programmers focus on their application logic, rather than implementation details specific to the web.

You can try to apply some functional programming ideas in other languages that have an imperative basis, but you haven't seen the real power unless you tried it in the environment of purely functional programming. Elm is a simple language with great learning resources and easy graphical output, which makes it easy to explore the power of functional programming. Plus programming in Elm is very readable.

All major editors have great support. With Atom for example, Elm plugins are available for linting, formatting, make/compiler support and Elmjutsu will simply overflow you with super useful functions, like navigate to referenced definition and show expression type.

The Elm Architecture means you don't need to spend valuable time and effort choosing the right frameworks, state management libraries, or build tooling. It's all built in.

Elm uses easy to use modules.

Use:

import List
import List as L
import List exposing (..)
import List exposing ( map, foldl )
import Maybe exposing ( Maybe )
import Maybe exposing ( Maybe(..) )
import Maybe exposing ( Maybe(Just) )

Creation:

module MyModule exposing (foo, bar)

Easy to learn, most functions have only one way, not 5 alternatives where you must study where to best use what.

Support for hot swapping and interactive programming is included.

The lack of side-effects and simple, consistent language semantics make it easy to quickly review incoming changes.

Pure functions, immutable data structures, amazing compiler, clean and homologous syntax used for HTML, logic, and optionally to replace CSS, elimination of entire classes of bugs so you don't even need most unit tests. These factors lead to better code, better programs, higher confidence, and ultimately, more satisfaction.

Luckily you do not have to learn Haskell to be able to do any Elm. It is meant to be a language that compiles to Javascript, so for Javascript programmers (Front end) not for CS students who want to learn as many different algorithms as possible.