Liutauras Vilda

Pete Letkeman wrote:Have you tried sky diving and did you enjoy it?

I did, and did I enjoy? Well, it was interesting to try, but probably no more jumps ahead. My Dad did his military service in Afganistan, he used to be a paratrooper, and what he says about the sky diving, is that second jump is the most scary, so I'm very reluctant to try again.

I also did try bungee jumping from the crane (75 meters high) - that was way more scary.

Please feel free to disregard this topic, I'm experimenting more in order to have more implementation details to consider, so maybe the answer will become apparent.

I think I was too early to try to make decision + created all that mess with naming which didn't help either.

So the initially posted version 2 would look now with improved naming like:
final class UserPersonalSettings {     public static UserPersonalSettings parse(String jsonToParse) {         JsonObject settings = new JsonParser()                 .parse(Objects.requireNonNull(jsonToParse).trim())                 .getAsJsonObject();         return new UserPersonalSettings(get(settings, "columnTitles"));     }     private static Map<String, String> get(JsonObject jsonObject, String attribute) {         return jsonObject.get(attribute).getAsJsonObject()                         .entrySet()                         .stream()                         .collect(toMap(Map.Entry::getKey, e -> e.getValue().toString()));     }     private final Map<String, String> columnTitles;     private UserPersonalSettings(Map<String, String> columnTitles) {         this.columnTitles = columnTitles;     }     public Map<String, String> getColumnTitles() {         return columnTitles;     } }

And the version 3 would look like:
final class UserPersonalSettings {     public static UserPersonalSettings parse(String jsonToParse) {         JsonObject settings = new JsonParser()                 .parse(Objects.requireNonNull(jsonToParse).trim())                 .getAsJsonObject();         return new UserPersonalSettings(settings);     }     private final JsonObject settings;     private UserPersonalSettings(JsonObject settings) {         this.settings = settings;     }     public Map<String, String> getColumnTitles() {         return get("columnTitles");     }     private Map<String, String> get(String attribute) {         return settings.get(attribute).getAsJsonObject()                          .entrySet()                          .stream()                          .collect(toMap(Map.Entry::getKey, e -> e.getValue().toString()));     } }
Sorry once again for the created confusion.

Junilu Lacar wrote:Sorry, Liutauras, but the names are supposed to help the reader understand the idea being represented in the code.

Good grief, I was really that terrible in representing my question.

How about now?
final class UserPersonalSettings {     private final JsonObject settings;     public UserPersonalSettings(String jsonToParse) {         this.settings = new JsonParser()                 .parse(Objects.requireNonNull(jsonToParse).trim())                 .getAsJsonObject();     }     public Map<String, String> getColumnTitles() {         return get("columnTitles");     }     private static Map<String, String> get(String attribute) {         return settings.get(attribute).getAsJsonObject()                          .entrySet()                          .stream()                          .collect(toMap(Map.Entry::getKey, e -> e.getValue().toString()));     } }

Liutauras Vilda wrote:If to pass just parsed JsonObject and later extract attributes in the same way as in Version1, then again, Version2 looks somewhat more complicated to me with not much benefit.

Over here I had in mind this, and this is probably what Stephan suggested in his initial reply
final class Version3 {     public static Version3 parse(String textToParse) {         JsonObject jsonObject = new JsonParser()                 .parse(Objects.requireNonNull(textToParse).trim())                 .getAsJsonObject();         return new Version3(jsonObject);     }     private final JsonObject something;     private Version3(JsonObject something) {         this.something = something;     }     public Map<String, String> getSomething() {         return get("something");     }     private static Map<String, String> get(String attribute) {         return something.get(attribute).getAsJsonObject()                         .entrySet()                         .stream()                         .collect(toMap(Map.Entry::getKey, e -> e.getValue().toString()));     } }

Reading all replies once again...

Probably I also need to consider the difference between the versions, that:

Version1 extracts the attribute/-s upon the need, while Version2 would extract them during Json string parsing if I decided to construct object with extracted and ready to use all attributes which are passed to a constructor.

Well, even as for an example I should have better reflect data types and better mimic actual cases. My apologies.

The parameter which is named as textToParse is actually a JSON string, which gets parsed into a JsonObject. Later on this object is meant to be used to extract various attribute-value pairs.

