Poetry of Programming

Its about Ruby on Rails – Kiran Soumya


Y do I like Scriptaculous?

Many doubt… Y do I like Scriptaculous?

I like Scriptaculous coz… I like Ajax…

mmm now don ask me Y do I like Ajax!

Scriptaculous demonstrates the usage of Ruby on Rails with AJAX helpers, and I luv all the script.aculo.us effects, drag-and-drop, Puff, Fade & Appear, Shrink & Grow… In-place Editor… etc etc. Everything… each n everythin…

I really cant stop thanking my young Guru, who introduced me to this.

And ofcourse, without Rails concept, all these effects wouldnt have been easily learnt! Like a curry(Rails) with all the spices(Scriptaculous) in it!

Rails is good! Ruby on Rails is the Best!

Ajax is Superb! Scriptaculous is Amazing and Fantastic!


What’s Web 2.0?

Starting from the static page, Web 1.0 has been turned to dynamic contents (like Google, yahoo etc), where users can interact with web pages, by providing instructions and contents through graphical interfaces. In short web 1.0 dealt with human-machine communication through web, accessible through wide range of operating system platforms, which was been possible by using http and html. Besides human to machine communication, the concept of web 2.0 concentrates on the following issues, that I have learned so far

  1. Machine to machine communication. You publish your content in one site, which has been automatically shared by thousands of web pages among other servers. This becomes possible through RSS. As a user, you can get updates of a web site contents, through using a RSS feeder.

  2. Human to human communication. For example point to point network, social community network etc, where pictures, emotions, biography, music etc personal resources can be shared with friends and friends community can be grown via friends of friends.

  3. Rich user experience. Using AJAX (Asynchronous JavaScript and XML), it becomes possible to send web requests from the client side to server side, through XHTTPRequest method call from browser end, which enables an user NOT to wait to work, until the reply of this web request returns back from the web server. One simplest example can be given as, in Gmail, we can attach as much as files and after then we can begin typing the mail. Lets say this type includes 6 minutes. By this time, Gmail starts sending the attachments to the server, lets say it takes 5 minutes. When my type finishes, the total process takes only 6 minutes, while not using AJAX it would take simply 11 (6+5) minutes. Web 2.0 sites provide, although NOT exactly, but a sort of much similar rich user experience like desktop application. Well one important thing to note, Ajax is not actually new technology, but uses old and very well known technology (JavaScript, xml etc) in new approach.

  4. Personal contribution over web content. Web 2.0 encourages personal contributions of the users over the web content. Blog is such a thing, which is called “Online diary”, where a person can enter his words, in daily basis. Each entry is specifically mentioned and maintained regarding it’s publish date. Several blogs in online has some common features, like archives, track back etc. Blogs has become popular, than the web 1.0 style “Persona web site”, as blog includes more personal touch. Another popular web 2.0 concept is wiki, which is called as “Online Encyclopedia”, where people can edit or contribute their knowledge there. Book marking is another web 2.0 features, where URL book marks can be saved and shared with others. Basically blog, wiki, url booking marking are the things are conceptual than latest technology and considers social aspect to share personal contents. These type of ideas encourages “tagging”, where any item can be tagged with one or more categories(in some cases these tags are being used in RSS feed).


Web 2.0 on Rocket Fuel

Ruby on Rails 1.1 is described as Web 2.0 on Rocket Fuel.

The much-anticipated new version 1.1 of Ruby on Rails hit the streets with fanfare a couple of days ago. And while even I am wary of the hyperbole that sometimes surrounds Ajax and Web 2.0, I’m very pleased to say that Ruby on Rails is the genuine article. Rails has become one of the real success stories in Web development in just the last year. Built by 37signals’ charismatic David Heinemeier Hanson and a host of contributors, Ruby on Rails has ascended to near-mainstream status nearly overnight.

For those of you not familar with Ruby on Rails, and a lot of you won’t be or have just barely heard of it, Ruby on Rails is a complete, open, and free application stack based on the Ruby programming language . This means it provides a complete solution for creating great online Ajax-based software of the kind that’s pouring out on the Web these days . Rails includes advanced Ajax support, Web services, an amazingly taut and clean model-view-controller implementation, and automatic object-relational mapping. Rails even includes seamless script.aculo.us and Prototype integration, as well as support for just about any database you will need.

