ZIP buffers values until matching pairs are available

CombineLatest - picks up the latest value from the upstream.

CombineLatest:

• One buffer slot per publisher

• Only keeps most recent value

• Example: a.send(1), a.send(2) - only 2 is buffered -The buffering is done by the combineLatest

Zip:

• Unlimited buffer per publisher

• Keeps values in sequence

• Example: a.send(1), a.send(2) - both 1 and 2 are buffered - The buffering is done by the ZIP

This is a reason Zip is good for sequential operations while CombineLatest is better for state/UI updates.

Here is a visual representation of how ZIP can be used for password validation

What do you think of it is?

It is a buggy implementation as a change in user name or password will require another change in the other publisher as well. A combineLatest is an appropriate candidate here.

Whats a good use case?

File Upload with Thumbnail

class Fileuploader {
    let fileData: AnyPublisher<Data, Error>
    let thumbnailData: AnyPublisher<Data, Error>
        private var cancellables = Set<AnyCancellable>()

    func uploadWithThumbNail() {
        Publishers.Zip(fileData, thumbnailData)
            .sink(receiveCompletion: { completion in
                switch completion {
                case .finished:
                    print("Both file and thumbnail uploaded")
                case .failure(let error):
                    print("Upload failed: \(error)")
                }
            }, receiveValue: { (file, thumbnail) in
                // Both are guaranteed to be ready together
                // One can't proceed without the other
                self.uploadToServer(file: file, thumbnail: thumbnail)
            })
            .store(in: &cancellables)
    }
}

CombineLatest is an operator that combines more than one publishers, then provides a tuple of the latest value from each publisher.

The combined publisher doesn’t produce elements until each of its upstream publishers publishes at least one element.

When to use?

When we want the downstream subscriber to receive the data of the most-recent element from more than one publishers.( when any of them emit a value.)

BMI Calculator example:

            class BMIViewmOdel: ObservableObject {
    @Published var height: Double = 0
    @Published var weight: Double = 0
    @Published var bmi: Double = 0
    @Published var type: String = "Obese"

    private var cancellables = Set<AnyCancellable>()

    init() {

        Publishers.CombineLatest($height, $weight)
            .map { height, weight in
                let heightInMeters = height / 100
                return weight/(heightInMeters * heightInMeters)
            }
            .sink{ [weak self] (bmi: Double) in
                self?.bmi = bmi
                self?.updateType(bmi)
            }.store(in: &cancellables)
    }

    private func updateType(_ bmi: Double) {
        self.type = switch bmi {
        case ..<18.5: "Underweight"
        case 18.5..<24.9: "Normal"
        case 24.9..<29.9: "Overweight"
        default: "Obeese"
        }
    }


}

struct ContentView: View {
    @StateObject var viewModel : BMIViewmOdel = BMIViewmOdel()
    var body: some View {
        Form {
            Section("Input") {
                TextField("Height", value: $viewModel.height, format: .number, prompt: Text("Enter heigh"))
                TextField("Weight", value: $viewModel.weight, format: .number, prompt: Text("Enter the weight"))
            }

            Section("Result") {
                Text("BMI: \(viewModel.bmi)")
                Text("Category: \(viewModel.type)")
            }

        }  .navigationTitle("BMI Calculator")
    }
}

Key items to note:

1. Won't emit ANY values until ALL publishers have emitted at least once

2.After the initial values are received, CombineLatest maintains the most recent value from each publisher. (Even if it is a passthrough subject although passthrough subject does not hold the value. :) )

Being rejected by an online form would feel like the end of the world to me. 😅

What brought about the change in my perspective? Two primary understandings:

1. Embracing the power of iteration and compounding:

I found that with repetitive, mindful practice, we can acquire and refine skills. Seeking perfection right off the bat often sets us up for disappointment.

2. Shattering the myth of perfection:

I learned that real progress is in attempts, feedback, and, believe it or not, rejections. Rejections aren't the end, but necessary steps on our journey towards success.

3. Transforming Rejections into Positive Sum Games: A Life and Interview Perspective

