Today, I have completed and submitted the last entry of my graphics design assignment.

I was supposed to create a figma UI for the company's website and support my knowledge of UI UX laws and principles in the written report.

Honestly, it was a bit harder than I expected. I took some time to get used to the new tool and it's features. But I think I did a good use of them and hope to receive a mark for this 😅.

Some of my friends helped me out when it comes to the requirements of the assessment. Gotta give her the credits.

Now, with ISDS and IMOB finals being left, I bravely march forward, carrying my sword 🗡️ to eliminate the rest of the exams ...

Wish me luck 🤞🏻 🍀

I have recently started revising the materials from the Introduction to Statistics and Data Science module at WIUT.

Here is what i love about the module:

• It covers a great range of things that are widely in every domain

... more to come

Today, I have been called to viva for the first time ever.

Initially, I got 98 from the coursework, and that caused questions in the examiner. I mean, if I was using GenAI or just copying others' work.

I did it all by myself, and It took quite a time to complete you know, as I was aiming to get something near 100.

However, thankfully, I managed to pass it and it was easy. The hard part was to get to this day 😂. I have been just going nuts, thinking about worst case scenario.

Ahh, relief... But for a moment.

Now here comes my finals

Wish me luck 🤞🏻 and pray for me ❤️

Peace 🕊️✌️

Prologue

In the heart of a bustling city, where the glow of monitors illuminates the night and the rhythmic tapping of keyboards creates a symphony of innovation, a young developer named Alex embarked on a journey that would change everything. This is a tale of perseverance, curiosity, and the relentless pursuit of mastery in the world of software development.

Chapter 1: The First Steps

Alex's journey began with a simple curiosity about how websites worked. The first encounter with HTML and CSS was like discovering a new language—cryptic yet fascinating. Hours were spent tweaking styles, adjusting margins, and experimenting with colors. The joy of seeing a static webpage come to life ignited an insatiable thirst for more knowledge.

One day, while browsing forums and open-source repositories, Alex stumbled upon JavaScript. It was a revelation. No longer confined to static elements, the newfound ability to manipulate the DOM and create interactive experiences was exhilarating. However, with this power came complexity. Debugging became a daily struggle, but every solved problem brought a deeper understanding and an ever-growing confidence.

Chapter 2: The Framework Chronicles

With a solid foundation in front-end technologies, Alex ventured into the world of frameworks. React, Vue, and Angular were whispered among developers like ancient spells of efficiency and reusability. Choosing React, Alex embraced the component-based architecture, state management, and the magic of hooks. But soon, the limitations of front-end knowledge became apparent—without a proper backend, the applications felt incomplete.

Diving into Node.js and Express, Alex built the first full-stack application—a simple task manager. The ability to store data in a database and retrieve it dynamically felt like wielding a newfound power. However, maintaining a growing application introduced new challenges—scalability, security, and performance optimization.

Chapter 3: The Open-Source Odyssey

Eager to learn from real-world projects, Alex explored open-source contributions. GitHub became a second home. Fixing bugs, writing documentation, and reviewing pull requests became daily routines. The first accepted pull request was a milestone—a validation that the journey was on the right path.

Through open-source, Alex met like-minded developers, joined hackathons, and contributed to major projects. Collaboration taught invaluable lessons about code quality, testing, and software architecture.

Chapter 4: The Cloud and Beyond

As applications grew in complexity, deployment and infrastructure became critical. Learning Docker, Kubernetes, and cloud services like AWS and Google Cloud opened a new dimension of software engineering. CI/CD pipelines automated deployments, and containerization ensured consistency across environments.

Alex’s journey also led to exploring backend frameworks like Django and FastAPI, improving API efficiency and security. Understanding databases, caching strategies, and microservices architecture added layers of expertise.

Chapter 5: The Mentor and the Apprentice

With years of experience and countless projects, Alex found a new purpose—mentorship. Helping aspiring developers navigate the learning curve became a passion. Sharing knowledge through blogs, talks, and workshops solidified concepts and reinforced the importance of community-driven learning.

Epilogue

The journey of a developer is never truly over. Technologies evolve, paradigms shift, and new challenges emerge. But the core of the journey remains unchanged—a passion for learning, a drive for problem-solving, and a commitment to innovation.

Alex’s story is not unique; it’s a story shared by countless developers across the world. And just like Alex, every developer has the power to carve their own path, leaving a mark on the ever-expanding universe of software development.