Ruby itself is one of the interesting stores in software development lately because it’s a dynamic language, meaning that it isn’t compiled and is somewhat more akin to Perl and Javascript than a traditional hardcore language like Java or C++ . But that’s where similaries to Javascript end since Ruby is an elegant object-oriented language designed to make programming easy and make routine software development tasks almost effortless. In fact, when I did my C#, Java, and Ruby Web services development comparison last year, Ruby won hands down in development time, compactness, and generated by far the most readable code, even though it was the very first time I’d used it.
Ruby on Rails 1.1

Rails is a natural extension of these concepts in that it adds a framework to Ruby to make it maximally easy to build Web-based online software, with the single-minded intent of pushing complexity out to the edge cases. To get a sense of how powerful Ruby is, my recent discussion (video here) with David Heinemeier Hannson at Real-World Ajax revealed that 37signals not only built their 5 world-class online applications purely with Ruby on Rails, but they support almost 400,000 users on just 13 servers.

Dion Hinchcliffe and David Heineimeier Hansson discuss Ruby on Rails 1.1But there are dozens and dozens of Web development products out there, many of them very good, so what makes Ruby on Rails so special? One is that the Rails’ design focuses on trying to make the common Web development tasks fall-down-the-stairs easy, and it invariably succeeds. Like the Rails home page says, “Ruby on Rails is an open source Web framework that’s optimized for programmer happiness and sustainable productivity. It lets you write beautiful code by favoring convention over configuration.” Rails proponents are reknowned for their plain spokeness and directness and the result of this attitude is clear throughout the framework.

Another real advance in Rails is the fact that it considerably reduces something called abstraction impedance. Abstraction impedance is a fancy $20 phrase that describes the barrier that exists when crossing from one way of thinking to another. Say the barrier of going from objects to databases, or Javascript to Ruby. Abstraction impedance is a productivity killer that sucks up programmer time doing things that don’t matter to what the application does. So instead of providing solutions to your users, you’re spending time converting information from one form to another. Rails makes this go away by giving the programmer plain old objects to deal with, no matter if you’re dealing with XML, relational database data, and now even Javascript in the browser.

This takes us to the new features in Ruby on Rails. As its biggest new feature, version 1.1 actually allows you to write your browser-side Javascript in Ruby. Javascript is a notoriously finicky language that doesn’t make it easy to create sophisticated Ajax appliations and that’s why IDEs, frameworks, and tools are springing up everywhere to make it simpler. Now Rails has just dropped one more complexity out of the process of building Web 2.0 software applications with RJS, the Ruby to Javascript compiler.

Web 2.0 software development has its own set of expectations and best practices: rapid feature evolution, real-time feature monitoring, all functionality available in both the GUI and as Web services so others can use them in their own apps, and more. Rails makes all of these easy to do using one of the highest productivity languages out there. That’s not to say Rails is perfect, it’s so new it couldn’t possibly be fault-free, but there is clear evidence today of its reliability, scalability and ease-of-use (once you get past a brief learning curve.)

What’s New In Rails: (complete list here)

  • RJS – Write your Ajax application’s Javascript in Ruby
  • ActiveRecord++ – Rails’ ActiveRecord is a powerful, automatic Object/Relational Mapping tool. It gets a major steroid boost in Rails 1.1.
  • API Support – Adding an API for your Web 2.0 software is now even easier
  • New Integration Tests – Rails understands testing and adds even more automatic test support
  • Backwards Compatibility – Even with 500 new changes, old Rails apps will almost universally run in Rails 1.1