Typically, when we're rejected for a job, a proposal, or any opportunity, it's easy to view the situation as a zero-sum game. We think we've lost, and the person or entity rejecting us has won. This can lead to feelings of personal failure, as if the rejection is a commentary on our value or worth.

For example, in a job interview scenario, you may not get the job, but that doesn't mean you're 'losing.' You gain experience, insight, and potentially feedback to help you improve for future interviews. Meanwhile, the company that rejected you isn't 'winning' in the sense of causing your loss; they're simply choosing the candidate that best fits their current needs.

1. What some one has learned with multiple iterations can not be mastered by me with few iterations

   The reality is that even though I want to win/be accepted in an exam, if someone else has gone through more iterations than me, the likelihood of the other person being accepted is higher. What is in my control is increasing the iterations I do and be ready to be accepted for another opportunity

So, understanding rejection in the context of a non-zero sum game helps to depersonalize it. It allows us to see rejection as a part of the process rather than an end in itself, encouraging growth, learning, and resilience.

Handling interview rejections is still a unique challenge. They're never pleasant, but they're also seldom personal. Several factors can play a part:

1. our state of mind on the day

2. competition

3. even an overwhelmed interview panel.

It's essential to remember that rejections are less about us as individuals and more about the specific requirements at that moment. There will be a day when we will reject someone else and realize that it isn't about them as individuals either.

Rejections are universal, inevitable, and difficult. Yet, they also offer opportunities for learning, growth, and resilience. I'm already curious about how I'll handle my next rejection after penning down these thoughts. 🤔

So, what's your experience? How do you approach rejections, and what lessons have they taught you? Let's start a conversation!

#rejections #failures #growthmindset #iteration #gametheory

This time I decided to let it be reviewed by LLMs ChatGPT and Bard.

Prompt

Hypothesis: Patience and Calm mind is the strategy. Rate this on different parameters of a hypothesis in scale 1-10

ChatGPT:

Bard

My understanding and follow up

I was puzzled by the testability score gap between the 2 models.

ChatGPT had 3/10

Bard had 7/10

As I read through, I learned that chatGPT was considering that Calm mind and patience is subjective and can not be measured. Hence the Hypothesis can not be tested.

Whereas Bard assumed that Calm mind and Patience if can be measured will lead to better the testability of the success of those who practice it.

ChatGPT does not make the assumption that mindset and Calmness can be measured objectively.

Bard makes the assumption and goes on to correlate the success with the assumptions.

Both are correct.

So Why would different models have different response?

Obviously they have different data sets.

What other factors that affect them?

Here is bard's response:

Here is chatGPT's response:

1. Requirements for a Feature

2. Growth in Organization

3. Appraisal

4. Debugging an issue that rarely occurs in production

5. Working with a new team member who does not share tribal knowledge of your team

6. Learning a new programming language

Under all these cases, if we have to solve problems sustainably and maintain good relationships with people we collaborate, we need patience with ourselves and with others

Each time we go through challenging situation, patience is the safest choice but often not the easiest .

Does it make business sense to be patient?

1. Patience helps one make better decisions and plans grounded in reality.

2. Patience helps one move from Fear by default mode to Trust by default mode. Fear by default always results in short term gains and long term debts

Quality of our Decisions affect our quality and reliability of ourselves as a product and the product we build.

Is it hard to be patient?

Yes and No.

If we do not consider it as a skill which takes time to learn, then Yes, it is hard to develop patience.

Patience is a skill and can be built by exercising it at every opportunity mindfully and recognizing the benefits you get out of it.

Recognize that Patience just like anyother skill needs time to become a second nature because it is about growing out of our comfort zone and better managing our frustrations.

We develop the muscle over several iterations. The more mindful we go through a phase, the earlier we can master patience for that situation.

How to develop patience?

First recognizing that this can not be achieved over a day or a week or a month is important. There will be moments where when you believe that you developed patience, a new situation will topple your current mindset and you might end up acting impulsively.

The below items helps one with developing patience

1. Setting realistic expectations for ourselves.

   1. Not every day is the same. Based on our daily circumstances, we should adjust our expectations of ourselves accordingly.

2. Practicing Gratitude

   1. Helps us from focusing on what we have got instead of what we are lacking

