DEV Community: Mahadev K

Building a Robust Task Execution Context in Go

Mahadev K — Sun, 29 Dec 2024 08:54:48 +0000

This might be my last take on error handling in go. I think this is the best one as well. We know every instruction that we execute is in a context. And the context can have errors. This is when I thought why not simply make a wrapper on top of the current context. So, all the task if executed via a specific fn then we could possibly check if the ctx has error and if so dont execute else execute and collect the error. This might become an anti-pattern but yeah until it becomes, we can try playing around.

Well cursor had few things to add ->

The Problem

The main challenge is this consider you need to call 4 functions from your current one then there needs to be 4 error handling blocks.
the same old if err != nil {return nil, err}
So if we have a context which saves the previous functions errors and passing down the context to a wrapper which checks the context errors before the actual fn execution will help in robust error handling.
Now you only have one error check for 4 function calls which is at the end where you check if taskCtx.Err() != nil {return nil, err}

The Solution: TaskContext

Let's build a TaskContext that solves these problems:

package taskctx

import (
    "context"
    "errors"
    "fmt"
    "sync"
)

type RunFn[T any] func() (T, error)

type TaskContext struct {
    context.Context
    mu       sync.RWMutex
    err      error
    multiErr []error
}

func NewTaskContext(parent context.Context) *TaskContext {
    if parent == nil {
        panic("cannot create context from nil parent")
    }
    return &TaskContext{Context: parent}
}

Key Features

1. Thread-Safe Error Handling

func (c *TaskContext) WithError(err error) *TaskContext {
    if err == nil {
        return c
    }

    c.mu.Lock()
    defer c.mu.Unlock()

    c.multiErr = append(c.multiErr, err)
    if c.err == nil {
        c.err = err
    } else {
        c.err = errors.Join(c.err, err)
    }
    return c
}

2. Single Task Execution

func Run[T any](ctx *TaskContext, fn RunFn[T]) T {
    var zero T
    if err := ctx.Err(); err != nil {
        return zero
    }

    result, err := fn()
    if err != nil {
        ctx.WithError(err)
        return zero
    }
    return result
}

3. Parallel Task Execution

func RunParallel[T any](ctx *TaskContext, fns ...func() (T, error)) ([]T, error) {
    if err := ctx.Err(); err != nil {
        return nil, err
    }

    results := make([]T, len(fns))
    var resultsMu sync.Mutex
    var wg sync.WaitGroup
    wg.Add(len(fns))

    for i, fn := range fns {
        i, fn := i, fn
        go func() {
            defer wg.Done()
            result, err := fn()
            if err != nil {
                ctx.AddError(fmt.Errorf("task %d: %w", i+1, err))
            } else {
                resultsMu.Lock()
                results[i] = result
                resultsMu.Unlock()
            }
        }()
    }

    wg.Wait()
    return results, ctx.Errors()
}

4. Controlled Concurrency

func RunParallelWithLimit[T any](ctx *TaskContext, limit int, fns ...func() (T, error)) ([]T, error) {
    // ... similar to RunParallel but with semaphore ...
    sem := make(chan struct{}, limit)
    // ... implementation ...
}

Usage Examples

Simple Task Execution

func ExampleTaskContext_ShipmentProcessing() {
    ctx := goctx.NewTaskContext(context.Background())

    order := dummyOrder()
    shipment := dummyShipment()

    // Step 1: Validate address
    // Step 2: Calculate shipping cost
    // Step 3: Generate label
    _ = goctx.Run(ctx, validateAddress("123 Main St"))
    cost := goctx.Run(ctx, calculateShipping(order))
    trackingNum := goctx.Run(ctx, generateLabel(shipment.OrderID, cost))

    if ctx.Err() != nil {
        fmt.Printf("Error: %v\n", ctx.Err())
        return
    }

    shipment.Status = "READY"
    shipment.TrackingNum = trackingNum
    fmt.Printf("Shipment processed: %+v\n", shipment)

    // Output:
    // Shipment processed: {OrderID:ORD123 Status:READY TrackingNum:TRACK-ORD123-1234567890}
}

Parallel Task Execution

