Project

to_robust

0.0
No commit activity in last 3 years
No release in over 3 years
to_robustchristimperley/ruby_to_robustHomepageDocumentationSource CodeBug TrackerWiki
Soft semantics for Ruby to automatically recover from fatal exceptions and to repair damaged programs. Used to improve robustness, expressiveness and performance in Grammatical Evolution.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
 Popularity
Downloads
2,163
Stars
0
Forks
0
Watchers
1
 Releases
Current version
1.0.0.pre
Total releases
1
First release
2013-12-12
Latest release
2013-12-12
 Issues
Open Issues
1
Closed Issues
3
Total Issues
4
Issue Closure Rate
75%
 Development
Primary Language
Ruby
Licenses
MIT
Average date of last 50 commits
2013-12-21
Reverse Dependencies
0

 Dependencies

Runtime

levenshtein
~> 0.2.2
 Project Readme

ruby_to_robust

ToRobust allows you to implement soft semantics in your programs so that they may automatically recover from a range of supported exceptions in some sensible manner, allowing the program to continue running.

The soft semantics provided by this project were originally designed to be exploited by Wallace.rb to provide robustness and support for soft grammars when using Grammatical Evolution.

Two different soft semantics solutions are provided by ToRobust, both based on the Local and Global robustness schemes outlined in Chris Timperley's Masters Thesis.

  • Global: The Global robustness module implements soft semantics by intercepting all exceptions thrown by a monitored method and using line information and other information provided by the exception to determine the root of the problem in the method source code which it then proceeds to "repair".
  • Local: Rather than manipulating the source code of the monitored function, the Local robustness measure operates by implementing a series of monkey patches which ensure that a set of supported exceptions are never (or rarely) thrown within the context of the monitored function.

Please note that the definition of a "repaired method" used by this project is a method which no longer produces errors (which would otherwise crash the program). This does not mean that the program does what its programmer wanted (although sometimes it might).

The implementation and behaviour of this robustness scheme is very different to the implementation used in Chris Timperley's Master Thesis.

  • In the original version Global robustness was either enabled or disabled, and was constantly active except in certain classes and modules. The new implementation allows Global robustness to be constrained to a given block or method, so that the program may operate as it otherwise would outside the "protected" block.
  • Exceptions are treated as soon as they are thrown outside the context of the monitored method. The original Global robustness would allow exceptions to propagate through the program (allowing them to be caught by a parent context) up till the point they would crash Ruby.
  • Performance is hugely improved! By providing the optional file name and line number parameters to dynamically evaluated procedures there is no need to use external files to extract detailed error information. Additionally, since the soft semantics are constrained to a given block or method, very few method calls have to be wrapped (and therefore slowed down).