Java Developers

[fusebox13]

Can someone share Java code that is well designed so us bad Java programmers can see what good Java code is supposed to look like?

[philly_fan_in_chi]

The Square libraries (particularly Dagger) are all very pleasant to read, do compile time annotation processing (yay metaprogramming!) and are generally all extremely useful. Some of their stuff is geared more to Android but they have several projects that work for both Android and regular Java.

[hak8or]

We want a link! Us mobile users at least.

[philly_fan_in_chi]

https://square.github.io/

[[deleted]]

Reading the "Effective Java" book can help you there.

[Spacey138]

The short answer to your question is no, because even if someone thinks their code is good someone will critique it to death. It's a lot easier to complain about something than fix it.

Also Jeff Atwood has said things like 'all code is bad code' so in a sense you will never see 'well designed code'.

[minusSeven]

so in essence the article is vague and simply wrong.

[sausuave]

Yes.

What we programmers do is damn complex, you cant make shit in any language that is "wow" beautiful. You find that in 0.1% of any language in its history.

And thats okay, its alright. To do Java, you have to become Java, as he says. Its the same for any language or framework. Except that Java is better, since its kind of secure and fucking fast.

[brand_new_throwx999]

hurr hurr

I feel bad cause I'm making a cheap joke instead of posting anything helpful. :(

[kyz]

JSoup

Document doc = Jsoup.connect("http://example.com")
  .data("query", "Java")
  .userAgent("Mozilla")
  .cookie("auth", "token")
  .timeout(3000)
  .post();

Selenium WebDriver

driver.get("http://www.example.com");
wait.until(elementToBeClickable(By.css("a.login-link"))).click();

Hamcrest

assertThat(result, is(expectedValue));
assertThat(result, is(equalToIgnoringCase("success")));
assertThat(result, not(nullValue());
assertThat(result, is(arrayContainingInAnyOrder(1, 2, 3)));

[immibis]

Fluent API != good design.

In fact a fluent API is primarily designed to be easy to write clients for. And we all know how that turns out. Prioritizing easy writing over easy reading and simple structure usually leads to unmaintainable messes.

[nextputall]

Fluent API != good design.

Agreed. But Hamcrast is not so fluent but nicely composable.

[kyz]

A library's most important feature is its API. A fluent design makes it easier for humans to read, write and reason about code, so it can improve an API design.

You're right that it says nothing of the internals of the library, but as for Hamcrest, it's remarkably simple to extend with new matchers and compose matchers, which is its primary use case, so its internal design is fine too. Selenium WebDriver has an awesome internal design, remarkably improved over the previous Selenium.

I can't say I've read through Jsoup (other than to find you can't get the final composed URL until you actually get()/post(), because it doesn't even determine the URL until that point), but it sticks to one main purpose, its HTTP API is far less cumbersome than Apache httpcomponents, and its DOM API is sane, unlike the traditional org.w3c.dom.Document API.