Java Archives

Tag Archive for: Java

6 Important Reasons for the Java Experts to learn Hadoop Skills

September 24, 2019/in Big Data, Data Engineering, Insights, Main Category/by Digvijay Upadhyay

You must be well aware of the fact that Java and Hadoop Skills are in high demand these days. Gone are the days when advancement work moved around Java and social database. Today organizations are managing big information. It is genuinely big. From gigabytes to petabytes in size and social databases are exceptionally restricted to store it. Additionally, organizations are progressively outsourcing the Java development jobs to different groups who are as of now having big data experts.

Ever wondered what your future would have in store for you if you possess Hadoop as well as Java skills? No? Let us take a look. Today we shall discuss the point that why is it preferable for Java Developers to learn Hadoop.

Hadoop is the Future Java-based Framework that Leads the Industry

Data analysis is the current marketing strategy that the companies are adopting these days. What’s more, Hadoop is to process and comprehend all the Big Data that is generated all the time. As a rule, Hadoop is broadly utilized by practically all organizations from big and small and in practically all business spaces. It is an open-source stage where Java owes a noteworthy segment of its success

The processing channel of Hadoop, which is MapReduce, is written in Java. Thus, a Hadoop engineer needs to compose MapReduce contents in Java for Big data analysis. Notwithstanding that, HDFS, which is the record arrangement of Hadoop, is additionally Java-based programming language at its core. Along these lines, a Hadoop developer needs to compose documents from local framework to HDFS through deployment, which likewise includes Java programming.

Learn Hadoop: It is More Comfortable for a Java Developer

Hadoop is more of an environment than a standalone innovation. Also, Hadoop is a Java-based innovation. Regardless of whether it is Hadoop 1 which was about HDFS and MapReduce or Hadoop2 biological system that spreads HDFS, Spark, Yarn, MapReduce, Tez, Flink, Giraph, Storm, JVM is the base for all. Indeed, even a portion of the broadly utilized programming languages utilized in a portion of the Hadoop biological system segments like Spark is JVM based. The run of the mill models is Scala and Clojure.

Consequently, if you have a Java foundation, understanding Hadoop is progressively easier for you. Also, here, a Hadoop engineer needs Java programming information to work in MapReduce or Spark structure. Thus, if you are as of now a Java designer with a logical twist of the brain, you are one stage ahead to turn into a Hadoop developer.

IT Industry is looking for Professionals with Java and Hadoop Skills

If you pursue the expected set of responsibilities and range of abilities required for a Hadoop designer in places of work, wherever you will watch the reference of Java. As Hadoop needs solid Java foundation, from this time forward associations are searching for Java designers as the best substitution for Hadoop engineers. It is savvy asset usage for organizations as they don’t have to prepare Java for new recruits to learn Hadoop for tasks.

Nonetheless, the accessible market asset for Hadoop is less. Therefore, there is a noteworthy possibility for Java designers in the Hadoop occupation field. Henceforth, as a Java designer, on the off chance that you are not yet arrived up in your fantasy organization, learning Hadoop, will without a doubt help you to discover the chance to one of your top picks.

Combined Java and Hadoop Skills Means Better Pay Packages

You will be progressively keen on learning Hadoop on the off chance that you investigate Gartner report on big information industry. According to the report, the Big Data industry has just come to the $50 billion points. Additionally, over 64% of the main 720 organizations worldwide are prepared to put resources into big information innovation. Notwithstanding that when you are a mix of a Java and Hadoop engineer, you can appreciate 250% pay climb with a normal yearly compensation of $150,000.It is about the yearly pay of a senior Hadoop developer.

Besides, when you change to Big Data Hadoop, it very well may be useful to improve the nature of work. You will manage unpredictable and greater tasks. It does not just give you a better extension to demonstrate your expertise yet, in addition, to set up yourself as a profitable asset who can have any kind of effect.

Adapting Big Data Hadoop can be exceptionally advantageous because it will assist you in dealing with greater, complex activities a lot simpler and convey preferable yield over your associates. To be considered for examinations, you should be somebody who can have any kind of effect in the group, and that is the thing that Hadoop lets you be.

Learning Hadoop will open New Opportunities to Other Lucrative Fields

Big data is only not going to learn Hadoop. When you are in Big information space, you have sufficient chance to jump other Java and Hadoop engineer. There are different exceedingly requesting zones in big information like Artificial Intelligence, Machine Learning, Data Science. You can utilize your Java and Hadoop engineer expertise as a springboard to take your vocation to the following level. In any case, the move will give you the best outcome once you move from Java to Hadoop and increase fundamental working knowledge.

