Python vs Ruby

Python's popularity and beginner friendliness has led to a wealth of tutorials and example code on the internet. This means that when beginners have questions, they're very likely to be able to find an answer on their own just by searching. This is an advantage over some languages that are not as popular or covered as in-depth by its users.

Python has an active and helpful community, such as the comp.lang.python Google Groups, StackOverflow, reddit, etc.

On top of the wealth of tutorials and documentation, and the fact that it ships with a sizeable standard library, Python also ships with both an IDE (Integrated Development Environment: A graphical environment for editing running and debugging your code); as well as a text-based live interpreter. Both help users to get started trying out code immediately, and give users immediate feedback that aids learning.

Python ships with a large standard library, including modules for everything from writing graphical applications, running servers, and doing unit testing. This means that beginners won't need to spend time searching for tools and libraries just to get started on their projects.

Python can be used across virtually all domains: scientific, network, games, graphics, animation, web development, machine learning, and data science.

Python's syntax is very clear and readable, making it excellent for beginners. The lack of extra characters like semicolons and curly braces reduces distractions, letting beginners focus on the meaning of the code. Significant whitespace also means that all code is properly and consistently indented.

The language also uses natural english words such as 'and' and 'or', meaning that beginners need to learn fewer obscure symbols. On top of this, Python's dynamic type system means that code isn't cluttered with type information, which would further distract beginners from what the code is doing.

Installs and works on every major operating systems if not already installed by default (Linux, macOS).

Python is commonly used in data science and has many libraries for scientific computing, such as numpy, pandas, matplotlib, etc.

The Python community has put a lot of work into creating excellent documentation filled with plain english describing functionality. Contrast this with other languages, such as Java, where documentation often contains a dry enumeration of the API.

As a random example, consider GUI toolkit documentation - the tkinter documentation reads almost like a blog article, answering questions such as 'How do I...', whereas Java's Swing documentation contains dry descriptions that effectively reiterate the implementation code. On top of this, most functions contain 'Doc Strings', which mean that documentation is often immediately available, without even the need to search the internet.

When learning Computer Science concepts such as algorithms and data structures, many texts use pseudo-code. Having a language such as Python whose syntax is very similar to pseudo-code is an obvious advantage that makes learning easier.

It's very simple for understanding how programming works. If you don't like programming in Python, you probably won't like programming. It is a good way to find out with little investment. If you like, it is a great language. I wouldn't look for a language that has everything you eventually need to know in programming, such as static typing, in my first language. It should be easy to learn. You can pick up the hard stuff later if you tackle C or C++ or assembler. It will make learning them much easier. If you start with them, you might quit programming due to the difficulty of learning.

Python's popularity also means that it's commonly in use in production at many companies - it's even one of the primary languages in use at Google. Furthermore, as a concise scripting language, it's very commonly used for smaller tasks, as an alternative to shell scripts.

Python was also designed to make it easy to interface with other languages such as C, and so it is often used as 'glue code' between components written in other languages.

There are outstanding projects being actively developed in Python. Projects such as the following to name a random four:

• Django: a high-level Python Web framework that encourages rapid development and clean, pragmatic design.
• iPython: a rich architecture for interactive computing with shells, a notebook and which is embeddable as well as wrapping and able to wrap libraries written in other languages.
• Mercurial: a free, distributed source control management tool. It efficiently handles projects of any size and offers an easy and intuitive interface.
• PyPy: a fast, compliant alternative implementation of the Python language (2.7.3 and 3.2.3) with several advantages and distinct features including a Just-in-Time compiler for speed, reduced memory use, sandboxing, micro-threads for massive concurrency, ...

When you move on from being a learner you can still stay with Python for those advanced tasks.

Python supports three 'styles' of programming:

• Procedural programming.
• Object orientated programming.
• Functional programming.

All three styles can be seamlessly interchanged and can be learnt in harmony in Python rather than being forced into one point of view, which is helpful for easing confusion over the debate amongst programmers over which programming paradigm is best, as developers will get the chance to try all of them.

Python's built-in support and syntax for common collections such as lists, dictionaries, and sets, as well as supporting features like list comprehensions, foreach loops, map, filter, and others, makes their use much easier to get into for beginners. Python's support for Object Orient Programming, but with dynamic typing, also makes the topic of Data Structures much more accessible, as it takes the focus off of more tedious aspects, such as type casting and explicitly defined interfaces.

Python's convention of only hiding methods through prefacing them with underscores further takes the focus off of details such as Access Modifiers common in languages such as Java and C++, allowing beginners to focus on the core concepts, without much worry for language specific implementation details.

One of the Guiding Principles of Python is that there should be only one obvious way to do things. This is helpful for beginners because it means that there is likely a best answer for questions about how things should be done.

It is very easy to learn and it has community support and many categories available.

Mobile versions are available but can be difficult to find. Examples for android are pydroid and qpython

Python is not limited to just be cross platform. It goes far beyond all high level languages since it can run on top of several other frameworks & architectures :
Examples of interpreters:

• Standard (PC Win/Lin/Mac, ARM, Raspberry, Smartphones): CPython usually, but some more specialized for smartphones: Kyvi, QPython, ...
• Web Browser JS : Brython, PyJS,
• .Net : IronPython
• Java: Jython
• Microcontrollers with WiFi like ESP8266 or ESP32: MicroPython
• Can be statically compiled (instead of interpreted) with Cython. (Do not mix up with cPython)

With python, you're sure your code can run (almost) everywhere, from 2€ computers to the most expensives.

So, for instance, with Jython you can access the Java libraries with Python language.

Python's syntax supports optional type annotations for use with a third-party static type checker, which can catch a certain class of bugs at compile time. This also makes it easier for beginners to gradually transition to statically typed languages instead of wrestling with the compiler from the start.

It is somewhere between C and Java.

According to Quartz, Python programming skills on average earn $100,000 per year. Closely followed by Java, C++, JavaScript, C, and R with $90,000 per year and above.

(If you can get over whitespace formatting)

Do something visually interesting in minutes by using the turtle standard library package.

Turtle graphics is a popular way for introducing programming to kids. It was part of the original Logo programming language developed by Wally Feurzig and Seymour Papert in 1966.

Imagine a robotic turtle starting at (0, 0) in the x-y plane. After an import turtle, give it the command turtle.forward(15), and it moves (on-screen!) 15 pixels in the direction it is facing, drawing a line as it moves. Give it the command turtle.right(25), and it rotates in-place 25 degrees clockwise.

Turtle can draw intricate shapes using programs that repeat simple moves.

Example Turtle Star Drawing

from turtle import *
color('red', 'yellow')
begin_fill()
while True:
    forward(200)
    left(170)
    if abs(pos()) < 1:
        break
end_fill()
done()

Want to start game development? No problem! Using pygame open-source library you can fast begin creating games without worrying about pointers or undefined behaviors which they exists in C/C++.

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.