DEV Community: Kareem Itani

I’ve Been Working on Something Big

Kareem Itani — Sat, 28 Mar 2026 17:55:29 +0000

EmailBuddy

I’ve been working on something really big, it’s been on my mind for maybe a year now and I’ve been working on it for 8 months already, so I want to talk about it. EmailBuddy is your help for your inbox.

What is EmailBuddy?

What is EmailBuddy? He’s supposed to be your one stop shop for cleaning up your email inbox. So for example, if you have like 100,000 emails and you don’t know where to even start, that’s the point of EmailBuddy. It’s supposed to help you in multiple different ways and try to help bring back some structure into your email.

Inbox Health & Score

One key feature we have is our inbox score. There is five main categories that comprise this score. Those are unread emails, spam emails, old newsletters, expired promotions, security emails. These are emails that may not be needed anymore like expired 2fa emails.

If we go a level deeper, we can interact with each score and see which emails are falling under these categories. You can get a summary from EmailBuddy saying what to do, then you can delete emails by cherry picking which ones you don’t need, or you can delete 100 at a time, or if you really don’t want them delete all of them at once.

Cleanup Feature

Another feature is the cleanup feature, this one is my personally favorite it pulls in your last 200 emails (it can get more emails if you click deeper scan) and it will sort it by senders who have sent you the most emails.

So for example, let’s say you have Amazon at the top of this list and it’s showing you have 150 emails. You can click the sender, then you can see all your emails from Amazon. You can get a summary from Emailbuddy and a recommendation on what to do with them.

Also, you will get four key actions: unsubscribe, mark as spam, mark as read, delete all. I like the control and transparency that comes from this feature. You see how much one sender is taking up your inbox and you get to take care of it in whatever way you feel like.

Automation

For the automation feature, there are toggles available that allow you to do delete certain emails such as delete old promos, old receipts, auto phishing emails. When you toggle these and then hit run it will remove all of these emails at once.

This one is a very strong feature, but it can be dangerous since it will or most of the work for the user but can be super effective.

Wrapping up

Those are some of the core features of the app to help people clean up and manage their emails. Currently, I have a roadmap setup for future updates.

If you are interested in the app I’ll leave a link right here if you want to give it a try. At the end of the day this project was for me to learn more about how app development is some and it’s been a blast learning.

Try it out: https://apps.apple.com/us/app/emailbuddy-clean-inbox/id6759539281

What It’s Like Moving from TD to Chase

Kareem Itani — Fri, 03 Oct 2025 04:40:44 +0000

Introduction

Recently I have moved over to Chase, and with that there comes a new system for me to learn. To understand this blog, I want to talk about the differences between TD and Chase, or at least my one month at Chase, and let’s go from there.

Working In Person

It’s been really nice to work in person. I get to see my teammates. It’s actually super convenient to get up and shoulder tap one of my coworkers and ask them for help rather than having to message them in Teams and, hopefully, they will respond. Rather than having to wait 15–20 minutes for someone to get back to me, it’s just nice to get up and say, like, “Hey, by the way…” or “Do you want to go get lunch?” It’s a very organic feeling.

I was lucky with the remote, but I felt like after a while I was slowly losing my mind. I needed to go out and see real people. The main time I got to be more personal at TD was when I was in Canada, because I was fully remote, and when I was there it was a great time. The building was huge, and it was really a perfect time compared to being in an office at Chase.

I do like to be in an office. I think my coworkers are very friendly, and they’re very helpful. But honestly, the more and more I go to the office and think about my time at TD, I think hybrid is the best. Sometimes you just don’t want to come in, and sometimes you really do want to come in. Being remote for too long will drive me crazy. And sometimes, just waking up in the morning and not feeling all right, you just want to work from home. So I think they both have their pros and cons.

As of now, I still enjoy going into the office. Let’s see how long that lasts, but luckily for me, the commute is not too bad like 45 minutes to an hour. But I do think hybrid is the best choice. The more I spend time being in an office, the more it reminds me of that.