func ExampleTaskContext_OrderProcessing() {
    ctx := goctx.NewTaskContext(context.Background())

    // Mock order
    order := []OrderItem{
        {ProductID: "LAPTOP", Quantity: 2},
        {ProductID: "MOUSE", Quantity: 3},
    }

    taskCtx := goctx.NewTaskContext(ctx)

    // Create inventory checks for each item
    inventoryChecks := goctx.Run[[]goctx.RunFn[bool]](taskCtx,
        func() ([]goctx.RunFn[bool], error) {
            return streams.NewTransformer[OrderItem, goctx.RunFn[bool]](order).
                Transform(streams.MapItSimple(checkInventory)).
                Result()
        })

    // Run inventory checks in parallel
    _, err := goctx.RunParallel(ctx, inventoryChecks...)
    fmt.Printf("Inventory check error: %v\n", err)

    // Output:
    // Inventory check error: task 1: insufficient inventory for LAPTOP
}

Benefits

Thread Safety: All operations are protected by mutexes
Error Collection: Maintains both first error and all errors
Context Integration: Works with Go's context package
Generic Support: Works with any return type
Concurrency Control: Built-in support for limiting parallel executions

Testing

Here's how to test the implementation:

func TestTaskContext(t *testing.T) {
    t.Run("handles parallel errors", func(t *testing.T) {
        ctx := NewTaskContext(context.Background())
        _, err := RunParallel(ctx,
            func() (int, error) { return 0, errors.New("error 1") },
            func() (int, error) { return 0, errors.New("error 2") },
        )
        assert.Error(t, err)
        assert.Contains(t, err.Error(), "error 1")
        assert.Contains(t, err.Error(), "error 2")
    })
}

Conclusion

This TaskContext implementation provides a robust solution for handling concurrent task execution with proper error handling in Go. It's particularly useful when you need to:

Execute multiple tasks concurrently
Collect errors from all tasks
Limit concurrent executions
Maintain thread safety
Keep track of the first error while collecting all errors

The complete code is available on GitHub.

Resources

What patterns do you use for handling concurrent task execution in Go? Share your thoughts in the comments below!

Building Robust SQL Transaction Execution in Go with a Generic Framework

Mahadev K — Thu, 05 Dec 2024 09:18:28 +0000

When working with SQL databases in Go, ensuring atomicity and managing rollbacks during multi-step transactions can be challenging. In this article, I'll guide you through creating a robust, reusable, and testable framework for executing SQL transactions in Go, using generics for flexibility.

We'll build a SqlWriteExec utility for executing multiple dependent database operations within a transaction. It supports both stateless and stateful operations, enabling sophisticated workflows like inserting related entities while managing dependencies seamlessly.

Why Do We Need a Framework for SQL Transactions?

In real-world applications, database operations are rarely isolated. Consider these scenarios:

Inserting a user and updating their inventory atomically.
Creating an order and processing its payment, ensuring consistency.
With multiple steps involved, managing rollbacks during failures becomes crucial to ensure data integrity.

Working with go in Txn management.

If you are writing a database txn there might be several boiler plates that you might need to consider before writing the core logic. While this txn management is managed by spring boot in java and you never bothered much on those while writing code in java but this is not the case in golang. A simple example is provided below

func basicTxn(db *sql.DB) error {
    // start a transaction
    tx, err := db.Begin()
    if err != nil {
        return err
    }
    defer func() {
        if r := recover(); r != nil {
            tx.Rollback()
        } else if err != nil {
            tx.Rollback()
        } else {
            tx.Commit()
        }
    }()

    // insert data into the orders table
    _, err = tx.Exec("INSERT INTO orders (id, customer_name, order_date) VALUES (1, 'John Doe', '2022-01-01')")
    if err != nil {
        return err
    }
    return nil
}

We cannot expect to repeat the rollback/commit code for every function. We have two options here either create a class which will provide a function as a return type which when executed in the defer will commit/rollback txn or create a wrapper class which will wrap all txn funcs together and execute in one go.

I went with the later choice and the change in code can be seen below.

