[Virtual Presenter] Good morning everyone! Today, we will be discussing a revolutionary programming language, Ruby, and the components that make it so powerful. We will learn how Ruby can be used to manipulate text files, handle files, execute system tasks, and support regular expressions. We will also discuss its characteristics, macro, inner workings, and how to configure the lexical analyser and parser. Let us now begin our discussion.. 

Scene 1

INTRODUCTION TO RUBY
AND EXPLAINING ITS 
COMPONENTS 
PERSENTATION BY:
1. MYHAMMAD SAFWAN FAROOQ
2. RASHID ALI
3. MOOSA KHAN

[Audio] Ruby is a powerful and versatile programming language that enables fast and effective coding. Unlike languages that require their source code to be compiled before running, Ruby is an interpreted language. It can be used for various tasks, including processing text files, handling files, using regular expressions, and executing system tasks. Ruby also stands out due to its natural and expressive syntax, making it easy for developers to express their ideas. At its core, Ruby is written in the C programming language, which is then translated to assembly language and further to 0s and 1s for computers to understand and execute.. 

Scene 2

WHAT IS RUBY AND WHY WAS IT MADE.
Ruby is an interpreted, object-oriented, dynamically typed programming languages which focuses 
on simplicity and productivity. It is a natural and very expressive language in which programmers 
can easily express themselves. Ruby is written in C, which translates to Assembly language, 
which  translates to machine language to further translate to 0 and 1  so that the computer 
understand
Following are some facts of  RUBY:
• Manipulation of text files
• File handling
• Execution of system tasks 
• Support for regular expressions

[Audio] Ruby is a programming language, developed in the mid-1990s, which draws inspiration from languages like Python and Perl. Its inimitable features include its object-oriented structure - all things are objects - and its wide range of integrated data types, including strings, arrays, hashes, regular expressions and range objects. If you are interested in gaining proficiency in a powerful and versatile language for web development, why not join us to learn more about Ruby!. 

Scene 3

RUBY 
CHARACTERISTICS
Everything is an object
Syntax inspired by Python and Perl
• String                
• Array
• Hash 
• Regular Expressions
• Range
Rich built in data types such as:

[Audio] In this slide, we will discuss lexical analysis in Ruby using the oedipus_lex gem. The gem provides us with the ability to define macros for certain regular expressions which we might need to write repeatedly for the lexer. We can also define code under the inner keyword that the lexer can execute. Finally, we can define the lexer rules that will be used for lexical analysis.. 

Scene 4