If you’re interested in picking up Ruby on Rails, here are twelve excellent tutorials (http://www.digitalmediaminute.com/article/1816/top-ruby-on-rails-tutorials) that can get you started. And finally, if you haven’t bought all of this yet, take a look at this screencast. It shows step-by-step how to develop a working blog application in Rails from scratch in just 15 minutes, complete with comments and an administration interface. That’s the power of Rails, it really does let you focus on delivering great online software and not get mired in details that don’t matter. In any case, Rails is so new it has almost no enterprise penetration. But as the next generation of programmers uses it more and more, expect that to change, along with the way enterprises develop with Web technology.


Script.aculo.us 1.6.4 Released on 6th September.

Thomas Fuchs has sync’d up to the latest Prototype adding features along the way:

* Update Prototype to V1.5.0_rc1 (read more on Justin Palmer’s blog)
* Add experimental alternate syntax for unit tests (Behaviour Driven
* Merge assertElementsMatch and assertElementMatches from Prototype’s
[4986] unittest.js [Sam Stephenson]
* Add assertRespondsTo and shouldRespondTo assertions

// object var testObj = { isNice: function() { } } // test assertRespondsTo(’isNice’, testObj);

* Make Sortable.serialize handle DOM IDs like “some_element_1” correctly, fixes #5324
* Add support for onStart, onDrag and onEnd events directly on Draggables (invoked from the Draggables.notify), fixes #4747 [thx scriptkitchen]

new Draggable(’some_id’,{ onStart:function(){ /* … / }, onDrag:function(){ // }, onEnd:function(){ / … */ } });

* Add autoSelect option to Autocompleters to auto select an entry if only one is returned, fixes #5183 [thx cassiano dandrea]
* Added delay option to Draggables and Sortables, see test/functional/dragdrop_delay_test.html for usage, implements #3325 [thx lsimon, tomg]
* Add version and timestamp to indvidual library files for easier identification (the files are preprocessed by the Rake fresh_scriptaculous task), fixes #3015 [thx Tobie]
* Add assertIndentical and assertNotIdentical unit test assertions, which test for equality and common type, fixes #5822 [thx glazedginger]
* Add integration test for Ajax autocompleter for results with no linebreaks, #4149
* Added a custom exception to all base effects when used on non-
existing DOM elements, added a assertRaise method to unit tests
* Add element shortcuts to Builder that can be activated by calling Builder.dump() (see the unit test), fixes #4260 [thx napalm]

Builder.dump(); var element = DIV({id:’ghosttrain’},[ DIV({style:’font-size: 11px; font-weight: bold;’},[ H1(’Ghost Train’), \”testtext\”, 2, 3, 4, UL([ LI({onclick:’alert(’test’)’},’click me’) ]), ]), ]);

* Make Effect.Puff work correctly for floating elements, fixes #3777
[thx michael hartl]
* Fix selection of correct option in SELECT element generated by
InPlaceCollectionEditor for indexed option arrays, fixes #4789 [thx
* Fix an issue with redrawing ghosted draggables that are inside a
scrolled container, fixes #3860 [thx gkupps, tsukue]
* Fix autoscrolling inside scrollable containers when window is
scrolled too, fixes #5200 [thx wseitz]
* Fix autoscrolling when dragging an element unto a scrollable
container, fixes #5017 [thx tomg]
* Fix a condition where overriding the endeffect on Draggables without
overriding the starteffect too leads to a Javascript error [thx
Javier Martinez]
* Fix a possible error with the drag/drop logic (affects the solution
to #4706)
* Fix various issues with IE detection and Opera, and setOpacity, fixes
#3886, #5973
* Remove revert cache code obsoleted by #4706, fixes #3436 (again) [thx]


Why Ruby on Rails?

The stack on the left is the Java books, the stack on the right is the Ruby books. The same breadth of material is covered. Well almost, there are on-line references for things like XSL, not covered in the Ruby books. But other than that the functionality is the same. So which stack will be easier to keep in my head? The choice is easy.

Check this url: http://www.garbett.org/?q=node/25#comment-13
Shawn gave a great comparision of Rails with Java.


Rails’ time extensions ported to JavaScript

Ström have ported Rails’ Numeric Time extensions to JavaScript since he needed to do some date calculations for a project. Now one should be able to calculate dates in JS like this:
(5).seconds() // => 5000
(2).weeks() + (2).hours() + (15).seconds() // => 1216815000
(1).week().fromNow().toDate() // => Fri Sep 22 2006 19:16:32 GMT+0200 (CEST)
var date = new Date(2000, 11, 18, 18, 15, 23);
(2).years().since(date).toDate() // => Thu Dec 19 2002 06:15:23 GMT+0100 (CET)
Thought it could be useful for others as well.
You’ll need the latest prototype and scripta.culo.us libraries, unit tests are included.


How to stop search engines from indexing your pages.

Got something you want to put online, but you don’t really want it showing up in search engine results? Here are two quick and easy solutions.
Use a specific meta tag

For each page you don’t want to appear in search engine results, have only one tag. Not a description, not some keywords, just a single tag for robots.

meta name=”robots” content=”noindex,nofollow,noarchive” />

Pop that into the of each page, and you’re telling search engines not to index the page, not to follow any links from the page, and not to archive the page.
Create a robots.txt file

If your pages are all in a separate directory, you can also block search engines by using a robots.txt file.

Create a text file and, in it, disallow all the directories you want protected:

User-agent: *

Disallow: /nameofdirectory

Disallow: /anothernameofdirectory

Do it for all the directories you want, then save the file as robots.txt, and upload it to your main directory. The search engine robots will hit the robots.txt, find out which directories you don’t want them sniffing in, and skip them.

So there you go. Two little things that can save you a world of trouble.

However, these aren’t completely effective solutions. If you really want to block search engines from accessing your pages, you can either password-protect your pages, or keep them offline.

The choice is yours. Have fun!


Conditional periodically_call_remote in Rails

Loading new sections or pages in a Rails app using AJAX can do a lot to increase overall application snappiness and lengthen the life cycle of each page load, but if any of these pages use the periodicallycallremote helper, then these periodical calls may persist longer than you would like.

The trick to fix this is to note that in the documentation for periodicallycallremote, the options for defining the target URL and callbacks are the same for the link_to_remote helper, which include an option called :condition.

So if you want your periodical calls to cease when different pages in your app are loaded using AJAX, then use the :condition option to have periodicallycallremote check against a variable:

<%= periodicallycallremote(
:condition => “check_var == true”,
:update => “myupdatediv”,
:frequency => 20,
:url => { :action => “bar” }) %>

Then in your templates define check_var true or false depending on whether you want the periodical updates to take place:

< script type=”text/javascript”>

 check_var = true;

The :condition option can take any sort of JavaScript code, you can be as creative as you like in defining when and under exactly what conditions your periodical calls are made. Take back control!


Google releases AJAX development toolkit

Google announced yesterday the official release of the Google Web Toolkit (GWT), a Java-based platform for the development of AJAX web applications that work in all mainstream web browsers. Designed to simplify AJAX development, GWT generates consistent, browser-neutral Javascript from simple Java source code.

According to Google, the modularity of Java facilitates a higher level of code reusability. Google also claims that using Java for AJAX development is beneficial because powerful Java IDEs like Eclipse significantly increase developer productivity. GWT provides a number of unique features that contribute to more effective AJAX development. With GWT, developers assemble applications by laying out various AJAX widgets in panels and associating operations with application events.

In some ways, it seems like GWT makes it possible for AJAX developers to leverage the same techniques used for conventional desktop application development. Developers can also create their own custom GWT widgets by combining existing widgets. New GWT widgets can then be deployed in JAR files and made available to other developers. The ability to create and distribute custom AJAX components that can be used in multiple web applications is certainly compelling, and it could potentially reduce the amount of time it takes to develop web applications. In addition to providing support for modular user interface construction, GWT also provides a robust RPC mechanism, a system for managing browser history, and a native Javascript interface that allows developers to mix Javascript into their Java code.

GWT comes with support for two different run modes. Hosted mode, which is primarily used for debugging, will run GWT applications as Java bytecode within the Sun’s Java virtual machine using a specialized web browser designed by Google. To run an application in web mode, developers use GWT’s custom compiler to generate Javascript and HTML that can be deployed on any web server.

Although Google’s Java-oriented approach is innovative, generative AJAX development is hardly a novel or unique idea. A number of other development platforms are available that provide similar functionality. Ruby on Rails, a powerful web application development platform that leverages the model-view-controller pattern, also uses sophisticated generative programming techniques to enable construction of robust AJAX applications. In general, Ruby on Rails is more conducive to rapid development than most comparable Java technologies, and Ruby code tends to be easier to read and maintain. The dynamic nature of Ruby eliminates the need for compilation, which also serves to improve developer productivity. While GWT appears to be geared towards developing AJAX interfaces with familiar desktop application idioms, Ruby on Rails provides a more comprehensive architecture that focuses less on client side functionality and includes complete support for database functionality and other elements of web application development. GWT also seems similar to Microsoft’s Atlas toolkit, which facilitates AJAX development with the .NET platform. Unfortunately, early reports indicate that Atlas provides less than stellar support for alternate browsers, a problem that will hopefully be fixed eventually when it becomes more mature.

Which platform will developers choose? Browser support and language preference are probably the two most relevant factors. Developers that favor Java will probably be more inclined to use GWT or other Java-based technologies. It is likely that many .NET developers will prefer Atlas. Ruby on Rails is best suited for developers that prefer the enhanced expressiveness of dynamic languages, or developers that need an end-to-end solution that also includes database support.


Can Ruby Live Without Rails?

I do not know, use, or have an opinion on the Ruby language yet. But since this language climbed up to the 13th place in the Tiobe index, it deserves to be taken seriously. Bruce Tate is a well know proponent of Ruby. While some people are quick to blame any Java developer who is looking into other languages,in my opinion it’s an attitude of weak people. If we want Java keep evolving, we need to look around. I’ve asked Bruce several questions about this programming language, and this is our blitz-interview.

Why this 13-year old language was not known in the programming community until the Ruby on Rails came about?

I looked into this extensively for my Beyond Java book. Three important points in time are

1) The emergence of a language. This does not always coincide with the emergence of the catalyst.

2) The emergence of the catalyst. With Oak/Java, you could argue that this catalyst was applets in Netscape.

3) Point of no return. We’ve never seen a language emerge, wait twenty years, and then explode. At some point, we decide that we know all there is to know about a language, and then nothing can really help it. I’d put Smalltalk and Lisp into the camp of good languages that will never dominate commercially.