Moving from Bank to Bank

In terms of moving from bank to bank, it wasn’t too bad. There were a lot of similarities a lot of red tape everywhere. The biggest difference was going from waking up and working right away, to waking up and getting dressed and going into the office and, you know, taking a commute. It is a big change, and for now I’m okay with it. Let’s see how long that lasts, but this is what I wanted, so we’ll see how long until I start to complain. Generally, I do notice a lot of similarities in processes across the banks.

Growth and Experience

I guess the biggest change in myself is that even though I’m switching to a new team and a new product, I’ve learned so much from my time at TD that I can transfer over to my new team. I am able to pick up on these concepts, and I know how the application works without even being there. I kind of understand the overall big pieces and what the application is supposed to do, and I’m able to put together a mental image of how everything should flow more or less. Honestly, that just boils down to experience.

That’s the biggest thing the more time I spend, the more everything starts to make sense. It’s really incredible to see how far you’ve come. I remember when I first started, I barely knew anything. From my first day at TD until now, I’ve learned so much, and it’s really shaped me into becoming a better developer in that sense.

Looking Ahead

Overall, the growth from entry-level to now being mid-level has been quite dramatic. The knowledge I’ve gained is huge, and I can only imagine how big the knowledge gap is going to be between me and senior. But I’m looking forward to pushing myself and getting there.

It’s such a rewarding feeling to look back and see how much you’ve grown. I’m looking forward to even more of that feeling.

Beyond Code: The Key to Becoming a Better Developer

Kareem Itani — Tue, 12 Aug 2025 14:16:00 +0000

The Importance of Reading PRs

Today I wanted to talk about something that might be a little underrated. You might be thinking, what could that be?

So, the ability to read a PR. It's something I didn’t realize was much more important than I expected.

Understanding the Thought Process Behind PRs

The ability to read a PR and understand where the changes are happening, why someone made this change, and their thought process while making it is an amazing skill. It’s much more useful than I initially realized when I was starting out.

It’s definitely a difficult skill to develop—just looking at code and trying to piece together why and how someone did something without having to pull down the branch or run the code. Simply analyzing it from a PR perspective is challenging.

The Value of Strong Code-Reading Skills

But I think it really helps. It’s a fundamental skill. Once you get good at it, you naturally become better at reading code. You start recognizing when something looks off.

In fact, if you’re struggling to read the code, it’s often because it was written poorly. That in itself is useful feedback—if someone reviews your PR and finds it hard to follow, that’s a sign something needs improvement.

At the core of it, this skill is about reading other people's code. Reading your own code is usually easier because it follows your thought process. But being able to understand how others think when they code? That’s what really makes you a better developer.

Overcoming the Intimidation of PRs

I remember when I first started professionally. I’d open a PR, and immediately, I’d feel overwhelmed—so many changes, red and green lines everywhere.

I had no clue what was touched or changed. I didn’t understand the code at all.

At some point, I decided to push through that fear. I told myself, I can do this. I started poking at the PR, slowly piecing things together. And if I got really stuck, I’d pull down the branch and run the code to see what changed.

The Breakthrough Moment

Taking that first step—just looking at the PR and attempting to understand it—was the game changer. I realized it’s okay if it’s difficult. The key was to not give up.

Once you improve at reading PRs, everything starts clicking. You begin to follow the flow of thought behind the code naturally.

And beyond that, it helps unlock a deeper understanding of coding principles—like OOP, design patterns, and different frameworks.

The Significance in a Developer’s Career

This is a fundamental skill that every developer needs. If you’re working in the field, you’re not the only one pushing code—you’re going to be reading a lot of other people’s code.

Having this skill will make your work smoother and earn you respect. People will notice when you catch mistakes they didn’t see or suggest a better way to write something.

How to Get Started