About This Repository

This repository embodies the spirit of Alex’s journey—a place for learning, collaboration, and innovation. Whether you're here to contribute, learn, or seek inspiration, remember that every line of code is a step forward in your own adventure.

Happy coding! 🚀

To manage and use two different GitHub accounts on your MacBook (M1 Air), you can configure your SSH keys and Git configurations for each account. Here's a step-by-step guide:

1. Generate Separate SSH Keys for Each Account

First, you need to generate SSH keys for both GitHub accounts.

For the 1st GitHub Account (00017501.wiut.student@gmail.com):

1. Open your terminal and generate an SSH key:

   ssh-keygen -t rsa -b 4096 -C "00017501.wiut.student@gmail.com"
   

2. When prompted to save the file, save it as:

   /Users/your-username/.ssh/id_rsa_00017501
   

3. When asked for a passphrase, you can leave it empty or set one (optional).

For the 2nd GitHub Account (hamidaxtamov1@gmail.com):

1. Generate another SSH key for the second account:

   ssh-keygen -t rsa -b 4096 -C "hamidaxtamov1@gmail.com"
   

2. Save it as:

   /Users/your-username/.ssh/id_rsa_hakucodes
   

3. Set a passphrase if needed (optional).

2. Add SSH Keys to SSH Agent

Once you've generated the keys, add them to the SSH agent.

1. Start the SSH agent:

   eval "$(ssh-agent -s)"
   

2. Add both keys to the SSH agent:

   For the 1st account:

   ssh-add ~/.ssh/id_rsa_00017501
   

   For the 2nd account:

   ssh-add ~/.ssh/id_rsa_hakucodes
   

3. Add SSH Keys to GitHub

You need to add the generated public SSH keys to their respective GitHub accounts.

1. Copy the public key for each account:

   For the 1st account:

   pbcopy < ~/.ssh/id_rsa_00017501.pub
   

   For the 2nd account:

   pbcopy < ~/.ssh/id_rsa_hakucodes.pub
   

2. Go to your respective GitHub profiles:

   • For the 1st account, navigate to Settings > SSH and GPG keys > New SSH key and paste the key.
   • Do the same for the 2nd account.

4. Configure SSH Config File for Multiple Accounts

Next, you need to configure your SSH config file so Git knows which SSH key to use for each account.

1. Open the SSH config file in your editor:

   nano ~/.ssh/config
   

2. Add the following configuration:

   # For 1st GitHub Account (00017501)
   Host github.com-00017501
       HostName github.com
       User git
       IdentityFile ~/.ssh/id_rsa_00017501
   
   # For 2nd GitHub Account (hakucodes)
   Host github.com-hakucodes
       HostName github.com
       User git
       IdentityFile ~/.ssh/id_rsa_hakucodes
   

   This tells Git which SSH key to use for each account.

5. Use Different GitHub Accounts in Different Repositories

Now, you can associate a specific GitHub account with each repository by configuring the git remote URL to match the correct SSH configuration.

For the 1st Account (00017501):

1. Navigate to the repository where you want to use the first account:

   cd /path/to/your/repo
   

2. Set the remote URL to use the 1st account:

   git remote set-url origin git@github.com-00017501:yourusername/yourrepo.git
   

For the 2nd Account (hakucodes):

1. Navigate to the repository where you want to use the second account:

   cd /path/to/your/second-repo
   

2. Set the remote URL to use the 2nd account:

   git remote set-url origin git@github.com-hakucodes:yourusername/yourrepo.git
   

6. Set Git User Config for Each Repository

To make sure commits are linked to the correct GitHub account, you need to set the user email and name for each repository.

For the 1st Account:

1. Navigate to the 1st account's repository:

   cd /path/to/your/repo
   

2. Set the username and email:

   git config user.name "00017501"
   git config user.email "00017501.wiut.student@gmail.com"
   

For the 2nd Account:

1. Navigate to the 2nd account's repository:

   cd /path/to/your/second-repo
   

2. Set the username and email:

   git config user.name "hakucodes"
   git config user.email "hamidaxtamov1@gmail.com"
   

7. Verify the Setup

To ensure everything is set up correctly, run the following commands in your repositories to check if the correct SSH key and user info are being used.

• Check the remote URL:

  git remote -v
  

• Check the commit user configuration:

  git config user.name
  git config user.email
  

Conclusion