Ruby is a little strange for two reasons: it has no major commercial support (outside of Japan), and it stayed below the radar in Japan for such a long period of time. But the real point that you’ve got to measure is the emergence of the catalyst. Right now, the whole Ruby community–book sales, education, components–everything is wrapped up in Ruby on Rails.

I’m interested in Ruby, and a whole lot of other people are in this camp too, because it’s a dynamic language with a catalyst. Other languages have better web development experiences–Seaside on Smalltalk, for example. But Rails has traction, and the combination of productivity in a clean language with good market share is tough to beat.

Is creation of Web applications the main/only area where this language shines (I’m talking about the real-world business applications)?

Specifically, Ruby is a great language for metaprogramming. Think domain specific languages, open classes, templates, etc. Ruby is a higher level language than Java, with some functional programming tendencies, and powerful idioms that Java doesn’t yet share. A few things that I notice about Ruby are:

  • Dependency injection happens, but not through a framework. You can redefine an object or class to do method injection trivially. (The concept is called open classes in Ruby.) This capability makes testing much easier than it is in Java.

  • Ruby has a JSP-like model for substitution, and you can use it as a template for HTML/XML documents, but also for code. For example, you can have a template with variable substitution, and append that text as code to a class. This capability makes application generators almost trivial. You’ve probably seen Rails scaffolding if you’ve seen a Rails demo. But you can extend this scaffolding to build a surprisingly complete application, given a powerful enough metamodel. The streamlined project does exactly this. (streamlinedframework.org).

  • You don’t see much emphasis at all on AOP. Ruby uses the language itself to handle crosscutting concerns. Ruby 2.0 will hook before and after, and then you really won’t need AOP. Just open up the class and add interceptors in the places you need them with a handful of code.