func TestSqlWriteExec_CreateOrderTxn(t *testing.T) {

    db := setupDatabase()
    // create a new SQL Write Executor
    err := dbutils.NewSqlTxnExec[OrderRequest, OrderProcessingResponse](context.TODO(), db, nil, &OrderRequest{CustomerName: "CustomerA", ProductID: 1, Quantity: 10}).
        StatefulExec(InsertOrder).
        StatefulExec(UpdateInventory).
        StatefulExec(InsertShipment).
        Commit()
    // check if the transaction was committed successfully
    if err != nil {
        t.Fatal(err)
        return
    }
    verifyTransactionSuccessful(t, db)
    t.Cleanup(
        func() { 
            cleanup(db)
            db.Close() 
        },
    )
}

func InsertOrder(ctx context.Context, txn *sql.Tx, order *OrderRequest, orderProcessing *OrderProcessingResponse) error {
    // Insert Order
    result, err := txn.Exec("INSERT INTO orders (customer_name, product_id, quantity) VALUES ($1, $2, $3)", order.CustomerName, order.ProductID, order.Quantity)
    if err != nil {
        return err
    }
    // Get the inserted Order ID
    orderProcessing.OrderID, err = result.LastInsertId()
    return err
}

func UpdateInventory(ctx context.Context, txn *sql.Tx, order *OrderRequest, orderProcessing *OrderProcessingResponse) error {
    // Update Inventory if it exists and the quantity is greater than the quantity check if it exists
    result, err := txn.Exec("UPDATE inventory SET product_quantity = product_quantity - $1 WHERE id = $2 AND product_quantity >= $1", order.Quantity, order.ProductID)
    if err != nil {
        return err
    }
    // Get the number of rows affected
    rowsAffected, err := result.RowsAffected()
    if rowsAffected == 0 {
        return errors.New("Insufficient inventory")
    }
    return err
}

func InsertShipment(ctx context.Context, txn *sql.Tx, order *OrderRequest, orderProcessing *OrderProcessingResponse) error {
    // Insert Shipment
    result, err := txn.Exec("INSERT INTO shipping_info (customer_name, shipping_address) VALUES ($1, 'Shipping Address')", order.CustomerName)
    if err != nil {
        return err
    }
    // Get the inserted Shipping ID
    orderProcessing.ShippingID, err = result.LastInsertId()
    return err
}

This code will be very much more precise and concise.

How the core logic is implemented

The idea is to isolate the txn to a single go struct such that it can accept multiple txns. By txn I mean functions which will do action with the txn that we created for the class.

type TxnFn[T any] func(ctx context.Context, txn *sql.Tx, processingReq *T) error
type StatefulTxnFn[T any, R any] func(ctx context.Context, txn *sql.Tx, processingReq *T, processedRes *R) error

These two are function types which will take in a txn to process something. Now in the data layer implementing a create a function like this and pass it to the executor class which takes care of injecting the args and executing the function.

// SQL Write Executor is responsible when executing write operations
// For dependent writes you may need to add the dependent data to processReq and proceed to the next function call
type SqlTxnExec[T any, R any] struct {
    db               *sql.DB
    txn              *sql.Tx
    txnFns         []TxnFn[T]
    statefulTxnFns []StatefulTxnFn[T, R]
    processingReq    *T
    processedRes     *R
    ctx              context.Context
    err              error
}

This is where we store all the txn_fn details and we will have Commit() method to try committing the txn.

func (s *SqlTxnExec[T, R]) Commit() (err error) {
    defer func() {
        if p := recover(); p != nil {
            s.txn.Rollback()
            panic(p)
        } else if err != nil {
            err = errors.Join(err, s.txn.Rollback())
        } else {
            err = errors.Join(err, s.txn.Commit())
        }
        return
    }()

    for _, writeFn := range s.txnFns {
        if err = writeFn(s.ctx, s.txn, s.processingReq); err != nil {
            return
        }
    }

    for _, statefulWriteFn := range s.statefulTxnFns {
        if err = statefulWriteFn(s.ctx, s.txn, s.processingReq, s.processedRes); err != nil {
            return
        }
    }
    return
}

You can find more examples and tests in the repo -
https://github.com/mahadev-k/go-utils/tree/main/examples

