Month: January 2022

Java is one of the most popular programming languages today. It is the third most popular programming language, according to the TIOBE Index for November 2021.

Java is used to create customized programs that are light and quick, as well as in complex projects. If you are an Android developer or app designer, you may have to work with Java often as it’s compatible with almost all devices and platforms (macOS, Windows, Linux).

For those who are planning to learn a programming language, this article highlights why learning Java should be their first choice. Let’s take a look.

Why Learn Java?

Here are some of the most common benefits of learning Java for web and mobile developers.

1. Inflated demand

As per Statista, Java is one of the most-used programming languages among developers worldwide. A majority of Android apps use Java as their primary backend language.

With an increasing demand for Android-based smartphones, Android app development is also rising. Hence, more and more app development companies are looking for developers who are experts in Java.

2. Good salary

Because of the extensive use of the language, Java developers are amongst the highest-paid professionals in the IT business. If we go by the statistics from Glassdoor, a Java developer in the USA earns $93,118 annually on average.

3. Beginner-friendly and easier to learn

One of the biggest factors in learning Java is that it doesn’t have a steep learning curve. It will be easy to get to grips with Java syntax if you are familiar with its predecessors, such as C++ or C#.

Java also has powerful memory management facilities, unlike its forerunners. Memory allocation, reallocation, and deallocation are all handled automatically by the Runtime Environment via a built-in component called the Garbage Collector. This automatically reduces the responsibilities of a developer and improves program quality.

Learning any new programming language can be a daunting task. From the syntax to the structure and the programming interface, there are many things that a developer needs to learn.

Java runs on the concept of Object-Oriented Programming, and since it’s a higher-level programming language, beginners usually find it easy to learn and understand. Having said so, this also depends upon each developer’s individual learning capacity.

4. An abundance of resources to learn Java

You can easily learn everything about Java through abundant online courses and resources. You can learn Java at CodeGym from scratch, where a variety of practice sessions are available. It also gives you the ability to validate your code right away, so you can definitely expedite your process of learning Java.

Apart from that, there are several coding boot camps specifically for the Java programming language. This makes studying extremely easy for anyone who wants to learn Java.

Since Java is an established coding language, you can also expect to get your queries resolved on the StackOverflow community and may also use open source libraries from Github.

5. A huge online community of Java users

StackOverflow, Java Forums, and other online learning forums are examples that the Java community is ever-growing. There are also many resources on the internet for Java, such as GitHub and StackOverflow to answer all your queries and address errors.

You can also use and learn from content generated by the community. A good example is the Java blog at CodeGym where your peers post useful articles to help you brush up on your Java skills.

6. Cross-platform language with a modest set of restrictions

You can work on Java using a PC, mobile devices, and Internet of Things devices and technologies, among other platforms. In fact, Java Virtual Machine (JVM) also lies at the core of Android mobile application development.

Hence, if you want to make a career in Android application development, understanding and learning Java should be the first step towards it.

7. Many publicly available libraries

Coding using Java has its own set of advantages. The key one is the availability of various open-source libraries that you can use in your applications. So, for many modules, you may not even need to code from scratch.

Instead, you can just use the open-source code, and integrate ready functionality into your code.

Some of the open-source libraries having support for Java include Apache Commons, Google Guava and many more.

8. Java has a rich API

Java has a large Application Programming Interface (API), such as Java Stream and others, which is handy for building apps without necessarily knowing how they are implemented on the inside. Almost everything is done with these APIs, including networking, I/O, databases, media, XML parsing, voice synthesis, and so on.

So, suppose if you want to include voice synthesis in your project, you don’t need to know the entire code that went behind this feature, rather, you just have to include its API in your code. And voila, the feature is integrated!

9. Java offers powerful development tools

Java has a plethora of Integrated Development Environments (IDEs) that provide programmers with a variety of features for software development. Debugging, syntax highlighting, code completion, language support, automatic refactoring, and other features in these IDEs make developing in Java easier and faster.

As per the IDC industry analyst Al Hilwa, Java was chosen by over 90% of Fortune 500 organizations to develop a large number of backend apps.

Java is supported by Android studio for Android developers, Eclipse, Netbeans, Intellij IDE, and Visual Studio Code.