My best advice? Give it a try. If you’re working, open a PR and attempt to understand what changes were made. If you’re unsure about approving, that’s fine—just go through it piece by piece.

If you’re not working at a company with PRs, try reviewing code with friends on a project. You don’t have to be perfect. Your PR comments can even be simple questions, like “Hey, what does this do?” That’s completely okay.

Final Thoughts

This is honestly one of the greatest skills I’ve developed.

So, let me ask you: Do you remember your first PR? What was it like reading and approving it for the first time?

Let me know your thoughts. And as always, have a good day!

Breaking Into Tech

Kareem Itani — Sun, 13 Jul 2025 17:30:00 +0000

The Struggle

The hardest part about breaking into tech is getting your first professional experience. Once you have your first professional job, it gets easier over time. The job itself is going to be difficult, but you’ll figure out how to do it and, through help from your coworkers and multiple hours of studying, you’ll do it, but the hardest part is getting your foot in the door.

The Importance of Experience and Projects

You see what you have on your piece of paper. In this case, it's your resume. Work experience and projects really go a long way to forming who you are. Like experience and projects honestly are the most important things on your resume, recruiters won’t look at your resume for more than 6, maybe 7 seconds. Make sure to find the main sticking point on your resume that can sell you as a person well.

Building a Strong Project

I recommend you work on a nice big large project, like a project with a database, frontend, backend and a good design.

It’s a good way of showing that you know what you're doing. That would be really great on a resume if you don't have experience.

Getting Your First Experience

Honestly, I recommend taking what you can. I started off with an unpaid internship back when I was in college.

You need something to hit the ground. Make sure people look at you. In the short term, it’s a learning experience for you, great for your resume and, in the long term, it could lead to your first full-time job. From that, you can do so much.

Networking and Putting Yourself Out There

Make sure, outside of your project and experience, there are other ways that you can improve yourself other than just your resume.

For example, going to coding meetups, and meeting other people in general.

You can also just go on LinkedIn and start connecting with some people that you would like to be. Maybe a developer at Amazon, or Meta, or Airbnb, or whatever it may be.

Just put yourself out there and make sure you can connect with them and talk to them.

The more connections you have, the more eyes you'll get, and the higher chance of maybe something working out.

Expanding Your Knowledge

Never stop learning. Try to expand your knowledge as much as you can.

Try to think of it like you're trying to look at the whole picture. For you to look at the whole picture, you need to keep stepping back.

The only way you can keep stepping back is with more and more knowledge you get. Let's step back and look at this other part of the picture.

And then step back and look at the other part of the picture. You want as much understanding of it as possible.

Final Thoughts

I know it's really rough out there to get a job in tech nowadays. Keep trying. Keep going. It might take some time, it may even take a lot of time. Your future self will take you for it just keep going.

Tech is really an amazing field, it has a lot of perks and benefits but it’s super competitive and hard to really break into but you have to write your own success story, keep going you will make it.

How to make an api endpoint call

Kareem Itani — Tue, 10 Jun 2025 13:30:00 +0000

What Is an API Endpoint?

An API endpoint is an endpoint that you can hit, that results in a certain action happening, that can lead to the frontend.

For instance, if you go on Facebook and you get to your profile, what this does is it hits a /profile page, this endpoint will take you over to your personal profile page for the specific user currently logged on.

An endpoint is essentially a thing you can go to, and it does something for you on the backend. This could be related to databases, scraping information, or other heavy-lifting tasks. It processes actions on the backend and sends data to the frontend or performs backend operations.

Understanding MVC (Model-View-Controller)

There’s this concept called MVC:

Model: This is the data object that you can fill up and want to return.
View: What the user sees at the end.
Controller: The first point of interaction with the API call.

For example, if we’re writing a controller:

Controllers catch certain endpoints. For instance, if we’re on port 8080 and we have a /home endpoint on our controller, the controller can check if /home is hit. Once it’s hit, the controller can trigger specific actions.