Though we bias towards distributed systems and consensus protocol nowadays, we still use sql and it still exists.

Let me know if anyone wish to contribute and build on top of this!!
Thanks for reading this far!!
https://in.linkedin.com/in/mahadev-k-934520223
https://x.com/mahadev_k_

Go Transformers

Mahadev K — Tue, 12 Nov 2024 17:50:05 +0000

Go-Utils

go-utils is a library that is aimed provide useful libraries in go to reduce the developer efforts on building stuffs and increasing
productivity.

Few functionalities are mentioned below.

Task Runner

The basic problem that this is trying to solve is how you want to run multiple tasks based on a request that you recieved.
Consider the following scenario.

processA processes one scenario and can produce error.
processB processes second scenario and can produce error.

As you can see all these process can result in an error. Inherently Golang is very verbose in error handling. Sometimes we don't want to see that redundant code.
Also this reduces the readability.

Now consider another scenario -
Once you handle the error for processA and you forgot for processB Golang wont throw a compile time error causing you to miss this case. A small miss can cause havoc. Though we are supposed to follow a lot of process before shipping to prod ask yourselves do you follow always or not?

To solve this I have developed an approach where you will be
more focussed on writing what matters and how easy would it be to look at a fn and understand what it does. This will also help in overcoming variable shadowing. Instances where we have multiple errors being assinged an error shadowing can occur and this can be bad. Following this pattern and right coding can help in avoiding such weird scenarios.

Examples -

A code with redundant error handling and reduced readability.

func FooBar() error {
    req := struct{
        isFoo bool
        isBar bool
    }{}
    ctx := context.TODO()
    err := processFoo(ctx, &req)
    if err != nil {
        return err
    }
    err = processBar(ctx, &req)
    if err != nil {
        return err
    }
    return nil
}

A code with the task runner

func FooBar() error {
    req := struct{
        isFoo bool
        isBar bool
    }{}
    ctx := context.TODO()
    runner := NewSimpleTaskRunner(ctx, req)
    _, err := runner.
        Then(processFoo).
        Then(processBar).
        Result()
    return err
}

As you can observe how better the code is readable and executable. This thought process and framework can improve the readability of the code.

Go-routine Enthusiasts

func FooBar() error {
    req := struct{
        isFoo bool
        isBar bool
    }{}
    ctx := context.TODO()
    runner := NewSimpleTaskRunner(ctx, req)
    _, err := runner.
        Parallel(processFooParallel).
        Parallel(processBarParallel).
        Result()
    return err
}

Stream Utils

We all know the famous lambdas and arrow functions. Golang
inherently doesnt support the arrow syntax. It would be nice to have
that in golang. For now suppose we need to do some Map operation that
is were things get hard. Well you are in for a cool implementation
from me to solve that for you. After this below implementation I would
ask you to think a soln of your own how this would have been implemented.

func TestMapRunner(t *testing.T) {
    // Create a map with some values
    floatingStrings := []string{"0.1", "0.2", "22", "22.1"}

    res, err := NewTransformer[string, float64](floatingStrings).
        Map(MapIt[string, float64](func(item string) (float64, error) { return strconv.ParseFloat(item, 64) })).
        Map(MapIt[float64, float64](func(item float64) (float64, error) { return item * 10, nil })).
        Result()
    if err != nil {
        t.Errorf("Testcase failed with error : %v", err)
        return
    }
    // Output: [0.1 0.2 22 22.1]
    t.Logf("Result: %v", res)
    assert.ElementsMatch(t, []any{float64(1), float64(2), float64(220), float64(221)}, res)

}

The above example is for a conversion of string to float64.
This will handle the errors for you if there are any. The only exception will be there can be runtime errors if there is any
Type Cast Issues So be careful with this. Try to write the testcases
which should avoid this issue.

Filter and Mapper Deadly Combo

An addition to the functionality is made now, filteration also works.
Happy time folks!!