10. Most of all, Java is free!

One of the reasons Java is so popular among individual programmers is that it is free to download under the Oracle Binary Code License (BCL). This implies that Java is free for development and testing environments, but a nominal price is required for commercial use.

The post 10 Reasons to Learn Java Programming Language appeared first on Hongkiat.

From currying to closures there are quite a number of JavaScript jargons (special words used within the field) knowing which will not only help you increase your vocabulary but understand JavaScript better.

Jargons are normally found in documentations and technical articles. But some of them like closures are pretty standard things to know about. Knowing what the word itself mean can help you know the concept it is named for better.

This post is the compilation of 10 such terms with their meaning and the context in which they are used in JavaScript. If you’re a beginner then this list has got you covered with the basics like hoisting. At the same time less-known or less-understood terms are also included in there.

1. Arity
2. Anonymous
3. Closure
4. Currying
5. Hoisting
6. Mutation
7. Pragma
8. Sentinel
9. Vanilla
10. Variadic

1. Arity

Arity (from Latin) is the term used to refer to the number of arguments or operands in a function or operation respectively. You’re most likely to come across this word in the realm of JavaScript when it is used to mention the number of arguments expected by a JavaScript function.

There is even a property named arity, of the Function object that returns the number of expected arguments in a function. It is now obsolete though and replaced by length.

The following function has an arity of 3.

function getName(first, middle, last){
 return first+' '+ middle +' '+last;
 }

2. Anonymous

Anonymous is an adjective. When something or someone is referred to as anonymous it means that thing’s or person’s name is unidentified. Likewise in JavaScript an anonymous function is the one that is not identified by a name.

(function (){
 //body
 })();

Above is an IIFE (Immediately Invoked Function Expression). The function in it is anonymous since it doesn’t have a name. Now, take a look at the one below.

var foo = function() {
 
 };

That is also said to be an anonymous function since there is no name after the key word function.

A little bit of doubt rises in the correctness of the use of the word “anonymous”. With IIFE, the function gets called right away, no name involved whereas, to call the latter function the syntax foo() is used.

It’s like we christened a nameless function with the name ‘foo’ and called it using that. Does that count as anonymous? I don’t know, I’ll leave that to the English experts. But, my confusion aside, they both are indeed referred to as anonymous function.

3. Closure

Here’s one of the definitions from oxford dictionary for closure: “A thing that closes or seals something, such as a cap or tie.”

In JavaScript, closure is an inner function, that is accessible outside of its outer function’s scope, with its connection to the outer function’s variables still intact.

To explain things (maybe not accurately but simply enough), consider closure as a waiter in a restaurant. A lot of things happen inside a restaurant kitchen, where we are not allowed to enter or see. But how are we supposed to get our food then?

That is where waiters come in. We call them, order the food, and then they’ll go to the kitchen, inform the chefs of the orders, and bring it to us when the order is ready. This way we’ve not broken any “rules” and can still manage to grab a meal.

The waiter is someone who is able to take our order into the kitchen and return with the food. JavaScript closures are similar to that, they are able to take our parameters and bring back us variables (references to those variables, to be precise) from inside a function that we aren’t allowed in.

function order() {
 var food; 
 function waiter(order) {
 chef(order);
 return food;
 }
 function chef(order) {
 if (order === 'pasta') {
 food = ['pasta', 'gravy', 'seasoning'];
 cook();
 }
 }
 function cook() { food.push('cooked'); }
 return waiter;
 }
 var myOrder = order();
 console.log(myOrder('pasta'));
 // Array [ "pasta", "gravy", "seasoning", "cooked" ]

As you can see from the above code, everything apart from waiter and its return value from inside the order function isn’t exposed to the outside world.

4. Currying

The effect, named after Haskell Curry, refers to using multiple functions with single arguments, in place of a single function with multiple arguments. Let’s see the add functions below for example.

function addx(x){
 function addy(y){
 return x+y;
 }
 return addy
 }
 
 function add(x,y){
 return(x+y);
 }
 
 console.log(addx(3)(4)); 7
 console.log(add(3,4)); 7

Both of the functions return the same result. The function addx accepts a parameter x while returning addy which in turn accepts the y value, performs the addition with x and returns the sum.