So Ruby is a fantastic applications language. I’m doing projects now with around 150 tables, a very sophisticated web interface with tree views and AJAX on 20% of the views, and very complex business logic around rebalancing trees and optimal distribution algorithms. Ruby’s symbolic programming model makes this logic easier to reason through, and Ruby’s superior testing help me tremendously. I’d do this project with 3 times the Java programmers, and it would take a little less than twice as long. (It won’t be as fast as I’d make it with Java, but I don’t need it to be. The latency, as always, is in the database.)

But all of this flexibility comes at a cost. I can’t see Ruby as a platform for building middleware or operating systems. Enterprise programming (distributed 2pc, hard core orm) will take some time, and more investment than you see at this point. Right now, Ruby is a great applications language. I’d expect to see Ruby grow as a rich client framework. But it’s not a one-size-fits-all tool.

I’d love to see better Java/Ruby integration. I think it’s going to be important over time.

Imagine, that you have the right to add five Ruby language elements to the next version of Java. What would they be? Can you include quick code samples as well?

  1. Closures.

Closures give you the ability to pass a code block as a parameter. At times, I’m simply looking for convenience. I can use a closure to print something 10 times:

10.times {puts "Hello"}

call do_something on each item in an array (this code example uses do and end in place of {}):

array.each do |item|