func TestFilterIt(t *testing.T) {
    // Create a map with some values
    floatingStrings := []string{"0.1", "0.2", "22", "22.1"}

    res, err := NewTransformer[string, int64](floatingStrings).
        Map(MapIt[string, float64](func(item string) (float64, error) {return strconv.ParseFloat(item, 64)})).
        Map(MapIt[float64, float64](func(item float64) (float64, error) { return item * 10, nil })).
        Map(MapIt[float64, int64](func(item float64) (int64, error) { return int64(item), nil })).
        Map(FilterIt[int64](func(item int64) (bool, error) { return item%2 == 0, nil })).
        Result()
    if err != nil {
        t.Errorf("Testcase failed with error : %v", err)
        return
    }
    // Output: [2 220]
    t.Logf("Result: %v", res)
    assert.ElementsMatch(t, []any{int64(2), int64(220)}, res)   
}

Import library to your project to build cool stuff.

go get -u github.com/mahadev-k/go-utils@v1.0.1

Add this to your go.mod.
Use it as done in the examples module.

module examples

go 1.23.2

require github.com/stretchr/testify v1.9.0

require (
    github.com/davecgh/go-spew v1.1.1 // indirect
    github.com/mahadev-k/go-utils v1.0.1 // indirect *go-utils*
    github.com/pmezard/go-difflib v1.0.0 // indirect
    gopkg.in/yaml.v3 v3.0.1 // indirect
)

Simple example

func TestMapRunnerLib(t *testing.T) {
    // Create a map with some values
    floatingStrings := []string{"0.1", "0.2", "22", "22.1"}

    res, err := streams.NewTransformer[string, int64](floatingStrings).
        Map(streams.MapIt[string, float64](func(item string) (float64, error) { return strconv.ParseFloat(item, 64) })).
        Map(streams.MapIt[float64, float64](func(item float64) (float64, error) { return item * 10, nil })).
        Map(streams.MapIt[float64, int64](func(item float64) (int64, error) { return int64(item), nil })).
        Map(streams.FilterIt[int64](func(item int64) (bool, error) { return item%2 == 0, nil })).
        Result()
    if err != nil {
        t.Errorf("Testcase failed with error : %v", err)
        return
    }
    // Output: [2 220]
    t.Logf("Result: %v", res)
    assert.ElementsMatch(t, []any{int64(2), int64(220)}, res)
}

Checkout the repo:
Github: https://github.com/mahadev-k/go-utils

Considering you had read this through and liked it. If you would like to connect with me
Follow me on X - https://x.com/mahadev_k_
Linkedin - https://in.linkedin.com/in/mahadev-k-934520223
Do propose more ideas for contributions to this repo if interested.
Thank you 🎉🥳

[Deepgram x DEV Hackathon Submission Post Translate-io]

Mahadev K — Mon, 11 Apr 2022 08:31:45 +0000

Overview of My Submission

Translate-io - One command to record audio for n minutes and get a recording file and a transcription out of it. One command to translate a file. Java/Spring implementation to get the transcription. SDK's for node.js, python, and c# is there this could open path for Java.

Submission Category:

Accessibility Advocates

Github

mahadev-k / translate-io

A language translation project

translate-io

A language translation project

This is a spring shell project offering deepgram speech to text translation

mvn spring-boot:run

shell command

sptt {mins} {seconds} {language(Optional)}- This will start recording audio for n minutes and then the whole audio will transcribed and shown in the notepad : Windows
stop-sptt {id} - Will stop recording and translation. 
translate-file {filepath} {language(Optional)} - Ex translate-file recordings/record.wav will translate the file to english and show you the transcription

View on GitHub

Additional Resources / Info

translate-io – TranslateShell.java 2022-04-11 11-58-13.mp4 - Google Drive

drive.google.com

translate-file recordings/song.mp3 it
-> Bella ciao transcript.

My Deepgram Use-Case

Hey everyone, welcome to spring-shell with deepgram API. Deepgram had provided sdks for python, node.js, and c# I believe but where’s Java. Also one of the idea was to translate the audio based on the language and then translating the transcript to the language the person understands. Like we watching a spanish movie and we get spanish transcript and we can send this spanish transcript to some service that could translate that into english.
Didnt get the time for this.

I tried to implement some speech-to-text translation with Java and had a lot of challenges with that. I haven’t worked on multithreading but in the past two days I learned a lot.

