5 ms·

You're stuck in 2007. People doing modern java use: @Path("/hello") @Produces(MediaType.APPLICATION_JSON) class HelloController { class Gree

by fizx 14y ago

You're stuck in 2007. People doing modern java use: @Path("/hello") @Produces(MediaType.APPLICATION_JSON) class HelloController { class Greeting { public Greeting(String name) { this.content = "Hello, " + name; } public final String content; } @GET public Greeting greet(@PathParam("name") String name) { return new Greeting(name); } } > curl http://localhost:8080/hello?name=me {"content": "Hello, me"}

latch 14y ago
I'm not sure if you are being sarcastic, but you do realize that's a lot of code for something so simple, right? get '/hello/:name' do content_type :json {:content => "Hello, #{params[:name]}"}.to_json end
- gizmogwai 14y ago
  I'm not sure if you are being sarcastic, but you do realize that your version is entirely static while the other one is ready for future evolutions? By changing a single line, the java version can also produce XML or text response. By changing two lines, it can also respond to POST requests. And that's just the top of the iceberg. Oh, and in the ends, it's way faster than Node, Ruby, Python and most of the dynamic languages.
  - Retric 14y ago
    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.
    - thebluesky 14y ago
      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.
  - latch 14y ago
    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
    - fizx 14y ago
      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
  - pi18n 14y ago
    > By changing two lines, it can also respond to POST requests. If you think this is a feature, you might actually like Sinatra/Ruby :)
  - masklinn 14y ago
    > 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
- mibbitier 14y ago
  I think you mean "characters". Rather than code. "public static void main()" isn't a lot of code. It's three keywords, and one identifier. You may consider it a lot of characters, but it's pretty rare that a programmers bottleneck is speed of typing. I wish people would stop confusing "number of characters" with "amount of code". And FWIW, I find your example far harder to decipher. I have to know what => means, # means, what : means, etc etc etc. Add to that, in your example, if you typo one of those characters, your code may well still run, but will fail. With Java, if you typo a single character, it's more likely the code just won't compile. We could all code in regular expressions or something akin to that, maybe perl one liners. But "number of characters" isn't a good aim. Readable, maintainable, well written code is.
  - latch 14y ago
    The last part of your comment is just language bias. symbols and hashes are fundamental to ruby. Why would I use string concatenation like my parent, when the language support string interpolation. It's as unclear to you as generics or annotations might be to someone who didn't know Java. Surely you see that? I think you are being pedantic about characters vs code. But, for what it's worth, I disagree. You are having to create 2 classes, define a field, a constructor and use four framework specific annotation. I consider all of that code (made up of characters). Both versions should be unit tested. The unit test might be more important in the Ruby version, but so too will it be easier to write.
    - mibbitier 14y ago
      I grew up reading assembly code listings. Being able to read code is a really really important skill IMHO. Something like Java is very very easy to read. It's mainly keyword based, rather than special character based. I'd much rather read a 1,000 line Java program, than a 100 line <concise language> program. The other point I'd make is that Java is probably about as verbose as english is. But we all manage, using English. We don't moan on and on that talking, writing, reading is so inefficient and we should all switch to something better. English also has odd grammar and spelling rules which are inconsistent and plain stupid sometimes. Yet, English works pretty well for what we use it for. Communicating.
- zootm 14y ago
  The sibling comments point out some good points about your general critique, but it's worth noting your code isn't really "equivalent"; almost everything you chopped was a datatype declaration, which isn't required in Java any more than in Ruby: @GET public Map<String,String> greet(@PathParam("name") String name) { return singletonMap( "content", "Hello, " + name ); } I like both of these systems, and Java is undeniably the more verbose language, but this framework really isn't an egregious example of that.
swah 14y ago
Its fine code once the design its settled, but while you're changing the schema, the backend java code and the frontend javascript, having to change all those classes gets tedious.

by fizx 14y ago

latch 14y ago

I'm not sure if you are being sarcastic, but you do realize that's a lot of code for something so simple, right? get '/hello/:name' do content_type :json {:content => "Hello, #{params[:name]}"}.to_json end

gizmogwai 14y ago
I'm not sure if you are being sarcastic, but you do realize that your version is entirely static while the other one is ready for future evolutions? By changing a single line, the java version can also produce XML or text response. By changing two lines, it can also respond to POST requests. And that's just the top of the iceberg. Oh, and in the ends, it's way faster than Node, Ruby, Python and most of the dynamic languages.
- Retric 14y ago
  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.
  - thebluesky 14y ago
    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.
- latch 14y ago
  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
  - fizx 14y ago
    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
- pi18n 14y ago
  > By changing two lines, it can also respond to POST requests. If you think this is a feature, you might actually like Sinatra/Ruby :)
- masklinn 14y ago
  > 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
mibbitier 14y ago
I think you mean "characters". Rather than code. "public static void main()" isn't a lot of code. It's three keywords, and one identifier. You may consider it a lot of characters, but it's pretty rare that a programmers bottleneck is speed of typing. I wish people would stop confusing "number of characters" with "amount of code". And FWIW, I find your example far harder to decipher. I have to know what => means, # means, what : means, etc etc etc. Add to that, in your example, if you typo one of those characters, your code may well still run, but will fail. With Java, if you typo a single character, it's more likely the code just won't compile. We could all code in regular expressions or something akin to that, maybe perl one liners. But "number of characters" isn't a good aim. Readable, maintainable, well written code is.
- latch 14y ago
  The last part of your comment is just language bias. symbols and hashes are fundamental to ruby. Why would I use string concatenation like my parent, when the language support string interpolation. It's as unclear to you as generics or annotations might be to someone who didn't know Java. Surely you see that? I think you are being pedantic about characters vs code. But, for what it's worth, I disagree. You are having to create 2 classes, define a field, a constructor and use four framework specific annotation. I consider all of that code (made up of characters). Both versions should be unit tested. The unit test might be more important in the Ruby version, but so too will it be easier to write.
  - mibbitier 14y ago
    I grew up reading assembly code listings. Being able to read code is a really really important skill IMHO. Something like Java is very very easy to read. It's mainly keyword based, rather than special character based. I'd much rather read a 1,000 line Java program, than a 100 line <concise language> program. The other point I'd make is that Java is probably about as verbose as english is. But we all manage, using English. We don't moan on and on that talking, writing, reading is so inefficient and we should all switch to something better. English also has odd grammar and spelling rules which are inconsistent and plain stupid sometimes. Yet, English works pretty well for what we use it for. Communicating.
zootm 14y ago
The sibling comments point out some good points about your general critique, but it's worth noting your code isn't really "equivalent"; almost everything you chopped was a datatype declaration, which isn't required in Java any more than in Ruby: @GET public Map<String,String> greet(@PathParam("name") String name) { return singletonMap( "content", "Hello, " + name ); } I like both of these systems, and Java is undeniably the more verbose language, but this framework really isn't an egregious example of that.

swah 14y ago

Its fine code once the design its settled, but while you're changing the schema, the backend java code and the frontend javascript, having to change all those classes gets tedious.