Step-by-Step Example: Get Profile Page

Let’s say we’re working on a controller with a getProfilePage method:

When getProfilePage is hit, it goes into the controller’s method.
Inside this method, it can call a service.
- A service is responsible for processing an action, such as interacting with a database or performing a calculation.
Once the service completes its task, it returns data back to the controller.
The controller then sends this data back to the frontend.

For example:

A user hits the getProfile endpoint.
The service retrieves information about the user based on their ID through a database query.
The database returns the user’s details to the service.
The service sends it back to the controller.
Finally, the controller returns it to the frontend, where it can be displayed to the user.

Frontend Interaction with API

From the frontend, you can make an API call to retrieve information. For instance:

When a frontend calls the getProfile endpoint, it expects the user’s data in return.
The backend handles the heavy lifting, fetching and processing the data while the frontend receives and displays the result.

Suggested Exercise: Login Page

To practice, try creating a simple login page:

Allow the user to input a username and password.
On clicking login, the frontend sends an API call to the backend.
The backend checks the database:
- If the user exists, return a success status (e.g., 200).
- If the user doesn’t exist, return an error (e.g., 401).
Upon success, display the user’s profile information.

This flow will help solidify your understanding of API endpoints.

Final Thoughts

This is the fundamental concept of making an API call. Controllers handle incoming requests, services perform backend tasks, and models structure the data returned to the frontend.

It takes some practice, but it’s a necessary skill for web development. Almost every website, if it’s not static, will need API calls. My advice: Keep it simple and start with basic exercises, like the login page example.

Let me know what kind of projects you’re thinking about making with this new information. Have a good day!

From Hacker to Judge: My First Hackathon on the Other Side

Kareem Itani — Thu, 15 May 2025 13:42:21 +0000

First-Time Judge Experience

Recently, I did something that I never thought I was going to do before, which was being a judge at a hackathon. For many years, I’ve been on the other end of just making projects and hoping they were good enough to win the hackathon, but I was lucky enough to be able to actually be a judge at a hackathon. I have judged over 12 projects and I want to talk about them, so let’s get into it.

So I guess the first question is, where was the hackathon hosted? It was hosted at Hunter College. They had a lot of nice people running the show.

Judges, Pairings, and Teams

There were 10 judges consisting of developers and professors from the school. Every judge was paired up, so in my case, I was lucky enough to have a professor from the school. He was very knowledgeable, had a lot of insight, and he was very nice to talk to. I think there were about 35 teams in total, which is a good number for a hackathon.

Memorable Projects

There were a lot of interesting projects. One of them was a local bartering app. If you have any food you don’t want, maybe someone else can offer you a different type of food, and you can have a nice exchange where you’re both happy. The goal was to reduce the amount of food that New York throws out in general.

There was another product that was very provoking. When creating an issue on GitHub, an AI bot will open up a PR and that PR contains the fix of the issue, so a developer can go in and check the PR to see if the solution was good enough. There could be some benefit to it, like if a product manager or anyone who isn’t very technical in the team uses it. But the big flaw I see is AI having trouble understanding where the code fix is going to go. In big enterprise code bases, a project is over 2000 files long and writing down updates on a button color might be very difficult due to the fact there are so many buttons. The product manager would have to have enough context to know which file the change would be going into and at that point the product manager doesn't fall under the categories of not very technical. There are a lot of flaws in the project, but I really do think it has potential.

Judging Process and Ceremony

There were two rounds for the judging process. The first round was all 8 projects per group of two judges, and the second round was a more refined one that the other judges judged, that consisted of about 3 teams.

After all that, we had our closing ceremony. They had a lot of prizes: a few monitors, mouse, chargers. They gave a shout-out to all the judges and mentors for being there, which was very nice. At the end, I really liked that they had handwritten cards for each judge. It had a personalized thank-you letter inside it, which felt very personal.

