Today, while solving puzzles from Java Puzzler book I myself created a new Java Puzzle. So, in this blog I am writing about that puzzle.
Puzzle
Will the code given below results in an infinite loop.
public class MyJavaPuzzle {
public static void main(String[] args) {
Double i = Double.NaN;
while(i != i){
System.out.println("Infinite Loop");
}
}
}
Solve this puzzle and have fun. Happy Puzzling!!!
Post your answer and explanation in comments.
These days organization expects their employees to write blogs/publish articles so that the organization gains more visibility. I believe blogs are a very good way by which you can gain more popularity and visibility in the developer’s community. But I see lot of blogs published on company’s official blog as developer’s personal experience or personal learning. These blogs lack the content and value as expected from a company blog. People just write the blog for the heck of writing it.
In my opinion writing such blogs does not increase the organization visibility.There should be a difference between what you should write in your personal blog to what you should write in an organization blog.
The blogs that you should write on a personal blog rather than on company blog are:-
1) Hello World blogs = These type of blogs does not provide any value as you can find such blogs all over the web. They just contain a very basic explanation of the concept or framework with or without a Hello World program. These blogs have one characteristic that the person who wrote this blog will also never read it again.
2) Opinionated blogs = These type of blogs contain your opinion about a topic, concept or an event. Writing opinionated blogs is not bad but
if you are writing your opinion on the company’s blog then it in a way represent your organization opinion also. So, when ever you write an opinionated blog, please match it with your organization values.
3) Blog with links to other blogs/articles= These blogs does not have any content of their own they just point to other links (video or text).
These are some of the types of blogs that should not be written on an official blog. Company’s blog should have good content and quality should matter over number of blogs published. Please post in your comments on what you think.
Reasons for incompetent software developers in India
Most of the times, I have heard that Indian developers don’t have the quality as compared to their counterparts who are working in western countries. Development teams in western countries often blame their offshore counterparts for slowing them down. It has been said that Indians are not technically competent; write poor code, they don’t give any suggestions for the problems, etc.
In my opinion, most of these are true. Yes, we are not at par with developers in western countries and we sometimes really suck. Please note that this is just my personal opinion and not all software developers in India are bad. It’s the problem of quantity versus quality. In this blog, I will be putting up some reasons why I feel Indians developers lag behind developers from other countries.
Reasons
There can be more reasons but at this point of time I can think of these 5 only. I am trying to make myself a better developer by reading, writing, listening. Tell me what you guys think?
Today, I was working on a user story which spans across two modules(A and B) of our project (C). As we follow test driven development, so I first wrote a test for the functionality that I need to add in module A and then wrote the piece of code(TDD is not the topic of this blog so please don’t go in detail). The test passed with the green bar and i moved to the B module. I wrote a test and then wrote a piece of code but this time test failed with error NoClassDefFoundError: org/objectweb/asm/CodeVisitor . I was a bit surprised why in one module A test is passing and in module B test is failing because both the projects had similar dependencies.
After googling, i found out that this error comes because hibernate has cglib-2.1_3.jar as the dependency which uses older version of asm jar which was having CodeVisitor class. CodeVisitor class has retired and does not exists in newer version of asm jars. But now the issue was why junit testcase was passing in A module. To find why test case in A module pass I did the maven dependency check on both module using
mvn dependency:tree
In module A, I found out out that it loaded cglib-nodep-2.1_3.jar not cglib-2.1_3.jar . cglib-nodep-2.1_3.jar was loaded because easymockclassextension has dependency on cglib-nodep jar.
In module B, I found out that it loaded cglib-nodep-2.1_3.jar not cglib-nodep-2.1_3.jar. This jar was loaded because hibernate has dependency on cglib jar.
Now the problem was why in A module cglib-nodep jar is loaded but in B module cglib jar is loaded. I looked at the pom.xml and found out that in A module easymockclassextension dependency was declared before the hibernate dependency
<dependencies> <dependency> <groupId>org.easymock</groupId> <artifactId>easymock</artifactId> <version>2.5.2</version> <scope>test</scope> </dependency> <dependency> <groupId>org.easymock</groupId> <artifactId>easymockclassextension</artifactId> <version>2.5.2</version> <scope>test</scope> </dependency> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.15</version> </dependency> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-core</artifactId> <version>3.3.2.GA</version> </dependency> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-annotations</artifactId> <version>3.4.0.GA</version> </dependency> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-commons-annotations</artifactId> <version>3.3.0.ga</version> </dependency> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-entitymanager</artifactId> <version>3.4.0.GA</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</version> <scope>test</scope> </dependency> </dependencies>
In module B pom.xml easymockclassextension dependency was declared after the hibernate dependency.
<dependencies> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.15</version> </dependency> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-core</artifactId> <version>3.3.2.GA</version> </dependency> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-annotations</artifactId> <version>3.4.0.GA</version> </dependency> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-commons-annotations</artifactId> <version>3.3.0.ga</version> </dependency> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-entitymanager</artifactId> <version>3.4.0.GA</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</version> <scope>test</scope> </dependency> <dependency> <groupId>org.easymock</groupId> <artifactId>easymock</artifactId> <version>2.5.2</version> <scope>test</scope> </dependency> <dependency> <groupId>org.easymock</groupId> <artifactId>easymockclassextension</artifactId> <version>2.5.2</version> <scope>test</scope> </dependency> </dependencies>
Because easyclassextension was declared before the hibernate dependency, cglib-nodep was getting loaded hence test was passing.
In this way, I learn that in maven dependencies are loaded in the order they are mentioned in pom.xml. As of version 2.0.9 maven introduced deterministic ordering of dependencies on the classpath.The ordering is now preserved from your pom, with dependencies added by inheritence added last.
Intent
To find all the indexes of a whole word in a given searchable string.
Motivation
Today, I had to write a piece of code in which I had to find all the indexes of a particular keyword in a searchable string. Most of the times, when we have to find index of a keyword in a searchable string we use indexOf method of String class.
For example,
String searchableString = “Don’t be evil. Being evil is bad”; String keyword = “be”;
So, we can find the index of keyword as
int index = searchableString.indexOf(keyword);
This will give us the index of first occurrence of keyword (“be”). Now suppose, we have to find all the indexes of keyword (“be”), we will have to loop over searchableString and find all the indexes of keyword “be”.
This can be done as follows
public static void findIndexes(){
String searchableString = "don’t be evil.being evil is bad";
String keyword = "be";
int index = searchableString.indexOf(keyword);
while (index >=0){
System.out.println("Index : "+index);
index = searchableString.indexOf(keyword, index+keyword.length()) ;
}
}
public static void main(String[] args) {
findIndexes();
}
This program will print :
Index : 6
Index : 14
There is a problem in this code as we should not get “Index : 14” because we are looking for a keyword “be” and the index it has found is from word “being” . This just looks for any occurrence of keyword in the string it does not have to be a whole word. To solve this problem, we will be writing a solution using Regular expressions.
Solution
We have to find out the indexes which correspond to the whole word. For example, we should only get “Index : 6” as that corresponds to the keyword “be” not “Index : 14” as it corresponds to the word “being” .
This can be done as follows :-
WholeWordIndexFinder.java
package org.dailywtf.string;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class WholeWordIndexFinder {
private String searchString;
public WholeWordIndexFinder(String searchString) {
this.searchString = searchString;
}
public List<IndexWrapper> findIndexesForKeyword(String keyword) {
String regex = "\\b"+keyword+"\\b";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(searchString);
List<IndexWrapper> wrappers = new ArrayList<IndexWrapper>();
while(matcher.find() == true){
int end = matcher.end();
int start = matcher.start();
IndexWrapper wrapper = new IndexWrapper(start, end);
wrappers.add(wrapper);
}
return wrappers;
}
public static void main(String[] args) {
WholeWordIndexFinder finder = new WholeWordIndexFinder("don’t be evil.being evil is bad");
List<IndexWrapper> indexes = finder.findIndexesForKeyword("be");
System.out.println("Indexes found "+indexes.size() +" keyword found at index : "+indexes.get(0).getStart());
}
}
IndexWrapper.java
package org.dailywtf.string;
public class IndexWrapper {
private int start;
private int end;
public IndexWrapper(int start, int end) {
this.start = start;
this.end = end;
}
public int getEnd() {
return end;
}
public int getStart() {
return start;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + end;
result = prime * result + start;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
IndexWrapper other = (IndexWrapper) obj;
if (end != other.end)
return false;
if (start != other.start)
return false;
return true;
}
}
Explanation
First of all a regular expression is built using the keyword. Regex \b defines a word boundary. \b allows you to perform a “whole words only” search using a regular expression in the form of \bword\b.
More information on regex could be found at this link. Next, we just iterate over the matcher till matcher can find any match. Whenever a match is found an wrapper object is created which contains the start and end position of the keyword.
Using the above code, we can find all the indexes of a keyword in a searchable string.
Anonymous Blogger
Today, I was thinking why I and many other bloggers write as anonymous blogger without disclosing their correct identity. I am writing down some reasons which lead me to write in an anonymous manner:-
Shekhar Gulati 