The function add simply takes both x and y at the same time, performs the addition and returns the sum. So far the first function might not seem very useful, until…

var add4 = addx(4);
 console.log(add4(8)); //12
 console.log(add4(6)); //10
 console.log(add4(-74)); //-70

Now, the former function suddenly gets interesting. In currying, you can always fix a step in a sequence of operations like the addition of 4 from the above code, which is helpful when one of the variables used in the operation is always the same.

5. Hoisting

Hoist means to raise something. Hoisting in JavaScript also means the same and what gets raised is the declaration (variable & function declarations).

Declarations are where variables and functions are created with keywords var(not for global) and function.

It doesn’t matter where you type the code to declare a function or variable, during evaluation all the declarations are moved up inside the scope where they reside (except for in strict mode). Hence, it is possible to write a working code with the code for function call placed before function declaration.

var name = 'Velma';
 console.log(sayCatchPhrase(name)); /"Jinkies!"
 
 function sayCatchPhrase(name) {
 phrases = {
 'Fred Flintstone': 'Yabba dabba doo!',
 'Velma': 'Jinkies!',
 'Razor': 'Bingo!',
 'He-Man': 'I Have the Power'
 };
 return phrases[name];
 }

6. Mutation

Mutation means change or modification. If you ever come across the word mutation in JavaScript it is probably referring to the changes that DOM elements went through.

There is even an API called MutationObserver to keep an eye out for the DOM mutations like addition of child elements or changes to the element’s attributes. (You can read more about MutationObserver in my post.)

7. Pragma

Pragma is short for pragmatic information. In plain English, pragmatic is an adjective that means sensible and practical. In programming, pragma refers to the code that consist of useful information on how a compiler or interpreter or assembler should process the program.

It does not contribute anything to the programming language itself and its syntax may vary. They only affect the compiler behavior. JavaScript also has few pragmas, one of them is strict.

"use strict";

By the above pragma, the JavaScript code will be executed in strict mode. In strict mode, bad syntax is not allowed, hoisting is not done, silent errors are shown, etc. It helps in writing a more secure and optimized JavaScript code.

8. Sentinel

Sentinels are soldiers who stand guard (Remember the ones from X-Men?). In programming, sentinels are values that are used to indicate the end of a loop or process. They can also be called “flags”.

You can use any reasonable value as a sentinel. Here’s an example of sentinels used in JavaScript; the indexOf method which returns -1 (the sentinel value) when the search value is not found in the targeted string. Below is a function that returns the position of an array value and if value is not found, returns -1.

function getPos(ary, val) {
 var i=0, len=ary.length; 
 for(;i<len;i++){
 if(ary[i]===val) return i+1;
 } 
 return -1;
 }
 console.log(getPos(['r','y','w'],'y')); //2
 console.log(getPos(['r','y','w'],'g')); //-1

9. Vanilla

I think everyone’s first ice cream flavor must’ve been vanilla. I also think that not only in ice cream, but in pretty much every sweet dish vanilla kind of became the standard flavor. I’ve seen quite a few cake recipes where they add at least one drop of it into the mix – just to increase the flavor.

And that’s what vanilla is, a traditional standard flavor. Vanilla JavaScript is referred to the standard JavaScript – no framework. Vanilla in fact is not only used to describe the standard version of JavaScript but also other languages like CSS.

10. Variadic

Variadic is an adjective created by joining “variable” and “adicity”. “Adicity” is from ancient Greek, with a meaning that is the same as the Latin word “arity” (Item 1 in this list). Thus, the term variadic is used to express something that has variable number of arguments.

In JavaScript, a variadic function takes in any number of arguments. It can be created using arguments property, apply method and since ES6, the spread operator. Below is an example using a spread operator.

function test(...a){
 console.log(a);
 }
 test('a','b','c',8,[56,-89]);
 //output is Array [ "a", "b", "c", 8, Array[2] ]

The post JavaScript Jargon: 10 Terms You Should Know appeared first on Hongkiat.

Reactive programming is an asynchronous programming paradigm that deals with data streams and the propagation of change.