3. The Ultimate: Self Care

   1. No one will care about us more than ourselves. We know what we are going through. This is the foundation part of developing Patience

Ending

Finally, remember that developing a skill requires the mindset to reframe skill development as a process of progress rather than an achieved state.

https://www.meetup.com/succeeding-in-software-career/events/292729665/

It was a virtual event.

Agenda:

To understand how often to meet and what to discuss.

Story time

Mars Climate Orbiter's mission failure was discussed. This was lost due to a misunderstanding between metric and imperial units.

Outcomes planned for this group

1. Discuss and learn about growing technically and getting promotions with in a organization

2. Finding relevant career opportunties for members here and share them

3. Next meeting to be in Person and in chennai

I could think of "writing" and "Paintings"

Paintings suffer from a problem which is context, unlike writing.

When writing as a communication medium began, asynchronously lot of people would have access to knowledge an older group of people experienced.

For Example:

The below one in tamil was written some 2000 years ago by Thiruvalluvar with 7 words. Its meaning can change anyone who reads it.

தெய்வத்தான் ஆகா தெனினும் முயற்சிதன்

மெய்வருத்தக் கூலி தரும்.

It's meaning:

Even though God be against it, Effort is bound to pay the wages of labour.

1. Adaptability

2. Learnability

Anxiety adversly affects both of them.

Tools which I often use while programming which I did not have to use for my prototype:

1. Stackoverflow

2. Google

What kind of work chatGPT has been good at until now for me?

1. Instructions to configure resources in Azure

2. Based on the context given, it is really good for creating javascript-related code

What kind of companies will be benefitted?

1. Start-ups who are finding PMF

   1. You can get a prototype done as fast as possible without ChatGPT

2. For Established Companies

   1. Any new feature developments.

Edge browser

I was never able to log in to chatGPT from the Edge browser. Chrome and Firefox had no issues.

1. Google Analytics

2. Tealium

3. Firebase

What did I like about Google Analytics?

1. It's interactiveness

2. The user segmentation

How does it help me?

1. Form a hypothesis.

2. Frame it as a question to validate the hypothesis

3. Create relevant user segmentation and validate the events

Example:

Hypothesis

The % of successful signup is 100 on Mobile devices

Question

Do mobile users have 100% successful signups?

How do I test it?

1. Create a user segment of mobile devices - With varied parameters given below

   1. App

   2. Device Brand name

   3. Exclude vs Include

2. Add a secondary dimension if required to look for a specific bunch of events

   1. The event starts/contains with "signup"

Below are my learnings:

1. Operational Expenses and Captial Expenditure are two topics that I enjoy reading about. These 2 topics are the core concepts in Cloud fundamentals. It made my learning so much more enjoyable.

2. Power of elimination: As I learned about the fundamentals it was easy to eliminate what could not be the correct answer

Preparation:

I used the below resources to prepare for it:

1. Az-900-1

2. Az-900-2

3. Azure Fundamentals

   1. This channel explains the concepts from the ground up with an example

During learning

One mistake I did was

not allotting a buffer time of say 2-3 days to revise/reflect on the videos again before the exam

One good thing I did was:

While watching the videos the first time, I analyzed all the options of the answers, not just the correct ones. That helped me mentally map the services and helped me better with the elimination of the answers

1. Stored into variable

2. Returned from a function

3. Passed as an argument

Returning a function from another function and storing them in a variable

func add(p1: Int, p2: Int) -> Int {

return p1+p2

}

func subtract(p1: Int, p2: Int) -> Int {

return p1-p2

}

func multiply(p1: Int, p2: Int) -> Int {

return p1*p2

}

func divide(p1: Int, p2: Int) -> Int {

return p1/p2

}

func mod(p1: Int, p2: Int) -> Int {

return p1%p2

}

The above code is refactored to below where functions are returned from another function and functions are stored in a variable.

enum Operation {

case add

case subtract

case multiply

case divide

case mod

}

