Main Features Of Ruby Programming Language And Its Comparison With Other Languages In An Essay.

Background of Ruby programming language

The main objective of this research is to highlight and identify the main features of ruby programming language such as abstraction and polymorphism. Comparison of ruby with other languages is done in the context of this paper. The main features that enhance creation of application and development of elegant features has been defined in the context of this report.

Ruby was created in the mid-1990s by yukihiro "Matz" Matsumoto. He was a japanese software engineer. When creating ruby, matsumoto was a specialist in perl, eiffel, smalltalk, lisp, and ada, among other programming languages. He sought to combine the best characteristics of each of these languages when he built ruby. Ruby's first public release was in 1995, but it wasn't extensively embraced until 2006, widely adopted. Since then, ruby has gained a massive global user base, with programmers from a wide range of industries using it to create some of the top apps in the world. In addition, ruby-related conferences attract large crowds of enthusiastic developers in key locations.

Yukihiro matsumoto needed an object-oriented programming language that could also be used to create scripts. The ruby programming language was established as a result. The names "Coral" And "Ruby" For the programming language were disputed by yukihiro matsumoto and keiju ishitshuka. Yukihiro matsumoto later chose "Ruby" For one of his employees' birthstone. Ruby's claim to fame was the ruby on rails web development framework, which was introduced in 2005.

Ruby on rails revolutionized web development by allowing programmers to create complex, user-friendly web applications in a fraction of the time previously required. Because it allowed small teams to quickly build large apps, ruby on rails was an early favorite among time-pressed startup owners. Shopify, square, instacart, twitch, soundcloud, github, kickstarter, ask.fm, and even hulu are just a few well-known ruby on rails websites today.

Matsumoto began working on ruby only a few years after graduating in 1993. He started working on ruby because he needed a scripting language with features that no other scripting language had. He was using perl, but he thought it was too much of a "Toy language." Python, too, failed; in his own words:

“i knew python then. But i didn’t like it because i didn’t think it was a true object-oriented language—oo features appeared to be an add-on to the language. I wanted a genuine object-oriented, easy-to-use scripting language as a language maniac and oo fan for 15 years. I looked for one but couldn’t find one.”( matsumoto & ishituka 2002)

Matsumoto's intentions for designing ruby can be understood as an attempt to produce a better, object-oriented version of perl. On the other hand, matsumoto has stated that the primary goal for designing ruby was to make himself and others happier. Matsumoto shared a slide near the end of a google technical talk he delivered in 2008 saying that he would like to see ruby assist all programmers on the planet to be more productive, like their work, and be happy. The ruby programming language was created with this goal in mind.

Ruby on Rails web development framework

While the ruby mri remains the preferred interpreter, depending on your project's operational goals and constraints, another ruby implementation may be more appropriate. 

Ruby programmers often use rubyspec, a community-driven project that defines anticipated ruby behavior through tests that can be run on any ruby interpreter. Ruby implementors use rubyspec to ensure that their ruby implementations adhere to the de facto behavior standard.

New ruby releases frequently coincide with new ruby mri versions due to the lack of a clear standard. “there's an open issue about decoupling ruby (the language) from the ruby mri design process worth highlighting. Developers of other ruby implementations sometimes find it challenging to keep up with the language changes introduced in each new mri version due to the vital link between the ruby language and the mri reference implementation.” ( matsumoto & ishituka 2002).

A wide range of use cases and settings are supported by a number of ruby implementations. Java enterprise-based environments. Mobile application development. Javascript implementations. Low-cpu-to-ram-ratio machines. Alternative implementations, in addition to supporting certain use cases, can sometimes provide an extra boost in speed or more efficient memory utilization, depending on the characteristics of your application. Mri is the most used ruby implementation, although it isn't always the best solution. In mri, for example, concurrency support is inferior to jruby or rubinius. Furthermore, despite continual advancements, the memory and garbage collection mechanisms used by mri continue to be problematic.