build a collection containing the squares of all items in an array:

array.collect {|number| number * number}

Other times, I want to customize the inside of a block of code. For example, when you deal with a file, you must make sure you handle exceptions, and clean up resources, leading to a repetitive ugly block of code. But with closures, you can do something like this:

File.open(filename) {|f| doSomethingWithFile(f)}

The open method can take care of all of the repetitive details for you. Closures help whenever you want to deal with blocks of something. Closures are a huge win for Ruby, and the design pattern is actually used frequently in Java within frameworks like Spring.

  1. Continuations

The second feature is the continuation. Using a continuation, you can capture the state of execution within one instance variable. Think of a continuation as a save_game in an adventure game. You can pick up the game, in progress, when you restore the game. This is a code example of a continuation:

def loop
for i in 1..10
puts i
callcc {|c| return c} if i == 5

This code captures the state of the loop method at the point where i is 5. If you called the method with the command:

continuation = loop

Ruby would produce


Then, you could type


and get the result


This type of processing is extremely important for the next-generation web server, and for implementing things like virtual machines (if you use a continuation-passing style, you can easily implement virtual machines with more stack depth, lightweight threads with cooperative multiprocessing, and many other interesting algorithms. RIFE builds their own version of continuations, so some Java frameworks already need this capability.

  1. Mix-ins

Within Ruby, you don’t need AOP as frequently. You can implement something like a Java interface, but a module can give you both the implementation plus a specification. Java uses whole frameworks to give you the same capability. In the age of pojo programming, it would be incredibly useful to say I want this POJO, and mix in security, persistence, and transactions. Ruby modules, which provide mix ins, can do just that.

4.Open classes

Open classes let you open up and redefine a class in any context. You don’t have to rewrite the Integer class, for example, to add in the processing for units that an ingeger, or fixnum in Ruby, might need. You just implement methods that handle the math and the syntax you need.

For example, you could say

class Fixnum

// A fixnum represents a time in miliseconds.

def days
// convert to miliseconds
self.hours * 24

def hours
// convert to miliseconds
self.minutes * 60

def minutes
// convert to miliseconds
self.seconds * 60

def seconds
// convert to miliseconds
self * 1000

def from_now
Time.now + self

def ago
Time.now – self


Now, I can say things like 10.days.ago, and 6.hours.from_now, adding a certain richness to my domain specific languages. This capability is extremely powerful for testing also.

  1. Full object orientation

In Ruby, everything is an object. When that’s true, frameworks become much easier to consume and write, because you don’t have to deal with so many mind-numbing special cases. Autoboxing gets you closer, but not all the way. Look at the API for an array. With a similar number of methods, the Ruby array is much, much more powerful. The reason is that the Ruby array doesn’t have to deal with every special case for primitive types.

Those are a good place to start, but there are many others as well.

I make my living working as a Java architect/developer. Can you give me a good pragmatic reason to learn Ruby? Is there a job market demand for Ruby skills?

Whenever you learn a new language, it changes the way you think. The Java programmers that I know that also know Ruby don’t use as much configuration, and take better advantage of their collections than Java counterparts do. They also look for more opportunities to do metaprogramming.

But there’s certainly a demand for Ruby developers, too. My latest book, From Java to Ruby, helps managers who need to do Ruby for technical reasons, understand the political implications of such a move. I wrote the book because of an increasing demand for literature for people seeking to use the right tool for the job, rather than blindly using the most popular choice of tools. I found that Ruby development efforts are out there.

I think we’re also constantly underestimating the possibilities for integration across languages. The ReST-based web services in Rails are very rich, and the integration options for JRuby, a Ruby virtual machine implemented in Java, can blow your mind. Think of Ruby scripting in a JSP, or Ruby rules in a Java rules engine, or Ruby tests for Java code. Minimally, Ruby is a fantastic scripting language, and Java developers can take advantage of this exploding frontier.


Don’t blink your eye! You may not see wat you saw before!

Everyone attracts to the webpage that looks good. Are you aware that the page is dead after it is completely opened? And we need to refresh the page now and then for the update data.

No refreshes to the page anymore! Learn Ajax! And make your webpage alive!



Yesterday’s Old-Technology is Today’s latest!!
Wat abt Tommorrow’s ???

Dunno about tommorrow… :(
None can Predict !
So lets go for today itself :-)
ie. Latest Technology !!!