Final Thoughts

Overall, honestly, for the first hackathon, being a judge was a lot more fun than I realized. It’s really nice to be in that position. It's interesting to see what people can cook up in 24–48 hours and loaded on caffeine. It felt like a breath of fresh air to meet some people in the field who have a common understanding of what you do. I might do it again. I may also drag a friend with me to do it and see what they think about it. I guess we’ll see what happens next

The Importance of Code Hygiene

Kareem Itani — Mon, 14 Apr 2025 19:49:21 +0000

Introduction

Welcome back today. I want to talk about tech debt and the importance of code hygiene. This is my advice and my input on it. We’ll dive into two critical aspects: managing code smells and removing unused libraries. These practices not only help in keeping your codebase clean but also improve overall project performance and maintainability.

Understanding Tech Debt

Tech debt is like the leftover food you have in your fridge that you don’t want to deal with until it's too late. You know it's important to deal with, but sometimes you just push it off. I think that’s the best way for me to put it.

Tech debt can be a combination of things in your codebase from lines of code that aren't being used anymore or libraries that are imported that may not need to be there. Essentially, it's just small mistakes or leftover messes that can quickly add up in your application.

The Sad Truth of Code Health

What's going to happen most of the time is that managers aren't going to value tasks like cleaning up tech debt over pushing new features, a UI update, a new endpoint, or maybe a new database column. They really don’t like to look into the health of the application.

Usually, when you work in a smaller team of a few people, it is harder to find time to do clean-up work when the higher ups only want the newest latest feature all the time. As a developer, you never have enough time to go back and clean it all up.

Routine Code Cleanup

Cleaning up tech debt is really important, and you'll thank yourself in the long run. Maybe set up something with your co-workers once a week when you review old code or, as you push your new code, take a second look.

Make sure everything is clean. You'll undo old libraries, methods that have been deprecated but no one removed. Outdated code creates unnecessary clutter.

The Challenge of Removing Code

It’s much easier to add code than it is to remove it. Once code gets wrapped up in other classes, methods, and functions, everything becomes entangled. Cleaning it up later is tough. You have to be careful when adding new code to prevent bloating the application.

Final Thoughts on Tech Debt

My advice to anybody is to take tech debt seriously. You won’t always have the chance to go back and clean it up, because you'll always be pushing forward to do something new.

I like to think about it like this: you are working in a kitchen as a chef, and work after you are done for the day, clean up your station so you can come back the next day and work in a good environment.

A Social Media App that Encourages Quality Over Quantity

Kareem Itani — Sun, 16 Mar 2025 22:06:16 +0000

Introduction

I’ve got some exciting news. I wanted to make a social media app for a while and I finally was able to do it with an interesting twist on the idea.

The Vision Behind the Idea

The biggest problem nowadays is that social media are filled with a bunch of junk posts that have no meaning to them. I want to make something that people want to put more effort into. I was aiming for a person's real look into their day or how they're feeling. I feel like Twitter has become, for example, just a mess of just garbage, sometimes where it's just a bunch of brain rot and low-effort content.

The Gimmick and Concept

Well, what’s the whole gimmick then? You can only make one post a day, and after that day is up, the post will be archived into your backlog. Where nobody can see it but you, so you can keep track. This should encourage people to make more thoughtful posts, hopefully sparking more organic posts, in a sense.

Technical Details

So, my front end, my back end, my knowledge of APIs, containers, Figma were all implemented. I did a lot of designing, redesigning, and restructuring. A lot of nights thinking about where this should go? How should I do this? What should I do with this? I used Next.js for the frontend framework. Since I haven't used it before, I thought it would be a good learning experience. I set up the backend with java/Spring for my services with a progress database. Used DTO, models, controllers, services for the backend to help me get the data from the database and then send it up to the frontend.

Feedback Request

