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.
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.
Top comments (0)