LEXICAL ANALYSIS IN RUBY
Macro:
•The macro keyword lets you define macros for certain regular 
expressions that you might need to write repeatedly. In the 
above lexer, the macro DIGIT is a regular expression (\d+) for 
detecting one or more integers. We place the regular expression 
inside forward slashes (/../) because oedipus_lex requires it that 
way. The lexer can handle any valid Ruby regular expression. See 
the Ruby docs for details on Ruby regexps.
Inner:
•Under the inner keyword you can specify any code that you 
want to occur inside your lexer class. This can be any logic that 
you want your lexer to execute. The Ruby code under the inner 
section is copied as-is into the final lexer class.
•Configuring the lexical analyser
•The most fundamental need of any parser is that it 
needs string tokens to work with, which we will 
provide by way of lexical analysis by using the 
oedipus_lex gem (the logical successor of rexical).
• In the above code, we have defined the lexical 
analyser using Oedipus Lex’s syntax inside the 
AddLexer class. Let’s go over each element of the 
lexer one by one:
Rule:
The section under the rule keyword defines your 
rules for the lexical analysis. Now it so happens that 
we’ve defined a macro for detecting digits, and in 
order to use that macro in the rules, it must be inside 
a Ruby string interpolation (#).

[Audio] Ruby is a well-known scripting language. In order to create an addition program, a parser is needed to interpret the tokens that are generated by the lexer. Racc, an LALR(1) parser generator for Ruby, is used for this purpose. AddParser class is utilized, which contains the logic for the parser. Logic is placed inside the inner keyword and the header keyword of the parser. In conclusion, this allows for the creation of the addition program.. 

Scene 5

PARSER IN RUBY
In order for our addition program to be successful, it needs 
to know what to do with the tokens that are generated by 
the lexer. For this purpose, we need racc, an LALR(1) parser 
generator for Ruby. It is similar to yacc or bison and let’s you 
specify grammars easily.
•Go ahead and create a file called parser.racc in the same 
folder as the previous lexer.rex and Rakefile, and put the 
following code inside it:.
•As you can see, we’ve put the logic for the parser inside 
the AddParser class. Yacc’s $$ is the result; $0, $1… is an 
array called val, and $-1, $-2… is an array called _values. 
Notice that in racc, only the parsing logic exists inside the 
class and everything else (i.e under header and inner) exists 
outside the class.
class AddParser
This is the core class that contains the parsing logic for the 
addition parser. Similar to oedipus_lex, it contains a rule section 
that specifies the grammar.
Header:
The header keyword tells racc what code should be put at the top 
of the parser that it generates. You usually put your require 
statements here.
inner
The inner keyword tells racc what should be put inside the 
generated parser class. As you can see there are two methods in 
the above example - next_token and prepare_parser.

[Audio] Ruby, a programming language, consists of multiple components that collaborate seamlessly. We will discuss two of these elements, lexical analysis and parsing, and explain how they interact to parse any valid Ruby code. To illustrate, we will provide an example of a code which makes use of both components. Let's begin!. 

Scene 6

PUTTING IT ALL TOGETHER
•Our lexical analyser and parser are now coupled to 
work with each other, and we now use them in a 
Ruby program to parse a file. Create a new file called 
adder.rb and put the following code in it:
•The prepare_parser is the same one that was 
defined in the inner section of the parser.racc above. 
The do_parse method called on the parser will signal 
the parser to start doing it’s job.
•In a separate file called text.txt put the following 
text:

[Audio] Good morning everyone. This slide is about an introduction to Ruby and explaining its components. We are briefly going to discuss two tools that are used to write Ruby programs- Lexer and Parser. Lexers, also known as scanners, are responsible for understanding and breaking down text into meaningful blocks. Parsers, on the other hand, work on these blocks to recognize patterns and produce an organized structure. Oedipus Lex does not have a command line tool like rexical for automatically generating a lexer from the logic specified, but rather it has a bunch of rake tasks defined for doing this job. Once the Rakefile is created with the code inside it, running rake parser will generate two files - lexer.rex.rb and parser.racc.rb. These two files will contain the classes and logic for the lexer and parser respectively. Finally, you can use your newly written lexer and parser with a ruby adder.rb text.txt command to get the desired output. Thank you.. 

Scene 7

•
Oedipus Lex does not have a command line tool 
like rexical for generating a lexer from the logic 
specified, but rather has a bunch of rake tasks 
defined for doing this job. So now create a 
Rakefile in the same folder and put this code 
inside it:
•
Running rake parser will generate a two new files 
- lexer.rex.rb and parser.racc.rb - which will house 
the classes and logic for the lexer and parser, 
respectively. You can use your newly written lexer
+ parser with a ruby adder.rb text.txt command. It 
should output 4 as the answer.

[Audio] Ruby is a powerful Object-Oriented programming language which allows for efficient and fast code generation. These code generators can be divided into two main categories - dynamic and static. Dynamic code generators are loaded and executed at runtime and then converted into Ruby code. Static code generators, in contrast, are used to generate full Ruby code based on provided data. When using either type of code generator, it is imperative that the include paths for the Ruby interpreter are correctly managed, to ensure that the static code is correctly imported.. 

Scene 8

CODE GENERATOR USED 
IN RUBY
The Ruby mapping supports two forms of code generation:
1.Dynamic 
2.Static.
Dynamic Code Generation in Ruby
Using dynamic code generation, ruby files are "loaded" at run 
time and dynamically translated into Ruby code, which is 
immediately compiled.
A static code generator is a code generator that generates a full 
static ruby code based on raw data.
We can safely use a combination of static and dynamic code 
generation in an application. For it to work properly, you must 
correctly manage the include paths for Ruby interpreter so that 
the statically-generated code can be imported properly

[Audio] Ruby is a general-purpose programming language, capable of tackling many types of tasks. It offers a range of features such as web development and system administration. Code optimization is a method of making code more efficient and less complex. This can lead to faster performance, making code easier to read, track and debug errors, and saving computational power. Ruby is the ideal language for application that require top performance, due to its support for code optimization.. 

Scene 9

CODE 
OPTIMIZATION 
IN RUBY
Ruby code optimization is a way to make your program perform any task 
more efficiently and quickly with fewer lines of code, less memory, or other 
resources involved, while producing the right results. 
Following are some key features of ruby code 
optimization:
Speed up the performance of the application;
Make code clean and readable;
Simplify error tracking and debugging;
Save a lot of computational power, and so on.

[Audio] We will be looking at two methods to print our desired output in Ruby: the 'puts' and 'print' functions. 'Puts' adds a new line after the string, whereas 'print' does not. For example, using 'puts' and 'print' to print "Hello World!" would result in "Hello World!" followed by a new line for 'puts', and "Hello World!Hello World!" for 'print'.. 

Scene 10

RUBY CODE EXAMPLES
•If you want to print Hello World! Or any other words, the 
following are the two methods you can use
•puts: Which signifies the put strings. After the string, there 
will be an addition of a new line.
•print: This function is similar to put; however, there won't 
be an implicit addition of newlines like input
•Output:
•Hello World!
•Hello World! Hello World!

[Audio] Our slide today is about Strings in Ruby and to get started let's take a look at how to create strings in Ruby. You can create strings in Ruby using both single and double quotes. Double quotes allow you to interpolate values into the string, but single quotes do not. Certain escape characters, such as the '\n' character to denote a new line, must be enclosed in single quotes. So it's important to remember the difference between these two methods when building your strings.. 

Scene 11

STRINGS
•There are different ways to create strings 
in Ruby, and it’s a typical variation of how 
Perl can create strings. Double quotes 
allow the interpolation of values into the 
string while it is not possible with single 
quotes. Many escape characters are 
enclosed in single quotes, \n is treated as 
double characters, then a backward slash 
and an n

[Audio] Arrays in Ruby are an important element of the Ruby language. They contain multiple values, giving us the ability to easily access and manipulate those values. Their use is similar to strings, in which a quotation or bracket notation is used to create an object. Arrays offer greater control and a more effective manner for interacting with multiple values.. 

Scene 12

RUBY ARRAYS
•Ruby arrays have the same 
operation as the strings. The 
same way a quote notation 
makes a String object, a 
bracket notation also makes 
an Array object.

[Audio] Ruby is a powerful programming language and this slide discusses how to use it to calculate the area of a rectangle. To do this, we need to use logic to apply the relevant formula. Converting the string to a float data type is important as it allows both integer and decimal values to be stored. 'Gets' is used to display a message to the user, 'puts' to take input from the user and '.to_f' to convert a value to a float type. Three variables are used in this calculation: 'l' (length), 'w' (width) and 'area' (the product of the two values which is the area of the rectangle).. 

Scene 13

RUBY CODE TO FIND THE 
AREA OF THE RECTANGLE
•We can easily find the area of a rectangle by creating logic 
which applies the above formula. Remember, convert the 
string into the float instead of integer because we expect 
the length and breadth to be of float type so as the result.
•Methods used:
•gets: It is used to display the message to the user.
•puts: It is used to take input from the user.
•.to_f: It used for converting a value into float type.
•Variables used:
•l : It is storing length given by the user.
•w : It contains width provided by the user.
•area : It is containing the product of length and breadth 
which is eventually the area of rectangle.

Scene 14

INTRODUCTION TO RUBY Presentation.

Scene 0

Ruby is a powerful and versatile programming language that enables fast and effective coding

Unlike languages that require their source code to be compiled before running, Ruby is an interpreted language

It can be used for various tasks, including processing text files, handling files, using regular expressions, and executing system tasks

Ruby also stands out due to its natural and expressive syntax, making it easy for developers to express their ideas

At its core, Ruby is written in the C programming language, which is then translated to assembly language and further to 0s and 1s for computers to understand and execute.

avatar

Ruby is a programming language, developed in the mid-1990s, which draws inspiration from languages like Python and Perl

Its inimitable features include its object-oriented structure - all things are objects - and its wide range of integrated data types, including strings, arrays, hashes, regular expressions and range objects

If you are interested in gaining proficiency in a powerful and versatile language for web development, why not join us to learn more about Ruby!

In this slide, we will discuss lexical analysis in Ruby using the oedipus_lex gem

The gem provides us with the ability to define macros for certain regular expressions which we might need to write repeatedly for the lexer

We can also define code under the inner keyword that the lexer can execute

Finally, we can define the lexer rules that will be used for lexical analysis.

In order to create an addition program, a parser is needed to interpret the tokens that are generated by the lexer

Racc, an LALR(1) parser generator for Ruby, is used for this purpose

AddParser class is utilized, which contains the logic for the parser

Logic is placed inside the inner keyword and the header keyword of the parser

In conclusion, this allows for the creation of the addition program.

Ruby, a programming language, consists of multiple components that collaborate seamlessly

We will discuss two of these elements, lexical analysis and parsing, and explain how they interact to parse any valid Ruby code

To illustrate, we will provide an example of a code which makes use of both components

This slide is about an introduction to Ruby and explaining its components

We are briefly going to discuss two tools that are used to write Ruby programs- Lexer and Parser

Lexers, also known as scanners, are responsible for understanding and breaking down text into meaningful blocks

Parsers, on the other hand, work on these blocks to recognize patterns and produce an organized structure

Oedipus Lex does not have a command line tool like rexical for automatically generating a lexer from the logic specified, but rather it has a bunch of rake tasks defined for doing this job

Once the Rakefile is created with the code inside it, running rake parser will generate two files - lexer.rex.rb and parser.racc.rb

These two files will contain the classes and logic for the lexer and parser respectively

Finally, you can use your newly written lexer and parser with a ruby adder.rb text.txt command to get the desired output

Ruby is a powerful Object-Oriented programming language which allows for efficient and fast code generation

These code generators can be divided into two main categories - dynamic and static

Dynamic code generators are loaded and executed at runtime and then converted into Ruby code

Static code generators, in contrast, are used to generate full Ruby code based on provided data

When using either type of code generator, it is imperative that the include paths for the Ruby interpreter are correctly managed, to ensure that the static code is correctly imported.

Ruby is a general-purpose programming language, capable of tackling many types of tasks

It offers a range of features such as web development and system administration

Code optimization is a method of making code more efficient and less complex

This can lead to faster performance, making code easier to read, track and debug errors, and saving computational power

Ruby is the ideal language for application that require top performance, due to its support for code optimization.

We will be looking at two methods to print our desired output in Ruby

'Puts' adds a new line after the string, whereas 'print' does not

For example, using 'puts' and 'print' to print "Hello World!" would result in "Hello World!" followed by a new line for 'puts', and "Hello World!Hello World!" for 'print'.

Our slide today is about Strings in Ruby and to get started let's take a look at how to create strings in Ruby

You can create strings in Ruby using both single and double quotes

Double quotes allow you to interpolate values into the string, but single quotes do not

Certain escape characters, such as the '\n' character to denote a new line, must be enclosed in single quotes

So it's important to remember the difference between these two methods when building your strings.

Arrays in Ruby are an important element of the Ruby language

They contain multiple values, giving us the ability to easily access and manipulate those values

Their use is similar to strings, in which a quotation or bracket notation is used to create an object

Arrays offer greater control and a more effective manner for interacting with multiple values.

Ruby is a powerful programming language and this slide discusses how to use it to calculate the area of a rectangle

To do this, we need to use logic to apply the relevant formula

Converting the string to a float data type is important as it allows both integer and decimal values to be stored

'Gets' is used to display a message to the user, 'puts' to take input from the user and '.to_f' to convert a value to a float type

Three variables are used in this calculation

'l' (length), 'w' (width) and 'area' (the product of the two values which is the area of the rectangle).