This application is built with spring-boot and spring-shell.
Spring-shell will help you type commands to run which found to be cool and I wanted to develop something based on that and I read about this hackathon on Friday and thought why not??

Application structure that I thought in my mind will be like follows.

Controller – Takes the command and pass it to TranslateService.

TranslateService – Offers multiple services speechToText, LiveTranslation(Not working 🤷‍♂️) etc...

Sub services – There can be apis that can support speechToText, Live translation etc... But there can be api’s that may not support both so we have two interfaces speechToText and LiveTranslation and Deepgram Implements both.

And the main service will call the subservice that we wish, now it is deepgram and if we want to change, we can easily have a class implementing the interfaces thus having a good abstraction and loose coupling. This is what I thought and you know what have happened when you go through the code.

The sub services perform the task and returns us the result.
Now, I think implementation of this in JS was the easiest way but you know Java made me strain a lot on multi-threading.

Multi-threading is mainly required to capture the audio parallelly as program executes other functionalities.

To brief about functionalites, see the following commands.

sptt <minutes> <seconds> <language (Optional)>

Capture audio for n minutes and m seconds and then send the recording for transcription which will be saved in /recordings folder of the project.

stop-sptt <threadid> to stop a running transcription.

translate-file <filepath> <language>

Run project : mvn spring-boot:run

Generate transcripts for a file. For hindi audio you can provide “hi” on the language.

Watch the video and checkout the project to get better understanding.

I saw a lot of cool projects done by a lot of people kudos to you all. Happy coding!

Java - Diamond of Death

Mahadev K — Wed, 26 Jan 2022 11:22:10 +0000

The title might be quite interesting. And people might be intrigued what’s this diamond of death... Some of you might have related this to the interfaces in java and if so, you are right! Anyway, we will see what this is all about.

In OOP we all know about one feature called inheritance. There will be a parent and then there will be a child inheriting the parent methods and attributes. The problem really comes when the child needs to inherit two or more classes and which is not possible in java. Multiple inheritance is just a “No” from Java. Why?? 🤔

From the above picture you could have understood the real issue of ambiguity for same method signature in the super classes. Poor kid couldn't get the money... Kid can also ask his grand pa right 🤔.
If you also add a class which has the same method and which acts as a grandparent for getting money then you can see the diamond formation, thus the name diamond of death.

Interfaces

So, Java introduced the so-called interfaces. Thus, the problem is solved with one simple way that a class can implement multiple interfaces. And to call the required parent’s super method,

Dad.super.getMoney(reason, amount)

Mom.super.getMoney(reason, amount)

The above example was only meant for demonstration purposes.

Interfaces really doesn’t provide any implementations. Any class that is implementing the interface should provide the implementation for the method.

Multiple implementation

Suppose two different features came and a class has to serve these two new features so the class can implement the two interfaces. One way to put this is consider our smart phone, we need a smart phone that has Wi-Fi and NFC. So, when designing the phone, we have to provide the implementations for the phone based on the features that is expected from the phone. So, here we can say that a phone that implements the NFC and Wi-Fi is the expected phone.
The cover of this document also creates the same idea.

Default keyword

Suppose a new functionality can be added to an existing interface which can be implemented by multiple classes and we cannot make all the classes to implement the method as if there are many classes to give their implementation then we can declare the new method as a default method and prioritized classes can implement that method and serving the new feature while the others will call the interfaces default method which has to handle the call in some way or throw some “UnsupportedOperationException”. I am also not sure about this feature, if anyone has more insights put down your thoughts in comments.

So, the story of interfaces and inheritance ends here... Anything you wish to share can be put in comments, happy learning 😊.

Stay safe, take care Bye-bye!

References

Java and Multiple Inheritance - GeeksforGeeks
java - Throw exception in interface default method - Stack Overflow

Java – Class and Objects.

Mahadev K — Sat, 04 Dec 2021 14:34:02 +0000

First of all thanks!!! 🥳🥳🥳 for the overwhelming response for my previous article.
https://dev.to/mahadev_k/java-a-brief-note-39hc

