And when those changes are made, I can change my version to:

   response = {:content => "Hello, #{params[:name]}"}
   respond_to do |wants|
      wants.json { response.to_json } 
      wants.xml { response.to_xml }
   end

I've been trying to ignore this particular flame-war, but your example is doing fundamentally less, because it's not binding objects to json (which was what you originally asked for).

I actually cannot write your example easily in Sinatra/Ruby/etc, without making my object either a Hash or an ORM subclass, customizing serialization, or pulling in uncommon libraries.

Here's your complete example, in reasonable Ruby. It's longer than the Java.

    class Greeting < Struct.new(:content)
      def content
        "Hello, #{super.content}"
      end
  
      def to_xml
        {:content => content}.to_xml
      end

      def to_json
        {:content => content}.to_json
      end
    end

    get '/hello' do

      response = { :content => Greeting.new(params[:name]) }

      respond_to do |wants|
        wants.json { response.to_json } 
        wants.xml { response.to_xml }
      end
    end

If I create an imaginary library that does exactly what we'd want here, it'd look like the following. It's marginally shorter than the java, but hard to argue anything about it being fundamentally better.

    class Greeting 
      include JsonObject
      field :content
      def content
        "Hello, #{@content}"
      end
    end

    get '/hello' do

      response = { :content => Greeting.new(params[:name]) }

      respond_to do |wants|
        wants.json { response.to_json } 
        wants.xml { response.to_xml }
      end
    end

That's a funny complaint when evaluating 4 lines of code one of which is end.

Java makes the assumption that you need a lot of boilerplate code, so being able to make changes easily seems like a big deal. Other languages avoid that boilerplate and can make the changes just as easily for free.

Making changes to a complex system is a "big deal" in any language. Pretty (and compact) syntax doesn't help much, especially when the refactoring tools are weak.

> By changing two lines, it can also respond to POST requests.

That's twice as many lines you need to replace as in Sinatra:

    get '/hello/:name' do

to

    route :get, :post '/hello/:name' do

> By changing two lines, it can also respond to POST requests.

If you think this is a feature, you might actually like Sinatra/Ruby :)