Code Chronicles: My Journey as a Developer - Reflections on the Past Few Months
Published: 2024-04-11 18:50:03

Welcome back, dear readers! It's been quite a journey over the past couple of months for me. As we settle into a new chapter, it's time to reflect on the lessons learned, the challenges faced, and the growth experienced. Let me share my learning experience of my corporate journey till now.

- Learned a lot about system design and it's importance in product-based company. Hence selecting a appropiate design pattern helps you to keep your work top-notch and avoid any negative feedback over your code-review. 
Design patterns are powerful tools for building flexible, maintainable, and scalable software systems. Whether we are designing a simple application or a complex enterprise system, the knowledge of design patterns will undoubtedly be invaluable in our journey as a software developer. 

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/95t1m2nhmb7wjao82ist.jpg)
Till now got a chance to cover all the **Creational-Design** pattern,
also from **Structural-Design** pattern only used Facade pattern. 
And few of them from the **Behavioural-Design** pattern. Will try to unveil in-depth about all the Design-pattern in next blog.

---

Also working in java gave me a chance to explore the features of java which definitely did took, some time for me to get hands-on in the early stage but once I got the hang of it are now definitely coming handy and make my code more readable and easily understandable.

> 
- Lambdas and Functional Interfaces
- Streams API
- Optional Class
- Using Generic Classes
- Using Tuples

**_Illustration of code before I use above java features_**
```
public static void main(String[] args) {
        List<String> nameList = Arrays.asList("Tejas", "Sammer", "Aditya", "Saurabh");
        List<String> convertedNameList = new ArrayList<>();
        for(String name : nameList){
            if(name.startsWith("S")){
                convertedNameList.add(name.toLowerCase());
            }
        }
        System.out.println(convertedNameList);
    }
```

_**A Better and Efficient way of writing above code**_

```
List<String> nameList = Arrays.asList("Tejas", "Sammer", "Aditya", "Saurabh");
Optional<String> convertedNameOpt =  nameList.stream().filter(name -> name.startsWith("S")).map(String::toLowerCase).reduce((s1, s2) -> s1 + ", " + s2);
        System.out.println(convertedNameOpt);
```

---

As a developer working in product-based company Code-review becomes a usual part of your day-to-day life. And writing cleaner code becomes your by default responsibilty. There few techniques which I picked up over the past few months:

> 

- Gaurd-Clause Technique
- Select appropiate data-structure depending upon the requirement
- Avoid unecessary deep-nesting loops
- Use multi-line descriptive comments to make you API decriptive and easily understandable.
- Make sure your code is idented and readable.
- Always declare a understandable variable-name and avoid abbreviation.
- Maintain Modularity in your code.
- Make you code Compact and avoid using uncessary variable declaration.

---
Well I was using _git_ before entering the corporate world but not at the full-potential 

- Understanding the _git-workflow_ is very important and chosing the correct one is your responsibilty. 
- Making use of rebasing instead of merging
- Importance of correct _base-of_
- How to avoid and resolve _merge-conflict_ in files.
- Using a _feature-branch_ for develpoment

---
Lastly as working for Infor, I developed the understanding for the _Supply-Chain Management_ system(Shipment-Planning, Shipment-Orders, Transport-Planning, Transport-Order, Shipment-Visibility and more) which is definitely something new and very-interesting to learn. 

---

Thanks for reading this blog and Let's meet again in next blog with something new and interesting.