RxSwift is a library for working with asynchronous code that presents events as streams of events with the ability to subscribe to them and allows you to apply functional programming approaches to them, which greatly simplifies working with complex sequences of asynchronous events.

Why should you use RxSwift?

RxSwift organizes work with streams of events and connections between objects.

The simplest and most obvious example is bindings: you can update the interface by simply setting a new value to a variable in the ViewModel. Thus, the interface becomes data-driven.

In addition, RxSwift allows you to describe the system in a declarative style, which simplifies the code and improves its readability. RxSwift is also constantly receiving new updates, fixing minor bugs, adding features from new Swift versions and new bindings.

And RxSwift is open source, you can keep track of all the changes.

RxSwift Basic Concepts

There are three main types of Rx code components:

• Observables,
• Operators, and
• Schedulers.

Observables

An Observable is a sequence with some special features. One of these features – and perhaps the most essential – is asynchronous.

Observables generate events over time, which is referred to as emitting. Events may include values such as numbers or instances of a custom type, or they might be recognized gestures such as taps.

Operators

The Observable class contains several helper methods that can perform various operations on the elements of the sequence.

Since they have no side effects, they can be combined, which allows you to build quite complex logic in a declarative style.

Scheduler

The scheduler allows us to run our observables on specific threads. There are two ways to set the observable scheduler: observeOn() and subscribeOn().

SubscribeOn() is responsible for which thread the entire observable process will run on until its events reach the subscriber. As you might guess, ObserveOn() deals with a thread that processes events received from subscriberOn().

With scheduler, you can easily download anything from the web on a background thread, and once you get the result, you can go to the main thread and affect the UI.

An RxSwift Example:

Now that we’ve figured out the basic concepts of the library and understood why we should use it, let’s look at one practical example.

import RxCocoa 
import UIKit
import RxSwift
class ViewController: UIViewController {
  @IBOutlet weak var countLabel: UILabel;
  @IBOutlet weak var tapButton: UIButton;
  var count = 0
  var disposeBag = DisposeBag()
  override func viewDidLoad() {
    super.viewDidLoad()
    countLabel.text = "(count)"
  tapButton.rx
    .tap
    .throttle(5.0, scheduler: MainScheduler.instance)
    .subscribe(onNext: { [weak self] in
    self?.count += 1
    self?.countLabel.text = "(self?.count ?? 0)"
    })
    .disposed(by: disposeBag)
  }
}

To simplify this example, let’s make the number on the counter increment when the button is pressed.

For this, first, you need to import the dependencies:

import RxCocoa
import RxSwift

Now let’s look at the piece of code in tapButton.rx, focusing on each line.

tapButton.rx
    .tap
    .throttle(5.0, scheduler: MainScheduler.instance)
    .subscribe(onNext: { [weak self] in
    self?.count += 1
    self?.countLabel.text = "(self?.count ?? 0)"
    })
    .disposed(by: disposeBag)
  }
}

As I mentioned above, RxCocoa provides us with the Rx family of methods that contain ready-made methods that return a ControlEvent to us.

In this case, we are interested in the tap method. We subscribe to receive events, where we pass a closure to the onNext parameter, which will be executed when each event occurs.

We are also incrementing the counter and updating the label. Since ControlEvent is essentially an infinite sequence, it will not have onError and onComplete parameters.

We should also mention DisposeBag separately. When you finish working with a sequence, you need to free memory. When we look at the source of ObservableType, we should see that the subscribe method returns an object of type Disposable.

And if you look at its protocol, it turns out that it requires a single disposal method, which, as you might guess from its name, serves this purpose. But manually deleting objects can be tedious, so you should use the DisposeBag class, and why?

If you are using a subscription and not adding it to the bag, deleting it explicitly, or otherwise completing the observable in some way, then you are likely to get a memory leak.

Therefore, to avoid this, DisposeBag should be used.

Conclusion

RxSwift is a relatively large library. If you want to familiarize yourself with all APIs, you need to read the documentation, code often, and read the source code.

A detailed study of the RxSwift documentation will not only increase your development efficiency but also deepen your understanding of the Swift language. Therefore, I can wish you all the best in your exploration of RxSwift.

The post Getting Started with RxSwift (The Basics) appeared first on Hongkiat.