Software Stories

As we continue developing the Crowd-Sourced Travel Planner project, I’ve had the opportunity to dive deep into React Native for building the front-end. In this post, I’ll share my thoughts on how React Native fits into the tech stack, what I’ve learned, and why it has become one of my favorite technologies so far.

Favorite Technology: React Native

Without a doubt, React Native has been my favorite technology to work with for this project. As someone with experience in React for web development, transitioning to React Native felt like a natural extension of my skillset. The main appeal of React Native lies in its ability to write cross-platform mobile applications using JavaScript, which means that the same codebase can be used for both iOS and Android. This is a game-changer, as it saves a lot of time and effort in building mobile apps for different platforms.

One of the standout features of React Native is its “live reload” functionality, which lets you see code changes immediately without needing to rebuild the entire app. This feature speeds up the development process significantly. Additionally, React Native’s component-based structure, similar to React for the web, makes it easy to break down the app into manageable pieces that are easy to maintain and debug.

The Technology I Had Difficulty Learning: React Native’s Navigation System

While React Native overall has been great, there was one area where I initially struggled: the navigation system. React Native uses different libraries for navigation, and the learning curve for setting up stack, tab, and drawer navigators was a bit steeper than I anticipated. At first, I found myself getting confused by the various methods of navigating between screens and passing data between them. But after spending more time with the documentation and experimenting with different approaches, I now appreciate how flexible the navigation system is. It’s crucial for building fluid, intuitive user experiences, and once you get the hang of it, it feels natural.

What I’d Change: Handling of UI Performance

One area where I’d like to see improvement in React Native is in its handling of complex UIs. While React Native does a great job at rendering most UI components, when dealing with large lists or complex animations, the app’s performance can sometimes suffer, especially on lower-end devices. To address this, I’ve learned to use libraries like React Native’s FlatList component, which optimizes rendering large lists by only rendering items that are visible on screen. However, it’s still an area where I think React Native could improve out-of-the-box performance for highly dynamic UIs.

Most Difficult Learning Curve: React Navigation

As mentioned earlier, React Navigation had the most difficult learning curve for me. I spent a lot of time trying to understand how the different navigators worked together and how to pass data efficiently between screens. It was tricky getting things to work as expected, but now that I’ve got the hang of it, I can confidently build navigation flows and handle user input in a seamless manner. React Native’s official documentation was helpful here, but there was a lot to absorb in terms of configurations and best practices.

Easiest Technology: Expo for Development

One of the easiest technologies I’ve worked with in this stack is Expo. Expo is a framework and platform for React Native that provides a suite of tools to simplify development. It includes things like a development server, hot reloading, and easy access to native device functionality like the camera or location services. Expo made it incredibly easy to get up and running with React Native, and I was able to see my changes instantly without much configuration. For anyone just starting out with React Native, I highly recommend using Expo to quickly prototype and test your app.

If I Could Start Over: Alternative Technologies

If I had to start over, I might consider using Flutter instead of React Native. Flutter, developed by Google, also allows for cross-platform development but has a different approach to rendering UI elements. While React Native relies on native components, Flutter uses its own rendering engine, which can result in more consistent UIs across different platforms. That said, I’m happy with React Native for this project, and I’ve learned a lot by sticking with it.

Technology I Wish Was Included: TypeScript

One technology I wish I had included in my stack earlier is TypeScript. While React Native is perfectly functional with plain JavaScript, using TypeScript could have helped catch type-related bugs early in development. As the project grows in complexity, having strong typing would make the codebase more robust and easier to maintain. If I had the chance to add TypeScript from the start, I definitely would.

As a CS student, I’ve definitely looked back at my old code and wondered, “What was I thinking?” I feel like we’ve all been there, writing code that works but isn’t easy to understand. That’s where clean code comes in. It’s not just about making your code look nice; it’s about writing code that’s readable, maintainable, and easy for others (or your future self) to work with.

---

What is Clean Code?

Clean code is code that is easy to read and understand. It’s like writing an essay that’s clear and well-organized, not just grammatically correct but also easy to follow. When your code is clean, it’s easier to debug, and when its easier to debug it’s also easier to maintain, and scale.

---

One Good Practice: Meaningful Variable Names

One thing I’ve learned is the power of meaningful variable names. Instead of using generic names like a or x, descriptive names help anyone reading your code understand what each variable represents.

Example:

# Bad
a = 10
b = 5
c = a + b

# Good
length = 10
width = 5
area = length + width

Using length, width, and area makes the code much clearer. Good naming doesn’t just help others; it helps you when you revisit the code later.

---

One Bad Practice to Avoid: Code Duplication

Code duplication may seem harmless, but it leads to maintenance problems. When you copy and paste code, you risk making mistakes when you need to update it. Reusing functions keeps your code cleaner and easier to modify.

