Agile development with Ruby

Do you remember the old waterfall model? The waterfall model is a sequential software development process, in which progress is seen as flowing steadily downwards (like a waterfall ) through the phases of Conception, Initiation, Analysis , Design (validation), Construction, Testing and maintenance .

Wide criticism: It is impossible, for any non-trivial project, to get one phase of a software product's lifecycle perfected before moving on to the next phases and learning from them. Clients may not be aware of exactly what requirements they want before they see a working prototype and can comment upon it; they may change their requirements constantly, and program designers and implementers may have little control over this.

Agile software development refers to a group of software development methodologies based on iterative development, where requirements and solutions evolve through collaboration between self-organizing cross-functional teams .

Agile methods break tasks into small increments with minimal planning, and do not directly involve long-term planning. Iterations are short time frames that typically last from one to four weeks. Each iteration involves a team working through a full software development cycle including planning, requirements analysis, design, coding, unit testing , and acceptance testing . The goal of an iteration is to have an available release (with minimal bugs) at the end of each iteration.

Minimize overall risk by adapting to changes quickly. The ultimate goal is to REDUCE COST .

Maintain the Theory of the Code : Great teams have a shared understanding of how the software system represents the world. Therefore they know where to modify the code when a requirement change occurs. They know exactly where to go hunting for a bug that has been found. They communicate well with each other about the world and the software.

Build Less: It has been shown that we build many more features than are actually used. In fact only about 20% of functionality we build is used often or always. More than 60% of all functionality built in software is rarely or never used!

Pay Less for Bug Fixes: Typically, anywhere between 60%-90% of software cost goes into the maintenance phase. Most of our money goes into keeping the software alive and useful for our clients after the initial build.

Pay Less for Changes: The only thing constant in today’s software market is change. If we can embrace change, plan for it, and reduce its cost when it eventually happens we can make significant savings.

Agile development => Set of chosen practices => Reduce cost => 1- Maintain code theory. 2- Build less. 3- Pay less for bugs. 4- Pay less for changes

Simple design meets the requirements for the current iteration and no more. Simple design reduces cost because you build less code to meet the requirements and you maintain less code afterwards. Simple designs are easier to build, understand, and maintain. Simple design<=> Build less

The practice of Refactoring code changes the structure of the code while maintaining its behavior. Costs are reduced because continuous refactoring keeps the design from degrading over time, ensuring that the code is easy to understand, maintain, and change. Refactoring <=> Pay less for change

Automated developer tests are a set of tests that are written and maintained by developers to reduce the cost of finding and fixing defects—thereby improving code quality—and to enable the change of the design as requirements are addressed incrementally. Automated developer tests reduce the cost of software development by creating a safety-net of tests that catch bugs early and enabling the incremental change of design. Have a look at TDD or BDD. Developer Tests <=> Pay less for bugs fixing

Ruby was conceived on February 24, 1993 by Yukihiro Matsumoto (Matz) who wished to create a new language that balanced functional programming with imperative programming. According to Matsumoto he "wanted a scripting language that was more powerful than Perl, and more object-oriented than Python. That's why I decided to design my own language".

Selecting even numbers from a range: (1..25).select {|x| x % 2 == 0 } #=> [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24]

Cumulative sum: [1,2,3,4] => [1,3,6,10] sum = 0 [1,2,3,4].map{|x| sum += x} #=> [1,3,6,10]

Ruby is a dynamic , reflective , general purpose object-oriented programming language that combines syntax inspired by Perl with Smalltalk-like features. Ruby originated in Japan during the mid-1990s and was initially developed and designed by Yukihiro "Matz" Matsumoto . It is based on Perl , Smalltalk , Eiffel , Ada , and Lisp . Ruby supports multiple programming paradigms , including functional , object oriented , imperative and reflective . It also has a dynamic type system and automatic memory management ; it is therefore similar in varying respects to Python , Perl , Lisp , Dylan , and CLU .

Dynamic programming language is a term used broadly in computer science to describe a class of high-level programming languages that execute at runtime many common behaviors that could include extension of the program, by adding new code, by extending objects and definitions, or by modifying the type system, all during program execution.

