CSC/ECE 517 Fall 2010/ch3 3e br: Difference between revisions

From Expertiza_Wiki
Jump to navigation Jump to search
No edit summary
No edit summary
 
(42 intermediate revisions by the same user not shown)
Line 1: Line 1:
==Introduction==
<p style="font-size: 14pt">eval() [Computer Programming]</p>
Version Control Systems are typically used in a software facility(s), and employed for the primary purposes of collaborative work. While working on a project with common resources (files, folders, information etc.), it becomes essential to put a definite order on the sanctity of the data if the resources are editable.  
=Introduction=
The eval facility is one of the most powerful features of Ruby (as well as other dynamic languages).
Kernel.eval method will parse and execute an arbitrary string of legal Ruby source code.  
To put it plainly, if your Ruby program can generate a string of valid Ruby code,  
the Kernel.eval method can evaluate that code. The eval facility gives developers the ability to  
modify the runtime behavior of program.  Illustrate the practical advantages of Ruby's eval(...)
and compare it with similar mechanisms in other languages.


For example, if there are 10 people working on a project, and 3 people are working on the same file. It becomes important on how they can add/modify data such that all are neither locked out waiting for a lock put by anyone, nor there is any inconsistency in the data. Also, at any point in the life-cycle of the software, the developers might feel the need to go back to an earlier state of the file. Version Control Systems allow to go back to any previous version of a file, as each version is stored in the central repository and is given a label.
=Origin=
[http://en.wikipedia.org/wiki/Lisp_%28programming_language%29 LISP] The first actual implementation of
LISP was by Steve Russell.  He realized that the Lisp ''eval'' function could be implemented in machine code.[3]  The result was a working Lisp interpreter which could be used to run Lisp programs, or more properly, 'evaluate Lisp expressions.'


Version control systems typically let us create versions of the resources, where each developer can work on a different version, therefore providing the flexibility. There are a whole bunch of features provided by the new Version Control Systems. We shall look at the evolution and history of the same in the subsequent sections.
[[File:http://en.wikipedia.org/wiki/File:LISP_machine.jpg|<span title="Original LISP machine"></span>]


==Taxonomy of Version Control==
=Security risks=
It may seem natural to perform <tt>eval()</tt> on user-supplied data, exposing the entire power of the underlying
programming language with a single statement.  For example, on a web site, the programmer might allow the user to
enter an expression, and with trivial effort on the part of the programmer, the result of the expression is computed. 
However, a moment's thought reveals the grave security risk posed by such an approach.  The user could intentionally
or unintentionally delete files, corrupt files, transmit sensitive information, etc.


<b>Branch</b> : When the development team needs to work on two distinct copies of a project, a branch is created. <sup>[4]</sup> The branch is a replica of the existing code at the time of its creation. On creation of the branch, changes made to a branch are confined to it and are not visible in any other branch.
=Context=
<b>Repository</b>: Repository is the data store where all the versions of all the files in the project are stored. A repository may be centralized or distributed.
<b>Check-Out</b>: Creating a working copy of the files in the repository on a local machine is called Check-out. Every user who checks out a file has a working copy of the file on his computer. Changes made to the working copy are not visible to the team members
<b>Check-In</b>: Putting back the edited files to the repository for use by everybody is called Check-In 


<b>Merge</b>: Merging is the process of combining different working copies of the file into the repository.[3] Each developer is allowed to work on their independent working copies, and everyone’s changes to a single file are combined by merging
=Implementation=
==Dynamic Programming Languages==
<b>Label</b>: A label is an identifier given to a branch when created. Also known as Tag
===Lisp===
 
<b>Trunk</b>: The highest location of the repository is called Trunk.
[http://en.wikipedia.org/wiki/File:LISP_machine.jpg Lisp] is the second-oldest high-level programming language in common use
today (after FORTRAN).  Invented in 1958 by John McCarthy at Massachusetts Institute of Technology, LISP was first actually implemented
in machine language by Steve Russell, who realized that by implementing the LISP <tt>eval()</tt> function in assembly language,
he could create a working LISP interpreter.
 
===Perl===
 
===Ruby===
 
 
  trane = %q{"John Coltrane".length}
 
  eval trane &rarr; 13
 
===JavaScript===
 
===PHP===
 
===Python===
 
===ColdFusion===
 
==Static Programming Languages==
===Java===
GroovyShell
 
==Command Line interpreters==
 
===Unix===
 
= References =
[http://en.wikipedia.org/wiki/Eval] Eval, Retrieved October, 2010.
 
[http://en.wikipedia.org/wiki/Eval] Eval, Retrieved October, 2010.
 
[http://www.amazon.com/Programming-Ruby-Pragmatic-Programmers-Second/dp/0974514055/ref=sr_1_2?s=books&ie=UTF8&qid=1286121051&sr=1-2] Programming Ruby: The Pragmatic Programmer's Guide

Latest revision as of 20:59, 4 October 2010

eval() [Computer Programming]

Introduction

The eval facility is one of the most powerful features of Ruby (as well as other dynamic languages). Kernel.eval method will parse and execute an arbitrary string of legal Ruby source code. To put it plainly, if your Ruby program can generate a string of valid Ruby code, the Kernel.eval method can evaluate that code. The eval facility gives developers the ability to modify the runtime behavior of program. Illustrate the practical advantages of Ruby's eval(...) and compare it with similar mechanisms in other languages.

Origin

LISP The first actual implementation of LISP was by Steve Russell. He realized that the Lisp eval function could be implemented in machine code.[3] The result was a working Lisp interpreter which could be used to run Lisp programs, or more properly, 'evaluate Lisp expressions.'

[[File:http://en.wikipedia.org/wiki/File:LISP_machine.jpg%7C]

Security risks

It may seem natural to perform eval() on user-supplied data, exposing the entire power of the underlying programming language with a single statement. For example, on a web site, the programmer might allow the user to enter an expression, and with trivial effort on the part of the programmer, the result of the expression is computed. However, a moment's thought reveals the grave security risk posed by such an approach. The user could intentionally or unintentionally delete files, corrupt files, transmit sensitive information, etc.

Context

Implementation

Dynamic Programming Languages

Lisp

Lisp is the second-oldest high-level programming language in common use today (after FORTRAN). Invented in 1958 by John McCarthy at Massachusetts Institute of Technology, LISP was first actually implemented in machine language by Steve Russell, who realized that by implementing the LISP eval() function in assembly language, he could create a working LISP interpreter.

Perl

Ruby

 trane = %q{"John Coltrane".length}

 eval trane → 13

JavaScript

PHP

Python

ColdFusion

Static Programming Languages

Java

GroovyShell

Command Line interpreters

Unix

References

[1] Eval, Retrieved October, 2010.

[2] Eval, Retrieved October, 2010.

[3] Programming Ruby: The Pragmatic Programmer's Guide

Retrieved from "https://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Fall_2010/ch3_3e_br&oldid=36630"