func chooseOperator(operation: Operation) -> (Int, Int) -> Int {

func add(p1: Int, p2: Int) -> Int {

return p1+p2

}

func subtract(p1: Int, p2: Int) -> Int {

return p1-p2

}

func multiply(p1: Int, p2: Int) -> Int {

return p1*p2

}

func divide(p1: Int, p2: Int) -> Int {

return p1/p2

}

func mod(p1: Int, p2: Int) -> Int {

return p1%p2

}

switch operation {

case .add:

return add

case .divide:

return divide

case .mod:

return mod

case .multiply:

return multiply

case .subtract:

return subtract

}

}

let addition = chooseOperator(operation: .add)

addition(1, 2)

let multiplication = chooseOperator(operation: .multiply)

multiplication(3, 2)

1. Aspiration

2. Jealousy

3. Fear

4. Hope

5. Love

6. Hate

Just like us others also long for the below:

1. Good salary

2. Promotions

3. Appreciation - Recognition for work

How are we different from others?

Each of our approaches to coping( with stress)

If our coping strategy leads us to

jealousy instead of aspiration,

fear instead of hope,

hate instead of love,

it is time to change our approach to coping with stress.

What lies at the foundation of this difference?

Fixed mindset vs Growth Mindset

How do I build a better coping strategy?

1. Remind yourself of how good you were without stress or with good coping strategies in the past

2. Write down your wins

3. Appreciate yourself for even small wins. None can notice that. You deserve kudos for even minor improvements. Be your cheerleader

4. Realize that this is an infinite game and you might have failures but by learning from them you will have more wins

5. Understand your journey is different from others. Never ever compare yourself to others if it causes jealousy.

Wrong decision helps us with a learning.

No decision only delays the unknown and let’s us be in fear and make things worse than what it could actually lead to.

No decision is still a decision. 😊

Making a wrong decision earlier also helps us build knowledge to course correct towards better decisions sooner than No decision approach.

Another factor to consider here is Reversible and Irreversible

Returns the result of combining the elements of the sequence using the given closure.

Can we form the result of a map/filter function using reduce?

Yes.

Reduce function takes a sequence as an input and returns a generic output not. By setting the appropriate initial result and closure function we can exploit the reduce function to return another sequence instead of a single value result.

Reduce function as a map

let numbers1 = [1, 2, 3, 4]
let numberSum1 = numbers1.reduce([], { x, y in
    return x + [2*y]
})
print(numberSum1)

Result

[2, 4, 6, 8]

Reduce function as a filter

let numberSum2 = [1, 2, 3, 4].reduce([], { x, y in
    return x + ((y % 2 == 0) ? [y] : [])
})

print(numberSum2)

Result

[2, 4]

Article that inspired me to write this post: https://swiftunboxed.com/lang/reduce/

1. It has value semantics and hence variable and value is unified.
2. Each instance can have only one owner
3. The value held by a variable can not be manipulated without changing the variable itself
4. Efficient compared to class due to copy on write and no involvement of retain count management
5. A Code that uses struct without any of its members being reference type is easy to reason because ownership is clearly defined
6. No memory leaks to deal with
7. When a variable becomes immutable, the instance also becomes immutable and if a variable is mutable then the instance also becomes mutable when it has mutable variables or mutable methods.

Classes:

1. The variable and instance are different and hence both can be manipulated separately
2. Each instance can have more than one owner
3. If an instance is amended, then all the references represented by different variables will be impacted
4. When a variable holding reference is made as immutable only the reference the variable holds is immutable not the instance the reference is pointing to. To make a class instance immutable, all its stored properties must be immutable

Thanks to KHAWER KHALIQ for providing such comprehensive writing on structs vs classes

https://khawerkhaliq.com/blog/swift-value-types-reference-types/

1. Executes only one item at a time irrespective of the number of tasks in the Queue
2. Good when there is a necessity to provide controlled access to a queue

func serialQueue() {
    let serialQueue = DispatchQueue(label: "test.com")
    serialQueue.async {
        sleep(10)
       print("SERIAL 1")

    }
    serialQueue.async {
        print("SERIAL 2")
    }
}

Result:

SERIAL 1
SERIAL 2

Irrespective of the sleep function value SERIAL 2 will be printed only after SERIAL 2 as in serial Queue the processing of the task will be in the order in which tasks gets added to the Queue.

