DEV Community: dhruv

One Dockerfile, Two Stages: A 50% Size Reduction Story

dhruv — Mon, 03 Nov 2025 04:43:44 +0000

The Power of Simple Optimizations

Sometimes the most impactful improvements come from stepping back and rethinking your approach. One of my pull request demonstrates this perfectly: 32 lines added, 23 removed, and a Docker image that's half the size with 72% fewer security vulnerabilities.

Let's break down exactly what changed and why it matters.

The Numbers

Before:

Image size: 2.04 GB
Security vulnerabilities: 290+
Build approach: Single-stage

After:

Image size: ~900 MB (50% reduction)
Security vulnerabilities: ~80 (72% reduction)
Build approach: Multi-stage

Code changed: 1 file, net +9 lines

---

## The Five Critical Insights

### 1. The Slim Base Image Difference

**Before:**
```

dockerfile
FROM python:3.11.2

After:


dockerfile
# Stage 1: Build
FROM python:3.11.2 AS builder

# Stage 2: Runtime
FROM python:3.11.2-slim

The Learning: The difference between python:3.11.2 and python:3.11.2-slim is substantial. The full image includes compilers, build tools, and system utilities you don't need at runtime. The slim variant strips these away.

Impact: This single change likely contributed 40–50% of the total size reduction.

2. Separate Build and Runtime Concerns

Before: Everything in one stage


dockerfile
RUN pip install poetry \\
    && poetry config virtualenvs.create false \\
    && poetry install
# ...poetry stays in final image

After: Two distinct stages


dockerfile
# Stage 1: Install and build
FROM python:3.11.2 AS builder
RUN pip install poetry
RUN poetry install

# Stage 2: Copy only what's needed
FROM python:3.11.2-slim
COPY --from=builder /usr/local/lib/python3.11/site-packages /usr/local/lib/python3.11/site-packages

The Learning: Build tools don't need to ship to production. Poetry, compilers, and development headers are essential for installation but deadweight at runtime.

Impact: Eliminates build dependencies from the final image while keeping all functionality.

3. Layer Consolidation Matters

Before: Multiple separate apt-get update calls


dockerfile
RUN apt-get update && \\
    apt-get install -y postgresql-client libpq-dev && \\
    rm -rf /var/lib/apt/lists/*

RUN apt-get update && apt-get install -y \\
    libmemcached11 \\
    libmemcachedutil2 \\
    libmemcached-dev \\
    libz-dev

RUN apt-get update && apt-get install -y dos2unix

After: Consolidated installation


dockerfile
RUN apt-get update && \\
    apt-get install -y postgresql-client libpq-dev \\
    libmemcached11 libmemcachedutil2 libmemcached-dev libz-dev \\
    dos2unix && \\
    rm -rf /var/lib/apt/lists/*

The Learning: Each RUN command creates a new layer. Multiple apt-get update calls mean multiple cached package lists. Consolidating reduces both layer count and duplicate data.

Impact: Smaller image size and better cache utilization during builds.

4. Copy Strategy Optimization

Before: Copy everything early


dockerfile
WORKDIR /blt
COPY . /blt
# ...then install dependencies

After: Copy dependencies first, code last


dockerfile
# Stage 1
COPY pyproject.toml poetry.lock* ./
RUN poetry install

# Stage 2
COPY . /blt

The Learning: Docker caches layers. If you copy your entire application before installing dependencies, every code change invalidates the dependency installation cache. Copying dependency files first means dependencies only reinstall when they actually change.

Impact: Faster builds during development and CI/CD.

5. Runtime vs. Build Dependencies

Before: All dependencies in final image


dockerfile
libmemcached-dev  # Development headers
libz-dev          # Development headers

After: Only runtime dependencies in final stage


dockerfile
# Builder: libmemcached-dev libz-dev
# Runtime: libmemcached11 libmemcachedutil2

The Learning: Development headers (-dev packages) are needed to compile extensions but not to run them. The runtime only needs the shared libraries.

Impact: Smaller attack surface and fewer vulnerabilities (72% reduction).

The Security Dimension

Reducing vulnerabilities from 290+ to 80 wasn't just about using a slim base image—it was about shipping less code.

Every package is a potential vulnerability:

Build tools contain vulnerabilities you'll never exploit (because you're not building in production)
Development headers expose attack surfaces you don't need
Unused system utilities are just risk without reward

The math is simple: Fewer packages = fewer CVEs = better security posture.

The Practical Takeaways

For Your Next Dockerfile

Always use multi-stage builds for compiled/installed dependencies
- Stage 1: Build and install
- Stage 2: Runtime with minimal base
Choose the smallest base image that works
- python:3.11-slim over python:3.11
- Alpine if you can handle the musl differences
Consolidate RUN commands
- Combine related operations
- Clean up in the same layer
Copy smartly
- Dependencies first
- Application code last
- Leverage layer caching
Distinguish -dev from runtime packages
- Build stage: libpq-dev, gcc, make
- Runtime stage: libpq5, binaries only

The ROI

Development: Faster builds, better caching
Deployment: Faster pulls, quicker rollbacks
Security: Smaller attack surface, fewer CVEs
Costs: Less storage, less bandwidth

Conclusion: Small Changes, Big Impact

This pull request is a reminder that optimization doesn't always require complex refactoring. Sometimes it's about:

Understanding what you're shipping
Separating what you need from what you needed
Applying fundamental best practices

One file changed. Fifty-five lines modified. Image size cut in half. Vulnerabilities reduced by 72%.

That's the power of thoughtful Docker optimization.

Before You Go

Action Item: Pull up your most recent Dockerfile and ask yourself:

Am I shipping build tools to production?
Could I use a slimmer base image?
Are my RUN commands consolidated?
Is my COPY strategy cache-friendly?

The answers might just cut your image size in half.

open source PR link - https://github.com/OWASP-BLT/BLT/pull/3072

References

Offline-First Kiosk: Lessons from the Field

dhruv — Sun, 02 Nov 2025 18:07:01 +0000

When "Impossible" Becomes "Deployed"

Picture this: You have a tight deadline to build a production-ready kiosk application. It needs to work offline, handle outdated hardware, be completely locked down for security, and provide a smooth user experience. Oh, and it needs to be deployed to physical devices that won't play nice with modern Android features.

Sound impossible? That's what I thought too.

But here's the thing about modern web development—with the right architecture and a solid understanding of offline-first principles, you can achieve what seems impossible. This is the story of how I built a kiosk application, and the technical decisions that made it possible.

The Mission: Offline-First in a Connected World

The brief was straightforward: create an information kiosk that could display data, handle user interactions, and most importantly, keep working even when the internet doesn't.

Why Offline-First Matters

In the world of kiosks, internet connectivity is a luxury, not a guarantee. Whether it's a venue with spotty WiFi, a remote location, or just network hiccups during peak usage, your app needs to be resilient. Users don't care about your excuses—they expect it to work, period.

The offline-first philosophy flips traditional thinking on its head:

Assume the network is unreliable (because it is)
Cache aggressively (but intelligently)
Provide immediate feedback (even if the server hasn't responded)
Sync when possible (but never block the user)

The Tech Stack: Choosing Speed Without Sacrificing Quality

With a tight deadline, every technology choice mattered. Here's what made the cut:

The Core Players

Vite - When you're iterating rapidly, waiting for builds kills momentum. Vite's lightning-fast hot module replacement meant changes appeared instantly.

React + Ionic Framework - Cross-platform UI components that look native and feel natural on touch devices. No need to reinvent the wheel for buttons, modals, and navigation.

Capacitor - The bridge between web and native. Need to lock down the device? Pin the app? Access hidden settings? Capacitor made it possible without writing Java.

TailwindCSS - Utility classes meant styling components in seconds, not hours.

TanStack Query - The secret weapon. This library handled caching, background refetching, optimistic updates, and error recovery with minimal configuration.

The Configuration That Changed Everything

const queryClient = new QueryClient({
  defaultOptions: {
    queries: {
      staleTime: 1000 * 60 * 5, // Data stays fresh for 5 minutes
      refetchOnWindowFocus: false, // Don't refetch when window regains focus
    },
  },
});

Offline-First Kiosk: Lessons from the Field

This Simple Configuration Meant

Data loaded once and stayed cached for 5 minutes
No unnecessary network requests
Instant UI updates from cache
Background refetching kept data current

The Hardware Plot Twist

Just when you think you've got everything figured out, reality throws a curveball.

The Challenge

The kiosk devices presented several obstacles:

Outdated Android version with limited Play Services
Locked-down settings requiring administrator access
Performance constraints that would make a modern smartphone weep
No easy way to install standard apps

The Creative Solutions

Problem #1: Can't access device settings

Solution: Activity Launcher app to access hidden administrator menus

Problem #2: Can't install apps from Play Store

Solution: Sideloading APKs manually

Problem #3: Performance limitations

Solution: Aggressive optimization everywhere

// Code splitting for heavy components
const EventInfo = lazy(() => import('../pages/EventInfo'));

// WebP images instead of PNG/JPEG
// Async font loading
// Minimal JavaScript bundles
// Tree-shaking with ES modules

Security: Locking It Down Tight

A kiosk app is only useful if users can't escape it or access things they shouldn't.

Multi-Layered Security

Layer 1: Android App Pinning
The nuclear option — users physically cannot leave the app without administrative action.

Layer 2: Custom Passcode System
Protected administrative functions with a custom implementation when built-in options weren't flexible enough.

Layer 3: Navigation Lockdown

Disabled back button
Blocked system gestures
Prevented accidental exits

Layer 4: Device Administrator Privileges
Used Activity Launcher to access device admin settings and override restrictions.

The Service Worker That Wasn't

Here's the ironic part: despite the emphasis on offline-first, the final implementation didn't use traditional service workers.

Why Not?

Time constraints — Service workers require careful lifecycle management and testing
Native deployment — Capacitor's native HTTP plugin provided caching out of the box
Complexity vs. benefit — TanStack Query handled most offline scenarios elegantly

The Offline-First Principles Remained

Even without a service worker, the architecture embodied offline-first thinking:

Local-first data with aggressive caching
Optimistic UI updates for instant feedback
Native caching mechanisms via Capacitor
Graceful degradation when network unavailable

Sometimes the best solution is the one that works with your constraints, not against them.

Data Management: The Smart Way

TanStack Query as Your Sync Engine

This library solved multiple problems:

Automatic Background Refetching: Data stayed current without manual intervention
Optimistic Updates: Click a button, see the result immediately, sync with server in background
Retry Logic: Automatic retries with exponential backoff
Cache Invalidation: Smart synchronization that knows when to refetch and when to use cached data

State Management Philosophy

Instead of Redux or MobX, the app used:

TanStack Query for server state
React Context for global UI state
URL parameters for navigation state
Local component state for UI interactions

Simple. Effective. Easy to reason about.

Lessons from the Trenches

What Worked Brilliantly

Vite for fast iteration
Ionic + Capacitor for native capabilities without native complexity
TailwindCSS for rapid UI development
TypeScript for fewer runtime bugs
Component architecture for extensibility

What I'd Do Differently

More time for testing edge cases
Add React error boundaries
Integrate performance monitoring early
Push progressive enhancement further

Checklist: Building Offline-First Apps

Choose Your Caching Strategy
- Service workers for web apps
- Native plugins for hybrid apps
- Aggressive but intelligent caching
Embrace Optimistic UI
- Update UI immediately and handle rollback on failure
Test Offline Scenarios
- Complete offline mode
- Slow 3G
- Intermittent connectivity
- Server errors
Plan for Sync Conflicts
- Last write wins?
- Server authority?
- User resolution?
Monitor Performance
- Bundle size
- Image formats
- Code splitting
- Lazy loading
Secure It Properly
- Lock down navigation
- Protect admin functions
- Use device-level security
- Test escape attempts

The Final Result

After focused development the kiosk app shipped:

Smooth, responsive UI
Offline-capable
Secure and locked-down
Handles outdated hardware gracefully
Easy to update and maintain

Conclusion: Offline-First Is a Mindset

Offline-first is not just service workers or IndexedDB. It's about designing for unreliable networks and building resilience at every layer.

Tools that helped

TanStack Query
Capacitor
Modern web frameworks
Fast build tools

What are your offline-first war stories? Drop them below.

Resources

TanStack Query Documentation: https://tanstack.com/query/latest
Ionic Framework: https://ionicframework.com/
Capacitor: https://capacitorjs.com/
Service Worker API: https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
Offline First Principles: https://offlinefirst.org/

Python Deque v/s List🐍

dhruv — Wed, 14 Aug 2024 11:04:26 +0000

I've always wondered why we use deque for working with queues in Python. After doing some research, I found out some cool things that deque has to offer, while using list for queues may not always be a good choice.
What is deque, anyway?
Essentially, it's very similar to a native Python list, but better.

Elements in a list are stored contiguously in a single block of memory and have a single pointer that points to the very first element. On the other hand, deque is a double-ended list with pointers at both ends.

Here are some factors which make deque a better choice than list:

Append Operation : Both list and deque take constant time complexity for appending, as list uses pointer arithmetic (e.g., o + length(4) = address 4) to find the last element and then append a new item. In case of deque, it has a rear pointer at the end. So it also takes constant time complexity

Pop Operation
: Both structures have the same constant time complexity as they find the last element using the same logic and then pop the last element from the list.
Prepending Operation
: Here's where the magic of deque begins! List structures need to shift forward each element by 1 position, and insert the value at first position making the whole process O(n) time complexity or linear time complexity. A deque, on the other hand, with its front pointer, performs prepending in constant time complexity by using a circular buffer and shifting the front pointer to -1. In reality, the new value is stored in a higher memory address, but under the hood, it is logically the first element of the deque after the prepend operation.

Popping from the left
: Again, list structures need to pop the leftmost element and shift each value by one position to the left, resulting in linear time complexity. On the other hand, deque pops the value at the front pointer and updates the front pointer to the right. Yes, it takes only constant time complexity, making the process significantly more efficient.
Insertion/Deletion into middle
: With a list, the time complexity ranges from O(1) to O(n) depending on the position of the element. In the case of deque, it ranges from O(1) to O(n/2).

If you have any feedback, then you can DM me on Twitter or Linkedin.

Beyond Read and Write: Executing Files with chmod

dhruv — Tue, 23 Apr 2024 07:43:46 +0000

In Linux, a non-executable file is one that cannot be directly run by the system as a program. These files typically contain data or instructions that require another program to interpret or process them. There are two main reasons a file might not be executable:

Missing permissions: In Linux, file permissions control what users can do with a file. These permissions include read, write, and execute. By default, some files might only have read/write permissions, meaning they can be viewed or modified but not directly executed.
File type: Certain file types, like text files (.txt), image files (.jpg), or document files (.pdf), are not meant to be executable programs. They contain data meant to be processed by specific applications.

Examples of non-executable files:

Data files: These include various file formats that store information, like images, documents, spreadsheets, audio, and videos. They require specific software to be opened and used.
Configuration files: These files contain settings for programs or the system itself. They are typically text files and are read by software to configure its behavior.
Log files: These files record system events or application activity. They are mainly for troubleshooting and are not meant to be executed.
Shell scripts: Shell scripts are text files containing commands intended to be executed by the shell. However, if they lack the necessary permissions (explained below), they won't be executable directly.

Finding non-executable files:

You can use the find command with the -not operator (if using GNU find) to search for files that lack execute permissions.

Making non-executable files executable:

Shell scripts: For shell scripts, you can grant them execute permission using the chmod command. This allows the script to be run from the terminal.
Other files: While possible, it's generally not recommended to make non-executable files executable unless you understand why they are non-executable and what the intended use is.

Understanding the 'chmod' Command:

The chmod command is an integral part of any Unix-like operating system and has been around since the early days of Unix. It stands for "change mode" and is used to define the way a file can be accessed.

How to use it
The basic usage of chmod involves invoking the command followed by the permissions you want to set and then the file or directory you're modifying.

$ chmod 755 filename.txt

Let's break down the command:

755: This is the permission setting you are applying. It's represented in octal notation (base-8). Here's how it breaks down:

The first digit (7) represents the permissions for the owner of the file:

r (4) - Read permission
w (2) - Write permission
x (1) - Execute permission (since 7 = 4 + 2 + 1)

The second digit (5) represents the permissions for the group that owns the file:

  r (4) - Read permission
  x (1) - Execute permission (since 5 = 4 + 1)

The third digit (5) represents the permissions for everyone else (users who are not the owner or part of the group):

  r (4) - Read permission
  x (1) - Execute permission (since 5 = 4 + 1)

In simpler terms, this command sets the following permissions for filename.txt:

Owner: can read, write, and execute the file.
Group: can only read and execute the file.
Everyone else: can only read and execute the file. Here are some important points to consider:

This is a common permission setting used for executable files (like shell scripts) that need to be run by users.
Be cautious when using 777 (read, write, and execute for everyone) as it grants unrestricted access to the file, which can be a security risk. You might need to use sudo before the command (sudo chmod 755 filename.txt) if you don't have the necessary permissions to modify the file.

The commonly used parameters

There are several permissions that you can set with chmod:

-u stands for 'user', the owner of the file.

$ chmod u+x filename.txt

-g stands for 'group', users who are members of the file's group.

$ chmod g+w filename.txt

-o stands for 'others', users who are not the owner of the file or members of the group.

$ chmod o-r filename.txt

Other supported parameters:
chmod supports a number of parameters like -f (force), -v (verbose), -c (changes), -R (recursive), --help (display help and exit), and --version (output version information and exit). Each parameter provides a specific functionality to the chmod command.

Warning:
It’s crucial to be careful when changing permissions, especially when using the -R (recursive) option. If misused, you could inadvertently give users unintended access to sensitive files or directories.

Can we Run a Script that's not Executable?

yes, we can!
If a shell script isn’t executable, we cannot run it directly in the terminal. Of course, the execute permission of the script can be changed so that we can run it. But, that may not always be possible. For example, if the script belongs to another user, we may not have the necessary privileges to change the execute permission of the script using the chmod command.

If we have an executable script, we can run it directly in the terminal. Suppose we have the following script, hello_world.sh:

#!/bin/bash
echo “Hello World"

This script just prints Hello World and exits. We specify the interpreter of the script on the first line after the shebang (#!). In our case, the interpreter is /bin/bash. This tells the operating system to use Bash as the interpreter for parsing the remainder of the script.

Let’s first check the execute permission of this script:

$ -l hello_world.sh
-rwxr-xr-x 1 dt dt 23 April  08:32 hello_world.sh

Since the execute permission of the script is set for all users, we can run it directly in the terminal:

$ ./hello_world.sh
Hello World

Now, we’ll consider the case when the script isn’t executable. First, let’s remove the execute permission of the script hello_world.sh using chmod:

$ chmod -x hello_world.sh
$ ls –l hello_world.sh
-rw-r--r-- 1 dt dt 23 April  08:32  hello_world.sh

As it’s apparent from the output of the ls –l command, nobody not even the owner of the script – has the right to execute this script. Let’s try to run it:

$ ./hello_world.sh
-bash: ./hello_world.sh: Permission denied

Our objective is to run the script hello_world.sh in the remainder of this tutorial.

One way to run a script that we don’t have the execute permission is to specify the shell explicitly while running the script. Let’s run the script, hello_world.sh, with the Bash interpreter:

$ /bin/bash ./hello_world.sh
Hello World

If we’re able to specify the interpreter while running the script, we can run the script with another interpreter, for example, the Korn shell:

$ /bin/ksh ./hello_world.sh
Hello World

Another way to run a script that isn’t executable is using the source command. Let’s run the script, hello_world.sh, using source:

$ source ./hello_world.sh
Hello World

Sourcing a script means that we run the script in the current shell. So, if the script contains an exit command, we must be cautious since we may exit from the current shell itself.

We can use the dot or period character (.) instead of source and get the same result:

$ . ./hello_world.sh
Hello World

If you have any feedback, then you can DM me on Twitter or Linkedin.

Lambda Function(Python)

dhruv — Sat, 13 Apr 2024 13:05:00 +0000

In Python, a lambda function is a small anonymous function without a name. It is defined using the lambda keyword and has the following syntax:

lambda arguments: expression

Lambda functions are often used in situations where a small function is required for a short period of time. They are commonly used as arguments to higher-order functions, such as map, filter, and reduce.

Function to double the input

def double(x):
  return x * 4

Lambda function to double the input

lambda x: x * x * x * x

The above lambda function has the same functionality as the double function defined earlier. However, the lambda function is anonymous, as it does not have a name.

Lambda functions can have multiple arguments, just like regular functions. Here is an example of a lambda function with multiple arguments:

Function to calculate the product of two numbers

def multiply(x, y):
    return x * y

Lambda function to calculate the product of two numbers

lambda x, y: x * y

Lambda functions can also include multiple statements, but they are limited to a single expression. For example:

Lambda function to calculate the product of two numbers, with additional print statement

lambda x, y: print(f'{x} * {y} = {x * y}')

In the above example, the lambda function includes a print statement, but it is still limited to a single expression.

Lambda functions are often used in conjunction with higher-order functions, such as map, filter, and reduce which we will look into later.

If you have any feedback, then you can DM me on Twitter or Linkedin.

bisect module and methods(python)

dhruv — Mon, 26 Feb 2024 12:23:27 +0000

The bisect module is written in python and here is the source code
What it does?
The bisect module in Python provides support for maintaining a list in sorted order without having to sort the list after each insertion. It uses a binary search algorithm to find the insertion point for a given element in a sorted list, which is more efficient than linear search.

Key functions provided by the bisect module:

bisect.bisect_left(list, num, beg, end): This function returns the sorted list after inserting the number in the appropriate position. If the element already exists, then the element is inserted at the leftmost possible position. import bisect

list = [1, 3, 4, 4, 6, 7]
bisect.bisect_left(list, 5)
print(list)  # Output: [4]

bisect.bisect_right(list, num, beg, end): This function works similar to bisect_left(), but if the element already exists, then the rightmost position is returned. bisect.bisect() is an alias for bisect_right(). import bisect

list = [1, 3, 4, 4, 4, 6, 7]
print(bisect.bisect_right(list, 4))  # Output: 5

bisect.insort_left(list, num, beg, end): This function returns the sorted list after inserting the number in the appropriate position. If the element already exists, then the element is inserted at the leftmost possible position.

import bisect

list = [1, 3, 4, 4, 6, 7]
bisect.insort_left(list, 5)
print(list)  # Output: [1, 3, 4, 4, 5, 6, 7]

bisect.insort_right(list, num, beg, end): This function works similar to insort_left(), but if the element already exists, then the element is inserted at the rightmost possible position. bisect.insort() is an alias for insort_right().

import bisect

list = [1, 3, 4, 4, 6, 7]
bisect.insort_right(list, 4)
print(list)  # Output: [1, 3, 4, 4, 4, 6, 7]

In all these functions, beg and end are optional arguments specifying the range in which to search for the insertion point. If omitted, the entire list is used.

If you have any feedback, then you can DM me on Twitter or Linkedin.

accessing rows and columns in a 2d array and insert method(python)

dhruv — Wed, 14 Feb 2024 20:22:00 +0000

In Python, a 2D array (or matrix) is essentially a list of lists. You can access elements, rows, and columns in a 2D array using indexing.

Here's how you can do it:

Accessing an element: To access an element in a 2D array, you use two indices. The first index is for the row and the second index is for the column. For example, matrix[i][j] will give you the element at the ith row and jth column.

Accessing a row: To access a row in a 2D array, you only need one index. For example, matrix[i] will give you the ith row.

Accessing a column: Accessing a column is a bit trickier because Python's list of lists structure does not have built-in support for accessing columns. You typically use a loop or a list comprehension to access a column. For example, [row[j] for row in matrix] will give you the jth column.

Suppose you want to access all of the items present in one row of a 2-dimensional array or a matrix and change it to some value(let's say 0 to 1), then you can do it this way:

// creating a matrix initializing 0 at all of the indices

matrix = [[0]*n for i in range(m)] # n = number of cells in a row or number of columns and m = number of rows

for i in range(n):
    matrix[row_number][i] = 1

If you want to access a particular column in the matrix, and change all the values of the column in a matrix to 1, then you can do this:

for j in range(m):
    matrix[j][column_number] = 1

Insert Method in python

arr.insert(i, n) #Here 'i' is the index and 'n' is any number

Note: When we Insert any number 'n' in the array using insert method, then it slides the remaining right side elements of the array to right

for example


arr = [1,2,3,4,5]

arr.insert(3, 1)

print(arr) //OUTPUT: [1,2,3,1,4,5]

If you have any feedback, then you can DM me on Twitter or Linkedin.

Integrity Constraints in DBMS

dhruv — Sun, 11 Feb 2024 09:00:12 +0000

There are four main types of integrity constraints in DBMS:

Domain Constraints: They define the domain or set of values that an attribute can hold (e.g., integers, characters, dates, times, strings, etc.).

ALTER TABLE employees
ADD CONSTRAINT CHECK_age (age >= 18 AND age <= 65);

Entity Integrity Constraints:

It ensures that the primary key column(s) contain unique and non-null values.

ALTER TABLE customers
ADD CONSTRAINT PRIMARY KEY (customer_id);

Referential Integrity Constraints: These constraints maintain relationships between tables by ensuring that foreign key values reference valid primary key values. This prevents orphaned records and ensures data consistency.

ALTER TABLE orders
ADD CONSTRAINT FK_customer_id
FOREIGN KEY (customer_id) REFERENCES customers(customer_id);

User-Defined Integrity Constraints: These constraints are custom constraints defined by the database administrator or application developer to enforce specific business rules or data requirements.

ALTER TABLE products
ADD CONSTRAINT CHECK_stock_quantity (stock_quantity >= 0);

what is candidate key?
In a relational database, a candidate key is a minimal superkey. A superkey is a set of one or more attributes that uniquely identify every row in a table. A candidate key is a superkey that does not contain any redundant attributes. In other words, no attribute in the candidate key can be removed without losing the uniqueness of the row.

primary key:

In a relational database, a primary key is a special constraint that uniquely identifies each row in a table. It is a column or combination of columns that cannot contain null values and must have unique values. The primary key is used to enforce referential integrity, which ensures that relationships between tables are maintained.

If you have any feedback, then you can DM me on Twitter or Linkedin.

Object Oriented Analysis and Designing Basics

dhruv — Mon, 25 Dec 2023 19:17:45 +0000

There are various concepts involved while developing a software, such as:

Object-Oriented Analysis(OOA):It involves investigating a problem domain to identify the objects and their relationships that are relevant to the problem
Object-oriented design (OOD): is the next step after OOA, which involves designing the software system based on the objects identified during OOA

Both combined is known as OOAD(Object-oriented analysis and design), which involves a number of techniques and practises, including object-oriented programming, design patterns, UML diagrams, and other use cases.

Here are some important aspects used in OOAD:

Object-Oriented Programming: involves modeling real-world objects as software objects, with properties and methods that represent the behavior of those objects
Design Patterns: Design patterns are reusable solutions to common problems in software design.
UML Diagrams: OOAD uses UML diagrams to represent the different components and interactions of a software system.
Use Cases: OOAD uses use cases to help developers understand the requirements of a system and to design software systems that meet those requirements.

what are the advantages of OOAD?

Reusability
Scalability
Maintainability
Flexibility

What are the disadvantages of it?

Complex to design
Time-Complexity
Difficult to make changes, once it has been designed
Cost

In one line, it is tough to build something complex

Example of Object Oriented Design:
Suppose you are designing a software system for a bank. You would start by performing object-oriented analysis to identify the objects and their relationships that are relevant to the problem. Some of the objects that you might identify include customers, accounts, and transactions. You would then use object-oriented design to create a software system based on these objects.
For example, you might create a class called Customer that has properties such as name, address, and account_number. You might also create a class called Account that has properties such as balance, interest_rate, and account_type. You would then use these classes to create a software system that allows bank staff to manage customer accounts and transactions.

MOST USED TERMS IN OBJECT-ORIENTED DESIGNING:

Objects: is an instance of a class. It is a concrete entity that has its own state and behavior, based on the properties and methods defined in the class
Class: is a blueprint or template for creating objects. It defines the properties and methods that an object will have, but it is not an object itself.
Messages: Objects communicate by message passing. Messages consist of the
integrity of the target object, the name of the requested operation, and any other
action needed to perform the function
Abstraction: is the removal of the irrelevant and the amplification of the essentials.
Encapsulation: : Encapsulation is also called an information hiding concept. Encapsulation not only bundles essential information of an object together but also restricts access to the data and methods
from the outside world.
Inheritance: OOD allows similar classes to stack up in a hierarchical manner where the lower or sub-classes can import, implement, and re-use allowed variables and
functions from their immediate superclasses.
Polymorphism: : OOD languages provide a mechanism where methods performing similar tasks but vary in arguments, can be assigned the same name. Depending upon how the service is invoked, the respective portion of the code gets executed.

If you are confused between Object and Class, because I was always confused in these concepts then you can remember this analogy:

Class provides the blueprint of the bicycle, but Object is the bicycle itself.

Doubt: How to design Objects?

We can Design an object in following phases:

Identifying the Object
Construction of design model for Object(Object Representation): Static model which describes the static structure using Class Diagram and Object Diagram. Dynamic Model which describes the dynamic structure of a system and show interaction between classes using Interaction diagrams and state-chart diagrams.
Classification of Operations: An operation specifies what is to be done and not how it should be done!So in this phase, the operations that would be performed on objects are defined...
Algorithm Design: The operations in the objects are defined using algorithms. An algorithm is a stepwise procedure that solves the problem laid down in an operation. Algorithms focus on how it is to be done.Computation Complexity, flexibility of the Algorithm, Understandability are the metrics for choosing the Optimal Algorithm
Design of Relationships: The strategy to implement the relationships needs to be chalked out during the object design phase.
Implementation of control for external interactions
Package classes and associations into modules: Hiding Internal Information from Outside view, Coherence of Elements, and Construction of Physical Modules

Design Optimizations methods:

Addition of Redundant Associations
Omission of Non-Usable Associations
Optimization of Algorithms
Saving and Storing of Derived Attributes

Thanks for Reading the Tutorial

If you have any feedback, then you can DM me on Twitter or Linkedin.

Little bit Git...

dhruv — Sun, 26 Nov 2023 23:22:52 +0000

Getting started head on...

git log

I was working on some project, the conflict error occured again and again while I was trying to push. So, I decided to use rebase and move ahead with the problem but I needed to git see the commit history before I could use git rebase so what command did I use back then?

Before you move forward!!!

Think hard...

The answer is this👇

git log <branch-to-rebase-onto>..HEAD

where <branch-to-rebase-onto> is replaced with the branch where I have to rebase it onto(generally it's origin/master)

git stash

I was trying to setup an environment for some open source project, which needed installation of Vagrant(it's a Virtual Machine Environment in simple words). While doing the setup of the environment, I went through several Errors!
I solved some with the help of my helpful brother and some on my own but then in the end, I figured out that some Changes that I made in my configuration file for Vagrant were not suitable for pushing to the origin of the main repository for that open source project.

In Short, there were some Changes specific for my own system(not suitable for a public repository)

Now I needed to add my changes to git commit without adding that configuration file, which command did I use to ignore that particular file?

The answer is this👇

git stash

If you want to reapply the changes back to the working directory, use this command👇

git stash pop

Stash Apply

There was a time when I wanted to restore some previously stashed work to a new Branch using git, How did I do it?

The answer is this👇

Create a New Branch:

git checkout -b new_branch_name

Apply Stashed Changes:

git stash apply

I can use this👇

git stash branch new_branch_name

where branch and new_branch_name are the branches from which you are taking stashed changes from and the branch you are pushing it to respectively

Tags:

Tags are necessary to mark specific points the history of the commits!
Releases are one important example

To push tags to a remote repository:

git push origin <tagname>

replace tagname with whatever tag you want to paste

git diff:

To review the changes that are currently staged (in the index) before committing them, use this👇

git diff --cached

If you have any feedback, then you can DM me on Twitter or Linkedin.

Github Actions Basics

dhruv — Sat, 18 Nov 2023 17:27:58 +0000

Github Actions are used to automate project management tasks by using workflows.

Each Workflow contains a series of tasks, which are implemented or run automatically everytime when the workflow runs.

Github Action is a CI/CD(Continuous Integration and Continuous Delivery) platform that allows you to automate your build, test and deployment pipelines

The Components of Github Actions:

1.Workflow:

Workflow is a configurable automated process that will run one or more jobs,
defined by a YAML file/Syntax,
and it's placed inside .github/workflows path

2.Events:

it is Something that triggers Workflows

3.Jobs:

Job is a set of steps in a workflow, each step is either a Shell script or an action
Steps are executed in order, and are dependent on each other.
Data Sharing mechanism is integrated into the steps, since they are dependent on each other

4.Actions:

Custom application for the Github Actions platform that performs a complex but frequently repeated tasks

5.Runners:

is a server that runs your workflow when they are triggered.

Let us Understand the Workflow file(YAML):

name: learn-github-actions

it will appear in the 'Actions' tab of the Github Repository
it is an optional step

run-name: ${{github.actor}} is learning Github actions

it specifies the name of workflow run, that will appear in the list of workflow runs on 'Actions' Tab

on: [push]

specifies the trigger for the Workflow

jobs:

Groups all the jobs that run in the learn-github-action workflow

check-bats-version:

Defines a job named check-bats-version. The child keys will define properties of the job.

runs-on: ubuntu-latest

configures the job to run on the latest version of the Ubuntu Linux runner(Fresh virtual machine hosted by Github)

steps:

groups together all the steps that runs in this job. Each item nested under this section is a separate action or a shell script.

-uses: actions/checkout@v4

The uses keyword specifies that this step will run v4 of the actions/checkout action.
This actions checks out your repository onto the runner, allowing you to run scripts or other actions against your code.

-uses: actions/setup-node@v3
 with:
    node-version: '14'

This step uses the actions/setup-node@v3 action to install the specified version of the Node that will be used for the project
This puts both the node & npm commands in your Path

-run: npm install -g bats

The run keyword tells the job to execute a command on the Runner.
In this case, you're using npm to install bats software testing package.

-run:bats-v

Finally you'll run the bats command with a parameter that outputs the software version.

Thanks for reading the tutorial!
If you have any feedback, then you can DM me on Twitter or Linkedin.

Hacktoberfest23 and MLH

dhruv — Mon, 13 Nov 2023 21:37:04 +0000

What is Hacktoberfest?

In simple words, Hacktoberfest provides opportunities to the beginners who want to start contributing in Open Source.
Hacktoberfest is an annual event that takes place every October and is aimed at encouraging contributions to open-source projects. It was started by DigitalOcean in collaboration with GitHub to promote community participation in the open-source ecosystem.
You experience new things with making open-source contributions through Hacktoberfest and participating in MLH Global Hack Week Open source was a testament to the enriching opportunities that such events offer. By actively engaging in these initiatives, you not only expand your technical skills but also gain exposure to a diverse and dynamic world of collaborative development.
I just had a little bit idea about things like giving back to the community, learning in public, but doing it yourself is just a very different feeling.

Up until now i was learning things only for the sake of learning, but you just don't code for yourself. It all ultimately boils down to whether it could be of some use to the society in some way or not, i call that testing phase for production use. Testing phase is something that exists at all levels whether it's your standard curriculum or some PHD level course.

Ram's story

Consider an example of a student named Ram, who, during his academic pursuits, acquired knowledge primarily for the purpose of achieving academic excellence, with a focus on obtaining high marks. Ram's approach to learning centered on the immediate goal of academic success, with less emphasis on understanding how the acquired knowledge could be applied to benefit the broader community.

While Ram may excel in the context of elementary education by prioritizing grades, this singular focus on academic achievement may inadvertently foster a mindset that places less importance on the broader implications and practical applications of acquired knowledge. In the professional realm, particularly as one advances in their career, an exclusive emphasis on grades may prove to be a limitation. Society tends to value individuals who not only possess theoretical knowledge but also demonstrate the ability to apply that knowledge in practical, meaningful ways.

As Ram progresses in his career, he may encounter challenges related to adaptability and collaborative work. The professional landscape values individuals who not only excel in academic settings but also contribute to the collective progress of projects and initiatives. The ability to communicate one's thought process, collaborate effectively, and apply knowledge to real-world situations becomes increasingly crucial.

In the long run, individuals who prioritize not just academic success but also the practical application of knowledge tend to thrive in professional environments.

Ram, realizing the evolving demands of the professional world, may need to adapt his work ethic to align more closely with the expectations of a collaborative and application-oriented work environment. Recognizing and addressing these aspects early in one's career can contribute significantly to long-term professional success and fulfillment.

Highs and Lows

Making Contributions first time is not easy, i accept it as the codebase looks so big, complex and people making PR on issues seem like people from another world on first go but actually it isn't that tough for a beginners.

Initially i was more focused on understanding how the things were working in the project, and came to conclusion that i need to learn more but this was not a solution. I needed to make a PR but didn't knew how to do it. Believe me, thoughts like would maintainers be friendly, can I even solve an issue when there are so many contributors grabbing the issues that i could have solved, let's focus on something else etc are just barrier, focus on only what you can do and neglect what you cannot do for the time being, you can learn it later(Don't make it a headache).
I was looking for projects from the start of October but due to college exams and pressure of starting something new, i couldn't find a good place to start. End date was coming close, and whatever issue i thought i could contribute to, had already been closed by maintainer as there were other contributors also. Thanks to Good-first-issue-finder , this site was created by Eddiehub organization(i found it during the MLH Global hack week Open source), and came to know about some projects that i could contribute to. First PR that i made under the tag of Hacktoberfest belonged to a Readme file but it came as a booster(I don't know why xD!) in confidence then i made 4 more PRs in just next 2 days including making a PR in code. It was just my thinking process that stopped me from contributing otherwise it was not very tough. Actually there are much more big things going on in Open source, beginners are like small kids playing in backyard of Open source but it is definitely eye opening as you have to start somewhere otherwise you won't be able to start!

Growth

Git/Github: You cannot just be a developer without Git and Github, it's mandatory(so contribute,learn more and more about Git and Github)
Learn in Public: Don't just learn for the sake of learning only, learn so that you can help the society in some way or other
Keep Contributing, Don't stop: Don't just stop at hacktoberfest, just keep looking for new projects and keep contributing
Collaboration while building: Ultimately each project that would be used by people will be build with developers when they collaborate, so learning about how to collaborate is more important than most of the people think!