Ruby vs Julia

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.

Julia runs almost as fast as (and in fact in some cases faster than) C code.

Dynamic and high level, but does not isolate the user from properly thinking about types. Can do explicit type signatures which is great for teaching structured thinking.

Out of the box Julia has a very good Read-Eval-Print-Loop, which both completes functions and types, as well as completion based on history of previous statements. It integrates well with the shell and has an excellent online help system.

Julia code is easy to read and avoid a lot of unnecessary special symbols and fluff. It uses newline to end statements and "end" to end blocks so there is no need for lots of semicolons and curly braces. It is regular in that unless it is a variable assignment, function name always comes first. No need to be confused about whether something is a method on an object or a free function.

Unlike Python and Ruby, since you can annotate the types a function operates on, you can overload function names, so that you can use the same function name for many data types. So you can keep simple descriptive function names and not have to invent artificial function names to separate them from the type they operate on.

The Julia language is written in itself to a much larger extent than most other languages, so a budding programmer can read through the depths of the standard library and learn exactly how things work all the way down to the low-level bit-twiddling details, which can be englightening.

Julia has built in n-dimensional arrays similar in functionality as Python's numpy.

You can have multiple functions with the same name, but doing different things depending on function arguments and argument types.

Julia requires no boilerplate code – a beginner needs to write only the parts they care about. This combined with the REPL provides the best learning experience available.

Julia provides a high level of abstraction, making platform-independent programming trivial and easing the learning curve.

You can perform operations on scalars, for example 2^2 or [1, 2, 3].^2.

Julia allows you to edit Julia code in the language itself and write powerful macros. It is a great introduction to metaprogramming features

The Julia REPL allows quickly testing how some code behaves and gives access to documentation and package management immediately in the REPL.