“mri is ruby's de facto official reference implementation, built-in c by the ruby core team led by yukihiro matsumoto ("Matz," The founder of ruby). If an os vendor offers knowledge of ruby as part of the os installation package, it's usually the mri version of ruby. Mri features a larger paid core team than any other ruby implementation and contributions from people and corporations interested in furthering the ruby ecosystem.” ( matsumoto & ishituka 2002).

Every christmas, another version of the ruby mri is published, frequently with better features on top of the standard library modifications. Ruby mri gets new features first, usually due to talks on the ruby core developer email list. Other ruby implementations are miles behind in particular circumstances.

• Jruby- ruby version built on the java virtual machine (jvm). A jvm-related ruby implementation is anticipated to acquire popularity as more languages than just java begin to operate on top of the jvm. Jruby, on the other hand, introduces standard jvm issues such as delayed ruby interpreter startup, debugging classpath issues if you're using 3rd party java libraries, increased memory usage, and the requirement that your code be thread safe.
• Rubinius- ruby's approach makes use of a low-level virtual machine to create a generic runtime for dynamic languages (llvm). Rubinius can typically run ruby code with less overhead than mri due to its infrastructure and jit compiler capabilities. Rubinius has a jit compiler, improved memory management, and a more developed virtual machine than jruby. Rubinius, unlike jruby, uses a c++ basis rather than a java one and supports ruby c libraries.
• Mruby- it's an embeddable ruby implementation. Mruby lets you use ruby as a scripting/automation language in native applications, videogame scripting, and even programming microcontroller boards like the raspberry pi.
• Opal - is a transpiler that turns ruby code into javascript.
• Rubymotion - it's a ruby implementation and a set of language bindings that let developers use ruby to interact with cocoa apis.

On the ruby landscape, there are a variety of runtimes and interpreters to choose from. The ruby reference implementation (ruby mri) has always been the interpreter of choice for most ruby applications. Based on your technical and functional goals and constraints, alternative ruby implementations may be the best fit for your project.

Ruby has proven to be a flexible language, with a wide range of ruby runtimes and translators varying from corporate big iron java deployment firms to software that controls the office objects you connected to your raspberry pi this weekend. It's critical to select the appropriate tool for the job. Alternative ruby implementation teams engage with the core ruby mri project to dramatically improve ruby's world when language updates are requested. They add to the diversity of the ruby implementation community by sharing their own ruby implementation experiences and opinions on language improvements.

Design goals of Ruby programming language

Web development - because of ruby on rails' renowned online development framework, one of ruby's claims to fame is web development. In 2005, ruby on rails was released, and it changed web programming. Before frameworks like ruby on rails, developers had to spend more time programming code on constructing a web application. Ruby on rails comes with everything a web developer needs to build a website. Rails use conventions to define the structure of each rails project, making it easier for developers to build up their apps. It contains code generators that will produce elements of your program with a single command, reducing the size of code developers must write.

• Static site generation -static site generators need code as well, but they produce all of a site's pages at the same time. These pages are then published to a server, and when you visit a url, you will be sent a static html file. Static site generators enable you to develop websites that are rapid, efficient, secure, and easy to deploy. They're also useful for static pages with little or no content.
• Devops and automation -ruby is a popular programming language for devops, automation, and website deployment. Heroku is a popular web app deployment tool that makes launching apps painless and straightforward, especially for non-devops users. When heroku initially launched, startups flocked to it because it allowed small teams to test, deploy, and stage their applications without a specialized devops engineer. Heroku now supports various languages, whereas it used to support ruby solely.
• Web servers -web servers can also be built with ruby. Passenger, unicorn, and puma are examples of ruby-based web servers. They handle incoming http requests, route them to the relevant backend web applications, and then manage the http response of the application. Ruby web application servers and ruby web development frameworks work together.
• Data processing -ruby is also a fantastic language for data analysis, filtering, and processing. Ruby's map, reduce, and select functions are useful tools for solving various data processing problems.
• Web scraping and crawling -ruby comes with a plethora of utilities that make pulling data from web pages a breeze. Vessel and other ruby libraries are used for crawling and downloading web pages. The html from the crawled pages is then parsed with nokogiri, a popular ruby package, to extract specific features of the page in a logical manner that may be used for data analysis.

