DEV Community: Benjamin Rukundo

Google I/O Extended 2022 Kampala

Benjamin Rukundo — Fri, 01 Jul 2022 03:12:06 +0000

Google I/O Extended is an annual developer event that takes place in different cities around the world held by local Google Developer Groups as an extended version of the main I/O conference in San Francisco.

The Google Developer Groups in Uganda in partnership with GDSC Makerere University hosted this year's event in Kampala on 25th June at MoTIV Uganda. The event was graced by a number of junior and senior developers including designers.

Each year we expect highly technical and in-depth sessions on advancing and emerging technologies in the different branches of tech from different experts in the field and the I/O Extended event provided this and so much more.

1. Solomon Opio, the leader of GDG and Tech Community lead at The Innovation Village flagged off the event, who briefly talked about Angular and Firebase technologies that were later explained in detail by the guest speakers.

Google has added a number of exciting features and updates to its products. some of the features that stood out to me include;

Adding more remote and rural areas to the Google maps.
Have more natural conversations with Google Assistant
Introduction of lambda 2 which is an advancement to Natural Language Processing and conversational capabilities between computers and people.

We were graced by two remarkable guest speakers who provided technical details on different technologies.

2. Habib Sentongo

He talked about the state of Angular which is a web framework designed to support developers as they build scalable performance web applications where there is scaling your product as user demand increases or scaling your team to meet the growing technical needs Angular has been there for you and your teams.

Apps are now powered by the more efficient Ivy Engine which has improved type checking and error reporting, better debugging, smaller bundle sizes and more.

Getting Started with Angular has been improved through its documentation that has been made easy and simpler for developers getting started with learning the framework, API's and more useful Angular concepts. Check out the Docs Angular Documentation.

2. Phillip Kigenyi

He talked about Firebase used for building apps and games developers love has been improved strengthening its integration with Google's most popular products and making their platform work better with the most popular developer ecosystem.
Extension events which is a great way for quickly adding features to your app with little to no code and has been made more customizable including extensions for marketing and payments.

Firebase hosting helps deploy your modern web applications faster and in a modern developer preview, you can deploy your firebase powered web applications built using Next js or Angular universal with a single deploy command.