Java with Hadoop opens new skylines of occupation jobs, for example, data scientist, data analyst business intelligence analyst, DBA, etc.

Premier organizations prefer Hadoop Developers with Java skills

Throughout the years the Internet has been the greatest driver of information, and the new data produced in 2012 remained at 2500 Exabyte. The computerized world developed by 62% a year ago to 800K petabytes and will keep on developing to the tune of 1.2 zeta bytes during the present year. Gartner gauges the market of Hadoop Ecosystem to $77 million and predicts it will come to the $813 million marks by 2016.

A review of LinkedIn profiles referencing Hadoop as their abilities uncovered that just about 17000 individuals are working in Companies like Cisco, HP, TCS, Oracle, Amazon, Yahoo, and Facebook, and so on. Aside from this Java proficient who learn Hadoop can begin their vocations with numerous new businesses like Platfora, Alpine information labs, Trifacta, Datatorrent, and so forth.

Conclusion

You can see that combining your Java skills with Hadoop skills can open the doors of several new opportunities for you. You can get better remuneration for your efforts, and you will always be in high demand. It is high time to learn Hadoop online now if you are a java developer.

Extraktion von Software-Metriken aus Java-Dateien mit ANTLR4

August 18, 2015/in Data Mining, Data Science, Java, Re-Engineering/by Sven Meyer

In der Software-Entwicklung wird mehr und mehr auf Metriken gesetzt, um den Entwicklungsprozess zu messen und zu verbessern. Tools wie SonarQube und FindBugs helfen dabei – doch sie haben ihre Grenzen. Sie brauchen build-fähige Projekte. Die Metriken sind manchmal nicht genau genug dokumentiert oder lassen sich nur schwer anpassen.

Dabei ist es gar nicht so schwierig, ein eigenes Tool zu schreiben. So können die Metriken selbst definiert, auf Textdateien angewendet, als Skript automatisiert und an beliebige Schnittstellen weitergeben werden – z. B. als CSV-Datei nach R, per Webinterface oder als E-Mail.

Im Folgenden wird gezeigt, wie mit ANTLR4 aus Java-Textdateien Metriken erhoben werden können. Das Beispiel-Projekt steht auf GitHub zur Verfügung.

Statische Code-Analyse mit ANTLR4

ANTLR4 (ANother Tool for Language Recognition) wird seit 1989 von Terence Parr, Professor an der University of San Francisco, entwickelt. Das Tool selbst ist kostenlos; die ausführliche Dokumentation kostet jedoch 27 US-Dollar. Für den Einstieg reicht die kostenlose Dokumentation. ANTLR4 ist eine Java-Bibliothek.

Beim Parsen erstellt ANTLR4 auf Basis einer Grammatik einen Syntaxbaum. Nach dem Parsen wird der Syntaxbaum mit einem Walker abgelaufen. Dabei auftretende Events können über ein Listener-Interface abgefangen werden. Durch das Verarbeiten der Events können eigene Metriken berechnet werden.

Das Listener-Interface selbst wird über die Grammatik spezifiziert. ANTLR4 generiert aus der Grammatik Listener in Java, von denen anschließend geerbt wird.

Für viele Programmiersprachen gibt es bereits fertige Grammatiken, die auf GitHub gemeinsam entwickelt werden (siehe z. B. Java-Grammatik). Ansonsten muss die Grammatik selbst geschrieben werden.

Das Beispiel-Projekt

Im Beispiel wird der Klassenname und die Anzahl von Methoden aus einer Java-Klasse erhoben:

/**

* A cat is a cat is a cat.

public class Cat {

private String name;

private int height;

public Cat(String name, int height) {

setName(name);

setHeight(height);

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getHeight() {

return height;

}

public void setHeight(int height) {

this.height = height;

}

Das Ergebnis wird in einer Map<String, Integer> ausgegeben.

Vorbereitungen

Im Beispiel werden Eclipse, ein ANTLR4-Eclipse-Plugin und Maven benutzt. ANTLR4 lässt sich auch unabhängig von Eclipse und Maven benutzen.

Nach der Installation des Eclipse-Plugins muss in der pom.xml eine Dependency ergänzt werden:

org.antlr

antlr4-maven-plugin

4.5

Die Java-Grammatik wird von GitHub heruntergeladen und unter src/main/antlr4/Java.g4 abgelegt. Anschließend werden per Rechtsklick auf Java.g4 -> Run As -> Generate ANTLR Recognizer die Hilfsdateien von ANTLR4 angelegt.

Damit die Hilfsdateien von Eclipse als Java-Quellcode erkannt werden, werden sie nach src/main/java/generated kopiert.

Metriken definieren

ANTLR4 erstellt aus der Grammatik einen JavaBaseListener. Zum Definieren der Metriken wird ein eigener Listener programmiert, der vom JavaBaseListener erbt. Wenn ANTLR4 später den Syntaxbaum durchläuft, ruft es die entsprechenden Listener-Methoden auf.

/**

* Listens to Events, if ANTLR walks a parse tree.

* @author Sven Meyer

public class Listener extends JavaBaseListener {

Im JavaBaseListener sind alle Events, auf die gehört werden kann, als Methode aufgeführt. Um nun den Klassennamen für die Metrik zu erfahren, wird das Event ClassDeclaration abgehört:

/** Listen to matches of classDeclaration */