By following these steps, you can seamlessly work with two different GitHub accounts on your MacBook. The SSH key setup will allow you to push and pull from repositories linked to either account, while the user configuration will ensure your commits are correctly attributed to the right GitHub account.

Python Engineer

We seek a highly skilled Python Engineer with expertise in cloud computing and a strong focus on integrating AI capabilities into our projects. The ideal candidate will possess robust proficiency in Python and its frameworks, coupled with a deep understanding of at least one major cloud provider.

Additionally, familiarity with Large Language Models (LLM) and Retrieval Augmented Generation (RAG) is essential for seamlessly integrating AI capabilities.

Responsibilities

• Facilitate development and deployment of cloud-native solutions, highlighting AI integration in our projects
• Architect and launch AI-driven applications, leveraging Python frameworks such as Django, Flask or FastAPI
• Integrate Large Language Models (LLM) and Retrieval Augmented Generation (RAG) into ongoing and upcoming projects to enhance language understanding and generation capabilities
• Team up with various cross-functional teams to comprehend project objectives and convert them into AI-driven technical resolutions
• Implement AI-based features and functionalities, utilizing cloud-native architectures and industry-standard practices
• Write maintainable and well-documented code, adhering to coding standards and best practices
• Stay updated with the latest advancements in Python, cloud computing, AI, and Cloud Native architectures, and proactively suggest innovative solutions to enhance our AI capabilities

Requirements

• Proven expertise in Python programming language, with significant experience in AI integration
• Proficiency in cloud computing with hands-on experience in major cloud platforms such as AWS, Azure, or Google Cloud Platform
• Familiarity with Large Language Models (LLM) and Retrieval Augmented Generation (RAG)
• Excellent problem-solving abilities and the capability to effectively collaborate within a team setting
• Superior communication skills and the competence to seamlessly explain complex technical concepts to non-technical stakeholders

Nice to have

• Knowledge of Cloud Native architectures and experience with tools like Kubernetes, Docker and microservices

We offer

We connect like-minded people:

• Delivering innovative solutions to industry leaders, making a global impact
• Enjoyable working environment, whether it is the vibrant office or the comfort of your own home
• Opportunity to work abroad for up to two months per year
• Relocation opportunities within our offices in 55+ countries
• Corporate and social events

We invest in your growth:

• Leadership development, career advising, soft skills and well-being programs
• Certifications, including GCP, Azure and AWS
• Unlimited access to LinkedIn Learning, Get Abstract, O'Reilly
• Free English classes with certified teachers
• Discounts in local language schools, including offline courses for the Uzbek language

We cover it all:

• Monetary bonuses for engaging in the referral program
• Medical & family care package
• Four trust days per year (sick leave without a medical certificate)
• Discounts for fitness clubs, dance schools and sports programs
• Benefits package (sports activities, a variety of stores and services)

Table of Contents

1. Software Installation
2. RStudio Interface
3. Arithmetic Operations
4. Mathematical Functions
5. Relational Operators
6. Data Classes
7. Missing Data
8. R Objects and Assignment

Software Installation

Required Software

• R: The core programming language
  • Download from CRAN (Comprehensive R Archive Network)
  • Platform-specific versions available for Mac, Windows, Linux
• RStudio: Integrated Development Environment (IDE)
  • Download from Posit website
  • Provides unified interface across operating systems

Important URLs

• R Download: https://cran.r-project.org/
• RStudio Download: https://posit.co/download/rstudio-desktop/

RStudio Interface

Key Components

1. Source Pane (Top Left)

   • Where R scripts are written and edited
   • Save files with .R extension

   # Example script content
   # Calculate average temperature
   temp_celsius <- 25
   temp_fahrenheit <- (temp_celsius * 9/5) + 32
   

2. Console (Bottom Left)

   • Displays executed commands and output
   • Direct command entry possible

   > 2 + 2
   [1] 4
   

3. Environment Pane (Top Right)

   • Shows active variables and objects

   # After running:
   temp_celsius    # Value: 25
   temp_fahrenheit # Value: 77
   

Arithmetic Operations

Basic Operators with Examples

# Addition
5 + 3        # Output: 8
# Subtraction
10 - 4       # Output: 6
# Multiplication
6 * 7        # Output: 42
# Division
15 / 3       # Output: 5
# Exponents
2 ^ 3        # Output: 8
# Modulo (remainder)
17 %% 5      # Output: 2
# Integer division
17 %/% 5     # Output: 3