Example:

# Bad
def calculate_rectangle_area(length, width):
    return length * width

def calculate_square_area(side):
    return side * side

# Good
def calculate_area(length, width):
    return length * width

def calculate_square_area(side):
    return calculate_area(side, side)

Here, the calculate_area function is reused, making the code shorter and more maintainable.

---

Why Clean Code Matters

Writing and focusing on clean code is a practical approach that makes your code easier to work with. As you grow in your programming journey, clean code will save you time and effort in debugging and collaboration. It makes your code future proof and scalable.

---

Wrapping Up

For me, the key takeaway is to start using more descriptive variable names and to avoid code duplication. These small changes make a huge difference in making code more readable and maintainable. Clean code might take extra effort up front, but it pays off in the long run.

---

References:

• Robert C. Martin, Clean Code: A Handbook of Agile Software Craftsmanship
• Martin Fowler, Refactoring: Improving the Design of Existing Code

1. Handling Stress: Take it Step by Step

Stress often comes from feeling overwhelmed, so break big tasks into smaller, manageable steps. Create a to-do list with achievable goals and focus on one task at a time. Need a quick breather? Try the 4-7-8 breathing technique, inhale for 4 seconds, hold for 7 seconds, and exhale for 8 seconds. It works wonders to calm your mind.

2. Working with Teammates: Communicate and Collaborate

Teamwork can be tricky, but clear communication makes all the difference. Use tools like Discord or Trello to keep everyone on the same page. Set clear deadlines and expectations early, and don’t hesitate to speak up if issues arise. Remember, a little empathy goes a long way, everyone’s juggling something.

3. Tackling Classwork: Prioritize and Plan

Organize your workload by prioritizing assignments with closer deadlines or higher weightage. Tools like Notion or Google Calendar can help you visualize your week and stay on top of due dates. Study smarter by focusing on the concepts you find most challenging, and don’t be afraid to ask for help from professors or peers.

4. Getting Unstuck: Change Your Perspective

When you hit a mental block, step away. A short walk, a workout, or even a snack break can help reset your brain. If you’re stuck on a problem, explain it to someone else or write it down. Sometimes, the solution becomes clearer when you reframe the issue.

5. The Power of Routine

A consistent routine helps reduce decision fatigue. Set regular times for studying, meals, and relaxation. It’s amazing how much easier life feels when your brain knows what to expect next.

6. Celebrate Small Wins

Don’t wait for the big milestones to reward yourself. Celebrate every little victory, finishing a tough assignment, completing a group meeting, or even just making it through a hectic week.

Final Thoughts

College is a journey, and it’s okay to feel overwhelmed sometimes. What matters most is how you handle those moments. By staying organized, communicating effectively, and knowing when to take a step back, you can face any challenge head-on.

In today’s tech job market, I’m always looking for ways to stand out, so recently, I decided to start learning Salesforce. As a widely-used CRM, Salesforce skills are in high demand across various industries, and it seemed like a smart addition to my resume.

Why Salesforce?

Salesforce’s broad applications make it a valuable skill for both technical and business roles. I started with Trailhead, Salesforce’s self-paced learning platform, which uses gamified modules and badges to keep things engaging. I focused on basics like creating workflows and managing data. Though the terminology felt complex initially, taking it step-by-step helped, and I’ve begun to feel confident in my skills.

Challenges and Progress

My first real win was building a simple custom app in Trailhead, which showed me I could apply my skills to meet real-world business needs. My goal is to eventually earn a Salesforce certification, making my experience official and more attractive to employers.

Advice for Beginners

If you’re considering Salesforce, start with a focused path like “Admin” or “App Builder” on Trailhead and take it one module at a time. The hands-on learning is worth it and builds confidence quickly.

Learning Salesforce has added a practical layer to my CS studies, and I’m excited to see where these new skills might take me in the tech field.

Welcome to Software Stories with Christopher Jones

Hey everyone, welcome to my blog! I’m Christopher Jones, a senior Computer Science student at Oregon State University, based out of Long Island, New York (Eastern Time Zone). I’m really excited to share my journey through software engineering, especially as I wrap up my degree.

A Little About Me

I got into computers and software when I was younger, always fascinated by how things work behind the scenes. Whether it was playing video games or taking apart devices just to see if I could put them back together, I’ve always had a passion for technology. That passion only grew, and it led me to pursue my degree in Computer Science here at OSU.

When I’m not buried in code, I enjoy mountain biking, playing guitar, lifting weights, and video games. Staying active and exploring the outdoors are my favorite ways to unwind after a long day, especially during the Spring and Summer. Gaming and playing guitar keeps me sharp and also reminds me of the importance of creativity and expression.

Welcome to blogs.oregonstate.edu. This is your first post. Edit or delete it, then start blogging!