If you want to try it out, here's the link to behere.onrender.com. Keep in mind it may take a minute for the front end and back to start up. It's something I've been working on for a while. If you'd like to give it a try, let me know if there's anything you liked or didn't like or thought about adding or anything. I thought it was a cute project to work on in the meantime between everything else I'm doing. So, yeah, let me know what you think.

Conclusion

I am glad I was actually able to make this app. If I had told my younger self back in college that I would have built such a complex website, I wouldn’t have believed it. This was a fun passion project. I thank you for reading along.

Level up your tech career by being social

Kareem Itani — Sat, 22 Feb 2025 23:29:53 +0000

The Importance of Being Social in a Tech Company

Have you ever thought about the most important skill as a software developer outside of coding? While technical skills are essential, there’s another aspect that could be even more important, that is being social. I’ve been thinking a lot about the role of social skills in the tech industry and I wanted to share some thoughts and how important it is.

Networking

Let’s face it - networking is important. You’ve probably heard it a million times, but it’s true. I believe who you know matters more than what you know. You could create something amazing like the next Facebook, but if no one knows who you are, it’s like it never happened.

For example, you’ve been working hard on a feature for months, and it turns out great. But if no one knows you built it, your manager might not even notice, and you could miss out on the recognition or promotion you deserve.

Building relationships within the company ensures that your efforts don’t go unnoticed. Even if the project is small, if people know you and see what you’re working on, you’re more likely to gain attention and opportunities.

Building Strong Connections

It’s not just about recognition, having strong connections with your coworkers makes collaboration easier. If you’re constantly engaging with your team and building a strong bond, it becomes much smoother to ask for help when needed.

You’re stuck on a bug for hours. Instead of struggling alone, if you’ve built a solid connection with someone, you can reach out without feeling awkward. Having that comfort level with your coworkers can make problem-solving faster and more enjoyable. You don’t want to be the person who only reaches out when something is wrong; being present and friendly makes your presence more liked.

Building Strong Connections Future Job Opportunities

Social connections can also open up new opportunities down the road. Imagine one of your coworkers leaves the company and months later offers you a referral at their new workplace. Referrals can significantly boost your chances of landing a job, especially when the job market is tough.

Building a network of people who trust you as a developer can make all the difference when it comes to finding new roles. Instead of stressing over applications, you’ll have connections vouching for you.

Conclusion

Being social is often overlooked in the tech world because of the main focus being put on your technical abilities, but being social also plays a crucial role in career growth. Networking, building connections, and opening doors for future opportunities are all key benefits of being socially engaged at work.

I’ve personally found that being social and outgoing has helped me grow faster in my career and meet people I wouldn’t have connected with otherwise.

So, if you’re in tech and you’re not social, I’d encourage you to give it a try. The rewards, both personally and professionally, are worth it. Leave a comment and let me know what you think!

The Harder the Struggle, the Bigger the Growth

Kareem Itani — Mon, 20 Jan 2025 23:28:05 +0000

Appreciate Yourself

You know what's one thing that all developers don't do? I've realized this further in my career.

No one really appreciates how far they've come. No one realizes how much they've done to get where they are. I find this very common among multiples, like people and developers. It scopes outside of being just a developer, but you kind of forget about all the previous challenges, difficulties, and goals.

You have to appreciate yourself. When times get hard, you keep going, and I'm sure you'll keep going. It won't be the last time that you get through something that you got stuck on. It happens, pat yourself on the back for what you've done in your career and don't be so harsh on yourself now.

Remembering Your Journey

You get so lost in the journey that you forget how far you've come.

The harder the struggle, the bigger the growth. Maybe you're working on how a four loop works, and now you're writing a full stack website that has a database and everything. Your challenges are still there, but just on a bigger scale. Sometimes you just have to appreciate the struggle.

Reflect on Your Growth

My best advice as a developer is just don't get into yourself too much. Because once you think that you're bad or not good enough, it's hard for you to get out of that mindset.