• Ruby white-space - except in strings, white-space characters, for instance, spaces and tabs, are usually disregarded in ruby code. However, they are sometimes utilized to interpret confusing sentences. When the -w option is enabled, such interpretations result in warnings. For instance, in ruby, c + d is taken as c+d where c is a local variable, c +d is taken as c(+d) where c is a method call.
• Line endings -ruby understands and takes semicolons and newline characters as the end of a sentence. Ruby recognizes the continuation of a sentence when it encounters operators like + or backslash at the end of a line.
• Identifiers -variables, constants, and methods have names referred to as identifiers. Case matters when it comes to ruby identifiers. It means that ruby, rom, and rom are two separate identifiers. Alphanumeric characters and the underscore character (_) are allowed in ruby identifier names.
• Reserved words - the following is a list of ruby's reserved words. These words are not allowed to be used as names for constants or variables. However, they can be used as method names.

“begin	Do	Next	Then
End	Else	Nil	True
Alias	Elseif	Not	Unfed
And	End	Or	Unless
Begin	Ensure	Redo	Until
Break	False	Rescue	When
Case	For	Retry	While
Class	If	Return	While
Def	In	Self	__file__
Defined?	Module	Super	__line__”

Here document - the method of producing strings from many lines is referred to as "Here document." After a << you can finish the string literal with a string or an identifier, and all lines after the current line up to the terminator are the string's value. If the terminator is quoted, the kind of quotation impacts the type of line-oriented string literal. It's crucial to remember that there must be no space between << and the terminator.