Eval : Evaluating code on runtime. eval “x=1; x+=5” #=> 6 instance_eval, class_eval Higher order functions : Passing functions as arguments. In Ruby we pass blocks (anonymous functions) (1..25).select {|x| x % 2 == 0 } Reflection : Modifying program structure and behavior; treating code like data.

Monkey patching: Example: Sum array values class Array def sum self.inject{|sum,current| sum+current } end end [1,5,7,8].sum #=> 21

In computer science, reflection is the process by which a computer program can observe and modify its own structure and behavior. Ruby has a very wide set of methods for introspection and reflection.

class Foo def hi puts “hi” end def bye puts “bye” end end # Introspection API Foo.new .methods(false) #=> [“hi”,”bye”]

class Foo end f = Foo.new f.methods(false) #=>[] f.define_method(:hi) { puts “hello world!" } f.methods(false) #=>[“hi”] f.hi #=> hello world!

Ruby’s attr_accessor is an example of Ruby’s reflection use: class Foo attr_accessor :name # getter # def name ; @name ; end # setter # def name=(sn); @name = sn; end end

Everything is object even null values! nil.class #=> NilClass This is called Unified Object Model UOM. Cool, you don’t have to think of primitive and reference values, everything is an object and has its methods. Treating everything as an object will extend the language dynamicity to unlimited scopes. You can treat methods as objects as well.

Everything is evaluated as an expression in Ruby. Example: You can do this: if num == "one" then val = 1 elsif num == "two" then val = 2 else then val = 3 end But this is better: val = if num == "one" then 1 elsif num == "two" then 2 else 3 end

Methods are higher order functions; you can pass code blocks to methods, this makes you focus on the ‘what’ part instead of the ‘how’ one of your problem. Example: selecting even numbers from a range: Traditional imperative way: res = [] input = 1..25 for x in input res << x if x % 2 == 0 end Functional way: res = (1..25).select{|x| x % 2 == 0} How about odd numbers? res = (1..25).select{|x| x % 2 > 0}

Functional programming emphasize immutability(pure methods) thus no side effects! s = "hello" #=> "hello“ s2 = s.upcase #=> "HELLO“ puts s.upcase! #=> "HELLO“ puts s , s2 #=> "HELLO“, “hello”

Ruby community embraces Test Driven Development, and recently the more recent type of it called Behavior Driven Development BDD. TDD or BDD => Automated test suit => reduce the cost of finding and fixing defects => improving code quality => Productivity  reduce cost

Remember: Agile development => reduce cost. Ruby code is at least 50% more concise than code written in other languages like Java, which means write less and get the same => productivity. Having less code means less bugs to fix and less code to maintain(refactor) => productivity. Ruby code is so readable, Ruby follows the principle of least surprise(POLS). Readable code means self documenting => productivity. TDD – BDD => improving code quality => Productivity

A Domain-specific language(DSL) is a computer language that’s targeted to a particular kind of problem, rather than a general purpose language that’s aimed at any kind of software problem. Regular expressions and CSS are 2 examples of DSLs. Any software language needs a parser and an interpreter(or compiler or a mix), but in DSLs, we have 2 types: external ones which need parsers and interpreters, and internal ones which rely on the hosting language power to give the feel of a particular language, and thus they don’t require their own parsers and they use the language’s interpreter.

ActiveRecord ORM: Traditional: user = User.find(:conditions=>[“name=? and age = ? ”, “khelll”, 18]) Cool: user = User.find_by_name_and_age(“khelll”,26)

Ruby is used in almost all fields. The most common use is RubyOnRails or RoR. RoR is a inspiring web framework that was implemented in almost all living languages. RoR is used by yellowpages.com and twitter.com. Ruby is used by system admins as it’s easier to write than shell scripts. Ruby is used in telecomunication systems.

CRuby, the official Ruby implementation. JRuby, Java based implementation that runs on JVM, it integrates Java to be used with Ruby. IronRuby, .Net implementation.

Agile development with Ruby

Recommended

More Related Content

What's hot (20)

Similar to Agile development with Ruby (20)

Recently uploaded (20)

Agile development with Ruby