I feel like everyone has a bit of impostor syndrome no matter what, so you can't really escape it. No one really thinks that they're good enough. If you're not struggling, then you can't get any better. In my case, writing these blogs is a struggle for me. This is way out of my comfort zone, but I’m trying to see if I can learn more about writing and getting my thoughts out there.

Be Your Biggest Fan

At the end of the day, no one is going to want you to succeed how much as you do, so try to be your biggest fan. Try to make your future self look back at what you have done and smile knowing that you were able to make it through all the struggle.

From Chaos to Clarity: Refactoring Long Methods into Pure Functions

Kareem Itani — Sun, 22 Dec 2024 06:15:28 +0000

The Problem with Long Methods in Code

Hey there, I’ve been thinking a lot about code structure recently, particularly long methods. Today, I want to share some thoughts and advice on dealing with long methods or functions, and why they can be an issue.

What is the difference between Methods and Functions

Methods and functions are very similar but they differ just a little bit, a function relies on data getting passed in through a parameter compared to a method which can be done globally.

For example, this would be a pure function in java and is dependent on parameters being passed in

public class MathUtils {
    public static int addNumbers(int a, int b) {
        return a + b;
    }
}

However, this method is accessing a variable outside of the method call

public class Counter {
    private int count = 0;

    public int increment() {
        count++;
        return count;
    }
}

Due to the fact that a method can access variables globally it can bit a bit tricky to test at times and can lead to unexpected side affects. Compared to a function which only will interact with what is passed on which can make it easier to test on.

The Issue with Long Methods

Long methods can quickly become a problem for developers. Imagine having a function that does multiple things—calling other functions, creating variables, making hash maps, arrays, and more. If one part of that process changes, it could cause unexpected results or side effects, which are not only frustrating but can also be tricky to debug. It makes the code harder to read and manage.

A method that is overloaded with too many responsibilities can also be a nightmare for other developers to follow. If you have a long method with many loops, method calls, and lots of logic packed in, it's likely going to confuse someone reading it later on.

Why Pure Functions Matter

One of the best practices to combat long methods is creating pure functions. You may be wondering, "What's a pure function?" Basically a pure function is one that does only one thing and does it well, without side effects.

For example, let’s say you’re building a calculator app. You don’t want one method to:

Receive the user’s input,
Determine the operation,
Perform the calculation,
Return the result,
And then prompt the user for another input.

That’s a lot of responsibility for one method. Instead, break it up: one method could receive the user’s input, another could handle the operation, and so on. Each method should focus on a single task and perform it without affecting other parts of the code.

Refactoring Becomes Easier

By breaking up methods into smaller, single-purpose methods, you make your code much easier to refactor. For example, if you need to change how the operation is performed in the calculator app, you know exactly where to go and what to change. There’s no risk of breaking other parts of the application because the method is isolated and doesn’t rely on other methods unnecessarily.

Identifying Issues Becomes Simpler

Pure functions make debugging much easier. If you expect a certain result like 17 from a method and get an unexpected outcome, you can quickly isolate the problem. If the issue lies in the next method and not the pure function, you already know the pure function is working as expected. This level of isolation is critical in keeping your code maintainable.

The Importance of Readability

Long, bloated methods are hard to read. When you submit a pull request and another developer is reviewing your code, you don’t want them to get confused. If your coworker needs to call you to clarify what you’ve changed, it’s a sign that your code may be too complicated. Refactoring your methods into smaller, single-purpose ones helps maintain clarity and allows others to understand your code more easily.

Planning Before You Code

Before you dive straight into coding, take a moment to plan. I know it’s easy to get excited and want to jump right into writing code, but if you take a little time to think through your approach, your code quality will improve. Break things down into smaller parts, make sure each method has a clear and single responsibility, and you'll find your code becomes much more manageable.

Final Thoughts