Flutter and firebase integration which has been improved by greatly reducing the number of steps it takes to get started and no longer requiring to use any platform specific Integrated Development Environments(IDE's). Check out the official Docs Firebase

Overall, the Google IO Extended 2022 event was a great and insightful experience and I look forward to more from Google come 2023.
A few pictures to highlight the event.

Feel free to connect with me on Linkedin, github and Twitter thank you.

this keyword

Benjamin Rukundo — Mon, 27 Jun 2022 18:14:22 +0000

Save post

Add Subtitle

this keyword in java [#3]

Write

Preview

Guide

Recap

In the previous articles, we discussed what Object-Oriented Programming is, objects, classes and respective constructors as well as how to access members of a class.
We also saw examples of these concepts in the previous two articles;

Today, we shall look at the "this" keyword in java and why it useful

this keyword

In java, this keyword is used to refer to the current object inside a method or also a constructor.

class Animal {
    int instanceVariable;

    Animal(int instanceVariable) {
          this.instanceVariable = instVariable;
          System.out.println("the this reference =" + this);
   }

public static void main(String[] args) {
      Animal age = new Animal(7);
      System.out.println("the object reference =" + age);
       }
}

Output:

the this reference = Animal@78gd345f
the object reference = Animal@78gd345f

This example above, the object we created named age of the class Animal and once we print the reference to the object and this keyword of the class.
In this, we see that the reference of both age and this is the same meaning this is nothing but the reference to the current object.

Use of the this keyword

1. Ambiguity variable names

Not only in Java but also other programming languages, it is not allowed to declare two or more variables having the same name inside a scope that is class or method. But however instance variables and parameters may have the same name without using the "this" keyword.

class Exam {
    // instance variable
    int tm;

    // parameter
    Exam(int tm){
              tm =  tm;
    }

     public static void main(String[] args) {
               Exam examOne = new Exam(3);
               System.out.println("examOne.tm = " examOne.tm);
    }
}

Output:

examOne.tm = 0

In this example above, we have passed 3 to the constructor but we are getting 0 as an output and this is because the Java compiler is getting confused because of the ambiguity in names between instance the variable and the parameter.

Rewriting the above code with the this keyword.

class Exam {

    int tm;
    Exam(int tm){
        this.tm = tm;
    }

    public static void main(String[] args) {
        Exam oj = new Exam(3);
        System.out.println("oj.tm = " + oj.tm);
    }
}

Output:

oj.tm = 3

In this case above, we are getting the expected output. This is because when the constructor is called, this inside the constructor is replaced by the object oj that has called the constructor. Hence the tm variable is assigned value 3.

Also, if the name of the parameter and instance variable is different, the compiler will automatically append the this keyword. For example the code below:

class Exam {
    int size;

    Exam(int p) {
        size = p;
    }
}

is equivalent to:

class Exam {
    int size;

    Exam(int p) {
        this.size = p;
    }
}

This with Getters and Setters

Another common use of this keyword is in setters and getters methods of a class. For example:

class Main {
   String name;

   // setter method
   void setName( String name ) {
       this.name = name;
   }

   // getter method
   String getName(){
       return this.name;
   }

   public static void main( String[] args ) {
       Main obj = new Main();

       // calling the setter and the getter method
       obj.setName("Toshiba");
       System.out.println("obj.name: "+obj.getName());
   }
}

Output:

obj.name: Toshiba

Here, we have used this keyword:

to assign value inside the setter method
to access value inside the getter method

One of the huge advantages of this() is to reduce the amount of duplicate code. However, we should be always careful while using this().

This is because calling constructor from another constructor adds overhead and it is a slow process. Another huge advantage of using this() is to reduce the amount of duplicate code.

Note: Invoking one constructor from another constructor is called explicit constructor invocation.

Passing this as an Argument

We can use this keyword to pass the current object as an argument to a method. For example,

class ThisExample {
    // declare variables
    int x;
    int y;

    ThisExample(int x, int y) {
       // assign values of variables inside constructor
        this.x = x;
        this.y = y;

        // value of x and y before calling add()
        System.out.println("Before passing this to addTwo() method:");
        System.out.println("x = " + this.x + ", y = " + this.y);

        // call the add() method passing this as argument
        add(this);

        // value of x and y after calling add()
        System.out.println("After passing this to addTwo() method:");
        System.out.println("x = " + this.x + ", y = " + this.y);
    }

    void add(ThisExample o){
        o.x += 2;
        o.y += 2;
    }
}

class Main {
    public static void main( String[] args ) {
        ThisExample obj = new ThisExample(1, -2);
    }
}

Output:

Before passing this to addTwo() method:
x = 1, y = -2
After passing this to addTwo() method:
x = 3, y = 0

In the above example, inside the constructor ThisExample(), notice the line,

add(this);

Here, we are calling the add() method by passing this as an argument. Since this keyword contains the reference to the object obj of the class, we can change the value of x and y inside the add() method.

For a further and more deep explanation about Object Oriented Programming, check out this wonderful playlist.
Object Oriented Programming in Java by Kunal Kushwaha.

Feel free to connect with me on Linkedin, github and Twitter thank you.

Java and Object Oriented Programming [#2]

Benjamin Rukundo — Mon, 20 Jun 2022 09:09:51 +0000

Recap

In the previous article, we discussed Object-Oriented Programming, objects, and classes, as well as how to access members of a class. We also saw examples of these concepts in the first article. Check out that article #1

In today's article, we are going to look at Constructors, their types and how to use them. This will be backed by examples.

What is a Constructor?

A constructor in Java is similar to a method that is invoked when an object of the class is created.

Specifically, a constructor has the same name as that of the class and does not have any return type.
Why constructors don't have return types.

An example to demonstrate this;

class Exam {
    Exam() {
       // Constructor body
   }
}

In this case, the Exam() is the constructor and it has the same name as that of the class and no return type.

NB: By default, there is a constructor when a class is created.

class Exam {
  private String name;

  // constructor
  Exam() {
    System.out.println("The constructor is called:");
    type = "Computer";
  }

  public static void main(String[] args) {

    // constructor is invoked while
    // creating an object of the Main class
    Exam obj = new Exam();
    System.out.println("The type is " + obj.type);
  }
}

Output:

The constructor is called:
The type is Computer

In the above demonstration, the constructor we created is Exam() and inside it we are initializing the value of the type variable.
Take note of the creation an object for the Exam class

Exam obj = new Exam();

The value of the type variable is initialized and the program prints the value of the type variables as Computer.

Types of Constructors

There are three types of Constructors:

1. Java No-Arg Constructors

A Java constructor, like methods, may or may not contain any parameters (arguments).

A constructor is known as a no-argument constructor if it does not accept any parameters.

Example 1:

Constructor() {
    // body of the constructor
}

Example 2:

class Exam {

  int i;

  // constructor with no parameter
  private Exam() {
    i = 5;
    System.out.println("Constructor is called");
  }

  public static void main(String[] args) {

    // calling the constructor without any parameter
    Exam obj = new Exam();
    System.out.println("Value of i: " + obj.i);
  }
}

Output:

Constructor is called
Value of i: 5

In the above example, we have created a constructor Exam().
The constructor is referred to as a no-arg constructor because it does not accept any parameters.

It's also worth noting that the constructor has been declared private, meaning it can't be accessed from outside the class. Therefore creating objects from outside the class is prohibited using the private constructor.

2. Parameterized Constructor

A Java constructor can also accept one or more parameters. Such constructors are known as parameterized constructors
Example:

class Exam {

  String languages;

  // constructor accepting single value
  Exam(String lang) {
    languages = lang;
    System.out.println(languages + " Programming Language");
  }

  public static void main(String[] args) {

    // call constructor by passing a single value
    Exam obj1 = new Exam("Java");
    Exam obj2 = new Exam("Python");
    Exam obj3 = new Exam("C");
  }
}

Output:

Java Programming Language
Python Programming Language
C Programming Language

In this case, the constructor named Main() takes a single parameter.
Therefore the expression passes a single value to the constructor

Exam obj1 = new Exam("Java");

3. Java Default Constructor

When we don't create a constructor, the Java compiler automatically creates a no-arg constructor during the execution of the program, thus the default constructor.

class Exam {

  int a;
  boolean b;

  public static void main(String[] args) {

    // A default constructor is called
    Exam obj = new Exam();

    System.out.println("Default Value:");
    System.out.println("a = " + obj.a);
    System.out.println("b = " + obj.b);
  }
}

Output:

a = 0
b = false

In this case, we haven't created any constructors. As a result, the java compiler creates the default constructor.

Java Constructor Overloading

class Exam {

  String language;

  // constructor with no parameter
  Exam() {
    this.language = "Java";
  }

  // constructor with a single parameter
  Exam(String language) {
    this.language = language;
  }

  public void getName() {
    System.out.println("Programming Langauage: " + this.language);
  }

  public static void main(String[] args) {

    // call constructor with no parameter
    Exam obj1 = new Exam();

    // call constructor with a single parameter
    Exam obj2 = new Exam("Python");

      obj1.getName();
      obj2.getName();
  }
}

Output:

Programming Language: Java
Programming Language: Python

In this case, we have two constructors in these examples: Exam() and Exam(String language). Here both the constructor initialize the value of the variable language with different values.

NB: We have used this keyword to specify the variable of the class. Read more about this keyword.

For a further and more deep explanation about Object Oriented Programming, check out this wonderful playlist.
Object Oriented Programming in Java by Kunal Kushwaha.

Feel free to connect with me on Linkedin, github and Twitter thank you.

Java and Object Oriented Programming [#1]

Benjamin Rukundo — Mon, 13 Jun 2022 03:49:10 +0000

What is Object Oriented Programming(OOP)?

This is a programming paradigm based on the concept of objects, which can contain data and code which data is in the form of fields also known as attributes or properties and code in the form of procedures also known as methods.

Many of the most widely used programming languages such as C++, Javascript and Python namely but a few implement Object Oriented Programming other than Java.

What are Objects?

Objects are always called instances of a class and has a state and behavior. For example, a dog is an object that has

State: name, breed, color etc
Behaviors: barking, running, sleeping etc

Class

A class in java is a blueprint for the object and before we create an object we first need to define the class.

Think of the class a sketch(prototype) of a house and it contains all details about the windows, floors, doors and the others. Based on these descriptions we build the house and therefor the House is the object.

NB: Many different houses can be made based on the same description of the class.

Creating a class in Java

We can create a class in Java using the class keyword. Such as

class className {
    // fields
    // nethods
}

In this, the fields and methods represent the state and behavior of the object respectively.

fields are used to store data
methods are used to perform some operations

Our car object we can create the class

class Car {
    // state or field
    String name;
    int manufacturer;
    String color;

    // behavior or method
    void braking() {
        System.out.println("Car is braking");
   }

   void speeding() {
        System.out.println("Car is speeding");
   }
}

In the above example, we have created a class named Car which has fields name, manufacturer, color and methods braking(), speeding().
Car is a prototype and now we can create any number of cars using the prototype. All the bicycles will share the fields and methods of the prototype.

Java Objects

An object is an instance of a class. Our class we created called Car then sportsCar, suvCar and f1Car can be considered as the objects of that class.

Creating an Object in Java

This is how an object of a class is created in java

className objectName = new className();

// for Car class
Car sportsCar = new Car();

Car suvCar = new Car();

// sportsCar and suvCar are the names of the objects.

Let's observe the use of the new keyword along with the constructor of the class to create an object. Constructors are almost the same as methods and use the same name as the class only that it doesn't have a return type. for example;

class Car {
    Car() {
    // constructor body
 }
}

// Car() is a constructor and doesn't have a return type

Access Members of a class

The name of the object is along with . (the dot operator) we can be able to access the members of a class. For example;

class Car {
    // state or field
    String name;
    int manufacturer;
    String color;

    // behavior or method
    void braking() {
        System.out.println("Car is braking");
   }

   void speeding() {
        System.out.println("Car is speeding");
   }
}

// create object named suvCar
Car suvCar = new Car();

// access fields
suvCar.name;
suvCar.maufacturer;

// access methods
suvCar.speeding();

Here you can be able to access the fields and methods of this class.

We are now able to understand what a class is and an object. Let's look at a fully working example;

class Lamp {

  // stores the value for light
  // true if light is on
  // false if light is off
  boolean isOn;

  // method to turn on the light
  void turnOn() {
    isOn = true;
    System.out.println("Light on? " + isOn);

  }

  // method to turnoff the light
  void turnOff() {
    isOn = false;
    System.out.println("Light on? " + isOn);
  }
}

class Main {
  public static void main(String[] args) {

    // create objects led and halogen
    Lamp led = new Lamp();
    Lamp halogen = new Lamp();

    // turn on the light by
    // calling method turnOn()
    led.turnOn();

    // turn off the light by
    // calling method turnOff()
    halogen.turnOff();
  }
}

Output:

Light on? true
Light on? false

In our next part we are going to look at methods, overloading and constructors.
Later we shall look into concepts like abstraction, encapsulation, inheritance and polymorphism.

For a further and more deep explanation about Object Oriented Programming, check out this wonderful playlist.
Object Oriented Programming in Java by Kunal Kushwaha.

Feel free to connect with me on Linkedin, github and Twitter thank you.

Binary Search

Benjamin Rukundo — Mon, 06 Jun 2022 03:09:48 +0000

As we saw previously, we looked at the linear search and how it is able to find a target element by iterating over each and every element in the array
Well, binary search is the second most fundamental search algorithm after linear search.

NB: While in linear search we have to find each element from an array by checking each and every element of this array. This means we have to continue iterating over every element until we find the element we are searching for or until we have reached the dead-end of the array.

Algorithm:

    arr = [2, 4, 6, 9, 11, 12, 14, 20, 36, 48] (Sorted array)
    target = 36
1. Find the middle element
2. Check:
    If target > middle => search in right else => search in left
3. if target == middle => we found element

Example:

Here, the space in which we are searching is getting divided into spaces.

Time complexity:

Best case: O(1)
Worst case: O(logn)

Explanation: find the maximum number of comparisons

=> Order agnostic Binary search

Let's say if we don't know that the array is sorted in ascending or descending order.

arr = [90, 75, 18, 12, 6, 4, 3, 1]
target = 75

Here, target > middle => search in left

Here, start > end -> Descending order
90 > 1
when start < end -> Ascending order

For further explanation about Binary search algorithm, kindly check out this wonderful toturial.
Binary Search in Java by Kunal Kushwaha

Feel free to connect with me on github and Linkedin, thank you.

Linear Search

Benjamin Rukundo — Mon, 30 May 2022 06:18:34 +0000

Searching
In programming it is a process of finding a given value position in a list of values. In our daily life it plays such an important role this can be finding something from a collection of data, you may need to find a word from a dictionary or find your friend from the crowd.

Linear/Sequential search

It is the basic simple search algorithm
In sequential search, we compare the target value with all the other elements given in the list. for example arr = {18, 12, 19, 77, 29, 50} (unsorted array) target = 77

In the above example, the target value is compared with all the elements in the array in sequential/linear way.

Time Complexity:

Best Case: O(1) -> constant

How many checks will the loop make in the best case i.e the element will be found at the 0th index that is only one comparison will be made for best case.

Worst Case: O(n)

 Worst case, here it will go through every element and then it says element not found

public class Main {

    public static void main(String[] args) {
        int[] nums = {23, 45, 1, 2, 8, 19, -3, 16, -11, 28};
        int target = 19;
        int ans = linearSearch(nums, target);
        System.out.println(ans);
    }
     // search in the array: return the index if item found
    // otherwise if item not found return -1
    static int linearSearch(int[] arr, int target) {
        if (arr.length == 0) {
            return -1;
        }

        // run a for loop
        for (int index = 0; index < arr.length; index++) {
            // check for element at every index if it is = target
            int element = arr[index];
            if (element == target) {
                return index;
            }
        }
        // this line will execute if none of the return statements above have executed
        // hence the target not found
        return -1;
    }

}

Solved my first leetcode question with linear search check it out Even number of digits
For further explanation about linear search algorithm, kindly check out this wonderful toturial
Linear Search in Java by Kunal Kushwaha

Feel free to connect with me on github and Linkedin, thank you.

Cooking up something

Benjamin Rukundo — Mon, 02 May 2022 10:00:50 +0000

Hello there, been off for a while without posting articles of late got a little fixed here and there but also been cooking up something too.
Happy new month to you.

Functions/Methods in Java

Benjamin Rukundo — Mon, 13 Dec 2021 01:31:41 +0000

What are java functions/methods?

A function is a block of code which only runs when it is called.

To reuse code: define the once and use it many times

General Syntax:

public class Main {
    static void nameOfMethod() {
    // code
  }
}

public class Main{
    access-modifier return-type method() {
     // code
     return statement;
  }
}

method() - name of calling function
return-type - A statement that causes the program control to transfer back to the caller of a method.
A return type may be a primitive type like int, flaot or void type(returns nothing)

Note: These are the few important things to understand about returning the values;

The type of data returned by a method must be compatible with the return type specified by the method for example if return type of some method is boolean, we can not return an integer

The variable receiving the value returned by a method must also be compatible with the return type specified for the method.

=> Pass by value:
example 1:

main() {
   name = a 
   greet(name);
}
static void greet(naam) {
    print(naam);
}

primitive data type like int, short, char, byte etc.(just pass value)

object of reference: passing value of reference variable

example1:

psvm() {
    a = 10;
    b =20;
    swap(a, b);
}
swap(num1, num2) {
    temp = num1;
    num1 = num2;
    num2 = temp;
}

Scopes:

function scope: Variables declared inside a method/function scope(means inside the method) can't be accessed outside the method.
block scope: Variables initialized outside the block can be updated inside the block
loop scope: Variables declared inside loop are having loop scope.
shadowing: Shadowing is the practice in Java is the practice of using variables in overlapping scopes with the same name where the variable in low-level scope overrides the variable of high-level scope.
Method/Function overloading: This happens when two functions have the same name.
This is allowed having different arguments with same method name.

For a more detailed introduction to java programming, I would surely encourage you to check out this wonderful toturial
Functions/Methods in Java by Kunal Kushwaha

Feel free to connect with me on github and Linkedin, thank you.

Java Switch Statements

Benjamin Rukundo — Tue, 12 Oct 2021 20:02:45 +0000

What are java statements?

Use the switch statement to select one of many code blocks to be executed.

Syntax:

switch(expression) {
  case x:
    // code block
    break;
  case y:
    // code block
    break;
  default:
    // code block
}

How does it work?

The switch expression is evaluated once.
The value of the expression is compared with the values of each case.
If there is a match, the associated block of code is executed.
The break and default keywords are optional, and will be described later in this chapter

The example below uses the weekday number to calculate the weekday name:

Example:

int day = 4;
switch (day) {
  case 1:
    System.out.println("Monday");
    break;
  case 2:
    System.out.println("Tuesday");
    break;
  case 3:
    System.out.println("Wednesday");
    break;
  case 4:
    System.out.println("Thursday");
    break;
  case 5:
    System.out.println("Friday");
    break;
  case 6:
    System.out.println("Saturday");
    break;
  case 7:
    System.out.println("Sunday");
    break;
}
// Outputs "Thursday" (day 4)

The break Keyword

When Java reaches a break keyword, it breaks out of the switch block.

This will stop the execution of more code and case testing inside the block.

When a match is found, and the job is done, it's time for a break. There is no need for more testing.

A break can save a lot of execution time because it "ignores" the execution of all the rest of the code in the switch block.

The default Keyword

The default keyword specifies some code to run if there is no case match:

Example:

int day = 4;
switch (day) {
  case 6:
    System.out.println("Today is Saturday");
    break;
  case 7:
    System.out.println("Today is Sunday");
    break;
  default:
    System.out.println("Looking forward to the Weekend");
}
// Outputs "Looking forward to the Weekend"

Note that if the default statement is used as the last statement in a switch block, it does not need a break.

For a more detailed introduction to java programming, I would surely encourage you to check out this wonderful toturial
Switch Statements + Nested Case in Java by Kunal Kushwaha

Feel free to connect with me on github and Linkedin, thank you.

Introduction to Control Flow in Java

Benjamin Rukundo — Thu, 07 Oct 2021 03:35:31 +0000

What is Control Flow?

A program's control flow is the order in which the program's code executes thus the use of control flow in a Java program being crucial.
The control flow in a Java program is regulated by conditional statements and loops.

Java supports the usual logical conditions from mathematics:

Less than: a < b
Less than or equal to: a <= b
Greater than: a > b
Greater than or equal to: a >= b
Equal to a == b
Not Equal to: a != b You can use these conditions to perform different actions for different decisions.

Java has the following conditional statements:

Use if to specify a block of code to be executed, if a specified condition is true
Use else to specify a block of code to be executed, if the same condition is false
Use else if to specify a new condition to test, if the first condition is false
Use switch to specify many alternative blocks of code to be executed

The if Statement

Use the if statement to specify a block of Java code to be executed if a condition is true.

Syntax:

if (condition) {
  // block of code to be executed if the condition is true
}

Note that if is in lowercase letters. Uppercase letters (If or IF) will generate an error.

In the example below, we test two values to find out if 20 is greater than 18. If the condition is true, print some text:

Example:

if (20 > 18) {
  System.out.println("20 is greater than 18");
}

We can also test variables:

Example:

int x = 20;
int y = 18;
if (x > y) {
  System.out.println("x is greater than y");
}

The else Statement

Use the else statement to specify a block of code to be executed if the condition is false.

Syntax:

if (condition) {
  // block of code to be executed if the condition is true
} else {
  // block of code to be executed if the condition is false
}

Example:

int time = 20;
if (time < 18) {
  System.out.println("Good day.");
} else {
  System.out.println("Good evening.");
}
// Outputs "Good evening."

The else if Statement

Use the else if statement to specify a new condition if the first condition is false.

Syntax:

if (condition1) {
  // block of code to be executed if condition1 is true
} else if (condition2) {
  // block of code to be executed if the condition1 is false and condition2 is true
} else {
  // block of code to be executed if the condition1 is false and condition2 is false
}

Example:

int time = 22;
if (time < 10) {
  System.out.println("Good morning.");
} else if (time < 20) {
  System.out.println("Good day.");
} else {
  System.out.println("Good evening.");
}
// Outputs "Good evening."

Short Hand If...Else (Ternary Operator):

There is also a short-hand if else, which is known as the ternary operator because it consists of three operands.
It can be used to replace multiple lines of code with a single line. It is often used to replace simple if else statements:

Syntax:

variable = (condition) ? expressionTrue :  expressionFalse;

Instead of writing:

Example:

int time = 20;
if (time < 18) {
  System.out.println("Good day.");
} else {
  System.out.println("Good evening.");
}

You can simply write:

Example:

int time = 20;
String result = (time < 18) ? "Good day." : "Good evening.";
System.out.println(result);

For a more detailed introduction to java programming, I would surely encourage you to check out this wonderful toturial Conditionals and Loops + Calculator Program by Kunal Kushwaha

Feel free to connect with me on github and linkedin, thank you.

Splendid week to you'll

Introduction to Java

Benjamin Rukundo — Sat, 02 Oct 2021 02:05:10 +0000

What is Java?

Java is a popular programming language, created in 1995.

It is owned by Oracle, and more than 3 billion devices run Java.

It is used for:

Mobile applications (specially Android apps)
Desktop applications
Web applications
Web servers and application servers
Games
Database connection and much more

Why Use Java?

Java works on different platforms (Windows, Mac, Linux, Raspberry Pi, etc.) and thus platform independent.

It is one of the most popular programming language in the world
It is easy to learn and simple to use
It is open-source and free
It is secure, fast and powerful
It has a huge community support (tens of millions of developers)
Java is an object oriented language which gives a clear structure to programs and allows code to be reused, lowering development costs
As Java is close to C++ and C#, it makes it easy for programmers to switch to Java or vice versa

How to get started

I would surely advice you to first downloading the Java Development Kit(jdk) from the official Oracle website here dependent on your system whether linux, Macos or Windows.

Next, I would download an Integrated Development Environment(IDE). They are a tone of IDE's out there but I would surely recommend Intellij IDE made by JetBrains due to a number of reasons here and there, you can download the Intellij community edition from here.

A quick hello world program

// a small Java program
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

For a more detailed introduction to java programming, I would surely encourage you to check out this wonderful Introduction to Java - Architecture & Installation by kunal kushwaha

Feel free to connect with me on github and linkedin, thank you.

Happy new month to all of you!

Getting started with open source ~ Git and Github

Benjamin Rukundo — Fri, 24 Sep 2021 22:13:21 +0000

What is open source?

Open source software is software with source code that anyone can inspect, modify, and enhance.

"Source code" is the part of software that most computer users don't ever see; it's the code computer programmers can manipulate to change how a piece of software—a "program" or "application"—works. Programmers who have access to a computer program's source code can improve that program by adding features to it or fixing parts that don't always work correctly

Making your first contribution

Being able to make your first contribution might seem overwhelming but with these few steps am sure you'll properly get the hang of what exactly to do.

How to contribute?

1.Fork the project

2.Make any changes in your forked repo

3.On this repo, click Pull Requests and raise a Pull Request selecting your fork on the right drop down

Questions can be asked by raising an Issue.

How to clone repo and make changes locally?

Click on the clone button (green in color). This gives you a copy
of the project. It's now yours to play around with.
Using Git on your local machine. Do this to download the forked copy of this repo to your computer.

  git clone https://github.com/yourGithubUsername/nameOfProject.git

switch to the cloned folder. This can be done with Gitbash or the integrated terminal in the VSCode editor.

cd nameOfProject

Make a new branch. Your name would make a good branch because it's unique.

 git checkout -b <name of new branch>

Open the file that needs to be contributed to an example the README.md file
Make the necessary changes needed to be made lets take an instance of adding your name to the README.md file and next to it add the link to your github username page.

For example, -

Full Name https://github.com/your-username

Stage your changes

 git add README.md

  git add .

Commit the changes.

 git commit -m "Add <your-github-username>"

Check the status of your repository.

git status

Pushing your repository to GitHub.

 git push origin <name of your branch>

 git branch -M main
 git push -u origin main

Navigate to your fork, on the top of the files section you'll notice a new section containing, a contribute button!
Click on the contribute button, it will open a drop down, click the pull request button on the drop down.
Note: A pull request allows your changes to be merged with the original project.
Wait for your changes to be merged.

Hurray! You successfully made a contribution! 🎉

And with surely these steps above and different alternatives, you can surely be able to make your first contribution. Happy Contributing indeed.

For more resources and information about contributing to open source using git and github, checkout this toturial Git and Github by Kunal Kushwaha

Feel free to connect with me on github and LinkedIn, thank you.