Order of Operations Examples

# Different results based on parentheses
4 + 2 * 3        # Output: 10 (multiplication first)
(4 + 2) * 3      # Output: 18 (addition first)

# Complex calculation
((10 + 5) * 2) / 5   # Output: 6

Mathematical Functions

Common Functions with Examples

# Square root
sqrt(16)              # Output: 4
sqrt(c(9, 16, 25))   # Output: 3 4 5

# Absolute value
abs(-7.5)            # Output: 7.5
abs(c(-2, 0, 2))     # Output: 2 0 2

# Logarithms
log10(100)           # Output: 2
log(exp(1))          # Output: 1

# Exponential
exp(2)               # Output: 7.389056

Function Help Example

# Getting help for sqrt function
?sqrt
# Returns documentation showing:
# sqrt(x)   # where x is a numeric vector

Relational Operators

Examples with Different Data Types

# Numeric comparisons
5 < 10               # Output: TRUE
7 >= 7               # Output: TRUE
3 == 3               # Output: TRUE
4 != 5               # Output: TRUE

# String comparisons
"apple" == "apple"   # Output: TRUE
"a" < "b"            # Output: TRUE

# Mixed type comparisons
5 == "5"             # Output: FALSE

Data Classes

Type Examples and Conversions

# Numeric
x <- 10.5
typeof(x)            # Output: "double"

# Integer
y <- 10L
typeof(y)            # Output: "integer"

# Character
name <- "John"
typeof(name)         # Output: "character"

# Logical
is_valid <- TRUE
typeof(is_valid)     # Output: "logical"

# Type conversion examples
as.integer(10.7)     # Output: 10
as.character(123)    # Output: "123"
as.numeric("456")    # Output: 456
as.Date(43800, origin = "1899-12-30") # "2019-12-01"

Testing Types

# Using is.* functions
x <- 10.5
is.numeric(x)        # Output: TRUE
is.integer(x)        # Output: FALSE
is.character(x)      # Output: FALSE

# Multiple checks
y <- "123"
is.numeric(y)        # Output: FALSE
is.numeric(as.numeric(y))  # Output: TRUE

Missing Data

Working with NA and NaN

# Creating missing values
x <- c(1, NA, 3, NaN, 5)

# Testing for NA
is.na(x)             # Output: FALSE TRUE FALSE TRUE TRUE

# Calculations with NA
sum(c(1, NA, 3))     # Output: NA
sum(c(1, NA, 3), na.rm = TRUE)  # Output: 4

# NA vs NaN
0/0                  # Output: NaN
NA + 1               # Output: NA

Type Conversion and Comparison

Understanding Type Conversion

# Different numeric types
x_int <- 5L          # integer
x_num <- 5           # numeric/double
x_int == x_num       # Output: TRUE (values are equal)
typeof(x_int) == typeof(x_num)  # Output: FALSE (types are different)

# Detailed example
varA <- 3.3          # double/numeric
varB <- "hello there"  # character
varC <- FALSE        # logical
varD <- 5L           # integer
varE <- 5            # double
varF <- varD + varE  # double (integer + numeric = numeric)
varG <- 2 * varC     # numeric (numeric * logical = numeric)

# Checking types
typeof(varA)   # "double"
typeof(varB)   # "character"
typeof(varC)   # "logical"
typeof(varD)   # "integer"
typeof(varE)   # "double"
typeof(varF)   # "double"
typeof(varG)   # "double"

Key Points About Type Conversion

4. Implicit Conversion

   • R automatically converts between integer and numeric types in calculations
   • Logical values convert to 1 (TRUE) or 0 (FALSE) in numeric operations
   • The "wider" type usually prevails (e.g., integer + numeric = numeric)

5. Value vs Type Comparison

   5L == 5     # TRUE (comparing values)
   typeof(5L) == typeof(5)  # FALSE (comparing types: "integer" vs "double")
   

6. Type Hierarchy

   • character > numeric > integer > logical
   • When mixing types, R usually converts to the higher type

   1L + 2.5    # Result is numeric (2.5 wins)
   TRUE + 1L   # Result is integer (1L wins)
   TRUE + 1.0  # Result is numeric (1.0 wins)
   

R Objects and Assignment

Variable Assignment Examples

# Basic assignment
age <- 25
name <- "Alice"

# Multiple assignments
height <- weight <- 70

# Complex assignments
bmi <- weight / (height/100)^2