So then what's up for today?? This will be an article that will navigate you through some basic concepts of OOP - Class and Objects.
Imagine when you were a child and you got a new toy, for the first week you will play with the toy and after that you will start to dismantle it and some of you will turn that into infinite pieces Why??To see how the toy works may be and rest of you, you know just angry for some reason!!! 🤷‍♂️.
So today we will just dig what’s in this class and objects and I think you will get some basic data types 🔍.

Basic Data types

To understand this first we can analyze the basic representation of data. We have numbers (byte, short, int, long), numbers with decimal points (float, double), letters (char). We represent these data in the Java with the help of what we call data types the one I gave in brackets.

In Java you can use primitive data types but it's better to use the boxed data types. Boxed data types wrap the primitive data type to an object.

int -> Integer
long -> Long

Reference
https://lastfiascorun.com/mexico/faq-what-are-boxed-types-in-java.html

Wrap the data types

Now we will wrap some of these data types to make a meaningful new data type.

This is very similar to the subway wrapper example. We wrapped all the veggies in the bread to form a new meaningful food and we called them wraps😋.

One might think can we have a class inside a class. Yeah, sure in real world we have double decker burgers right and so, each layer will act as an instance of class here.

We can leave these subway wraps and burgers here so that someone else can eat 😀.

Access Modifiers

Access modifiers is nothing but it helps you control who can access what. In the above example we were able to access all the attributes/variables with just the “. (dot)” operator but it is not the right way as it simply states anyone can change the data or any class can change the data. This brings us to the necessity of a control over the class and variables access.

And so, we have the 4 access controls.

Private -> Private will set the perimeter of access to the privately declared variables and methods to the declared class level.

Public -> Public literally has no perimeter and anyone can access.

Protected -> Protected variables can only be accessed in the package level or subclass (child class) level.

Default (no access specifier) -> Default will set the perimeter of access till the package level.

Represent A Class

From being foodie till now we can switch to some sci-fi. We will try to represent an element well known to those who know the “Wakanda”.

The above class shows how an element is classified. An element has,

Atomic number - Integer

Element name - String

Element symbol ->\ String

Atomic mass -> Double

Whenever we find a new element, we will fill all these fields with the new elements value and store the element with some reference. This can be related to filling some form and putting a tag over the form to easily pick and get to know what’s inside the form.

Now we will fill out the details of the rare strong element out there,

The “Vibranium”.

package oop;

public class Element {

    /**
     *This variable can be accessed in the package level and the current package is oop, won't be accessible in the main package
     */
    Integer atomicNumber;

    /**
     * This variable is accessible in the class level and so to access it outside we have a get method below and to
     * change the value we have a set method too.
     **/
    private Integer atomicMass;

    /**
     * This variable is accessible anywhere even in the main package
     */
    public String elementName;

    /**
     * Currently this will be accessible only inside this package -> oop
     * This variable can also be accessed by a class which inherits this class.
     */
    protected String elementSymbol;

    public Integer getAtomicMass(){
        return this.atomicMass;
    }

    public void setAtomicMass(Integer atomicMass){
        this.atomicMass = atomicMass;
    }


}

package oop;

public class OopMain {

    public static void main(String[] args) {

        //vibranium holds the reference of the new memory location allocated to it
        Element vibranium = new Element();

        vibranium.atomicNumber = 22; // accessible as it is default and we are in the same package
        vibranium.elementName = String.valueOf("Vibranium"); //accessible public var
        vibranium.elementSymbol = String.valueOf("Vi"); //accessible as we are in the same package protected
        //vibranium.atomicMass = 35; not accessible as it is a private variable
        //we will use setter to set atomic mass
        vibranium.setAtomicMass(35);

        System.out.printf(
                "Element [%s] :\n" +
                        "Atomic Number : %d\n" +
                        "Atomic Mass : %d\n" +
                        "Element Symbol : %s\n"
                        ,vibranium.elementName
                        ,vibranium.atomicNumber
                        ,vibranium.getAtomicMass()
                        ,vibranium.elementSymbol
        );

        /**
         * Vibranium is supposed to be similar to titanium and so the properties are similarly provided 😀
         * This element doesn't exist !!
         */

    }

}