The best advice I can give is to practice breaking down your code into pure functions. It takes time and patience, but it’s worth the effort. You’ll thank yourself later when your code is clean, maintainable, and easy to debug.

Remember, coding is a journey, and we all make mistakes along the way. Don’t be too hard on yourself, give it time, keep learning, and stay optimistic. I hope this advice is useful, and I’m sure you’ll get better with practice.

Thanks for reading! Until next time.

Navigating the Full-Stack Path

Kareem Itani — Fri, 01 Nov 2024 01:35:44 +0000

Getting started

Hello! We're back with another blog. I hope the last one went well! Today, I want to talk about how someone can become a full-stack developer, sharing my own experience, advice, and what worked for me. I'll cover technologies, frameworks, helpful websites, and more.

Starting with the Back End

To begin your journey, I recommend focusing on the back end. Start by learning Java, which might feel a bit verbose and challenging at first, but it gives you a strong foundation in programming. Make sure you understand the fundamentals of Java, including concepts like data structures, OOP, before branching into frameworks like Spring and Spring Boot. Once you have a solid grasp of these, it’s time to learn how APIs work.

A good way to practice is by creating simple projects such as a weather app that utilize APIs.

One more thing before we move forward

Now we have a good foundation of Java. Let's try to push the boundaries a bit. APIs will help us do so, question is what is an API. Best way for me to put it is someone that you can reach out to that will give you a bunch of information that you ask for. For example, let's say we want to make an app about the weather, well we don’t have much information about that but if we use the weather API we can ask them and they give us back a bunch of information about the weather like the temperature,wind speed,whether it's raining or not. It can provide us with a lot of useful information for our application.

Moving to the Front End

Once you're comfortable with the back end and APIs, it’s time to shift focus to the front end. Start with the basics: HTML and CSS. After building a solid understanding of these, move on to JavaScript. Once you’re familiar with all three, it's a good idea to pick up a front-end library like React to add more functionality and scalability to your projects.

After mastering these, you can try creating a personal website. For added practice, make API calls from the front end, not just the back end—this will help you understand how to link the two more effectively. If you're interested in state management, learning Redux is a great option.

Combining Front and Back End

Once you understand both the front end and the back end, it’s time to combine them. A great way to start is by building something simple, like a login page. Here’s an example flow:

Enter a username and password.
Click “Login” to trigger an API call to your back end.
Your back end processes the information and sends a response.

This exercise gives you a complete picture of how the front end and back end communicate, which is essential for full-stack development.

Building Larger Projects

With the basics in place, you can now move on to more complex projects. A great next step would be building a social media app where the front end and back end communicate, and everything is dynamic and updatable.

Resources to Help You Learn

There are plenty of great resources available to help you along the way:

FreeCodeCamp: An excellent platform with free courses and tutorials.
CodePen: A site where you can explore front-end projects, read other people's code, and practice your skills.

In addition to these platforms, watching tutorials and following experienced developers online is highly beneficial.

The Learning Process

Becoming a full-stack developer is a journey that requires patience and persistence. It’s natural to get stuck, feel frustrated, or doubt your abilities. If you have friends or colleagues who code, don't hesitate to reach out for help. They’ve likely experienced the same struggles, and getting a new perspective can often solve your issue faster.

Over time, your coding practices will improve. You'll learn how to break down problems, write pure functions (functions with a single purpose and no side effects), and organize your code more efficiently using classes.

Final Thoughts

In summary, here’s the pathway I recommend:

Start with Java to understand coding fundamentals.
Learn data structures and back-end frameworks like Spring Boot.
Practice building APIs.
Shift to the front end with HTML, CSS, and JavaScript.
Learn a front-end library like React.
Combine your front-end and back-end knowledge to build small, functional projects.
Scale up to larger, more complex applications over time.

Be patient with yourself, and remember that failure is a part of the process. Every mistake is an opportunity to learn and improve. Stick with it, and you'll find yourself getting better each day. Good luck!