The Gift of Time: "Why We Shouldn't Rush Our Growth"

Unknown Dev — Sat, 30 Nov 2024 07:39:12 +0000

Why are we in a hurry if we can't pay for time? 💭

In a world that constantly demands instant results and quick fixes, it's easy to forget the value of patience, consistency, and resilience. Personal growth is a journey, not a race. Here's why we should embrace this mindset:

1. Time is Free, Yet Priceless:
Since we can't pay for time, why the hurry? Every second is a gift, an opportunity to learn, grow, and become better. There’s no need to rush through life's precious moments.

2. The Importance of Patience:
Great things take time. Patience is key, whether you're learning a new skill, building a career, or working on personal development. Allow yourself the time to absorb, reflect, and improve without the pressure of immediate success.

3. Consistency is the Secret:
Consistency is what transforms average into excellence. By steadily working towards your goals, even in small daily increments, you build a solid foundation for success. Remember, consistency beats intensity every time.

4. Embrace Resilience:
Challenges and setbacks are part of the journey. Resilience allows us to bounce back, learn from our mistakes, and keep moving forward. Embrace the bumps along the way as they shape you into a stronger, more capable person.

5. Compete Only with Yourself:
Your growth should be your sole priority. Compete only with who you were the previous hour, not with others. This mindset keeps you focused on your journey and prevents unnecessary stress and comparison.

6. Celebrate Small Wins:
Every step forward, no matter how small, is progress. Celebrate your achievements, learn from your mistakes, and keep pushing forward.

Take your time, learn, and stay true to yourself. Personal growth isn’t about racing to the finish line; it’s about enjoying the process and evolving into the best version of yourself.

🌱 Growth is a journey, not a race.

If you find this inspiring, you can confidently Share it and inspire others✨

Day 3 & 4: Double Attack!

Unknown Dev — Fri, 15 Nov 2024 13:13:21 +0000

Day 3 & 4: My TypeScript Journey

Hey Devs! Over the past two days, I’ve been diving deeper into TypeScript and exploring some exciting concepts. Here’s a quick recap of what I’ve learned:

1️⃣ Type Aliases: Simplifying code by creating custom types for better readability and reuse.

type User = {
  id: number;
  name: string;
};

const user: User = {
  id: 1,
  name: "John",
};

2️⃣ Type Assertion: Explicitly telling TypeScript how to treat a variable—it’s all about being precise with data.TypeScript provides two ways to write type assertions, which allow you to tell the compiler to treat a value as a specific type:

1. Angle Bracket Syntax

This uses <Type> before the value:

let cid: any = 1;
let customerId = <number>cid; // "cid" is treated as a number

Note: This syntax doesn’t work in .tsx files because it conflicts with JSX.

2. `as` Syntax (Preferred)

This uses the as keyword after the value:

let cid: any = 1;
let customerId = cid as number; // "cid" is treated as a number

Key Notes:

Type assertions don’t change the runtime value; they only affect how TypeScript understands the value during type-checking.
Use type assertions when you’re confident about the type and want to bypass the compiler’s type inference.

3️⃣ Using Types in Functions: Ensuring my functions are safer by clearly defining parameter and return types.

function addNum(x:number,y:number): number{
    return x + y
}

console.log(addNum(2, 4))

4️⃣ Void: Functions that don’t return anything—it’s great for logging or side effects!

function log(message:string | number):void{
    console.log(message)
}
log('Hello, World!')

5️⃣ Interfaces: Structuring data more effectively, especially with optional and readonly properties.

interface Person{
  readonly id:number
  name:string
  age?:number
}
const user1 : Person={
  id:1,
  name:'john'
}

// interface don't use or allow union
// interface Point = number | string
// const p1:Point = 1

// Only type Alias or type variables allows the use of union
type Point = number | string
const p1:Point = 1

// interface with functions

interface MathFunc{
 (y:number, z:number) :number
}
const add : MathFunc = (y:number, z:number)  => y + z
const sub : MathFunc = (y:number, z:number)  => y - z
const resultAdd = add(2,3)
const resultSub = sub(9,3)
console.log(resultAdd, resultSub)

6️⃣ Classes: Building reusable blueprints for objects with private, public, and protected properties.

class Personal {
 private id: number;
  name: string;
  age: number;

  // class method: functions within a class
  constructor(id: number, name: string, age:number) {
    this.id = id;
    this.name = name;
    this.age = age;
  }
}
const brad = new Personal(1, "Brad Simon", 20);
const ted = new Personal(2, "teddy jones", 20);

console.log(brad, ted);

7️⃣ Generics: Writing reusable, type-safe components—this one was a game-changer!

// Generics: basically used to build reuseable components
function getArray<T>(items:T[]):T[] {
  return new Array().concat(items)
}
let numArray = getArray<number>([1,2,3,4])
let strArray = getArray<string>(['ben','try','grow','build'])

strArray.push('hey')

Weekend Plans 🎯

I also stumbled upon Exercism, a platform with TypeScript challenges, and I’m planning to test everything I’ve learned so far with some of their problems over the weekend. I think this will be a great way to consolidate my first week of learning and tackle real-world scenarios.

Community, I Need You! 🧠

If you’ve tried Exercism or have other resources/tips for sharpening my TypeScript skills, I’d love to hear your thoughts! Also, if you have advice on balancing TypeScript fundamentals with practical projects, I’m all ears.

Check out my wall for posts on my first two days of learning—let’s grow together! 💡

DEV Community: Unknown Dev