• Begin statement – shows the code to be implemented before the program is executed.
• End statement shows the code that should be executed at the end of the program.
• Ruby comments -a comment blocks the ruby interpreter from seeing a line, a portion of a line, or many lines. The hash character (#) can be used at the start of a line.
• Ruby variables -a variable is a referencename for something that has value. In programming, we say that we assign a value to a variable. A variable is a location in computer memory where a value is stored. In ruby, a variable can be a string, an integer, or anything else. Variables can have a variety of values given to them throughout time. In ruby, variable names are made up of alphanumeric characters and the underscore (_) character. A number cannot be the first character in a variable. The interpreter can tell the difference between a literal number and a variable with more ease. A capital letter cannot be used to start a variable name. In ruby, an identifier that starts with a capital letter is considered a constant.
• Ruby constants are value holders with a single value that remains constant across time. A constant in ruby is an identifier that starts with an uppercase letter. It is standard practice in programming to write all characters of a constant in uppercase. Unlike other programming languages, ruby does not require constants to have a single value over time. The interpreter generates a warning only when assigning a new value to an existing constant.
• Ruby literal -a literal is a textual depiction of one of a type's values. Boolean, integer, floating-point, string, character, and date are examples of literal types. A literal will be given a value at compile-time, but a variable will be given a value at runtime.

A lexical analyzer in ruby language acts as the interface between the source code and the compiler.  Lexical structures provided in ruby language consist of the The process can be split into the stages of scanning and evaluation. Scanning involves segmenting code blocks and input data into syntactic units while evaluation is associated with transforming generated lexemes into values or tokens.

We prefer convention over configuration when writing rails code, and we adhere to rails' conventions. As a result, we don't have to write many configuration codes. If you configure your rails applications in the same way, this can be considered the standard. Rails have a default way of doing things and have established some standards that should be followed when using the framework. One of the few conventions is naming conventions.

• Class names and module names use camel case. For instance, “application controller."
• Snake_case is used to name methods and variables.

To map models to database tables, active record employs specific naming standards. To discover the appropriate database tables, rails pluralizes the class names. In rails, both regular and irregular nouns can be pluralized (and singularized). When there are two or more words in a model class name, it must be written in camel-case, whereas database table names must be written in snake_case.

You can alternatively use “active record::Base.table name= function” To indicate a table name that should be used instead of the one rails expects due to naming conventions. The table name= function is available to all models that inherit from application record because it derives from active record::Base.

Because the aforementioned techniques construct an association between each instance of the declaring model and a single instance of the other model, the association name must match the singular form of the associated model name when declaring an association using methods like belongs to and has one. The association name must match the plural form of the other model's name when declaring an association between one instance of the declaring model and numerous instances of the other model.

Ruby implementations and its usage

Because a controller is a ruby class, it uses the standard naming practice for ruby classes. It's written in camel case and has the controller suffix.

• The controller's name is frequently plural. Take note of how tasks controller uses the plural form of tasks.
• The suffix of the controller keyword is usually single. We don't use controllers as a suffix, in other words.

Snake_case is used in controller actions, which are methods. They normally have the same names as the routes defined in the routes config file. Controller actions are commonly named after the normal crud activities done by restful routes, index, show, new, create, edit, update, and delete in the case of restful routes.

The snake case form is used for route names, and they usually match the name of the appropriate controller sans the controller suffix. Depending on the resource type, route names might be singular or plural. We have both solitary and plural resources in rails. However, both singular and plural resources map to a plural controller by default.

The name of the folder under app/views should match the controller's name it's connected with. Snake_case should also be the name of the folder. Use snake case followed by the proper response type and file extension in this specific order, separated by a dot, to match the respective action names (.). The view file format with the related controllers' view folder is as follows:

“app/views/controller_name/action_name.response_type.file_extension”

Text, strings, numbers, and other data kinds are represented as data types in ruby. Because it is an object-oriented language, all data types are based on classes. The different ruby data types are as follows:

• A numberis typically defined as a sequence of numbers separated by a decimal mark (a dot). The underscore can be used as a separator if desired. Integers and floats are the two types of numbers. Ruby accepts both integers and floating-point numbers. Based on their size, integers are divided into two categories: Bignum and fixnum. 
• Boolean: This data type holds only one bit of information whether something is true or false.  
• A stringis a collection of letters that create a phrase or a word when put together. To form strings, text is enclosed in single (") or double ("") quotations. Strings can be made with both double and single quotations. The string class represents string objects.
• Hashes: A hash is used to assign a value to a key and they can be used to reference each other. The => symbol designates a value to a key. A comma separates each key pair, and curly braces surround all the pairings. Hashes and arrays are created almost in a similar way. The presence of a comma at the end of a sentence is ignored.
• Data or a list of data in a program is kept in arrays. An array can store any kind of data including hashes. The data contained in an array is separated by a coma and enclosed using square brackets. An array's elements are numbered from 0 to 1. The presence of a comma at the end of a sentence is ignored.
• Symbolsare a type of light string. A symbol is preceded by a colon (:). They are used instead of strings since they are so much smaller. Words are less powerful than symbols.

An assignment expression defines more than one value for one or more lvalues. A variable that might appear on the lefthand side of an assignment operator is known as a lvalue. (values on the righthand side of an assignment operator are commonly referred to as rvalues.) in ruby, lvalues are variables, constants, attributes, and array elements. For different types of lvalues, the rules for and meaning of assignment expressions vary slightly, and each type is covered in depth in this section.

In ruby, assignment expressions can have three different forms.

• A simple assignment uses one lvalue, the = operator, and one rvalue. Consider the following scenario:

           “x = 1  # set the lvalue x to the value 1”

• A shorthand phrase that updates the value of a variable by executing another operation (such as addition) on the variable's current value is called an abbreviated assignment. Assignment operators like += and *=, which combine binary operators with an equal sign, are used in the abbreviated assignment.

        “c += 1    # set the lvalue x to the value c + 1”

• Finally, any assignment phrase with multiple lvalues or rvalues is referred to as a parallel assignment. Here's an easy example:

         “x,y,z = 1,2,3   # set x to 1, y to 2 and z to 3”

The parallel assignment becomes more complex when the number of lvalues differs from the number of rvalues, or when there is an array on the right. The rest of the details are listed below.

An assignment expression's value is a value (or an array of values) that has been assigned to it (or an array of values). Furthermore, the assignment operator is "Right-associative," Meaning that the numerous assignments in a single statement are evaluated from right to left. This means that the assignment can be chained to give many variables the same value. Assignments have a more significant impact on program state through changing the value of a variable (or another lvalue) than the value of an assignment expression. The assignment's effect on the program state is an unintended consequence. Many expressions have no side effects and have no bearing on the program's current state. They have the power of idempotent. This signifies that the expression can be evaluated multiple times and always provide the same result. Also, assessing the expression has no bearing on the value of other expressions.

Alternative implementations and its advantages

Variables, which are the most common lvalues in assignment expressions, come to mind when we think of assignments. Local, global, instance variables, and class variables are the four types of variables in ruby. The initial character in the variable name distinguishes them from one another. We don't need to differentiate between the sorts of variables because the assignment works the same for all four. It's important to remember that ruby's object instance variables are never exposed outside the object, and an object name never qualifies variable names.

As you might assume, assigning a variable to a value sets the variable to that value. The only snag is with variable declaration and ambiguity in the names of local variables and methods. Variables do not need to be explicitly declared in ruby; they automatically exist when allocated. Also, there is no prefix like $ to distinguish between local variable names and method names. As a result, a simple statement like x may refer to a local variable or self method with the same name. If ruby has seen any earlier assignment to the variable to settle the ambiguity, it recognizes the identifier as a local variable. It does so even if the assignment was never completed.

In addition to loops, conditionals, and iterators, the ruby programming language includes some statements for changing the flow of control in a program. Put another way, these statements are pieces of code that execute one after the other until the condition is true, and then the code terminates when the condition is false. The statements that can change the control flow in a ruby program are as follows:

• Break statement: When the condition is true, the break statement in ruby is used to exit the loop. The break statement is commonly used in while loops because the output is displayed until the condition is true, and the loop exits when the condition is false. Inside the loop, the break statement is utilized. The break keyword is used to execute the break statement. For while, case-control statements can also employ the break statement.

 

Figure 1:Example of a break statement code

• Next statement: The next command in ruby is used to jump to the next iterator in a loop. In c and java, the next statement is the same as the continued statement. There will be no more iteration when the next statement is utilized. In most for and while loops, the next statement is used.

 

 Figure 2:Example of a next statement

• Redo statement: The redo statement restarts a loop's or iterators current iteration. The redo and next statements are not interchangeable. The next statement always transfers control to the conclusion of the loop, allowing the statement after the loop to begin to run. In contrast, the redo statement returns control to the top of the block or loop, allowing iteration to begin again.

 Dynamic approaches and polymorphic in ruby language and platforms enhances creation of application that are fast. Performance is a feature enhanced in ruby programming that provides an approach for systematic application development.

 

Figure 3:An instance of redo statement

• Return statement: This is used to quit a method, whether it has value or not. It always gives the caller value. With the return statement, you have a lot of alternatives. If no expression is used with the return statement, the value of the method is always returned as nil. The comma always separates a list of expressions after the return statement (). The method's return value will be an array containing the values of the supplied expressions in this scenario.

 Figure 4:Example of return statement

• Throw/catch statement: The terms "Throw" And "Catch" Describe a control structure as a multi-layer break. Throw which is a keyword is used to end the current loop and move control outside the catch block. Throw's biggest feature is that it can exit the current loop or procedures; in other words, it can traverse any number of layers. Here, the catch is a "Labeled block" Of code that causes the throw block to leave.

 

 Figure 5:Example of a throw/catch statement

Subprograms are one of the most critical topics in programming language design since they are the essential building blocks of programs. Memory space and coding time are saved as a result of this reuse.  Functions and method types are defined types that can be implemented in ruby programming language.

• There is just one entry point for each subprogram.
• The caller is suspended while the called subprogram is running, implying that only one subprogram is running at any given moment.
• Control always returns to the caller when the called sub-program's execution finishes.

The subprogram abstraction interface and operations are described in a subprogram definition. A subprogram call is an explicit command to run the called subprogram. After being called, a subprogram is said to be active if it has started but not yet completed its execution. Procedures and functions are the two basic forms of subprograms.

Data abstraction is the concept of displaying important features while obscuring functional aspects. This programming method separates the interface from the implementation. Data abstraction is part of object-oriented programming. Abstraction reduces the amount of data available to the developer, allowing them to focus on a small number of concepts at a time. The foundation of software development is an abstraction.

Conclusion

Data abstraction is a set of methods, classes, and constants in ruby modules. Consider the math module's sqrt() function. We call the sqrt() function in the math module and send the number as an argument without comprehending the underlying mechanism when we need to compute the square root of a number that is not negative.

Data abstraction with classes: Using classes in ruby, we may achieve data abstraction. We can utilize access specifiers to group information and methods (private, protected, public) in the class. The class will decide which data should be visible and which should be hidden.

Access control for data abstraction: Access control has three degrees: (private, protected, and public). These are the actual data abstraction implementations in ruby.

• Because only necessary details are made available to the user, it helps increase the security of a system.
• It improves code re-usability and eliminates code redundancy.
• Could independently change the internal class implementation without affecting the user.

 

 Figure 6:Example on abstraction

Ruby is an object-oriented programming language (oop). It uses classes as the outline for objects. The essential building blocks of ruby code are objects with two properties: States and behaviors (anything in ruby is an object). Ruby classes are the blueprints for an object's properties (also known as states) and behaviors (called methods in ruby).

Encapsulation in ruby provides something similar in terms of limiting our focus. Ruby limits its focus to what is necessary for the task at hand, comparable to how we don't need to consider the purpose of life when working as programmers. It's ok to ponder life's purpose, but it's unlikely to be relevant for most of your programming time. Encapsulation is the intentional creation of barriers in code to prevent erroneous access to and alteration of states and behaviors that aren't relevant to the purpose.

Ruby concurrency is defined as the ability for two jobs to start, run, and finish simultaneously. But that doesn't rule out the possibility of them both running simultaneously (e.g., multiple threads on a single-core machine). On the other hand, parallelism occurs when two jobs are executed simultaneously (e.g., multiple threads on a multi-core processor).

Because it functions as planned, parallelism is easier to comprehend. Two requests come at the same time on the server, and the server handles them both at the same time. This signifies those two cores in a computer are operational at the same time.

Ruby is a dynamic programming language comparable to spoken languages in that it has no hard and fast rules for generating features. One of ruby's goals is to make web app development simple and fast. As a result, there is far less tedious work when compared to many other programming languages. Ruby gives code that is relatively small, elegant, and reliable. Ruby is a free programming language and also open-source. It is unrestricted in copying, using, modifying, and disseminating. Since ruby may be used in several applications, developers can easily make changes to their code without feeling confined. One of ruby's features is mark-and-sweep garbage collection, which helps developers to trace of reference counts in extension libraries. It can also dynamically load extension libraries. These are just a few reasons why ruby is a good programming language.

Exception handling is a process that involves handling errors raised or that occur during the entire execution of a program. Block are used to handle exception that are raised, for instance the base class exception can be used to handle exception such as indexerror. Event handling is handled when an event of certain type is triggered.

Begin and end blocks are used in ruby to mark the beginning and the end of a control structure for handling and exception.

An exception handler is usually executed when an exception occurs while and event handler is triggered when a certain event is fired. The process of raising an exception involves transfer of the entire flow-of-control to the handling block (wang, feng, huang & tan, 2016).

Both exception and event handling are important mechanisms that are used to control runtime errors that occur in a program. Abnormal termination of a program can be avoided and the responsive message displayed to the user.

• Python supports django web framework while ruby has enhanced for ruby on rails.
• Mixins can be used for development in python language while not mixins can not be used in ruby (rodrigues & terra, 2018).
• Ruby is fully object oriented while python does not support all the features of object-oriented paradigms.
• Python is supported by multiple integrated development environment while in ruby eclipse is the main ide.
• Python has support for functions whereas in ruby function implementation is not supported (andonov, 2019).

• The main distinct feature between ruby and perl is that ruby has provision and more support for object-oriented approaches and principles. Data abstraction and encapsulation are advanced features highly supported in ruby as compared to perl.
• Catalyst is the major web framework developed in perl while ruby on rails if the main framework for developing web applications in ruby (andonov, 2019).
• Perl has support for more unicode characters as compared to ruby.

Readability and writeability is the ability of a programming language to easily be read and understood. Performance of a programming language is influenced by elegance in the code base as well as dynamic features of compilation (klochkov & mulawka, 2021). Computational time for ruby is lower as compared to other languages and therefore ruby has high performance that can be denoted with a space time of o(n).

Ruby has an elegant syntax that is easy to read and understand, this makes it possible for implementation of solutions using the language. Performance is measure in terms of the execution speed and computational for a certain segment of a program.

Figure 7: Ruby oop program.

Ruby is an interpreted language with support strong object-oriented principles and paradigms that enhance implementation of class defined types. Encapsulation enhances definition of the same program in different forms as well as enhances provision of generated types.

 

 Figure 8:Program results.

Conclusion

Programming languages are designed and organized in different ways to enhance readability and writeability features. Programming paradigms are used to support execution and performance features of a programming language.  Principles and paradigms that enhance development of application and adoption of integrated environment using ruby language can be used to enhance performance features.

The main objective of this research that has highlighted the main features and paradigms supported by ruby has been achieved. Comparison with other languages and the main features of ruby that make is suitable for developing application has been provided in this report. Future research of this research can be used to focus on data encryption and other frameworks that can be used to develop applications with ease.

References

Aerts, j., & law, a. (2009). An introduction to scripting in ruby for biologists. Bmc bio-informatics, 10(1), 1-9.

Andonov, f. (2019). Comparative analysis of python with other programming languages. Yearbook telecommunications, 6, 1-15. Doi: 10.33919/ytelecomm.19.6.1

Bächle, m., & kirchberg, p. (2007). Ruby on rails. Ieee software, 24(6), 105-108.

Banks, m., & ruby, j. (eds.). (2011). Made to be seen: Perspectives on the history of visual anthropology. University of chicago press.

Bennett, a. Scripting in ruby.

Flanagan, d., & matsumoto, y. (2008). The ruby programming language: Everything you need to know. " O'reilly media, inc.".

Klochkov, d., & mulawka, j. (2021). Improving ruby on rails-based web application performance. Information, 12(8), 319. Doi: 10.3390/info12080319

Matsumoto, y. Ruby (programming language) information.

Matsumoto, y., & ishituka, k. (2002). Ruby programming language.

Rodrigues, e., & terra, r. (2018). How do developers use dynamic features? The case of ruby. Computer languages, systems & structures, 53, 73-89. Doi: 10.1016/j.cl.2018.02.001

Seaton, c. (2015). Specialising dynamic techniques for implementing the ruby programming language. The university of manchester (united kingdom).

Sahli, m. A., & romney, g. W. (2010). Agile teaching: A case study of using ruby to teach programming language concepts. Journal of research in innovative teaching, 3(1).

Sheeran, m. (1992). A note on abstraction in ruby. In functional programming, glasgow 1991 (pp. 332-338). Springer, london.

Ueno, k., fukasawa, y., morihata, a., & ohori, a. (2014, november). The essence of ruby. In asian symposium on programming languages and systems (pp. 78-98). Springer, cham.

Vinoski, s. (2006). Enterprise integration with ruby. Ieee internet computing, 10(4), 91-95.

Wang, x., feng, z., huang, k., & tan, w. (2016). An automatic self-adaptation framework for service-based process based on exception handling.concurrency and computation: Practice and experience,29(5), e3984. Doi: 10.1002/cpe.3984