<h2 id="introduction">Introduction</h2>
One of the most used classes in Java is the <code>String</code> class. It represents a string (array) of characters, and therefore contains textual data such as &quot;Hello World!&quot;. Besides the <code>String</code> class, there are two other classes used for similar purposes, though not nearly as often - <code>StringBuilder</code> and <code>StringBuffer</code>.
Each exists for its own reason, and unaware of the benefits of the other classes, many novice programmers only use Strings, leading to decreased performance and poor scalability.
<h2 id="string">String</h2>
Initializing a String is as easy as:
<pre><code class="hljs">String string = &quot;Hello World!&quot;;
</code></pre>
It's atypical, as in all other cases, we'd instantiate an object using the <code>new</code> keyword, whereas here we have a &quot;shortcut&quot; version.
There are several ways to instantiate Strings:
<pre><code class="hljs">// Most common, short way
String str1 = &quot;Hello World&quot;;

// Using the `new` keyword and passing text to the constructor
String str2 = new String(&quot;Hello World&quot;);

// Initializing an array of characters and assigning them to a String
char[] charArray = {&#x27;H&#x27;, &#x27;e&#x27;, &#x27;l&#x27;, &#x27;l&#x27;, &#x27;o&#x27;, &#x27; &#x27;, &#x27;W&#x27;, &#x27;o&#x27;, &#x27;r&#x27;, &#x27;l&#x27;, &#x27;d&#x27;};
String str3 = new String(charArray);
</code></pre>
Let's take a look at the source code of the class and make a few observations:
<pre><code class="hljs">public final class String
 implements java.io.Serializable, Comparable&lt;String&gt;, CharSequence {
 /** The value is used for character storage. */
 private final char value[];

 /**
 * Initializes a newly created {@code String} object so that it represents
 * an empty character sequence. Note that use of this constructor is
 * unnecessary since Strings are immutable.
 */
 public String() {
 this.value = new char[0];
 }

 /**
 * Allocates a new {@code String} so that it represents the sequence of
 * characters currently contained in the character array argument. The
 * contents of the character array are copied; subsequent modification of
 * the character array does not affect the newly created string.
 *
 * @param value
 * The initial value of the string
 */
 public String(char value[]) {
 this.value = Arrays.copyOf(value, value.length);
 }
 
 ...
}
</code></pre>
We can first observe how the text itself is saved - in a <code>char</code> array. That being said, it's logical for us to be able to form a String from an array of characters.
A really important thing to note here is the fact that <code>String</code> is defined as <code>final</code>. This means that <code>String</code> is immutable.
<blockquote>
What does this mean?
</blockquote>
<pre><code class="hljs">String str1 = &quot;Hello World!&quot;;
str1.substring(1,4).concat(&quot;abc&quot;).toLowerCase().trim().replace(&#x27;a&#x27;, &#x27;b&#x27;);
System.out.println(str1);
</code></pre>
Output:
<pre><code class="hljs">Hello World!
</code></pre>
Since <code>String</code> is final, none of these methods really changed it. They merely returned the changed state which we didn't use or assign anywhere. Each time a method on a String is called, a new String gets created, the state is changed and it's returned.
Again, taking a look at the source code:
<pre><code class="hljs">public String concat(String str) {
 int otherLen = str.length();
 if (otherLen == 0) {
 return this;
 }
 int len = value.length;
 char buf[] = Arrays.copyOf(value, len + otherLen);
 str.getChars(buf, len);
 return new String(buf, true);
}
</code></pre>
The original <code>str</code> is never changed. Its value is copied and the text we concatenate is added to it, after which a new <code>String</code> is returned.
If we did something like this:
<pre><code class="hljs">String str1 = &quot;Hello World!&quot;;
String str2 = str1.substring(1,4).concat(&quot;abc&quot;).toLowerCase().trim().replace(&#x27;a&#x27;, &#x27;b&#x27;);
System.out.println(str2);
</code></pre>
Then we'd be greeted with the output:
<pre><code class="hljs">ellbbc
</code></pre>
Now, let's take a look at these two Strings:
<pre><code class="hljs">String str1 = &quot;qwerty&quot;;
String str2 = &quot;qwerty&quot;;
</code></pre>
When we instantiate a <code>String</code> like this, the value, in this case <code>qwerty</code> is saved in the Java Heap Memory - which is used for dynamic memory allocation for all Java objects.
While we have two different reference variables in this example, they're both referring to only one memory location in Java Heap Memory. While it may seem that there are two different String objects, in reality there is only one - <code>str2</code> never gets instantiated as an object, but rather is assigned the object in memory that corresponds to <code>str1</code>.
This happens due to the way Java was optimized for Strings. Each time you wish to instantiate a String object like this, the value you want to add to the Heap Memory is compared to the previously added values. If an equal value already exists, the object isn't initialized and the value is assigned to the reference variable.
These values are saved in the so-called String Pool, which contains all literal String values. There is a way to bypass this though - by using the <code>new</code> keyword.
Let's take a look at another example:
<pre><code class="hljs">String str1 = &quot;qwerty&quot;;
String str2 = &quot;qwerty&quot;;
String str3 = new String(&quot;qwerty&quot;);

System.out.println(str1 == str2);
System.out.println(str1 == str3);
System.out.println(str1.equals(str2));
System.out.println(str1.equals(str3));
</code></pre>
Output:
<pre><code class="hljs">true
false
true
true
</code></pre>
This is logical, as <code>str1</code> and <code>str2</code> point to the same object in memory. <code>str3</code> is instantiated explicitly as <code>new</code> so a new object is created for it, even though the String literal already exists in the pool. The <code>equals()</code> method compares their values, not the objects to which they point, which is the reason it returns <code>true</code> for all of these Strings.
It's important to note that <code>substring()</code> and <code>concat()</code> methods return a new <code>String</code> object and save it in the String pool.
This is a very small piece of code, but if we consider some big projects using hundreds of <code>String</code> variables and thousands of operations like <code>substring()</code> or <code>concat()</code>, it can cause serious memory leaks and time delays. That's exactly why we want to use <code>StringBuffer</code> or <code>StringBuilder</code>.
<h2 id="stringbufferandstringbuilder">StringBuffer and StringBuilder</h2>
<h3 id="mutability">Mutability</h3>
<code>StringBuffer</code> and <code>StringBuilder</code> objects basically hold the same value as a <code>String</code> object - a sequence of characters. Both <code>StringBuffer</code> and <code>StringBuilder</code> are also mutable which means that once we assign a value to them, that value is processed as an attribute of a <code>StringBuffer</code> or <code>StringBuilder</code> object.
No matter how many times we modify their value, as a result a new <code>String</code>, <code>StringBuffer</code>, or <code>StringBuilder</code> object will not be created. This approach is much more time efficient and less resource consuming.
<h3 id="stringbuildervsstringbuffer">StringBuilder vs StringBuffer</h3>
These two classes are almost identical to one another - they use methods with the same names which return the same results. Although there are two major differences between them:
<ul>
<li>
Thread Safety: <code>StringBuffer</code> methods are <a rel="nofollow" target="_blank" href="https://stackabuse.com/synchronized-keyword-in-java/">synchronized</a>, which means that only one thread can call the methods of a <code>StringBuffer</code> instance at a time. On the other hand <code>StringBuilder</code> methods are not synchronized, therefore multiple threads can call the methods in <code>StringBuilder</code> class without being blocked.
So we have come to a conclusion that <code>StringBuffer</code> is a thread-safe class while <code>StringBuffer</code> isn't.
Is that something you should worry about? Maybe. If you are working on application which uses multiple threads it can be potentially dangerous to work with <code>StringBuilder</code>.
</li>
<li>
Speed: <code>StringBuffer</code> is actually two to three times slower than <code>StringBuilder</code>. The reason behind this is <code>StringBuffer</code> synchronization - only allowing 1 thread to execute on an object at a time results in much slower code execution.
</li>
</ul>
<h3 id="methods">Methods</h3>
Both <code>StringBuffer</code> and <code>StringBuilder</code> have the same methods (besides <code>synchronized</code> method declaration in the <code>StringBuilder</code> class). Let's go through some of the most common ones:
<ul>
<li><code>append()</code></li>
<li><code>insert()</code></li>
<li><code>replace()</code></li>
<li><code>delete()</code></li>
<li><code>reverse()</code></li>
</ul>
As you can see the each method name pretty much describes what it does. Here is a simple demonstration:
<pre><code class="hljs">StringBuffer sb1 = new StringBuffer(&quot;Buffer no 1&quot;);
System.out.println(sb1);
 
sb1.append(&quot; - and this is appended!&quot;);
System.out.println(sb1);
sb1.insert(11, &quot;, this is inserted&quot;); 
System.out.println(sb1);
sb1.replace(7, 9, &quot;Number&quot;); 
System.out.println(sb1);
sb1.delete(7, 14);
System.out.println(sb1);
sb1.reverse();
System.out.println(sb1);
</code></pre>
Output:
<pre><code class="hljs">Buffer no 1
Buffer no 1 - and this is appended!
Buffer no 1, this is inserted - and this is appended!
Buffer Number 1, this is inserted - and this is appended!
Buffer 1, this is inserted - and this is appended!
!dedneppa si siht dna - detresni si siht ,1 reffuB
</code></pre>
<h2 id="stringvsstringbuildervsstringbuffer">String vs StringBuilder vs StringBuffer</h2>
<table class="table table-striped" style="width:100%">
 <tr align="center">
 <th colspan="2"></th>
 <th>String</th>
 <th>StringBuffer</th>
 <th>StringBuilder</th>
 </tr>
 <tr align="center">
 <td colspan="2" align="left">Mutable</td>
 <td>No</td>
 <td>Yes</td>
 <td>Yes</td>
 </tr>
 <tr align="center">
 <td colspan="2" align="left">Thread-Safe</td>
 <td>Yes</td>
 <td>Yes</td>
 <td>No</td>
 </tr>
 <tr align="center">
 <td colspan="2" align="left">Time Efficient</td>
 <td>No</td>
 <td>No</td>
 <td>Yes</td>
 </tr>
 <tr align="center">
 <td colspan="2" align="left">Memory Efficient</td>
 <td>No</td>
 <td>Yes</td>
 <td>Yes</td>
 </tr>
</table>
Note: As we can see from the table above, <code>String</code> is both less efficient in time and memory, but that doesn't mean we should never use it again.
In fact, <code>String</code> can be very handy to use because it can be written fast and if you ever develop an application which stores Strings that are not going to be manipulated/changed later, it's absolutely fine to use <code>String</code>.
<h2 id="codeexample">Code Example</h2>
In order to show how much efficient <code>String</code>, <code>StringBuffer</code>, and <code>StringBuilder</code> are we are going to perform a benchmark test:
<pre><code class="hljs">String concatString = &quot;concatString&quot;;
StringBuffer appendBuffer = new StringBuffer(&quot;appendBuffer&quot;);
StringBuilder appendBuilder = new StringBuilder(&quot;appendBuilder&quot;);
long timerStarted;

timerStarted = System.currentTimeMillis();
for (int i = 0; i &lt; 50000; i++) {
 concatString += &quot; another string&quot;;
}
System.out.println(&quot;Time needed for 50000 String concatenations: &quot; + (System.currentTimeMillis() - timerStarted) + &quot;ms&quot;);

timerStarted = System.currentTimeMillis();
for (int i = 0; i &lt; 50000; i++) {
 appendBuffer.append(&quot; another string&quot;);
}
System.out.println(&quot;Time needed for 50000 StringBuffer appends: &quot; + (System.currentTimeMillis() - timerStarted) + &quot;ms&quot;);
 
timerStarted = System.currentTimeMillis();
for (int i = 0; i &lt; 50000; i++) {
 appendBuilder.append(&quot; another string&quot;);
}
System.out.println(&quot;Time needed for 50000 StringBuilder appends: &quot; + (System.currentTimeMillis() - timerStarted) + &quot;ms&quot;);
</code></pre>
Output:
<pre><code class="hljs">Time needed for 50000 String concatenations: 18108ms
Time needed for 50000 StringBuffer appends: 7ms
Time needed for 50000 StringBuilder appends: 3ms
</code></pre>
This output may vary depending on your Java Virtual Machine. So from this benchmark test we can see that <code>StringBuilder</code> is the fastest in string manipulation. Next is <code>StringBuffer</code>, which is between two and three times slower than <code>StringBuilder</code>. And finally we have <code>String</code> which is by far the slowest in string manipulation.
Using <code>StringBuilder</code> resulted in a time ~6000 times faster than regular <code>String</code>'s. What it would take <code>StringBuilder</code> to concatenate in 1 second would take <code>String</code> 1.6 hours (if we could concatenate that much).
<h2 id="conclusion">Conclusion</h2>
We have seen the performance of <code>String</code>s, <code>StringBuffer</code>s, and <code>StringBuilder</code>s as well as their pros and cons. Now, the final question arises:
<blockquote>
Which one is the winner?
</blockquote>
Well the perfect answer on this question is &quot;It depends&quot;. We know that <code>String</code>s are easy to type, easy to use, and are thread-safe. On the other hand they are immutable (which means more memory consumption) and very slow when doing string manipulation.
<code>StringBuffer</code>s are mutable, memory efficient, and thread-safe. Their downfall is the speed when compared to much faster <code>StringBuilder</code>s.
As for <code>StringBuilder</code>s, they are also mutable and memory efficient, they are the fastest in string manipulation, but unfortunately they are not thread-safe.
If you take these facts into the consideration, you will always make the right choice!

Guest Contributor

String vs StringBuilder vs StringBuffer in Java

Usman Malik

Python for NLP: Creating a Rule-Based Chatbot

<h2 id="introduction">Introduction</h2>
If you've read anything about <a rel="nofollow" target="_blank" href="https://spring.io/">Spring</a>, developed a project, or was even remotely interested in how it works, you've been introduced to the <code>@RequestMapping</code> annotation.
It's one of the basic annotations in Spring which maps HTTP requests (URLs) with methods:
<pre><code class="hljs">@RequestMapping(&quot;/&quot;)
public void helloWorld() {
 return &quot;Hello World!&quot;;
}
</code></pre>
It allows us to run methods and pieces of code each time an endpoint is hit by the end-user with an HTTP request. In this case, it's a simple root mapping that returns the String &quot;Hello World!&quot; when the root endpoint is hit.
<h2 id="therequestmappingannotation">The @RequestMapping Annotation</h2>
The <code>@RequestMapping</code> annotation itself offers more than shown in the previous example. Let's briefly cover some of the basic use cases of the annotation.
<h3 id="requestmappingscopes">@RequestMapping Scopes</h3>
The mapping can be assigned at a class level or a method level:
<pre><code class="hljs">@RequestMapping(&quot;/admin&quot;)
public class AdminController() {
 @RequestMapping(&quot;/adminPanel&quot;)
 public String adminPanel() {
 return &quot;adminPanel.html&quot;;
 }

 @RequestMapping(&quot;/statistics&quot;)
 public String statistics() {
 return &quot;statistics.html&quot;;
 }
}
</code></pre>
Here, the <code>/admin</code> mapping is assigned on the class level, whereas the <code>/adminPanel</code> and <code>/statistics</code> mappings are assigned to methods. The class-level mapping will be used as a prefix for all of these method-level mappings: <code>/admin/adminPanel</code> and <code>/admin/statistics</code>.
This way, we can segregate our application into logical parts. For an example, all administrator related logic will be behind the <code>/admin</code> wall, which only administrator users can enter. All non-administrator users will be redirected to the client side of the application.
<h3 id="multiplemappingspermethod">Multiple Mappings per Method</h3>
If need be, we can assign multiple mappings to a single method, such as:
<pre><code class="hljs">@RequestMapping({&quot;/&quot;, &quot;/index&quot;, &quot;/home&quot;})
public void helloWorld() {
 return &quot;Hello World!&quot;;
}
</code></pre>
Hitting any of these endpoints will result in the <code>helloWorld()</code> method handling our request.
<h3 id="requestmethods">Request Methods</h3>
The most common attribute used is the <code>method</code> attribute which allows us to specify and narrow down the request method that our method handles (GET, POST, DELETE, etc.) :
<pre><code class="hljs">@RequestMapping(value = &quot;/addProduct&quot;, method = RequestMethod.POST)
public String addProductPost(@ModelAttribute(&quot;product&quot;) Product product) {
 // some code
}
</code></pre>
If we don't specify a request method, the default request method is <code>GET</code>.
<h3 id="requestheaders">Request Headers</h3>
We can further specify the mapping by defining one or more headers. In this case, the <code>helloWorld()</code> method will handle the request if its <code>content-type</code> is <code>text/plain</code> or <code>text/html</code>:
<pre><code class="hljs">@RequestMapping(value = &quot;/header&quot;, headers = {&quot;content-type=text/plain&quot;, &quot;content-type=text/html&quot;})
String helloWorld() {
 return &quot;Hello World!&quot;;
}
</code></pre>
<h3 id="pathvariables">Path Variables</h3>
A lot of websites rely on path variables to showcase a specific product, page, profile, etc. to the end-user, such as <code>example.com/viewProduct/324</code>, where <code>324</code> is the product ID:
<pre><code class="hljs">@RequestMapping(&quot;/viewProduct/{productId}&quot;)
public String viewProduct(@PathVariable int productId, Model model) {
 Product product = productService.getProductById(productId);
 model.addAttribute(&quot;product&quot;, product);

 return &quot;viewProduct&quot;;
}
</code></pre>
Here, after the mapping, we encase the path variable with curly brackets (<code>{}</code>) and assign that value to our <code>productId</code>. The <code>@PathVariable</code> annotation takes care of this for us. Then, we can find the product via our <code>ProductService</code> and display it to the end-user.
Of course, the same approach can be used for other variables such as:
<pre><code class="hljs">@RequestMapping(&quot;/users/{username}&quot;)
public String viewUser(@PathVariable(&quot;username&quot;) String username) {
 Profile profile = profileService.getProfileByUsername(username);
 // rest of the code
}
</code></pre>
<h3 id="requestparameters">Request Parameters</h3>
Very similar to path variables, many applications rely on request parameters to alter the state of the page. We can use the <code>@RequestParam</code> annotation to bind a request parameter to a variable:
<pre><code class="hljs">@RequestMapping(&quot;/login&quot;)
public String login(@RequestParam(value = &quot;error&quot;, required = false) String error, @RequestParam(value = &quot;logout&quot;, required = false) String logout, Model model) {

 if (error != null) {
 model.addAttribute(&quot;error&quot;, &quot;Wrong username or password!&quot;);
 }
 if (logout != null) {
 model.addAttribute(&quot;msg&quot;, &quot;You have successfully logged out!&quot;);
 }
 return &quot;login&quot;;
}
</code></pre>
<h3 id="producibleandconsumable">Producible and Consumable</h3>
Using the <code>@RequestMapping</code> annotation, we can also produce or consume media types. To produce a media type such as &quot;JSON&quot;, you can use the <code>produces</code> attribute alongside the <code>@ResponseBody</code> annotation, whereas to consume a media type you can use the <code>consumes</code> attribute:
<pre><code class="hljs">@RequestMapping(&quot;/annotations&quot;)
public class SomeController {
 @RequestMapping(value = &quot;/produce&quot;, produces = {&quot;application/json&quot;})
 @ResponseBody
 String produces() {
 return &quot;Here&#x27;s how you use the &#x27;produces&#x27; attribute&quot;;
 }

 @RequestMapping(value = &quot;/consume&quot;, consumes = {&quot;application/JSON&quot;, &quot;application/XML&quot;})
 String consume() {
 return &quot;Here&#x27;s how you use a &#x27;consume&#x27; attribute&quot;;
 }
}
</code></pre>
<h2 id="composedrequestmappingvariants">Composed @RequestMapping Variants</h2>
A single mapping can correspond to different methods if we ensure there's no ambiguity as to which method should handle which version of the mapping.
We can have multiple methods with the same mapping if their request method is different:
<pre><code class="hljs">@RequestMapping(&quot;/hello&quot;)
public String hello() {
 return &quot;hello&quot;;
}

@RequestMapping(value = &quot;/hello&quot;, method = RequestMethod.POST)
public String helloPost() {
 return &quot;hello post&quot;;
}

@RequestMapping(value = &quot;/hello&quot;, method = RequestMethod.PUT)
public String helloGet() {
 return &quot;hello put&quot;;
}

@RequestMapping(value = &quot;/hello&quot;, method = RequestMethod.DELETE)
public String helloDelete() {
 return &quot;hello delete&quot;;
}
</code></pre>
This same method has 4 different variations:
<ul>
<li>Default (GET)</li>
<li>POST</li>
<li>PUT</li>
<li>DELETE</li>
</ul>
With more variations, the readability of code gets reduced, and this quite honestly is already verbose for a simple mapping. Request mappings in bigger applications can get very complex and convoluted, and we'd want to keep it simpler and more readable.
For this purpose, we're introduced to several new annotations, the <code>@RequestMapping</code> variants:
<ul>
<li><code>@GetMapping</code></li>
<li><code>@PostMapping</code></li>
<li><code>@DeleteMapping</code></li>
<li><code>@PutMapping</code></li>
<li><code>@PatchMapping</code></li>
</ul>
There are quite literally just shortcut versions for the mappings above where <code>@PostMapping(&quot;/hello&quot;)</code> is equal to <code>@RequestMapping(value=&quot;/hello&quot;, RequestMethod.POST)</code>.
Taking a closer look at how these annotations are defined, we can get a clear idea of what they do:
<pre><code class="hljs">@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@RequestMapping(method = RequestMethod.GET)
public @interface GetMapping {

 @AliasFor(annotation = RequestMapping.class)
 String name() default &quot;&quot;;

 @AliasFor(annotation = RequestMapping.class)
 String[] value() default {};

 @AliasFor(annotation = RequestMapping.class)
 String[] path() default {};

 @AliasFor(annotation = RequestMapping.class)
 String[] params() default {};

 @AliasFor(annotation = RequestMapping.class)
 String[] headers() default {};

 @AliasFor(annotation = RequestMapping.class)
 String[] produces() default {};
}
</code></pre>
That being said, we can rewrite the examples above:
<pre><code class="hljs">@GetMapping
public String hello() {
 return &quot;hello&quot;;
}

@PostMapping
public String helloPost() {
 return &quot;hello post&quot;;
}

@PutMapping
public String helloGet() {
 return &quot;hello put&quot;;
}

@DeleteMapping
public String helloDelete() {
 return &quot;hello delete&quot;;
}
</code></pre>
As this is both a simpler, more readable and newer way of writing annotations, it's generally preferred to write them like this. If need be, you can still define any other attributes such as the <code>value</code>, <code>params</code>, <code>path</code>, etc.
<h2 id="conclusion">Conclusion</h2>
<code>@RequestMapping</code> is a quintessential annotation in the Spring framework which allows us to map HTTP requests with methods we'd wish to run.
As of Spring 4.3, it's preferred and advised to use the shortcuts made for this annotation for a more readable and less verbose codebase.

David Landup

Spring Annotations: @RequestMapping and its Variants

Marcus Sanatan

Phaser 3 and Tiled: Building a Platformer

Dhananjay Singh

Spring Cloud Stream with RabbitMQ: Message-Driven Microservices

<h2 id="introduction">Introduction</h2>
Machine Learning is gaining popularity and usage over the globe. It has already drastically changed the way certain applications are built and will likely continue to be a huge (and increasing) part of our daily lives.
There's no sugarcoating it, Machine Learning isn't simple. It's pretty daunting and can seem very complex to many.
Companies such as Google took it upon themselves to bring Machine Learning concepts closer to developers and allow them to gradually, with major help, make their first steps.
Thus, frameworks such as <a rel="nofollow" target="_blank" href="https://www.tensorflow.org/">TensorFlow</a> were born.
<h2 id="whatistensorflow">What is TensorFlow?</h2>
TensorFlow is an open-source Machine Learning framework developed by Google in Python and C++.
It helps developers easily acquire data, prepare and train models, predict future states, and perform large-scale machine learning.
With it, we can train and run deep neural networks which are most often used for <a target="_blank" href="/pytesseract-simple-python-optical-character-recognition/">Optical Character Recognition</a>, <a target="_blank" href="/image-recognition-in-python-with-tensorflow-and-keras/">Image Recognition/Classification, <a target="_blank" href="/what-is-natural-language-processing/">Natural Language Processing</a>, etc.
<h2 id="tensorsandoperations">Tensors and Operations</h2>
TensorFlow is based on computational graphs, which you can imagine as a classic graph with nodes and edges.
Each node is referred to as an operation, and they take zero or more tensors in and produce zero or more tensors out. An operation can be very simple, such as basic addition, but they can also be very complex.
Tensors are depicted as edges of the graph, and are the core data unit. We perform different functions on these tensors as we feed them to operations. They can have a single or multiple dimensions, which are sometimes referred to as their <a rel="nofollow" target="_blank" href="http://mathworld.wolfram.com/TensorRank.html">ranks</a> - (Scalar: rank 0, Vector: rank 1, Matrix: rank 2)
This data flows through the computational graph through tensors, impacted by operations - hence the name TensorFlow.
Tensors can store data in any number of dimensions, and there are three main types of tensors: placeholders, variables, and constants.
<h2 id="installingtensorflow">Installing TensorFlow</h2>
Using <a target="_blank" href="/what-is-maven/">Maven</a>, installing TensorFlow is as easy as including the dependency:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.tensorflow&lt;/groupId&gt;
 &lt;artifactId&gt;tensorflow&lt;/artifactId&gt;
 &lt;version&gt;1.13.1&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
If your device supports <a rel="nofollow" target="_blank" href="https://www.tensorflow.org/install/gpu">GPU support</a>, then use these dependencies:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.tensorflow&lt;/groupId&gt;
 &lt;artifactId&gt;libtensorflow&lt;/artifactId&gt;
 &lt;version&gt;1.13.1&lt;/version&gt;
&lt;/dependency&gt;

&lt;dependency&gt;
 &lt;groupId&gt;org.tensorflow&lt;/groupId&gt;
 &lt;artifactId&gt;libtensorflow_jni_gpu&lt;/artifactId&gt;
 &lt;version&gt;1.13.1&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
You can check the version of TensorFlow currently installed by using the <code>TensorFlow</code> object:
<pre><code class="hljs">System.out.println(TensorFlow.version());
</code></pre>
<h2 id="tensorflowjavaapi">TensorFlow Java API</h2>
The Java API TensorFlow offers is contained within the <code>org.tensorflow</code> package. It's currently experimental so it's not guaranteed to be stable.
Please note that the only fully supported language for TensorFlow is Python and that the Java API isn't nearly as functional.
It introduces us to new classes, an interface, enum, and exception.
<h3 id="classes">Classes</h3>
The new classes introduced through the API are:
<ul>
<li><code>Graph</code>: A data flow graph representing a TensorFlow computation</li>
<li><code>Operation</code>: A Graph node that performs computation on Tensors</li>
<li><code>OperationBuilder</code>: A builder class for Operations</li>
<li><code>Output&lt;T&gt;</code>: A symbolic handle to a tensor produced by an Operation</li>
<li><code>SavedModelBundle</code>: Represents a model loaded from storage.</li>
<li><code>SavedModelBundle.Loader</code>: Provides options for loading a SavedModel</li>
<li><code>Server</code>: An in-process TensorFlow server, for use in distributed training</li>
<li><code>Session</code>: Driver for Graph execution</li>
<li><code>Session.Run</code>: Output tensors and metadata obtained when executing a session</li>
<li><code>Session.Runner</code>: Run Operations and evaluate Tensors</li>
<li><code>Shape</code>: The possibly partially known shape of a tensor produced by an operation</li>
<li><code>Tensor&lt;T&gt;</code>: A statically typed multi-dimensional array whose elements are of a type described by T</li>
<li><code>TensorFlow</code>: Static utility methods describing the TensorFlow runtime</li>
<li><code>Tensors</code>: Type-safe factory methods for creating Tensor objects</li>
</ul>
<h3 id="enum">Enum</h3>
<ul>
<li><code>DataType</code>: Represents the type of elements in a Tensor as an enum</li>
</ul>
<h3 id="interface">Interface</h3>
<ul>
<li><code>Operand&lt;T&gt;</code>: Interface implemented by operands of a TensorFlow operation</li>
</ul>
<h3 id="exception">Exception</h3>
<ul>
<li><code>TensorFlowException</code>: Unchecked exception thrown when executing TensorFlow Graphs</li>
</ul>
If we compare all of this to the <a rel="nofollow" target="_blank" href="https://www.tensorflow.org/api_docs/python/tf">tf module in Python</a>, there's an obvious difference. The Java API doesn't have nearly the same amount of functionality, at least for now.
<h2 id="graphs">Graphs</h2>
As mentioned before, TensorFlow is based on computational graphs - where <code>org.tensorflow.Graph</code> is Java's implementation.
Note: Its instances are thread-safe, though we need to explicitly release resources used by the Graph after we're finished with it.
Let's start off with an empty graph:
<pre><code class="hljs">Graph graph = new Graph();
</code></pre>
This graph doesn't mean much, it's empty. To do anything with it, we first need to load it up with <code>Operation</code>s.
To load it up with operations, we use the <code>opBuilder()</code> method, which returns an <code>OperationBuilder</code> object that'll add the operations to our graph once we call the <code>.build()</code> method.
<h3 id="constants">Constants</h3>
Let's add a constant to our graph:
<pre><code class="hljs">Operation x = graph.opBuilder(&quot;Const&quot;, &quot;x&quot;)
 .setAttr(&quot;dtype&quot;, DataType.FLOAT)
 .setAttr(&quot;value&quot;, Tensor.create(3.0f))
 .build(); 
</code></pre>
<h3 id="placeholders">Placeholders</h3>
Placeholders are a &quot;type&quot; of variable that don't have a value at declaration. Their values will be assigned at a later date. This allows us to build graphs with operations without any actual data:
<pre><code class="hljs">Operation y = graph.opBuilder(&quot;Placeholder&quot;, &quot;y&quot;)
 .setAttr(&quot;dtype&quot;, DataType.FLOAT)
 .build();
</code></pre>
<h3 id="functions">Functions</h3>
And now finally, to round this up, we need to add certain functions. These could be as simple as multiplication, division, or addition, or as complex as matrix multiplications. The same as before, we define functions using the <code>.opBuilder()</code> method:
<pre><code class="hljs">Operation xy = graph.opBuilder(&quot;Mul&quot;, &quot;xy&quot;)
 .addInput(x.output(0))
 .addInput(y.output(0))
 .build(); 
</code></pre>
Note: We're using <code>output(0)</code> as a tensor can have more than one output.
<h3 id="graphvisualisation">Graph Visualisation</h3>
Sadly, the Java API doesn't yet include any tools that allow you to visualize graphs as you would in Python. When the Java API gets updated, so will this article.
<h2 id="sessions">Sessions</h2>
As mentioned before, a <code>Session</code> is the driver for a <code>Graph</code>'s execution. It encapsulates the environment in which <code>Operation</code>s and <code>Graph</code>s are executed to compute <code>Tensor</code>s.
What this means is that the tensors in our graph that we constructed don't actually hold any value, as we didn't run the graph within a session.
Let's first add the graph to a session:
<pre><code class="hljs">Session session = new Session(graph);
</code></pre>
Our computation simply multiples the <code>x</code> and <code>y</code> value. In order to run our graph and compute it, we <code>fetch()</code> the <code>xy</code> operation and feed it the <code>x</code> and <code>y</code> values:
<pre><code class="hljs">Tensor tensor = session.runner().fetch(&quot;xy&quot;).feed(&quot;x&quot;, Tensor.create(5.0f)).feed(&quot;y&quot;, Tensor.create(2.0f)).run().get(0);
System.out.println(tensor.floatValue());
</code></pre>
Running this piece of code will yield:
<pre><code class="hljs">10.0f
</code></pre>
<h2 id="savingmodelsinpythonandloadinginjava">Saving Models in Python and Loading in Java</h2>
This may sound a bit odd, but since Python is the only well-supported language, the Java API still doesn't have the functionality to save models.
This means that the Java API is meant only for the serving use-case, at least until it's fully supported by TensorFlow. At least, we can train and save models in Python and then load them in Java to serve them, using the <code>SavedModelBundle</code> class:
<pre><code class="hljs">SavedModelBundle model = SavedModelBundle.load(&quot;./model&quot;, &quot;serve&quot;); 
Tensor tensor = model.session().runner().fetch(&quot;xy&quot;).feed(&quot;x&quot;, Tensor.create(5.0f)).feed(&quot;y&quot;, Tensor.create(2.0f)).run().get(0); 

System.out.println(tensor.floatValue());
</code></pre>

<h2 id="conclusion">Conclusion</h2>
TensorFlow is a powerful, robust and widely-used framework. It's constantly being improved and lately introduced to new languages - including Java and JavaScript.
Although the Java API doesn't yet have nearly as much functionality as TensorFlow for Python, it can still serve as a good intro to TensorFlow for Java developers.

How to Use TensorFlow with Java

When you want Git to track a file in a repository, you must explicitly add it to the repo, which can become a bit cumbersome if you have many files. Another option would be to add/stage all files to the repo, which is much quicker. In general it is best to manually add each to avoid staging files that you don't want, but if you know what you're doing this can save some time.
Like everything in Git, there are a few ways to do this. The behavior and options available also changes depending on the version of Git you're using, so for this article we'll be focusing on Git 2.x, which should be installed on most machines.
<h2 id="stageallfiles">Stage all Files</h2>
Using this command will stage all files in your repository, which includes all new, modified, and deleted files. The command is as follows:
<pre><code class="hljs">$ git add -A
</code></pre>
The <code>-A</code> option is shorthand for <code>--all</code>.
Another way to do this would be to omit the <code>-A</code> option and just specify a period to indicate all files in the current working directory:
<pre><code class="hljs">$ git add .
</code></pre>
Note: The command <code>git add .</code> only stages files in the current directory and not any subdirectories, whereas <code>git add -A</code> will stage files in subdirectories as well.
<h2 id="stageallnewandmodifiedfiles">Stage all New and Modified Files</h2>
The previous commands will also remove a file from your repository if it no longer exists in the project. If that is an undesired behavior in your case then you should use the <code>--ignore-removal</code> option, which will only stage new and modified files:
<pre><code class="hljs">$ git add --ignore-removal .
</code></pre>
<h2 id="stageallmodifiedanddeletedfiles">Stage all Modified and Deleted Files</h2>
Another variation of this command would be to only stage modified and deleted files, but not any new files. For many existing projects this is actually a safer command than the others since it only affects files already tracked by the repo, and it won't add any others unless you specifically tell it to.
This behavior is achieved via the <code>-u</code> flag, which is shorthand for the <code>--update</code> option:
<pre><code class="hljs">$ git add -u
</code></pre>
<h2 id="addingfilesbywildcard">Adding Files by Wildcard</h2>
Although this technically isn't adding all files, it's another way to add a batch of files. Git allows you to add multiple files at once by using wildcard patterns.
So, for example, if you wanted to add all Python files in your current directory to your repo you'd want to use a command like this:
<pre><code class="hljs">$ git add *.py
</code></pre>
Although, most projects have subdirectories, in which case you'd have to run this command on each one to add all of your Python files. But there is a faster way. Instead you could use the <code>**</code> syntax, which matches all subdirectories.
So, for another example, this command would add all JavaScript files, including those in subdirectories:
<pre><code class="hljs">$ git add **/*.js
</code></pre>

Scott Robinson

Git: Add All Files to a Repo

<h2 id="introduction">Introduction</h2>
This is the second article in the series of articles on Concurrency in Java. In the <a target="_blank" href="/concurrency-in-java-the-executor-framework/">previous article</a>, we learnt about the <code>Executor</code> pool and various categories of <code>Executors</code> in Java.
In this article, we will learn what the <code>synchronized</code> keyword is and how we can use that in a multi-threading environment.
<h2 id="whatissynchronization">What is Synchronization?</h2>
In a multi-threaded environment, it is possible that more than one thread may try to access the same resource. For example, two threads trying to write in to the same text file. In the absence of any synchronization between them, it is possible that the data written to the file will be corrupt when two or more threads have write access to the same file.
Also, in the JVM, each thread stores a local copy of variables on its stack. The actual value of these variables may be changed by some other thread. But that value may not be refreshed in another thread's local copy. This may cause incorrect execution of programs and non-deterministic behavior.
To avoid such issues, Java provides us with the <code>synchronized</code> keyword, which acts like a lock to a particular resource. This helps achieve communication between threads such that only one thread accesses the synchronized resource and other threads wait for the resource to become free.
The <code>synchronized</code> keyword can be used in a few different ways, like a synchronized block:
<pre><code class="hljs">synchronized (someObject) {
 // Thread-safe code here
}
</code></pre>
It can also be used with a method like this:
<pre><code class="hljs">public synchronized void somemMethod() {
 // Thread-safe code here
}
</code></pre>
<h2 id="howsynchronizationworksinthejvm">How Synchronization Works in the JVM</h2>
When a thread tries to enter the synchronized block or method, it has to acquire a <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Lock_(computer_science)">lock</a> on the object being synchronized. One and only one thread can acquire that lock at a time and execute code in that block.
If another thread tries to access a synchronized block before the current thread completes its execution of the block, it has to wait. When the current thread exits the block, the lock is automatically released and any waiting thread can acquire that lock and enter the synchronized block:
<ul>
<li>For a <code>synchronized</code> block, the lock is acquired on the object specified in the parentheses after the <code>synchronized</code> keyword</li>
<li>For a <code>synchronized static</code> method, the lock is acquired on the <code>.class</code> object</li>
<li>For a <code>synchronized</code> instance method, the lock is acquired on the current instance of that class i.e. <code>this</code> instance</li>
</ul>
<h2 id="synchronizedmethods">Synchronized Methods</h2>
Defining <code>synchronized</code> methods is as easy as simply including the keyword before the return type. Let's define a method that prints out the numbers between 1 and 5 in a sequential manner.
Two threads will try to access this method, so let's first see how this'll end up without synchronizing them, and then we'll lock the shared object and see what happens:
<pre><code class="hljs">public class NonSynchronizedMethod {

 public void printNumbers() {
 System.out.println(&quot;Starting to print Numbers for &quot; + Thread.currentThread().getName());

 for (int i = 0; i &lt; 5; i++) {
 System.out.println(Thread.currentThread().getName() + &quot; &quot; + i);
 }

 System.out.println(&quot;Completed printing Numbers for &quot; + Thread.currentThread().getName());
 }
}
</code></pre>
Now, let's implement two custom threads that access this object and wish to run the <code>printNumbers()</code> method:
<pre><code class="hljs">class ThreadOne extends Thread {

 NonSynchronizedMethod nonSynchronizedMethod;

 public ThreadOne(NonSynchronizedMethod nonSynchronizedMethod) {
 this.nonSynchronizedMethod = nonSynchronizedMethod;
 }

 @Override
 public void run() {
 nonSynchronizedMethod.printNumbers();
 }
}

class ThreadTwo extends Thread {

 NonSynchronizedMethod nonSynchronizedMethod;

 public ThreadTwo(NonSynchronizedMethod nonSynchronizedMethod) {
 this.nonSynchronizedMethod = nonSynchronizedMethod;
 }

 @Override
 public void run() {
 nonSynchronizedMethod.printNumbers();
 }
}
</code></pre>
These threads share a common object <code>NonSynchronizedMethod</code> and they will simultaneously try to call the non-synchronized method <code>printNumbers()</code> on this object.
To test this behavior, let's write a main class:
<pre><code class="hljs">public class TestSynchronization {
 public static void main(String[] args) {

 NonSynchronizedMethod nonSynchronizedMethod = new NonSynchronizedMethod();

 ThreadOne threadOne = new ThreadOne(nonSynchronizedMethod);
 threadOne.setName(&quot;ThreadOne&quot;);

 ThreadTwo threadTwo = new ThreadTwo(nonSynchronizedMethod);
 threadTwo.setName(&quot;ThreadTwo&quot;);

 threadOne.start();
 threadTwo.start();

 }
}
</code></pre>
Running the code will give us something along the lines of:
<pre><code class="hljs">Starting to print Numbers for ThreadOne
Starting to print Numbers for ThreadTwo
ThreadTwo 0
ThreadTwo 1
ThreadTwo 2
ThreadTwo 3
ThreadTwo 4
Completed printing Numbers for ThreadTwo
ThreadOne 0
ThreadOne 1
ThreadOne 2
ThreadOne 3
ThreadOne 4
Completed printing Numbers for ThreadOne
</code></pre>
<code>ThreadOne</code> started first, though <code>ThreadTwo</code> completed first.
And running it again greets us with another undesired output:
<pre><code class="hljs">Starting to print Numbers for ThreadOne
Starting to print Numbers for ThreadTwo
ThreadOne 0
ThreadTwo 0
ThreadOne 1
ThreadTwo 1
ThreadOne 2
ThreadTwo 2
ThreadOne 3
ThreadOne 4
ThreadTwo 3
Completed printing Numbers for ThreadOne
ThreadTwo 4
Completed printing Numbers for ThreadTwo
</code></pre>
These outputs are given completely to chance, and are completely unpredictable. Each run will give us a different output. Factor this in with the fact that there can be many more threads, and we could have a problem. In real-world scenarios this is especially important to consider when accessing some type of shared resource, like a file or other type of IO, as opposed to just printing to the console.
Now, let's adequately <code>synchronize</code> our method:
<pre><code class="hljs">public synchronized void printNumbers() {
 System.out.println(&quot;Starting to print Numbers for &quot; + Thread.currentThread().getName());

 for (int i = 0; i &lt; 5; i++) {
 System.out.println(Thread.currentThread().getName() + &quot; &quot; + i);
 }

 System.out.println(&quot;Completed printing Numbers for &quot; + Thread.currentThread().getName());
}
</code></pre>
Absolutely nothing has changed, besides including the <code>synchronized</code> keyword. Now, when we run the code:
<pre><code class="hljs">Starting to print Numbers for ThreadOne
ThreadOne 0
ThreadOne 1
ThreadOne 2
ThreadOne 3
ThreadOne 4
Completed printing Numbers for ThreadOne
Starting to print Numbers for ThreadTwo
ThreadTwo 0
ThreadTwo 1
ThreadTwo 2
ThreadTwo 3
ThreadTwo 4
Completed printing Numbers for ThreadTwo
</code></pre>
This looks about right.
Here, we see that even though the two threads run simultaneously, only one of the threads enters the synchronized method at a time which in this case is <code>ThreadOne</code>.
Once it completes execution, <code>ThreadTwo</code> can starts with the execution of the <code>printNumbers()</code> method.
<h2 id="synchronizedblocks">Synchronized Blocks</h2>
The main aim of multi-threading is to execute as many tasks in parallel as is possible. However, synchronization throttles the parallelism for threads which have to execute synchronized method or block.
This reduces the throughput and parallel execution capacity of the application. This downside cannot be entirely avoided due to shared resources.
However, we can try to reduc the amount of code to be executed in a synchronized fashion by keeping the least amount of code as possible in the scope of <code>synchronized</code>. There could be many scenarios where instead of synchronizing on the whole method, it is okay to just synchronize a few lines of code in the method instead.
We can use the <code>synchronized</code> block to enclose only that portion of code instead of the whole method.
Since there is less amount of code to be executed inside the synchronized block, the lock is released by each of the threads more quickly. As a result, the other threads spend less time waiting for the lock and code throughput increases greatly.
Let's modify the earlier example to synchronize only the <code>for</code> loop printing the sequence of numbers, as realistically, it's the only portion of code that should be synchronized in our example:
<pre><code class="hljs">public class SynchronizedBlockExample {

 public void printNumbers() {

 System.out.println(&quot;Starting to print Numbers for &quot; + Thread.currentThread().getName());

 synchronized (this) {
 for (int i = 0; i &lt; 5; i++) {
 System.out.println(Thread.currentThread().getName() + &quot; &quot; + i);
 }
 }

 System.out.println(&quot;Completed printing Numbers for &quot; + Thread.currentThread().getName());
 }
}
</code></pre>
Let's check out the output now:
<pre><code class="hljs">Starting to print Numbers for ThreadOne
Starting to print Numbers for ThreadTwo
ThreadOne 0
ThreadOne 1
ThreadOne 2
ThreadOne 3
ThreadOne 4
Completed printing Numbers for ThreadOne
ThreadTwo 0
ThreadTwo 1
ThreadTwo 2
ThreadTwo 3
ThreadTwo 4
Completed printing Numbers for ThreadTwo
</code></pre>
Although it may seem alarming that <code>ThreadTwo</code> has &quot;started&quot; printing numbers before <code>ThreadOne</code> completed its task, this is only because we allowed the thread to reach past the <code>System.out.println(Starting to print Numbers for ThreadTwo)</code> statement before stopping <code>ThreadTwo</code> with the lock.
That's fine because we just wanted to synchronize the sequence of the numbers in each thread. We can clearly see that the two threads are printing numbers in the correct sequence by just synchronizing the <code>for</code> loop.
<h2 id="conclusion">Conclusion</h2>
In this example we saw how we can use synchronized keyword in Java to achieve synchronization between multiple threads. We also learnt when we can use synchronized method and blocks with examples.
As always, you can find the code used in this example <a rel="nofollow" target="_blank" href="https://github.com/chand31290/codingExamples/tree/master/SynchronizedExample">here</a>.

Chandan Singh

Concurrency in Java: The synchronized Keyword

In the Git version control system you're able to push and pull code from any number of remote repositories. This is beneficial for when you want to pull in updates from someone else's fork of a project, for example. Or you may just want to have a way to link your local Git repo with the remote one on GitHub. Either way, it's beneficial to associate a remote repository to your local one. In this short article I'll explain exactly how to do that.
The command you'll want to use is <code>git remote add</code>, and is generally used in the following way:
<pre><code class="hljs">$ git remote add &lt;remote-name&gt; &lt;remote-location&gt;
</code></pre>
The remote name is helpful for being able to reference this repository without having to type out the entire location. You can also set these remotes as your default <code>push</code> or <code>pull</code> locations, shortening your Git commands even more.
For example, to add a remote origin to your repository, you would use the command like this:
<pre><code class="hljs">$ git remote add origin git@github.com:scottwrobinson/camo.git
</code></pre>
Once you've added a remote to your repo you can then verify it with the <code>-v</code> flag:
<pre><code class="hljs">$ git remote -v
origin git@github.com:scottwrobinson/camo.git (fetch)
origin git@github.com:scottwrobinson/camo.git (push)
</code></pre>
<h2 id="addingremotesforfetchandpull">Adding Remotes for Fetch and Pull</h2>
In the output of the last command you may have noticed that there are actually two lines listed for the &quot;origin&quot; remote repository. This means you can actually set two different remote repositories for &quot;origin&quot;, one for the push operation and one for fetch. This can be done with the following commands:
<pre><code class="hljs">$ git remote set-url &lt;remote-name&gt; &lt;repo-url-for-fetching&gt;
$ git remote set-url --push &lt;remote-name&gt; &lt;repo-url-for-pushing&gt;
</code></pre>
This kind of setup can be helpful if you're pulling in changes from the main branch of a project and then pushing any changes you make to a separate branch of your own, for example.