So the revised versions to reflect better actual scenario would look like:
final class Version1 {     private final JsonObject something;     public Version1(String textToParse) {         this.something = new JsonParser()                 .parse(Objects.requireNonNull(textToParse).trim())                 .getAsJsonObject();     }     public Map<String, String> getSomething() {         return get("something");     }     private static Map<String, String> get(String attribute) {         return something.get(attribute).getAsJsonObject()                          .entrySet()                          .stream()                          .collect(toMap(Map.Entry::getKey, e -> e.getValue().toString()));     } } final class Version2 {     public static Version2 parse(String textToParse) {         JsonObject jsonObject = new JsonParser()                 .parse(Objects.requireNonNull(textToParse).trim())                 .getAsJsonObject();                 return new Version2(get(jsonObject, "something"));     }     private static Map<String, String> get(JsonObject jsonObject, String attribute) {         return jsonObject.get(attribute).getAsJsonObject()                          .entrySet()                          .stream()                          .collect(toMap(Map.Entry::getKey, e -> e.getValue().toString()));     }     private final Map<String, String> something;     private Version2(Map<String, String> something) {         this.something = something;     }     public Map<String, String> getSomething() {         return something;     } }
The thing is liked about the Version1 is, that regardless of how JSON object will grow in a future, the change is just the matter of adding extra getter.

In case of Version2, there would be a need to modify private constructor, add extra field, add getter if the arguments would be passed after they get extracted. If to pass just parsed JsonObject and later extract attributes in the same way as in Version1, then again, Version2 looks somewhat more complicated to me with not much benefit.

I hope now I was a bit clearer. However, please ignore variables naming as well as lack of validation - I just took these out of my head to visualise idea.

Thanks Stephan

Hello, a small dilemma, which version do you prefer? Why? Know any situations where one has advantages/disadvantages over the other?

Mock simplified examples:
final class Version1 {     private final String something;     public Version1(String textToParse) {         this.something = textToParse;     }     public String getSomething() {         return something;     } } final class Version2 {     public static Version2 parse(String textToParse) {         return new Version2(textToParse);     }         private final String something;     private Version2(String something) {         this.something = something;     }     public String getSomething() {         return something;     } }
The use of each.

Version1:
Version1 v1 = Version1.parse(text); v1.getSomething();
Version2:
Version2 v2 = new Version2(text); v2.getSomething();
Thank you for insights.

Junilu Lacar wrote:If instead I just simply convert the null reference into some default value, the mistake will be masked.

About this thing I was thinking yesterday in a bed. Actually it was mentioned here almost exactly what I wanted to write this morning (time zones may differ).

As an addition I came up in my mind with word "metadata". null does not carry any metadata, so indeed, one can't figure out whether it was intentionally passed or in fact was a programming mistake passing a null as argument. I'd say it applies same passing to constructors or methods. Probably at most what you can give is 50/50 if you need to define some odds whether program "works" correctly or not. Didn't use word "behaves", because it does exactly what the programmer tells program to do, so it does behave correctly - and that is the most unfortunate thing in my opinion, you no longer can be certain about the correctness of your program.

original code wrote: public ProjectServiceImpl(Project project) {      if (project == null) {          project = new Project();      }      this.project = project; }

I won't tell anything useful, but want to point out, what is mostly confusing about this code is to me as a user.

If project is null, it takes the parameter variable (copy of originally passed argument reference which appear to be null), initializes it, and later assigns it to member field project and right after, itself goes out of scope.

So, what we end up with is, that originally passed, as argument project, still remains as null at the caller level... oh, will stop right here.

If I'd need to stick with these semantics code, much clearer for my brains to parse it would be such version:

public ProjectServiceImpl(Project project) {      if (project == null) {          this.project = new Project();      } else {          this.project = project;      } }
Subtle difference, but leaves less questions in my head which would have been, such as: what is the project passed as argument is referring to now? (it would be still null as Java is "pass by value", but might be confusing to some readers).

Enissay Dave wrote:Does grade matter ?  Since it's not included in your certificate, I guess the one shouldn't spend a lot of time in preparation... What do you think ?

Sounds like you need a paper, not the knowledge. Unfortunately, but many students think the same way also about the university degrees. I prefer knowledge if you ask me - so it does matter!

Hi Nexas, a warm welcome!

Jeanne Boyarsky wrote:When you get the book, you'll see it recommends this site .

So you say at the end of the day Nik had no other available options as just to end up here?