@Override

public void enterClassDeclaration(JavaParser.ClassDeclarationContext ctx) {

setClazzName(ctx.Identifier().toString());

}

Um die Anzahl der Methoden zu erhalten, wird ein Counter bei jedem Auftreten einer MethodDeclaration erhöht.

/** Listen to matches of methodDeclaration */

@Override

public void enterMethodDeclaration(JavaParser.MethodDeclarationContext ctx) {

methodCount++;

}

ANTLR ausführen

Damit ANTLR ausgeführt werden kann, braucht es noch die zu lesende Datei und den Listener. Dazu sind nur wenige Zeilen Code notwendig:

public Map extract(File importFile) throws Exception {

/** Prepare input for ANTLR. */

InputStream is = new FileInputStream(importFile.getAbsolutePath());

ANTLRInputStream input = new ANTLRInputStream(is);

JavaLexer lexer = new JavaLexer(input);

CommonTokenStream tokens = new CommonTokenStream(lexer);

JavaParser parser = new JavaParser(tokens);

/** Parse. */

ParseTree tree = parser.compilationUnit();

/** Create standard walker. */

ParseTreeWalker walker = new ParseTreeWalker();

/** Initiate walk of tree with listener. */

Listener listener = new Listener(parser);

walker.walk(listener, tree);

/** Save the results. */

Map result = new HashMap<>();

result.put(listener.getClazzName(), listener.getMethodCount());

Ein Test prüft, ob der Klassenname und die Methodenanzahl richtig extrahiert werden:

@Test

public void test() throws Exception {

/** Prepare. */

// String = clazzName, Integer = methodCount

Map result = new HashMap<>();

/** Execute. */

Extractor e = new Extractor();

result = e.extract(new File("src/main/resources/Cat.java"));

/** Test. */

// clazzName should be Cat

assertTrue(result.keySet().contains("Cat"));

// count of methods should be 4

assertEquals(new Integer(4), result.get("Cat"));

}

Die fertige Projektstruktur sieht in Eclipse so aus:

Abbildung 1: Die fertige Projektstruktur.

Nun kann der Test erfolgreich durchgeführt werden.

Abbildung 2: Der Testfall läuft erfolgreich.

Fazit

Damit der Code produktiv genutzt werden kann, sollten noch mögliche I/O- und ANTLR-Fehler behandelt werden. Außerdem müssen die erhobenen Daten weitergegeben werden, um z. B. als CSV-Datei in R importiert werden zu können.

Erfahrungsgemäß ergeben sich aus dem großen Sprachumfang viele Sonderfälle, die bei der Definition von Metriken berücksichtigt werden müssen. Hier helfen Testfälle weiter, um eine korrekte Messung sicherzustellen.

Das Beispiel konnte zeigen, dass leicht eigene Metriken aus Java-Quellcode erhoben werden können. So werden Quellcode und strukturierte Texte für die Analyse und Optimierung zugänglich.

Referenzen & Links

ANTLR4
Die Projektseite von ANTLR4.
Java-Grammatik
Die ANTLR4-Grammatik für die Java-Programmiersprache.
Beispielprojekt auf GitHub
Das in diesem Tutorial verwendete Beispielprojekt auf GitHub.
ANTLR4-Eclipse-Plugin
Das Eclipse-Plugin, das zum Ausführen von ANTLR4 in Eclipse benutzt werden kann.
Rascal MPL
Eine Meta-Programmiersprache. Erlaubt nicht nur die Analyse, sondern auch das Erzeugen + Verändern von Quellcode.
Fallstudie Java-Korpus
Eine laufende Fallstudie des Autors, in der ANTLR4 benutzt wird, um die typische Verwendung von Java-Sprachkonstrukten in 2,8 Mio. Dateien zu untersuchen.