Concurrent Queue:

1. Executes multiple tasks (if added) at a time

func customConcurrentQueue() {
    let concurrentQueue = DispatchQueue(label: "test.concurrentqueue", attributes: .concurrent)
    concurrentQueue.async {
        print("CONCURRENT Task 1 started")
        print("CONCURRENT Task 1 finished")
    }
    concurrentQueue.sync {
        print("CONCURRENT Task 2 started")
        print("CONCURRENT Task 2 finished")
    }
}
customConcurrentQueue()

Result of Execution 1:

CONCURRENT Task 1 started
CONCURRENT Task 2 started
CONCURRENT Task 2 finished
CONCURRENT Task 1 finished

Despite Task 1 beginning first, Task 2 which began later was completed. That is concurrency.

Result of Execution 2:

CONCURRENT Task 2 started
CONCURRENT Task 1 started
CONCURRENT Task 2 finished
CONCURRENT Task 1 finished

Synchronous

When a task is executed synchronously, the calling thread is blocked, and only when the execution is completed, the calling thread can continue its execution

Sync in Concurrent Queue

func testSyncInConcurrent() {
    DispatchQueue.global().sync {
        print("1")
    }
    print("Post Sync Execution")
    DispatchQueue.global().async {
        print("2")
    }
    DispatchQueue.global().async {
        print("3")
    }
}
testSyncInConcurrent()

Result

1
Post Sync Execution
3
2

Irrespective of any number of executions, 1 will be always printed first in sequence as testSyncInConcurrent() is blocked by the synchronous block of execution.

Sync in Serial Queue

func testSyncinSerial() {
    let serialQueue = DispatchQueue(label: "test.com")
    serialQueue.sync {
        print("1")
    }
    print("Post Sync Execution")
    serialQueue.async {
        print("2")
    }
    serialQueue.async {
        print("3")
    }
}
testSyncinSerial()

Result:

1
Post-Sync Execution
2
3

Asynchronous:

When a task is executed asynchronously, the calling thread is not blocked and can continue to execute other tasks it has been enqueued with.

Let us execute all async tasks in a serial Queue. Since serial queue does always execute the tasks one by one, even though the tasks are asynchronous in nature, they get executed one by one.

func testAsyncInSerial() {
    let serialQueue = DispatchQueue(label: "test.com")
    serialQueue.async {
        print("1")
        sleep(10)
    }
    print("Post ASync Execution")
    serialQueue.async {
        print("2")
    }
    serialQueue.async {
        print("3")
    }
}

Result:

1
Post ASync Execution
2
3

Let us execute multiple async tasks in a concurrent queue. Unlike the last time in serial queue, the order of execution does not follow as the tasks are added to the queue. With each new execution of the code the order of tasks executed has changed.

func testAsyncInConcurrent() {
    let concurrent = DispatchQueue.global()
    concurrent.async {
        print("BEGIN 1")
        sleep(10)
        print("END 1")
    }
    print("Post ASync Execution")
    concurrent.async {
        print("BEGIN 2")
        print("END 2")
    }
    concurrent.async {
        print("BEGIN 3")
        print("END 3")
    }
}
testAsyncInConcurrent()

Result of Execution 1

BEGIN 1
Post ASync Execution
BEGIN 2
END 2
BEGIN 3
END 3
END 1

Result of Execution 2:

BEGIN 1
Post ASync Execution
BEGIN 3
END 3
BEGIN 2
END 2
END 1

console.log("A" > "a") //Intuition says true

Swift:

print("A">"a") //Intuition says true

What is the expected result? My mental about English alphabets were Upper case letters were bigger than Lower case letters. Hence I expected the result to be true.

Result is:

false

Why is my intuition wrong?

My mental model of alphabets was correct in Real-world but the Programming languages' model about alphabets are different than mine.

Index of a in Unicode table - 0061

Index of A in Unicode table - 0041

An interesting perspective I read about Intuition and programming is here

References:

https://www.unicode.org/charts/PDF/U0100.pdf

https://unicode-table.com/en/#basic-latin

https://javascript.info/comparison