Now we have the vibranium’s data filled in and stored in a memory location. So how did that happen?? Spot the “new” keyword, “new” keyword will help you create a space for your element in the heap memory and returns you the reference to the memory location.

And we have the vibranium now !!!. This time we can ask Jarvis to create the element 😎.

Jarvis.createElement(vibranium);//Will have to ask Tony stark for the Jarvis services 🤷‍♂️.

Always keep the variables private to the class and access those variables outside using getters and setters.
This covers the idea of Encapsulation.

I have pushed all the code mentioned above in the github. Feel free to checkout !!! 😀

mahadev-k / JavaSeries

A Java exploration repository 🚀🚀🚀.

JavaSeries

A Java exploration repository 🚀🚀🚀.

#Run and Execute

Import JavaSeries as an existing project from your intellij idea/eclipse
Execute main class in the main package or oopMain in the oop package to see the results.
This project is made with Java-17 though not any Java-17 features are used.

View on GitHub

This Keyword

This keyword refers to the current instance. Whenever we want to access a variable of an object that we created with the help of class we use the reference of that object stored in a variable of type class. Similarly, if any method inside the class wants to use the reference of the current object, we can use the “this” keyword.

public void setAtomicMass(Integer atomicMass){
        //Variable 'atomicMass' is assigned to itself
        atomicMass = atomicMass;
        this.atomicMass = atomicMass;
    }

Constructor and new keyword

As we know that an object is created with the help of “new” keyword. Once the object is created at least one constructor is called. If we didn’t define the constructor java compiler will provide a default constructor. Constructors can be used to set initial values of attributes.


/** 
* Constructor 
*/ 
Element(){ 
this.elementName = "Element"; 
}

That's it for this article guys !!!. This was a bit huge will see you all in the next article until then take care, good bye 🙌🙌🙌🙌

Java – A brief note.

Mahadev K — Sat, 20 Nov 2021 07:14:44 +0000

Hey everyone, this is just an article portraying some basics of Java. Those who are new to Java, welcome to Java club and those who already know Java just jog your memory 😀.

Java is a high-level, class-based, object-oriented programming language that is designed to have as few implementation dependencies as possible. It is a general-purpose programming language intended to let programmers write once, run anywhere (WORA) - Just Wikipedia stuff but makes sense though🤷‍♂️.

High-Level Language

Those who are new to programming will think what is a high-level language.
So high-level language means a language that can be understood by a human being but not a machine.

How can we relate this though. We can say like computer speaks language “x” (Assembly language) and we humans speak language “y” (We have so many languages and for programing we prominently use English). Now you might think how computer understands if we know English how will computer understand that?? Here comes our translator. Translator is basically a compiler that converts the high-level language to binaries or assembly language🎶.

OOP

Object-oriented programming is programing paradigm based on objects. This will help in increasing the modularity and reusability of code. It is the opposite of procedural programming.

Basically, an object is a subway wrapper which wraps data(veggies) and methods(taste). So, if you want two types of taste you can order two different wrapper and so you can see the modularity here. This doesn’t convey the proper meaning but it does make some sense I guess at least for those who love wrappers🌯🌯🌯🌯🥳🥳🥳. To be honest I haven't even tasted one of these 😁.

More about class and objects will be covered in the next articles💡.

Write Once Run Anywhere (WORA)

Java is a platform-independent language. But what does that mean?? Java hired an intermediate person who converts the written code to an intermediate code/ set of instructions rather than native machine code, these instructions are then converted to machine code with the help of JVM (Java Virtual Machine).

But how this helps?? Once we compile our program usually it will convert to native machine code as I said earlier. So, the code has to be ran in each different machine to generate their specific machine codes for our program. But in case of java, we have to supply the bytecodes only.

Irrespective of which machine we supply our bytecodes to and if the machine supports JVM it will convert them to native machine code and run the same.

Now some genius might think what if we can manipulate the bytecode and run them so can we can get some advantages. Sorry man the code will get corrupted bytecode verifier will catch you 😎.

This article is going endlessly, so will see you all in the next article until then good bye, take care🙌.