# Listing objects
ls()                 # Shows all objects in environment

# Removing objects
rm(age)              # Removes single object
rm(list = ls())      # Removes all objects

Naming Conventions Examples

# Valid names
valid_name <- 1
validName <- 2
VALID_NAME <- 3
.hidden_name <- 4

# Invalid names (will cause errors)
# 1name <- 5      # Can't start with number
# _name <- 6      # Can't start with underscore
# name-1 <- 7     # Can't use hyphen

Practice Exercises: 7. Create variables of different types and test their classes 8. Perform arithmetic operations with variables 9. Try working with missing values and understand their behavior 10. Practice naming conventions and object assignments

References

[[R data type and packages]] -> the continuation of the R chronicles (Week 2)

R programming tutorial -> A 2 hours-long video tutorial

Core Study Context and Background:

• The study investigates the impact of information technology on retail industry, specifically focusing on employee and customer acceptance of smart retail technologies (SRT) in Jordan (549 page)
• Data was collected from 134 retail stores across Jordan's metropolitan cities, with 480 customer responses (558 page)

Key Technology Adoption Findings:

• Technology readiness was found to significantly impact retail performance (β = 0.620), indicating that a 1% increase in technology readiness results in a 62% improvement in retailer performance (561 page)
• Perceived usefulness showed substantial impact (β = 0.576) on retailer performance, suggesting a 57.6% improvement for each 1% increase (561 page)

Smart Retail Technology (SRT) Implementation:

• SRT provides retail customer services through smart device networks and integrated retail infrastructure (551 page)
• The study projects SRT assets to reach $36 billion by 2021 (551 page)

Customer Behavior and Technology Acceptance:

• Store reputation plays a crucial role - consumers see reputable stores as more trustworthy and show favorable attitudes toward SRT (552 page)
• Both employee and customer preparedness need to be considered when implementing new technologies (565 page)

Implementation Challenges:

• Retail stores must ensure smart and user-friendly innovations are introduced to reduce consumer discontent (565 page)
• The study found that intelligent, easy, and realistic technology can reduce consumer discontent and molestation (565 page)

Future Research Recommendations:

• Future studies should investigate customer adoption of specific technologies like smart displays, smart shopping carts, and NFC systems (566 page)
• Research could expand to developing countries like Malaysia, India, and China to increase generalization possibilities (566 page)

Regional Context:

• Jordan's retail sector shows significant potential for growth in modern, organized retail segments (566 page)
• The country's unique geographic location makes it a natural corridor for regional growth and international shopping (566 page)

Study Limitations:

• Respondents could opt out of providing certain details
• Self-administered questionnaires may have impacted efficacy
• Potential sampling errors in randomized sampling locations (566 page)

References

• Source:
  • Research Gate Paper
• Ref:
  • Theeb, K.A., Mansour, A.M., Khaled, A.S.D., Syed, A.A. and Saeed, A.M.M. (2023) ‘The impact of information technology on retail industry: an empirical study’, Int. J. Procurement Management, Vol. 16, No. 4, pp.549–568.

I really liked detailed steps you enlisted and how the technology might require the change in the Karzinka’s internal processes and how to make sure users can adapt to it seamlessly.

However, I would strongly recommend you to prove your arguments with reliable sources from the similar cases that we identified earlier or ones that can be found online.

Here is the illustration from your draft:

“ A comprehensive strategy for implementing this is to, first, create a new app specifically for the self checkout system or to update the current Korzinka application… “ 

Here, you have mentioned the development or update of the existing app and how it will be utilized. The similar idea is discussed in this research paper

It would be so great if you could identify the arguments and advantages for this step from other sources, proving that Karzinka can benefit from it.

In short, the general structure is the following (of course, you can also add your own solutions, but overall recommendation is to support them with external academic sources) :

According to (source authors), bla-bla-bla has successfully worked out, showing (result of the implementation), and thats why Karzinka might as well benefit from integration of the bla-bla-bla by doing bla-bla-bla

You can use in-text citations and proper referencing using this book

Additionally, in my response to Question #2, I also mention a few study cases with some statistical results and where (company or place) the case has taken place , and you may also refer to those justifications.

On top of that, I have earlier send a detail document on the solution that we have chosen with the group (the self-checkout) - that's basically a summary of a related research paper. You may also want to go over it.

Thank you very much 🙏🏻🙏🏻🙏🏻