In this candid conversation, Prometheus (Yash) and Sahil dive into the implications of Trump's proposed 26% tariffs on India, touching on broader geopolitical shifts, India’s role on the global stage, the future of homegrown innovation, and how automation might reshape global power dynamics. It's a thought-provoking exchange blending realism, speculation, and a deep curiosity about the road ahead.

Tariffs, Tech, and Tomorrow

Conclusion

As the conversation winds down, both agree that while predictions may vary, the world is undoubtedly entering a period of rapid change. With shifting alliances, emerging technologies, and rising national ambitions, India finds itself at a pivotal moment. The dialogue ends with cautious optimism and a shared hope that whatever unfolds, people and nations prioritize stability, resilience, and long-term vision.

I’ll be breaking my learnings into bite-sized posts. If you’re interested in leveling up your knowledge, follow my posts, and let’s learn together! Feel free to connect to me on LinkedIn.

Chapter 1: Reliable, Scalable, and Maintainable Applications

In this chapter, we will be focusing on three concerns, Reliability, Scalability and Maintainability that are important in most software systems.

1. Reliability

Reliability is one of the most critical aspects of any data-intensive application. A reliable system continues to function correctly, delivering the desired performance, even when faced with challenges like hardware or software faults, or human errors.
However, reliability can be compromised by faults and failures in the system. Understanding the difference between the two is crucial:

• 𝗙𝗮𝘂𝗹𝘁: A fault occurs when a component deviates from its expected behavior (e.g., hardware issues, bugs, or human mistakes).

• 𝗙𝗮𝗶𝗹𝘂𝗿𝗲: A failure happens when the system as a whole stops delivering the required service to users, impacting overall functionality.

2. Scalability

Scalability is the key to ensuring your system can handle growth in data volume, traffic, or complexity. A scalable system describe a system’s ability to cope with increased load.

Describing Load

Before we can think about scaling, we need to define the current load on the system. Only then can we explore what happens when the load increases. 𝗟𝗼𝗮𝗱 𝗽𝗮𝗿𝗮𝗺𝗲𝘁𝗲𝗿𝘀 help describe this. The choice of parameters depends on your system’s architecture. Examples include:

• Requests per second to a web server

• Read/write ratio in a database

• Number of simultaneously active users

• Cache hit rate, etc

Describing Performance

Once the load is defined, it's important to consider how performance changes as the load increases:

• What happens to performance if you increase load (e.g., double the traffic) without changing system resources like CPU, memory, and bandwidth?

• How much more resources (CPU, memory, etc.) are needed to maintain performance when the load increases?

Scalability ensures that your system grows efficiently without compromising performance.

Response Time

Response time is the total time a user waits after making a request until they get a response. It includes:

• The time it takes for the system to actually process the request (called service time).

• Any delays caused by the network.

• Time spent waiting in line if other requests are being processed (queueing delays).

Random additional latency could be introduced by a context switch to a background process, the loss of a network packet and TCP retransmission, a garbage collection pause, a page fault forcing a read from disk, mechanical vibrations in the server rack, or many other causes.

Latency

Latency is specifically the time a request spends waiting to be processed. It's the "idle" time before the actual work on the request starts.
𝗜𝗻 𝘀𝗵𝗼𝗿𝘁,

Response time = Processing time + Network delays + Queueing time.
Latency = Waiting time before processing starts.

Key points for understanding response time and their impact on user experience:

• Average Response Time: Commonly reported but not always accurate in reflecting typical user experience. It’s often calculated as the arithmetic mean.

• Mean vs. Percentiles: The mean doesn’t show how many users experience a particular delay. Percentiles are better for understanding typical and worst-case response times.

• Median (50th Percentile): The median response time is a good measure of typical user experience, where half the requests are faster and half are slower.

• Higher Percentiles (p95, p99, p999): These show the response times for the slowest 5%, 1%, and 0.1% of requests, respectively, and are crucial for understanding the "worst-case" scenarios (tail latencies).

• Impact on User Experience: High percentile response times affect user satisfaction and business outcomes. For instance, Amazon found that slower responses reduce sales and customer satisfaction.

• Challenges with High Percentiles: Optimizing extremely high percentiles (e.g., 99.99th) is costly and yields diminishing returns, often influenced by random external factors.

• Service Level Agreements (SLAs): Percentiles are used in SLAs to define acceptable service performance and availability, often including specific percentile thresholds for response times.

• Queueing Delays and Scalability Testing: Queueing delays contribute significantly to high percentile response times. When testing scalability, ensure load generation is independent of response time to get accurate measurements.

3. Maintainability

Over time, various people will work on the system (both in engineering and operations), maintaining its current behavior and adapting it to new use cases.

The 3 key principles to minimize maintenance issues and avoid creating outdated (legacy) systems:

1. 𝗢𝗽𝗲𝗿𝗮𝗯𝗶𝗹𝗶𝘁𝘆: Ensure the system is easy for operations teams to keep running smoothly.

2. 𝗦𝗶𝗺𝗽𝗹𝗶𝗰𝗶𝘁𝘆: Make the system easy for new engineers to understand by removing unnecessary complexity.

3. 𝗘𝘃𝗼𝗹𝘃𝗮𝗯𝗶𝗹𝗶𝘁𝘆: Facilitate future changes to the system, allowing it to adapt to new, unforeseen use cases as requirements evolve.

Maintainability covers many aspects, but ultimately, it’s about making life easier for the engineering and operations teams working with the system.

Chapter 2: Data Models and Query Languages

This chapter discusses various data models and query languages in database design.

Object-Relational Mismatch

A common criticism of the SQL data model is that when data is stored in relational tables, an awkward translation layer is needed between the objects in the application code and the database model of tables, rows, and columns. This disconnect between the models is often referred to as an impedance mismatch.

Object-relational mapping (ORM) frameworks like ActiveRecord, Hibernate and many others help minimize the boilerplate code needed for this translation layer, but they cannot entirely conceal the differences between the two models.

Relationships in Database

• 1 : 𝗠𝗮𝗻𝘆 𝗿𝗲𝗹𝗮𝘁𝗶𝗼𝗻𝘀𝗵𝗶𝗽: When one entity participates in many relationships and the other entity participates in one relationship then this is called 1 : Many relationship. Ex: A user can be stay in single city but that city can be used by many other users.

• 𝗠𝗮𝗻𝘆 : 𝗠𝗮𝗻𝘆 𝗿𝗲𝗹𝗮𝘁𝗶𝗼𝗻𝘀𝗵𝗶𝗽: When both entities participates in many relationships then this is called Many : Many relationship. Ex: A user can buy many courses and one course can be bought by many users.

• 1 : 1 𝗿𝗲𝗹𝗮𝘁𝗶𝗼𝗻𝘀𝗵𝗶𝗽: When both entities participates in single relationship then this is called 1 : 1 relationship. Ex: employee can have single id card associated and that id card will also be assigned to single entity.

Choosing the Right Data Model for Your Application

• Relational model: If your application does use many-to-many relationships then use relational model instead of document model.

• Document model: Ideal for applications with one-to-many relationships (tree-structured data) or where records have minimal relationships.

• Graph model: When your data has highly interconnected relationships and many-to-many connections are complex, graph models become a good choice.

However, the final choice might depend on specific application requirements, such as the need for scalability, flexibility, or performance considerations.

Chapter 3: Storage and Retrieval

Index in DB:

• An index is an additional structure (that acts as metadata) that is derived from the primary data in DB.

• Well chosen indexes speed up read queries.

• Index usually slows down writes, because the index also needs to be updated every time data is written.

Underlying data structures used to implement indexing:

1. 𝗸𝗲𝘆 𝘃𝗮𝗹𝘂𝗲 𝗯𝗮𝘀𝗲𝗱 𝗶𝗻𝗱𝗲𝘅𝗶𝗻𝗴

• To avoid running out of disk space we use compaction (Compaction means throwing away duplicate keys in the log, and keeping only the most recent update for each key.)

2. 𝗦𝗦𝗧𝗮𝗯𝗹𝗲𝘀 𝗮𝗻𝗱 𝗟𝗦𝗠-𝗧𝗿𝗲𝗲𝘀

• SSTables (Sorted String Tables) store key-value pairs that allows efficient lookups and range scans (retrieving records within specific range).

• LSM-Trees (Log-Structured Merge-Trees) are optimized for write-heavy operations and does periodical merging the data using compaction.

• Both store data in sorted order and on disk.

3. 𝗜𝗻𝗱𝗲𝘅𝗶𝗻𝗴 𝗶𝗻 𝗗𝗕 𝘄𝗶𝘁𝗵 𝗕 𝘁𝗿𝗲𝗲

• B-trees store key-value pairs in sorted order, enabling efficient lookups and range queries.

• Data is organized into fixed-size blocks (called pages), each page is typically 4 KB, with one page read or written at a time.

• The branching factor refers to the number of child page references in a single B-tree page.

• Most databases use B-trees with 3–4 levels, minimizing page references. A 4-level tree with 4 KB pages and a branching factor of 500 can store up to 256 TB.

Types of indexing in DB.

1. 𝗣𝗿𝗶𝗺𝗮𝗿𝘆 𝗜𝗻𝗱𝗲𝘅
   The primary index is created automatically on primary key column. Only one primary index is allowed per table.

2. 𝗖𝗹𝘂𝘀𝘁𝗲𝗿𝗲𝗱 𝗶𝗻𝗱𝗲𝘅
   A clustered index stores all row data within the index.

3. 𝗡𝗼𝗻-𝗰𝗹𝘂𝘀𝘁𝗲𝗿𝗲𝗱 𝗶𝗻𝗱𝗲𝘅
   A non-clustered index stores only references to the data within the index.

4. 𝗠𝘂𝗹𝘁𝗶 𝗰𝗼𝗹𝘂𝗺𝗻 𝗶𝗻𝗱𝗲𝘅𝗲𝘀
   If we need to query multiple columns of a table then we use multi column indexes

5. 𝗙𝘂𝗹𝗹-𝘁𝗲𝘅𝘁 𝘀𝗲𝗮𝗿𝗰𝗵 𝗮𝗻𝗱 𝗳𝘂𝘇𝘇𝘆 𝗶𝗻𝗱𝗲𝘅𝗲𝘀
   All the above indexes are used to query exact data. In contrast, a full-text search index retrieves relevant records by analyzing the search query, including synonyms, ignoring grammatical variations, and finding words that appear near each other in a document.

Chapter 4: Encoding and Evolution

Programs store data in memory in the form of data structures like objects, array, trees, graphs, etc. However, if you want to send this data over the network or write it to a file then its not directly possible. You first have to convert this data into a sequence of bytes.

This translation from the in-memory representation to a byte sequence is called encoding (serialization or marshalling), and the reverse is called decoding (parsing, deserialization, unmarshalling).

When it comes to encoding, there are two formats in which we represent data:
1. 𝗧𝗲𝘅𝘁-𝗯𝗮𝘀𝗲𝗱 𝗲𝗻𝗰𝗼𝗱𝗶𝗻𝗴: JSON, XML, CSV
2. 𝗕𝗶𝗻𝗮𝗿𝘆 𝗲𝗻𝗰𝗼𝗱𝗶𝗻𝗴: Protobuf, Avro

Compatibility in Binary Encoding

Compatibility refers to the relationship between a process that encodes data and another that decodes it. To ensure smooth data exchange, the format or schema used for encoding and decoding must remain synchronized, even as the schema evolves.

Types of Compatibility

1. Backward Compatibility: Newer versions of the system can read data written by older versions.

2. Forward Compatibility: Older versions of the system can read data written by newer versions.

Challenges with RPC:

RPC helps the client (someone who request a resource) to directly execute a function written on the server (who can serve that request).

• Unpredictability: Unlike local function calls, RPCs can fail due to network issues or remote machine unavailability, which are outside your control.

• Timeouts and Unknown Outcomes: RPC requests may return without a result due to timeouts, leaving uncertainty about whether the request was processed.

• Retry Issues: Retrying failed requests can lead to duplicate actions if responses are lost but requests succeed.

• Latency Variability: Network latency is variable and significantly slower than local function calls.

• Data Encoding Challenges: Parameters must be encoded for network transmission, which can be problematic with complex data types.

• Interoperability Issues: Different programming languages require datatype translations, which can be complex and error-prone.

Even after these challenges, RPC remains a valuable tool in distributed systems due to its ability to simplify the development of remote interactions.

Chapter 5: Replication

Replication involves creating multiple copies of the same data and storing them across different nodes to enhance data availability and fault tolerance.

Types of Replication

1. Leader and Followers Replication

• In this model, a leader node handles both read and write requests, while follower nodes can only accept read requests.

• The leader is often referred to as the master or primary node, while followers may be called read replicas, slaves, secondaries, or hot standbys.

• This type of replication is typically configured to be completely asynchronous.

2. Synchronous Replication

• Data is written to both the primary and secondary storage systems simultaneously.

• This method prioritizes high availability and aims for zero data loss.

3. Asynchronous Replication

• In this approach, data is first written to the primary storage and then replicated to the secondary storage after a delay (may be due to network delay, etc).

• While this method focuses on speed and efficiency, it carries a risk of data loss if the primary site fails before the latest changes are replicated.

___________________________________________________

REMAINING CONTENT COMING EVERY WEEK…

___________________________________________________

Noteworthy Points (WIP)

I will continue adding more points to the list below as I progress through the book.

• Horizontal scaling: Distributing load across multiple machines is also known as a shared-nothing architecture.

• Some systems are elastic, meaning that they can automatically add computing resources when they detect a load increase, whereas other systems are scaled manually (a human analyzes the capacity and decides to add more machines to the system). An elastic system can be useful if load is highly unpredictable, but manually scaled systems are simpler and may have fewer operational surprises.

• Polyglot persistence is a hybrid approach that uses different data storage technologies to handle different data storage needs within a software application.

• In both relational and document DBs, the related item is referenced by a unique identifier, which is called a foreign key in the relational model and a document reference in the document model.

• Document databases are sometimes called schemaless, but that’s misleading, as the code that reads the data usually assumes some kind of structure—i.e., there is an implicit schema, but it is not enforced by the database.

• In schema-on-read (the structure of the data is implicit, and only interpreted when the data is read), in contrast with schema-on-write (the traditional approach of relational databases, where the schema is explicit and the database ensures all written data conforms to it).

• Schema-on-read is similar to dynamic (runtime) type checking in programming languages, whereas schema-on-write is similar to static (compile-time) type checking.

Building and managing such systems at scale used to require a high budget and advanced technical skills. However, alternatives like AWS, Google Cloud, and Azure are now available, allowing you to avoid building your infrastructure from scratch.

If you are a software developer, applying for a software engineering or architecture position at MAANG companies, or simply looking to upskill, knowledge of designing scalable and distributed systems is crucial. In this article, we will explore one such concept. We’ll start from a monolithic system and see how to scale it into a distributed system capable of handling millions of users.

Single Server Architecture

A single server architecture consists of a client and a server. A client can be anything — a mobile app, web application, etc. — that is trying to make requests to the server for data. This type of architecture is also known as monolithic architecture because all the code (frontend, backend, database) is kept on a single server.

Monolithic systems have their own advantages. However, in today’s world, performance and efficiency play a major role, and that’s where monolithic systems fall short after a certain point.

The drawback of such systems is that they are not scalable. Since all the code is on a single server, each server has its own hardware limitations — such as RAM, CPU, and storage — beyond which it becomes very difficult to scale. The process of increasing system resources to their limits is called vertical scaling. Additionally, such systems can handle only a specific number of users (traffic) at any given time. For example, if a large number of users (say 10K requests) try to request resources and the system can handle only (say 1K requests), the system will crash.

This is the type of system we currently have which is shown in above image. There are various steps that we will follow throughout this article to scale our system. These are general steps to build scalable systems, though real-life systems are quite complex, and their architecture and components will vary from this example. Each system will have different architecture based on its requirements.

Let’s now see how we can start scaling this system.

1. Application and DB separation

The first step we can take is to separate the database from the application code (both frontend and backend). This separation keeps the business logic and data source distinct. This approach is a form of horizontal scaling, where different components are placed on separate servers.

By doing this, we reduce the load on the application server, improving efficiency while also enhancing data security.

2. Adding multiple application servers

The next step is to separate the application code based on its functionality. For example, if you’re building an e-commerce site, you could separate the frontend code, payment processing code, user management code, etc., onto individual servers, as shown below.

As illustrated in the diagram, this approach isolates the code into multiple application servers (AP), making it more modular, loosely coupled, and secure. The main advantage of dividing the application across multiple servers is that if one server goes down, it won’t break the entire application — other parts will continue to function. However, if there’s an API call from one server to another that has gone down, that specific API call will fail.

It’s important to note that dividing the application into multiple servers does not necessarily mean adopting a microservices architecture.

3. Load balancers

The architecture we’ve built so far has become quite efficient. However, since we’ve added multiple application servers, a new challenge arises: how do we determine which server should handle each request from the client? There needs to be a component that manages client requests (load/traffic) and directs them to the appropriate application server based on specific logic. This is where load balancers come into play.

For example: If we have four application servers, we could use the round-robin load balancing algorithm to distribute the load. This algorithm sends one request to each application server (AS) in sequence, ensuring the load is evenly distributed across all servers.

At this stage, various load balancing algorithms can be implemented, including:

1. Round Robin

2. Weighted Round Robin

3. IP Hash

4. Least Connection

5. Weighted Least Connection

6. Least Response Time

Having a good understanding of these algorithms and knowing when to use each one can be highly beneficial in practice.

Subscribed

4. Database replication (master / slave concept)

In our current architecture, we have only one database, which handles both read and write operations. This increases the overall latency of the system. Additionally, if the database goes down, our application won’t be able to retrieve any data. To address this issue, we implement database replication.

Database replication involves adding multiple slave databases and copying all data from the current database (which acts as the master) to these slave databases. The slave databases are used solely for reading data, while the master database is responsible for writing data. Whenever we write data to the master, it is replicated across all slave databases to ensure consistency.

5. Cache

To further enhance the performance of our system, we can implement a cache server. A cache server helps retrieve data quickly without needing to query the database or recompute the data. Typically, we cache data that doesn’t change frequently and is often requested by the frontend or client.

The cache server is located alongside the application server. When a request reaches the application server, it first checks if the data is available in the cache. If the data is present, it’s sent directly from the cache to the client. If not, the application server (AS) will query the database to retrieve the data.

We should always aim to minimize database calls by storing and retrieving data from the cache whenever possible, as database queries are costly and significantly contribute to increased latency.

When cached data becomes outdated due to updates in the database, we refer to this as stale data, meaning the cache needs to be updated. There are various cache invalidation techniques to refresh the cache, such as setting expiry times or clearing the cache completely.

6. CDN

CDN stands for Content Delivery Network. At this stage, we will separate all static files from the application server and store them on a CDN server. The CDN is designed to store static files like images, fonts, assets, and other resources that do not change frequently.

Clients can make direct requests for these files to the CDN server instead of routing them through the application server.

7. Data Centers

The system architecture we have designed so far can be hosted in a single country. If we replicate this architecture across multiple regions or countries, we create a data center that handles geo-specific requests.

8. Database scaling

As discussed, we can leverage database replication to help our system handle millions of users. Another technique to further boost database performance is database scaling, which can be implemented at the database level. There are two types of database scaling:

1. Vertical Scaling: In this approach, we increase system resources, such as RAM or CPU, for our database.

2. Horizontal Scaling: Here, we add multiple database nodes, typically using a method called sharding. Sharding can also be categorized into two types:

• Vertical Sharding: This involves dividing a table into multiple tables by rows.

• Horizontal Sharding: This approach divides a table into multiple tables by columns and is the more common method. To join these tables, we perform denormalization.

The consistent hashing technique is used to shard tables that are already sharded.

In addition to all these strategies, you can also incorporate a messaging queue into your architecture, such as RabbitMQ or Kafka, to handle asynchronous messaging.

By progressing step by step, we can achieve scalability, enabling our systems to handle millions of users while maintaining performance efficiency.

I hope this article has helped you learn some new concepts related to building scalable distributed systems and that you found it worthwhile. Thank you for reading! Please make sure to like and share this article on your social media platforms.

✦ Tidyings

Beck outlines a series of tidyings that can be applied to improve code structure and readability:

1. Guard Clauses: Use guard clauses to exit early from functions when conditions aren't met, reducing nested code and improving clarity.

2. Dead Code Removal: Identify and eliminate unused code segments to reduce clutter and potential confusion.

3. Normalize Symmetries: Enforce consistent code patterns and formatting to promote readability and collaboration.

4. New Interface, Old Implementation: Create simplified interfaces to interact with existing code, making modifications easier without disrupting core functionality.

5. Reading Order: Arrange code elements logically for better comprehension, considering language-specific conventions.

6. Cohesion Order: Enhance code cohesion by grouping related elements together and managing coupling between dependencies.

7. Variable and Constant Naming: Use descriptive names for variables and constants to self-document their purpose.

8. Explicit Parameters: Make function inputs explicit to clarify data flow and dependencies.

9. Chunk Statements: Break down large code blocks into smaller, more manageable sections for improved readability.

10. One Pile: When code is overly fragmented, consider consolidating it into a single view to facilitate understanding.

11. Explanatory Comments: Add comments to elucidate complex logic or non-obvious code constructs.

12. Redundant Comment Removal: Eliminate comments that merely restate the code's functionality.

✦ Managing Tidyings

Beck emphasizes the importance of managing tidyings within the development process:

13. Separate Tidying Pull Requests: Isolate code structure changes from functional changes in code reviews to ensure clarity and focus.

✦ Theory of Tidying

The book delves into theoretical considerations for when to apply tidyings:

14. Reversible Structure Changes: Prioritize reversible design modifications to maintain flexibility and minimize risks.

15. Coupling and Cascading Changes: Understand the implications of coupling between code elements and strategies to mitigate cascading effects, such as automated tools for multi-file updates.

Conclusion

By embracing the principles of "tidy first," developers can create code that is not only functional but also clear, maintainable, and adaptable to future changes. This approach fosters a more sustainable and efficient development process, ultimately leading to more robust and well-structured software systems.

Git is a distributed version control system that is used to track the changes (different versions of the software) made by many different people (distributed) to the repository (where the software is stored) of the software. It helps developers to easily submit those changes which are made to the source code just by executing a few git commands. Whenever a developer makes any changes to the code and wants them to be merged with the official repository of the project then he/she has to make a pull request which will eventually submit those changes to the repository.

At a time, thousands of people push changes to the same repository and keeping track of all these changes is very difficult. For this, we need a version control system. In this post, we will discuss the various git commands which we can use for creating a branch, checking the status, pushing the changes, updating the project and much more.

For doing all of this we will be using a website called GitHub where we can host our open source projects and is based on git version control system.

Before diving deep lets first understand all the git commands which we will be using in this blog post.

Git commands:

There are even more git commands which you can go through which are available here.

Recommended Books to learn Git & GitHub

1. Git: The Ultimate Guide for Beginners: Learn Git Version Control

2. Pragmatic Version Control Using Git: 01

Using Git Commands on GitHub

Firstly, to use git commands with GitHub you will need a GitHub account, if you don’t have one then you can create it here.

After creating an account login and click on “+” icon at the top-right and select “New repository” to create a new GitHub repository. You will see the below screen where you have to enter the details related to your repository like the name of the repository, description, choose whether you want to make your repository public or private and lastly, you can choose whether to initialize your repository with a README.md file or not. After that, you can select a license for your repository and then create the repository.

If you want to run git commands on Windows or Mac systems then you have to install Git through this link. And if you are using Linux you can run this command inside your terminal: sudo apt-get install git (for Debian) or sudo yum install git (for Fedora).

Before you can make changes or add files to the repository you first have to clone the repository from GitHub on to your local machine by pressing the button “clone or download” from your repository page or just by running the command which is shown below.

git clone https://github.com/sahilbhosale63/FirstRepo.git

Here in the place of “sahilbhosale63”, you have to put your own username and in place of “FirstRepo.git” you have to add your own GitHub repository name. Make sure that your repository name mentioned here matches your actual repository name. If this is not the case then you will get an error.

Now that you have the project locally available on your system you can make changes to this project locally and then you can follow the steps below to push this project onto your GitHub repository.

The changes can vary depending upon the needs of what exactly you want to do like fixing an issue or writing some snippets of documentation, etc. It doesn’t matter what exactly you want to do the commands used to push the changes to the remote server remains the same.

Initially, go inside the folder (in this case FirstRepo) from your terminal and then you have to initialize the repository. This is the primary step that you have to do when you are initially pushing changes to the remote server i.e on your GitHub repository.

git init

After that, you have to tell git that which files you want to upload on to the staging area, all the files which are available locally or only the files in which you have made the changes.

To add all of the files inside the folder to the staging area you have to run git add . or for a specific file use git add [file-name.txt]

In this case, we will be creating a file called “sample” using gedit sample which is a text file and will be adding this file to the staging area.

Before you can do anything else you have to add your name and email address using the following command.

git config --global user.name 'Your Name' git config --global user.email 'youremail@domain.com'

To check what’s in the staging area we can use the command below.

Since we have previously added the “sample” file to the staging area therefore when we run git status command we can see that files which we have added in the staging area.If you want to remove any file from the staging area you can run the command below. Here, the “sample” is the name of a file.

git rm --cached sample

Now after you have done with adding files to the staging area you can now commit those changes for that you have to run the following command.

git commit -m "Initial Commit"

Since we have previously added the “sample” file to the staging area therefore when we run git status command we can see that files which we have added in the staging area.If you want to remove any file from the staging area you can run the command below. Here, the “sample” is the name of a file.

git rm --cached sample

Now after you have done with adding files to the staging area you can now commit those changes for that you have to run the following command.

Here, the “-m” stands for a message where you have to enter your commit message meaning you have to write a message about what changes you have made so that whenever you push these changes on the GitHub other people working on that project can easily recognize these changes.

In this case, we will enter “Initial Commit” as our commit message. You can put whatever you want to until and unless it is related to the changes which you have made.

Now that we have committed these changes lets talk about the concept of branches in git.Till now whatever we were doing was directly onto the master branch (our project on the remote location). So if you have not created any branch then whenever you commit changes it will by default apply to the master branch. But this is not a proper way of committing changes instead we can create a separate branch and make our changes on that branch.

To create a new branch.

git branch FirstBranch

You can give whatever name you want to your branch here we have given “FirstBranch”.

But if you run the git status command then it will tell you that you are still on the master branch. So to switch to the “FirstBranch” branch which we have created run the following command.

git checkout FirstBranch

Let’s create a new file called login.html using touch login.html command and add it to the staging area by using git add . and then commit it using git commit -m 'Login File' through the “FirstBranch” branch.

Now to merge the changes which we have made in the “FirstBranch” with the “master” branch then we have to first switch to the master branch by git checkout master command. And then merge those changes using git merge Firstbranch command.

Finally, to push all of these changes to the remote repository on GitHub you have to run the following two commands.

//To add origin
git remote add origin 
https://github.com/sahilbhosale63/FirstRepo.git
//To push changes
git push -u origin master

Here it will ask you to enter your GitHub credentials, so enter your username and password and after that, all your local changes will be pushed onto your GitHub repository. You can go to your repository page on GitHub where you will see your changes live.

Here it will ask you to enter your GitHub credentials, so enter your username and password and after that, all your local changes will be pushed onto your GitHub repository. You can go to your repository page on GitHub where you will see your changes live.

Thanks for reading and if you like the content then support us on Patreon. Your support will surely help us in writing more of such content.

If you have any questions regarding Git and GitHub you can comment them down below. And don’t forget to share this blog post with others on social platforms.

“Providing intelligence to a machine” is what we call artificial intelligence. This is the most simple, appropriate, and logical one-line definition of Artificial Intelligence (AI).

Artificial means a system that has been created or developed by humans and intelligence means an ability to think. The main goal here is to make machines think like humans and make them do all those things that humans are capable of doing. Now the question is how to make a machine intelligent and make them do the things which humans can do? To make artificial systems think like humans we need some knowledge or data.

So you might be thinking why do we require data or knowledge to make a machine intelligent? To understand this thing you first have to understand how the human brain works and how people think in general. We humans think or predict based on the knowledge or the data which we have gained from the surrounding, books, peers, etc and the most important thing which is learning from our own mistakes and based on this we make further decisions and act accordingly in the environment (the world).

The same thing goes with artificial systems. They also take the data, process it, make mistakes, and learns from those mistakes, and then they take much more accurate decisions through experience along the way.

We have now understood why we need data so let’s address another question which is where to use this data or how to feed it into a machine to make it intelligent? For this we create models and we called them Machine Learning (ML) models. The model works the same way as the human brain. We need a lot of data so that our ML models can make accurate decisions. And this collection of large amounts of data is called a dataset.

This dataset is further broken down into 2 parts one is called trained data (will be used to train the ML model) and another is called test data (will be used to test the model after training). We don’t do this manually we have tools in python to do this. And this division of dataset into 2 parts is not an exact 50-50% breakup its approximately 50%.

Artificial intelligence and its subfields

Artificial Intelligence has various subfields but out of them, the most popular ones are Natural Language Processing (NLP), Machine Learning (ML), & Computer Vision.

1. Natural Language Processing (NLP)

   Natural Language Processing (NLP) deals with the processing of human language like English and making it understandable to a machine so that it will know how to respond when humans speak to them. Applications of NLP would be Amazon Alexa, Apple’s Siri, or Google Assistant.

   You just have to speak or provide tasks to these devices by communicating with them by asking questions such as what is the weather? or turning on the lights, etc through your language and then they will process your language and provide responses accordingly.

2. Computer Vision

   Computer Vision deals with identifying the objects in an image or in a video stream. The most popular example of computer vision would be self-driving cars.

3. Machine Learning

   Another most popular subfield of artificial intelligence is Machine Learning(ML). Machine Learning provides an ability to a machine to think, learn, and to predict. By using Machine Learning we don’t have to explicitly program a machine to do a particular task by writing a lot of if and else statements.

   Deep Learning is a subfield of Machine Learning in artificial intelligence (AI) which uses neural networks to make even accurate decisions like that of the human brain.

Types of learning in ML

There are different ways in which we can teach a machine how to learn. The main ingredient for making machines capable of learning is the data or the dataset which we use. We take this dataset and apply a learning technique (from the ones which have mentioned below) and accordingly feed the data to a machine learning model so to make machines understand things. Each of these techniques works differently and this is what we will see below.

1. Supervised Learning

   In Supervised Learning, we have the dataset and each data point (single unit of information) in that dataset is associated with a label. So, whenever we pass this dataset as an input to an ML model we also specific beforehand what will be the output for all the data points in that particular dataset.

Let’s say we have images of a cat and a dog as the input data as shown above. Here, we also tell the model what each of these images represents, either it is a cat or it is a dog. The names which are used to represent these images are known as labels.

Supervised Learning Algorithms:

• Linear Regression

• Logistic Regression

• K-Nearest Neighbors

• Decision Tree

• Random Forest

• Support Vector Machines

2. Unsupervised Learning

   In Unsupervised Learning, unlike in supervised learning where we know the input as well as the output beforehand here we only know the input and we have to predict the output. Now to predict the output we use a concept called as clustering meaning grouping of the data.

   In the above plot, we have plotted all of our data points from the dataset on to a graph, and these data points represent 3 shapes, triangles, rectangles, and circles. After identifying the shapes we have drawn 2 lines to make groups or to cluster those data points based on their properties. Here, the property could be the shape of the object.

   After grouping, we can easily predict the output that the first group represents triangles, the second one represents rectangles and the last one as circles.

   Types of Unsupervised Learning:

   - Clustering

   - Association

3. Reinforcement Learning

   Reinforcement Learning is all about learning from the environment. In Reinforcement Learning, there is an agent that acts in the environment who takes decisions. Learning from the environment means, as the agent comes across new data which the agent as never seen before and then it tries to predict what that new data is all about and based on his decision the agent is either rewarded or being punished (penalty is imposed).

Getting started with Data Science

1. Picking up a Programming languages

   • Python: An easy to learn programming language which is one of the most popular languages when it comes to the field of Data Science.

   • R language: The R programming language is also great and is specifically designed for statistical computing and data analysis.

2. Tools and Libraries

   • Numpy: Numpy is a python library used for working with large multi-dimensional arrays and matrices.

   • Pandas: Pandas is a tool used for data manipulation and data analysis written in the python programming language.

   • Mathplotlib: Mathplotlib is a python library used for creating static, animated, and interactive visualizations.

   • Scikit-Learn: Scikit-Learn is a machine learning library for python and is used for data analysis like classification, regression, clustering, preprocessing, etc.

   • Tensorflow: TensorFlow is a software library for dataflow and differentiable programming which is developed by Google.

   • Keras: Keras is a neural network library written in Python which is capable of running on top of TensorFlow, Microsoft Cognitive Toolkit, R, Theano, or PlaidML.

3. Mathematics for Machine Learning (ML)

   • Linear Algebra, Calculus, Statistics and Probability.

4. IDEs

   • Jupyter Notebook: Jupyter Notebook is used to write the code, equations, visualizations, and narrative text inside a web browser.

   • R Studio: R Studio is an Integrated Development Environment where you can write code in R programming language.

   • PyCharm: Pycharm is an IDE developed by JetBrains specifically for writing code in the python programming language.

5. Reading Research Papers of Artificial Intelligence & Machine Learning

   There are various software companies that do a lot of research in the field of artificial intelligence / data science and publish research papers. One of the great companies in this field is DeepMind which is now acquired by Google.

   DeepMind: https://deepmind.com/research

   These papers might be confusing to understand but don’t worry these are complex research papers and its ok if you don’t completely understand them. You will get used to it as you move along in your journey.

   These are some of the things which you can learn to get started with data science. Apart from this, there are a hell lot of things (tools & libraries) which are out there but the things which I have mentioned above are the basics and the building blocks for learning and getting staring into this field.

   To progress in the field of data science or software development you always have to keep your self updated via reading books, blogs, videos, etc. As technology is changing rapidly the things which we use today might get deprecated or may not be in use tomorrow.

Practicing What You Have Learned so far

Just learning things will not help you also have to practice or implement what you have learned in the artificial intelligence field. For this, there is a great platform out there called Kaggle which you can use to practice the concepts of data science by taking part in the competitions.

While doing so you can also make some money if you perform well in those competitions. But don’t do it for money, your primary focus should be on learning.

Free Resources for Learning Data Science

1. Intro to Artificial Intelligence by Udacity

2. Towards Data Science Publication on Medium

3. A 2020 Vision of Linear Algebra by Gilbert Strang

Thanks for reading and if you like the content then support us on Patreon. Your support will surely help us in writing more of such content.

Introduction of Tree Data Structure

A tree is a hierarchical data structure (top to bottom and left to right) which consists of nodes and edges. Nodes are where we store all of our data. The data can be anything it can be integers, strings, characters, etc. The starting node or the first node in a tree is called a root node. And the nodes which don’t have any children are called the leaf node. The path which connects two nodes is called an edge.

Every node in a tree can have multiple children’s and based on the number of children’s a tree have we give that tree a unique name. Example: If every node in a tree has two children then that tree will be called as a binary tree, if every node in a tree has three children’s then it is called as a ternary tree and so on.

Below is a diagram which illustrates a binary tree.

To construct a tree, we can use linked lists.

There are some concepts in trees one is called traversing and another one is searching. Don’t get confused between traversing and searching they both are two different things. Traversing means visiting each and every node in a tree at least once. In searching, we search for a particular node in a tree and after finding that element we stop.

Traversing a tree data structure

There are 3 tree traversal techniques. And in all those techniques, the order in which we traverse the root node changes. But when it comes to the left child and right child of a tree we traverse them in the same sequence i.e we traverse the left child first and then the right child in every traversal technique.

1. Preorder Traversal (Root – Left – Right)

   In Preorder, the root node is printed first and then the left and right child. Therefore it is called preorder traversal.

//Creating a node with two pointer left and right
struct node{
  char data;
  struct node *left, *right;
}

//Preorder Traversal on a Binary Tree
void Preorder(struct node *t){

  //Checking if the tree is Null or not.
  if(t != NULL){

    //Print value inside the node
    printf("%c", t->data);

    //visit the left subtree
    Preorder(t->left);

    //visit the right subtree
    Preorder(t->right);
  }
}

2. Inorder Traversal (Left – Root – Right)

//Creating a node with two pointer left and right
struct node{
  char data;
  struct node *left, *right;
}

//Inorder Traversal on a Binary Tree
void Inorder(struct node *t){

  //Checking if the tree is Null or not.
  if(t != NULL){ 

    //visit the left subtree
    Inorder(t->left);

    //Print value inside the node
    printf("%c", t->data);

    //visit the right subtree
    Inorder(t->right);
  }
}

3. Postorder Traversal (Left – Right – Root)

   In Postorder, the left and right child are printed first and then the root node. Therefore it is called Postorder traversal.

//Creating a node with two pointer left and right
struct node{
  char data;
  struct node *left, *right;
}

//Postorder Traversal on a Binary Tree
void Postorder(struct node *t){

  //Checking if the tree is Null or not.
  if(t != NULL){ 

    //visit the left subtree
    Postorder(t->left);

    //visit the right subtree
    Postorder(t->right);

    //Print value inside the node
    printf("%c", t->data);
  }
}

All the above 3 tree traversal techniques will take the same time complexity and space complexity of O(n).

Types of trees

1. Binary Tree

   Binary tree is a tree in which every node consist of either two children’s or zero children’s. Except the leaf node all the other nodes will have two children’s.

2. Binary Search Tree

   As the name suggests it’s a binary tree (having two or zero children) but in this case here we have a condition and that is the elements present in the left subtree must be lesser than the value of the root element and the elements which are present at the right subtree must be greater than the value of the root element. This condition is applicable to each and every node in the binary search tree because each node will have either a left subtree or a right subtree or both.

3. Balanced Binary Search Tree (AVL Tree)

   Now to check if the tree is balanced or not there is a concept called Balanced Factor (BF). The Balanced Factor for a particular node in an AVL tree can be either -1, 0, or 1 (which means the node is balanced). If the balanced factor of the node is other than these numbers say 2 or -2 then we have to balance that particular node. Below is the formula to find the balanced factor.

   Balanced Factor (BF) = Height of Left Subtree (LST) – Height of Right Subtree (RST)

   Every time we insert a node into the balanced binary search tree (AVL tree) we have to check whether we have any kind of imbalance in a tree or not. If there is any imbalance then we have to balance it using the below imbalance techniques.

There are 4 types of imbalances possible in AVL tree.

a. Left-Left Imbalance (LL imbalance)

From the below figure we can see that the tree has LL imbalance. So we have to rotate the tree in a clockwise direction to make it balanced.

b. Right-Right Imbalance (RR imbalance)

If we have RR imbalance in a tree then we have to rotate the tree in a anticlockwise direction to make it balanced.

c. Left-Right Imbalance (LR imbalance)

If we have an LR imbalance in a tree then we have to perform 2 rotations. First rotate anticlockwise (RAC) and second rotate clockwise (RCW).

d. Right-Left Imbalance (RL imbalance)

If we have an RL imbalance in a tree then also we have to perform 2 rotations. First rotate clockwise (RCW) and second rotate anticlockwise (RAC).

What should be the approach for solving a tree problem?

Any Data Structure can be implemented either iteratively (using loops) or recursively (using recursion functions). And the same goes with the tree data structure. But implementing a tree data structure could be quite confusing at first.

To solve a tree data structure, you should have a good understanding of how recursion works. Because most of the time we will be using recursion to implement a tree data structure. By using recursion we can solve a tree problem in fewer lines of code.

But if you are using an iterative way to solve a tree problem then you might have to write a lot of code and it might be really confusing to understand it. It’s totally up to you which approach you want to follow while implementing a tree.

Thanks for reading and if you like the content then support us on Patreon. Your support will surely help us in writing more of such content.

Steps:

• Use the ensemble and make prediction

• Then calculate a loss function eg: mean squared error

• Fit a new model using the loss function

• Add this new model in ensemble

• Repeat

Types of ensemble methods:

• Voting

• Averaging

• Stacking

• Bootstrap

• Aggregating (Bagging)

• Boosting

Cross-validation is a modelling process where the data is divided into multiple folds (pieces) and then we perform experiments by taking each fold at a time and considering it as a validation set and all the other folds combined as a training set.

The data can be divided into any number of folds. Say we have divided the data into three folds, then,

• Experiment 1: Fold 1 – validation set, Fold 2,3 – training set

• Experiment 2: Fold 2 – validation set, Fold 1,3 – training set

• Experiment 3: Fold 3 – validation set, Fold 1,2 – training set

After performing all experiments on the #mlmodels, we get scores (model quality/model accuracy) for each experiment. We can take the average of it and consider the overall score.

This process is resource heavy and so it might not produce instant results for larger datasets as compared to smaller datasets. Overall it helps increase the model quality.

1. Drop the columns that has missing values

   • Here, we drop the columns that have missing values.

   • With this approach, there is a chance that we may lose access to lot of useful information.

   • You should use this approach only if most of the values in a column are missing and not otherwise.

2. Imputation

   • Here, we replace all the missing values in a column with the average value of that column. For example, if column has 3, 2, 1 as values then we take average of this column that is 2 and replace it with missing values.

   • It’s a standard approach.

   • The imputed value is not always right, however, it results in good accuracy as compared to the previous way.

3. Extension to Imputation

   • Here, we follow the process of imputation and then for each column with missing value we also create a new column.

   • The location at which the value is imputed we mark an entry in the newly created column to specify that this location has imputed value.

   • This may increase the accuracy of prediction, but in some cases it can also make no difference.

If you want to become a data scientist 👨‍💻, then you must be good at working with datasets. Being familiar with the dataset is the first step towards building ML models.

Before working with the data from the dataset it’s important to split the dataset into three parts.

• Training set: Used for training the model.

• Validation set: Used to pick the best model for prediction. Once you have trained and tested various models you have to decide which model makes accurate predictions based on the validation set.

• Testing set: Once you have finalized the model you can then test the model with a testing set.

The ratio in which you divide the data depends on the size of the dataset and there is no specified number on how to split the data. However, you can generally split the dataset into 60% training set, 20% validation set and 20% testing set.

That’s all about splitting the dataset in Machine Learning. In the next post, we will see how to explore the dataset with Pandas.

• It represents the output of an ML model.

• For example, In a supervised learning algorithm, if you are developing a model for predicting house prices then your dataset will have a “Price” column, so this column will be your prediction target.• Only one column can be the prediction target.

• Represented as “y”.

• It can be accessed with a dot notation approach as follows.y = my_dataset.Price

Features

• Features are nothing but the inputs that are provided to a model.

• The feature can be any number of columns from the dataset, except for the prediction target.

• Based on the selected input columns (features) the output will be predicted by the model.

• Represented as “X” as follows.

features = [‘TotalRooms’, ‘Floors’, ‘Landsize’]X = my_dataset[melbourne_features]]

For more blogs visit LionGuest Studios.com

List in python

• The List is a data structure in python which stores data linearly or sequentially one after the other. It is somewhat similar to arrays in other programming languages. The only difference between an array and a List is the arrays can store data of the same type whereas Python’s List can store data with multiple data types (a combination of integer, string, floating-point, etc).

• Lists are represented using square brackets [ ]. The initial item in a list starts with an index number ‘0’.

• The list is a mutable data structure which simply means that once it has created the items inside which can be changed later.

Creating a List in python

Lists can be created by putting values inside the square brackets and assigning it to a variable.

empty_list = [ ]

Here, empty_list is the name of the variable which will contain a list as represented by square brackets. And inside the square brackets, you don’t have any elements which simply means that the list is empty.

Examples:

list_of_numbers = [ 1, 2, 3, 4, 5] 
list_of_Strings = ['Ana', 'Pat', 'Simon', 'Amanda']

Note that the strings inside the list are represented by quotes (single or double quotes anything will work) and numbers have no quotation mark.

list_with_different_data_types =  [ 'Micheal', 15, 20.5, [1, 2, 3]  ]

This is a list that contains multiple data types. Also, the lists can contain another list too. In this case, element number 3 is an element of a list which is a list in itself.

Adding elements to a List in python

1. append() function:

If you want to insert an element at the end of the list then you can use the append function. Inside this function, you have to pass the value or the element that needs to be inserted in a list.

original_lst = ['A', 'B', 'C', 'D', 'E']
original_lst.append('F') #This will insert element ‘F’ at the end of the list

print(original_lst)

Output:
['A', 'B', 'C', 'D', 'E', 'F']

You can even insert an entire list to an already created list with the append() function.

lst = ['A', 'B', 'C', 'D', 'E']
new_lst = ['F', 'G', '1', '2', '3']

lst.append(new_lst)

print(lst)

Output:
['A', 'B', 'C', 'D', 'E', ['F', 'G', '1', '2', '3']]

Note: If you want to add a single element to a list then use append() and if you want to add multiple elements into a list then use extend(). Go to extend() function.

2. insert() function:

   If you want to insert an element at a specified location in a list then you can use the insert(location, element_to_insert) function which takes two parameters. In the first parameter, you have to pass the location at which the element is to be inserted and in the second parameter, you have to pass the value of the element.

my_list = ['one', 'three']

Now let’s add element ‘two’ to the above list at index 1 for that you have to use the insert function.

my_list( 1, 'two' )

Output:
['one', 'two', 'three']

Deleting elements from a List in python

1. remove() function:

   If you want to delete a particular element from a list using its value then you can use the remove() function. For example, if you want to remove element ‘B’ from the list then you have to pass this as an argument to the remove() function.

list = ['A', 'B', 'C', 'D', 'E']

list.remove('B')
print(list)

Output:
['A', 'C', 'D', 'E']

2. del keyword:

   If you want to delete a particular element from a list using its index then you can use the del keyword. Let say you want to delete ‘Marry’ from the below list then you can delete that element using its index no.

list = ['Merry', 'Adam', 'Watson', 'Anna']

del list[0] #passing index 0 because Marry is present at the index  
print(list)

Output:
['Adam', 'Watson', 'Anna']

3. pop() function:

   The pop() function works the same way as the del keyword but the only difference is that the pop() function will also return the element which has been deleted from the list.

list = ['Merry', 'Adam', 'Watson', 'Anna']
item_popped = list.pop(0) 

print(item_popped) 
print(list)

So, If you want to delete an element from a list in python using the value then use the remove() function. And if you want to delete an element using index no then use the del keyword or pop() function. In case if you also want to get the item that you have deleted then use the pop() function which will return you that item.

Accessing elements inside a List (indexing) in python

Each element in a list as an index no starting with zero. To find an element inside the list you have to use its index no. Accessing an element using its index no is called indexing. This can be done by passing the index number inside the square brackets.

list[indexNo]

In the below list, if you want to access the individual elements inside a list then you can pass the index as follows.

my_list = ['one', 'two','three']

print(my_list[0])    # accessing element ‘one’
print(my_list[1])    # accessing element ‘two’
print(my_list[2])    # accessing element ‘three’

Output:
one
two
three

Slicing a list in python

Slicing is nothing but dividing a list. In case if you want to print some part of the list and not the entire list then you can use slicing.

Slicing is done using “:” colon symbol. It has 3 parts list[ start : end : stepSize ]. Step size is optional.

Before the colon, you have to specify the start index of the list (i.e the index from which you want to slice a list) and it is denoted by start. After the colon, you have to specify the end index of the list (till what index do you want to slice the list) and it is denoted by the end. Here, note that the value which you specify for the end part will not be included in the final list after slicing.

Let’s take an example and understand this.

slice_this_list = [10, 20, 30, 40, 50, 60]

So, to slice them you have to use the index number of both the start and the end elements. The index of starting element 20 is 1 and the index of ending element 50 is 4. You will use these index nos in order to slice the list.

print(slice_this_list[1 : 4])

What do you think it will print? It will print 20, 30, 40 only 3 elements. But we also want to print 50, right? The last element is not included in the slicing because python will exclude the end and will stop at one index before the end i.e in this case index 3.

You have specified end as 4, so it will stop at one element before index 4 which is index 3. And the element which we have at index 3 is 40. Therefore, it is slicing till element 40.

Now, if you also want to get the element 50 then you have to increase our end index to 5.

print(slice_this_list [ 1 : 5 ])

Here, you are slicing the list in sequential order (one after the other) but if you want to skip some elements in the middle then you can use step size. By default step size is 1 which will slice the elements in sequential order. You can increase it to any value, in this case, let’s increase it to 2.

print(slice_this_list [ 1 : 5 : 2 ])

# Here,
# 1 represents - start
# 5 represents - end
# 2 - represents - step size

This will print the following as output.

Output:
20 40

In case if you want to start from a particular element and then print all the elements then don’t specify the end part keep it blank.

my_list = [10, 20, 30, 40, 50, 60, 70]

Here, Let’s start printing from the element 30 to the last element i.e 70.

Output:
[30, 40, 50, 60, 70]

The same can be done if you want to print all the elements from the staring index to the desired element. Let’s slice the above myList till the index 5. For that keep the start part blank.

print(my_list[  : 5 ]) #end part is kept blank to print all the in the list after

Output:
[10, 20, 30, 40, 50]

Note that it will slice till one element before the index 4.

Sorting a List in python

Sorting a list is arranging the elements inside the list in either ascending or descending order. There are two ways to sort a list in python.

1. sorted() function:

   sorted() function takes a list as an input and returns a sorted list in ascending order. The original list remains unchanged. Now if you want to sort the list in descending order then you can even pass reverse = True as a second argument (which is optional) to the sorted() function.

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

sorted_list_ascending_order = sorted(original_list)
sorted_list_descending_order = sorted(original_list, reverse= True)

print(original_list)
print(sorted_list_ascending_order)
print(sorted_list_descending_order)

Output:
[5, 2 , 1, 4, 3]
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]

2. sort() function:

   Instead of creating a new variable and storing the sorted list inside that variable, you can also sort the list and store it inside the same variable using the sort() function.

Output:
[1, 2, 3, 4, 5]

Note that if you have a list with different data types then you cannot sort that list with any of the above functions as it is not possible.

Printing all the elements inside a list in python

In order to print all the elements inside a list in python you can use a for loop with the “in” keyword.

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

for element in list:
    print(element)

Output:
1
2
3
4
5

Other operations performed on a List

1. Reversing a List in python

   list.reverse(): Reversing a list in python is very easy. In order to reverse a list, you have to use the reverse() function in python which will reverse all the elements inside that list.

reverse_this_list = [5, 10, 15, 20, 25, 30]
print(reverse_this_list.reverse());

Output:
[30, 25, 20, 15, 10, 5]

2. Finding length of a list

   len(List): If you want to know the total no of elements inside a list then you can use a len() function which will return the total elements present inside the list.

Output:
5

3. Splitting a string into a list in python

   string.split(): If you have a string say “Welcome to LionGuest Studios” and want to split the entire string in such a way that each word in a string is represented as an element inside a list. For that, you have to use the split() function. If you don’t specify any parameter then it will split the string based on white space or a tab.

string_to_list = "Welcome to LionGuest Studios"
string_to_list.split()

Output:
['Welcome', 'to', 'LionGuest', 'Studios']

4. Joining two or more List in python

   a. extend() function:

   If you want to add elements at the end of the list or if you want to join two lists then you can use the extend function. This will add elements of list2 to list1 without affecting list2.

#example with "extend"

list1 = [1, "Mac", 20.5]
list2 = ["Mongo", 50, 40.5]

list1.extend(list2)

print(list1)
print(list2)

Output:
[1, 'Mac', 20.5, 'Mongo', 50, 40.5]
['Mongo', 50, 40.5]

Note: If you want to add a single element to a list then use append() and if you want to add multiple elements into a list then use extend().

b. + operator

To join two or more lists together we can use the “+” operator. This works the same way as the extend function but here it will not modify the given lists. You have to store the results of this operation to a new variable so that you can use it later.

Output:
[1, 'Mac', 20.5]
 ['Mongo', 50, 40.5]
 ['X', 'Y', 'Z']
 [1, 'Mac', 20.5, 'Mongo', 50, 40.5, 'X', 'Y', 'Z']

5. Counting occurrence of an item in a list

   list.count(): In order to count the total occurrence (frequency) of a particular element in a list we can use the count function.

this_list = [10, 20, 30, 20, 10, 50 ,20 ,20]

# To count the occurrence of number 20
count_of_no = this_list.count(20)
print("Total number of times the no. 20 has occured in a list is:", count_of_no)

Output:
Total number of times the no. 20 has occured in a list is: 4

That’s all it is. Thanks for the read. If you like the content then support us on Patreon. Your support will surely help us in writing more of such content.

This blog post will not be a structured kind of blog. We will explore various concepts of object oriented programming paradigm as we move forward while following a proper flow of information. Explaining these concepts individually will not make much sense since each of these concepts are interrelated to each other.

Before diving deep into the 4 pillars of oop lets first understand want are access modifiers in Java.

Access Modifiers in Java

The Access modifiers are reserved keywords in Java that can be used with variables, methods, constructors, and classes. They are used to restrict the scope of the variables, methods, constructors, and classes within classes and packages (In general, packages are also known as directory or a folder). The Access modifiers will help us in writing quality code as well as in enhancing the security of the software. There are four access modifiers in Java each of them are explained briefly.

1. public – Whenever you use a public keyword before any variable or a method then that variable or a method can be accessed inside any class or packages.

2. default – By default, if you don’t use any access modifier before variables, methods, constructors, or classes then in that case java will consider them as default access modifiers. The default access modifier can be accessed only inside a particular package in which it’s declared as well as inside the sub-packages if present.

3. private – If the variables, methods or constructors are declared as private then they can be accessed only inside that class where they are declared. When using a private keyword with classes, only make inner classes or nested classes as private and not the outer class. If we declare the inner class as private then it can be accessed from the outer class, but if the outer class itself is made private then this makes no sense since you will not be able to access any elements present inside that class.

4. protected – If the variables, methods, or constructors are made protected then they can only be accessed within the package they are defined as well as inside the subclasses (with the help of inheritance). The classes cannot be made protected.

The 4 Pillars of OOP (object oriented programming) Paradigms in Java

Polymorphism, Inheritance, Encapsulation, and Abstraction are the 4 pillars of OOP (object oriented programming). Let’s understand each of them with an example. Imagine that we have a car manufacturing company and we want to design two cars, one is an SUV car and another one is a sports car. As we know, every car has various things in common and they have some differences as well. So, we will try to represent all of these things in object oriented way such that we can get a proper understanding of each of the 4 paradigms of the OOP.

First, we will create 4 classes, Main class, SUV class, Sports class, and Car class. The Car class will contain all the common properties of both the SUV and Sports cars. So, the Car class will be the parent of both SUV and Sports classes. The SUV and Sports classes will contain car-specific properties for SUV cars and Sports cars respectively. Inside the Main class, we will create the objects of these two car types.

Initially, this is how each of these classes will look like. You can create separate files for each class or you can also specify all these classes in a single file as well. The recommended way is to create separate files for each class.

SUV.java

public class SUV extends Car{

}

Sports.java

public class Sports extends Car{

}

Car.java

public class Car{

}

1. Polymorphism in Java

   Whenever people buy a car they are more interested in knowing the speed of the car. So, as a car manufacture company we have to make an engine for both our SUV as well as for our sports car that could take our car’s speed to the next level. To add an engine to our car, we will create a method called “engine()” which will take a single parameter of type string called “engineType”. The value of the “engineType” variable will be “SUV Engine” or “Sports Engine”. You can pass in any values, this is just for the sake of this example.

   The engine() method will go under our Car class because it doesn’t matter what type of car your building it will always have an engine. And depending upon the type of the car which we are building we will tell the engine() method to create an engine for that type of car. For example, if we are building SUV car then we will tell the engine() to create an engine for SUV car by passing the value “SUV Engine” to the “engineType” parameter inside the method.

   We can also make this method “public” so that we can access it inside the “Main.java” as that’s where we will be creating all of our objects.

Car.java

public class Car{

    public void engine(String engineType){
        System.out.println("Create Engine: " + engineType);
    }
}

In the case of Sports car, people are also interested in knowing how many seconds the car’s engine will take to go from 0 to 100 kmph. So, for this, we can also pass another parameter called “secondsToReachHundred” to the engine() method so that we can know in how many seconds our engine can reach 100 kmph. But if we pass this parameter to the above engine() method then it can cause a problem. Since whenever we will create the engine for our SUV class by calling the engine() method then during that time also we have to pass the value to the second parameter “secondsToReachHundred” as well since the engine() takes two parameters as input which we don’t want, Right.

To solve this, we can create another method specifically for our Sports car, so that whenever we will create the engine then we can call that method as shown below.

Car.java

public class Car{

    // For the SUV and other car types
    public void engine(String engineType){
        System.out.println("Create Engine: " + engineType);
    }

    // For the sports car
    public void engine(String engineType, int secondsToReachHundred){
        System.out.println("Create Engine: " + engineType + secondsToReachHundred);
    }
}

As you can see above, we have created another method called engine() which takes two parameters “engineType” and “secondsToReachHundred”. This method can be called by any car that wants to know much time it will take for the engine to reach a hundred, but more specifically by the Sports car.

This is called polymorphism which is the first pillar out of the 4 pillars of OOP. In polymorphism, we can have various methods with the same name (in this case, engine) but each method will take different signatures or parameters. You can also create a method with the name “engine()” which can take no parameters as well. In this case, we don’t need a method with no parameters and that’s the reason we have not created such a method.

A Polymorphism is of two types:

a. Compile time polymorphism

In this type of polymorphism, Java can decide during the compile-time which of these methods needs to be called since all the methods have the same name. The example which we have seen above is the compile-time polymorphism as Java can decide which engine() method needs to be called based on the number of parameters passed to the method while calling the method. This is also known as static polymorphism.

b. Runtime polymorphism

Whenever we have a method present inside the parent class and we override that method in our child class then this is called as runtime polymorphism or dynamic polymorphism.

Overriding a method simply means that you already have a method defined in the parent class, but for some reason you don’t want to use that method, instead want to create your own so that you can define your own code into that method. In such cases, the method name and its parameters should remain same as that of the method present inside parent class while defining your own method in child class.

In our above example, we have engine(String engineType) method in out Car class which only prints a message to the output window. Now let’s override this method into the Sports class which is a child of the Car class. While doing so we will also create a boolean variable called “isElectric” whose value will be currently set to false which represents that the car engine doesn’t work on electric, as shown below.

Sports.java

public class Sports extends Car{

    boolean isElectric = false;

    @Override
    public void engine(String engineType){
        if(!isElectric){
             System.out.printf("The %s does not work on electric, it works on petrol. \n", engineType);
        }   
    }
}

Main.java

public class Main {
    public static void main(String[] args) {
        Sports lamborghini = new Sports();
        lamborghini.engine("Sports Engine");
    }
}

In this case, while compilation the Java compiler will not know which engine() method you are exactly calling, either of the Sports class or of the Car class, since both of these classes have these methods present with the same name as well as with the same parameters or signature. This decision can only be taken during runtime only and therefore this is called runtime polymorphism or dynamic polymorphism.

If you run the above program at this stage then the output will be as follows.

Output:The Sports Engine does not work on electric, it works on petrol.

2. Inheritance in Java

   In our example, the SUV class and the Sports class both are children of the Car class since both can inherit and access the properties (variables and methods) present inside the Car class into their class. The Car class is the parent. This is called inheritance which is the second pillar out of the 4 pillars of OOP.

3. Encapsulation in Java

   As we know, the variables which are made private cannot be accessed outside the class. This is good for security purposes because we don’t want all the classes to access these variables. But what if some of the classes want to access these variables?

   To achieve this, we can use something called getter and setter methods. With the help of these methods, we can indirectly access the private variables of the classes. This helps us in achieving Encapsulation as we are enclosing the private variable with getter and setter methods because of which we cannot directly manipulate the private variable.

   Let’s now create two private variables inside our SUV class. The first variable is the “navigationSystemSupported” which will tell whether the car supports a geographic navigation system or not and the second variable will “noOfSeats” which as the name suggests will tell the total number of seats the SUV car will have.

   To create getter and setter methods for these two variables, on your IDE (I’m using Intellij IDEA) right-click and select “Generate”.

This will generate the below boiler plate code for you.

This will generate the below boiler plate code for you.

SUV.java

public class SUV extends Car{

    private boolean navigationSystemSupported;
    private int noOfSeats;

    public boolean isNavigationSystemSupported() {
        return navigationSystemSupported;
    }

    public void setNavigationSystemSupported(boolean navigationSystemSupported) {
        this.navigationSystemSupported = navigationSystemSupported;
    }

    public int getNoOfSeats() {
        return noOfSeats;
    }

    public void setNoOfSeats(int noOfSeats) {
        this.noOfSeats = noOfSeats;
    }
}

Now let’s access these variables from our Main class. To do this, we will first create the object of the SUV class using the new keyword. Then using the setter methods “setNavigationSystemSupported” and “setNoOfSeats” we will set the values of the variables navigationSystemSupported and noOfSeats as shown below.

SUV rangeRover = new SUV();
rangeRover.setNavigationSystemSupported(true);
rangeRover.setNoOfSeats(9);

Main.java

public class Main {

    public static void main(String[] args) {

        Sports lamborghini = new Sports();
        lamborghini.engine("Sports Engine");

        SUV rangeRover = new SUV();
        rangeRover.setNavigationSystemSupported(true);
        rangeRover.setNoOfSeats(9);

        if(rangeRover.isNavigationSystemSupported())
            System.out.printf("The SUV has %d seats and supports navigation system. \n", rangeRover.getNoOfSeats());
        else
            System.out.printf("The SUV has %d seats and does not supports navigation system. \n", rangeRover.getNoOfSeats());
    }
}

In the end, we are printing the values of the private variables using getter methods “isNavigationSystemSupported” and “getNoOfSeats” as shown above.

Output:The Sports Engine does not work on electric, it works on petrol. 
The SUV has 9 seats and supports navigation system.

This is all about encapsulation which is the third pillar out of the 4 pillars of OOP.

4. Abstraction in Java

   Abstraction is the last pillar out of the 4 pillars of OOP in Java. There is usually confusion between people when it comes to encapsulation and abstraction. Encapsulation, as we have already seen above is used to hide or encapsulate the data so that our data could remain secure.

   In Abstraction, you might have seen this definition that “Abstraction is used to hide the implementation details”. But what exactly does it mean? The definition itself seems confusing 😂. So, let me clear this out of you.

   In Abstraction, we usually make the class abstract and some or all of its methods abstract as well (we will see how to make a class or method abstract in few moments). This means that we don’t write the implementation or the body of the methods which are abstract. We only write the method name and specify the number of parameters it will take and then we put a semicolon as shown below.

Example.java

# This is an abstract class
abstract class MyClassName{

    # This is an abstract method that doesn't have a body
    abstract int newMethod();
}

Now whichever class will inherit this abstract class, that class will always have to define or implement these methods in its class. So, here what’s happening is that the abstract method doesn’t have the implementation of the methods present in it. The implementation is present in some other classes which will inherit this abstract class. Therefore, the definition of abstraction states that it hides the implementation.

Abstraction can be achieved with the help of abstract keyword or by using interfaces

a. abstract keyword

• A method or a class can be made abstract with the help of the “abstract” keyword.

• An abstract class can contain both abstract methods as well as normal methods.

• An Abstract method doesn’t have implementation.

• An abstract class cannot be instantiated with the new keyword (i.e we can’t create objects of the abstract class).

• To use the abstract class or its methods you can inherit this class using the “extend” keyword.

Also, we will define one abstract method called “carChassisAvailable” that will tell how many car chassis are available in the factory for both SUV and sports car. This abstract method will take two parameters “chassisSUV” (total chassis of SUV car available) and “chassisSports” (total chassis of sports car available) and the sum of both these values will be returned as an integer value.

CarFactory.java

// Abstract class
public abstract class CarFactory {

    // Normal method
    public void totalCarsManufactured(){
        System.out.println("A total of 50 cars are manufactured to date.");
    }

    // Abstract method with no implementation
    abstract int carChassisAvailable(int chassisSUV, int chassisSports);

}

We will write the implementation for the above abstract method inside the Car class as follows. Notice that we are extending the CarFactory class using extend keyword.

Car.java

public class Car extends CarFactory{

    // For the SUV and other car types
    public void engine(String engineType){
        System.out.println("Create Engine: " + engineType);
    }

    // For the sports car
    public void engine(String engineType, int secondsToReachHundred){
        System.out.println("Create Engine: " + engineType + secondsToReachHundred);
    }

    // Implementation for the abstract method present in CarFactory
    @Override
    int carChassisAvailable(int chassisSUV, int chassisSports) {
        return chassisSUV + chassisSports;
    }
}

Now we can call the totalCarsManufactured() and carChassisAvailable() methods by creating an object of the Car class inside the Main class.

Main.class

Car totalCars = new Car();
totalCars.totalCarsManufactured();
int chassis = totalCars.carChassisAvailable(40, 50);
System.out.println("Total Car Chassis Available: "+chassis);

The output of this will be look like this.

Output:A total of 50 cars are manufactured to date.
Total Car Chassis Available: 90

b. Interfaces

Another way of achieving abstraction is by using interfaces.

• To declare interface we use the “interface” keyword.

• To use the interface we use the “implements” keyword.

• An interface doesn’t allow normal methods as the abstract class does. It only allows abstract methods which provide total abstraction.

• All methods present inside the interface have no implementation (methods without body).

• No need to specify an abstract keyword before a method. By default, all the methods specified inside the interface are abstract.

• Java doesn’t support multiple inheritance. But using interfaces we can achieve it.

Now here we will create a new file for our interface and will create an abstract method but this time using an interface.

The interface will also have a name, here we will give “CarFactoryInterface” as a name for our interface. Then we will define a “noOfAssemblyLines()” method that illustrates the number of assembly lines in the car factory and the implementation of this method will be written inside the Car class.

To use the interface in the Car class we have to use the implements keyword. Then we will define the noOfAssemblyLines() method inside the Car class.

Car.java

public class Car extends CarFactory implements CarFactoryInterface{

    // For the SUV and other car types
    public void engine(String engineType){
        System.out.println("Create Engine: " + engineType);
    }

    // For the sports car
    public void engine(String engineType, int secondsToReachHundred){
        System.out.println("Create Engine: " + engineType + secondsToReachHundred);
    }

    // Implementation for the abstract method present in CarFactory
    @Override
    int carChassisAvailable(int chassisSUV, int chassisSports) {
        return chassisSUV + chassisSports;
    }

    // Implementation for the abstract method present in CarFactoryInterface
    @Override
    public void noOfAssemblyLines() {
        System.out.println("There are 2 assembly lines, one for SUV and another for Sports car.");
    }
}

If you noticed clearly then you will see we are accessing methods from two different classes CarFactory and CarFactoryInterface at the same time This is a kind of multiple inheritance. You can create any number of interfaces as you want and implement them using commas like “public class Example implements A, B, C”. But a class can only inherit from a single parent class using the extend keyword.

At the end, you can call the noOfAssemblyLines using the Car object inside the Main class.

Main.class

package com.company;

public class Main {

    public static void main(String[] args) {

        Sports lamborghini = new Sports();
        lamborghini.engine("Sports Engine");

        SUV rangeRover = new SUV();
        rangeRover.setNavigationSystemSupported(true);
        rangeRover.setNoOfSeats(9);

        if(rangeRover.isNavigationSystemSupported())
            System.out.printf("The SUV has %d seats and supports navigation system. \n", rangeRover.getNoOfSeats());
        else
            System.out.printf("The SUV has %d seats and does not supports navigation system. \n", rangeRover.getNoOfSeats());


        Car totalCars = new Car();
        totalCars.totalCarsManufactured();
        int chassis = totalCars.carChassisAvailable(40, 50);
        System.out.println("Total Car Chassis Available: "+chassis);

        totalCars.noOfAssemblyLines();
    }
}

Finally, this is what you will see as an output.

Output:The Sports Engine does not work on electric, it works on petrol. 
The SUV has 9 seats and supports navigation system. 
A total of 50 cars are manufactured to date.
Total Car Chassis Available: 90
There are 2 assembly lines, one for SUV and another for Sports car.

That’s all for this blog post 4 pillars of OOP (Object Oriented Programming) Paradigms in Java. Thanks for the read. If you like the content then support us on Patreon. Your support will surely help us in writing more of such content.

An Object Oriented Programming (OOP) is one of the styles of writing robust, modular, reusable, and maintainable code. A programming style that revolves around objects knows as object oriented programming (OOP). It follows the principle of software engineering called DRY “Don’t Repeat Yourself” which helps in minimizing the repetition of code.

Let’s understand the object oriented programming concepts in java by combining it with a real word example.

The part 2 of the Object Oriented Programming series can be found here: 4 pillars of OOP: Object Oriented Programming Paradigms

Classes and Objects in Object Oriented Programming

Class in java allows us to define all the variables and methods at one place related to a particular entity. For example, Let’s say we want to build a car (in this case car is the entity) then for that we first have to create a blueprint or a design of that car and that will contain the car’s dimensions like width & height, car’s name, model no, car’s speed, braking system, auto or manual mode, etc. These are the things that we first have to figure out related to the car, and based on this data or blueprint we can create the actual physical car.

In OOP, the class is where we define all of such data and because of that class is also called a blueprint. The data which is stored inside a class is in a form of variables and methods. As just after creating a blueprint or a design of a car the physical car is not created, the same way whenever we define a class in java no object will be created which means no car will be created.

To create a car in java we first have to create an object of that class. Creating an object simply means allocating memory to the class which we have created. This is done with the help of a new keyword in Java. After allocating the memory, the object will now have all the data (variables and methods) which we have defined inside our class. Using this object, we can manipulate the data which is present inside that object. You can create as many car objects as you want from the Car class provide different properties to every object. Refer to the figure shown below which will provide you with a pictorial view of how the classes and objects work.

The above image contains a Car class and using this class we are creating multiple car objects. This Car class contains two variables, company (the company who manufactured the car), speed (speed of the car) and lastly, we have a method called as getSpeed() which prints the speed of the car.

To create a physical car we first have to create an object of this class with the help of a new keyword in Java. So, here we have created 3 objects from this class, the first one represents the Honda Car which has a speed of 100 km/hr, the second object represents the Jeep car with a speed of 500 km/hr and the third object represents the BMW car with the speed of 800 km/hr.

The above example of the class and objects is representation in the code below.

import java.io.*;

 class MainClass {

        public static void main(String[] args) {   

            Car honda = new Car();     
            honda.company = "Honda";     
            honda.speed = 100;     
            honda.getSpeed();    

            Car jeep = new Car();     
            jeep.company = "Jeep";     
            jeep.speed = 500;     
            jeep.getSpeed();     

            Car bmw = new Car();     
            bmw.company = "BMW";     
            bmw.speed = 800;     
            bmw.getSpeed(); 
    }
}

 class Car{
     String company;
     int speed;

    void getSpeed(){ 
        System.out.println(company+" car's speed is "+ speed+ " Km/hr"); 
    }
 }

Output:
Honda car's speed is 100 Km/hr
Jeep car's speed is 500 Km/hr
BMW car's speed is 800 Km/hr

Don’t worry if you didn’t understand each and everything which is written inside the above code. As we move along, everything will make sense.

A constructor tells us how much space to allocate to an object in memory. Every class in java has a constructor inside it and this constructor is called the default constructor. This default constructor is created by java and will be used to allocate memory to the object. By default, while creating an object a default constructor will be called. The reason why java calls a default constructor is that the constructor knows how much memory will be required to create an object of that class. You can also create your own constructors and a class can support any number of constructors.

A job of a constructor is to allocate space in memory for an object and to initialize the variables at the time of object creation. A constructor is also called a member method because it is present inside the class, it has the same name as the class name and it is represented by round brackets ‘( )‘. A constructor will always have a public access modifier because it can be called from inside any class.

// Constructor Example
class Car{

    // This is a default constructor
    public Car(){

    }
}

Whenever you will create a class you will not see the above code for the default constructor. But it will be there and while compiling the code the java compiler will call this default constructor if the compiler doesn’t find any other constructor.

Now with the default constructor, you manually have to initialize your variables after the object is created which is quite hectic at times. For, example, as we have seen above, whenever we were creating the object of the Car class at that time we were assigned the company name and the speed to the Car object manually inside our code. But we can also initialize any of these parameters at the time of object creation. To achieve this you can create your own constructors. The advantage of creating your own constructor is that you can initialize any number of variables present inside the class at the time of object creation.

class Car{

    int speed;
    String engineType;

    // This is a default constructor
    public Car(){

    }

    // Creating your own constructors

    // Constructor which takes one parameter
    public Car(String speed){
          this.speed= speed;
    }

    // Constructor which takes two parameter
    public Car(int speed, String engineType){
         this.speed= speed;
         this.engineType = engineType;
    }

    // You can call any one of the above constructors 

}

Here, The constructor which you will be creating will look the exact same as the default constructor, the only difference is the parameters which it will take. You can create any number of constructors as you want but the only condition is that it should take different numbers of parameters.

Calling a constructor in Java

In order to create an object, we use a new keyword in Java. By using this keyword Java compiler understands that you want to create an object. But just using the new keyword will not create an object for you as you also need to know how much space you need in memory to allocate for the object.

For that, you have to call the constructor. So, after the new keyword, you also have to write the constructor name (either the default constructor or the constructor which you have created) by passing appropriate parameters. This will call the constructor that will then tell the Java compiler how much space the object will require and the new keyword will allocate that much space and then the entire object will be stored inside a variable.

Below diagram illustrates this process.

Here, our aim is to simply create a Mercedes physical car using the Car class (blueprint). For that, we first need to know how much space we will need to store our Mercedes car object in memory (this is nothing but creating a physical car in the real world). To get the space needed to store the object we have to call the Car constructor. In this case, we are calling the Car constructor which we have created that only takes a single parameter called speed. Since we want to initialize the speed variable at the time of object creation we will call the constructor which we have created and pass in the value 100 which represents speed to the constructor.

// Calling constructor and creating an object
import java.io.*;

class MainClass {

    public static void main(String[] args) {       

      // Calling our custom constructor & Creating the object      
      Car mercedes = new Car(100);     
        mercedes.company = "Mercedes-Benz";     
         mercedes.getSpeed(); 
     }
 }

 class Car{
     String company;
     int speed;

     // Creating our own custom constructor 
    // which takes speed as a parameter 
    public Car(int speed){     
    this.speed = speed; 
    } 

    void getSpeed(){      
    System.out.println(company+" car's speed is "+ speed+ " Km/hr"); 
    } 
}

Output:
Mercedes-Benz car's speed is 100 Km/hr

Keys points to remember about a Constructor in object oriented programming

• A constructor is a member method.

• It has the same name as the class name.

• It will never return anything.

• It tells us how much space in memory needs to be allocated for an object.

Keywords used in object oriented programming

Since the Java programming language follows the object oriented programming style of writing code, it supports various keywords like static, this, super, final, which can make our life much easier in writing and maintaining our Java code and while working with object oriented programming style. These Java keywords are explained in detail below.

Static Keyword in Java

Whenever you want to call any method in java we first have to create an object of that method and then only we can call that method. Now when will the object be created? When your program execution will start. From where the program execution starts in java? From the main method, Right. But here is a catch, main() is also a method itself, Right? Yes, then who creates an object of the main() method? The answer is no one creates an object of the main() method.

But we have seen that to call a method we have to create an object of that method and here we are saying we don’t create an object of the main() method. Here, the problem is main() is the starting point from where our program execution will start, so before starting the program execution how can we can an object which is not possible. This is a deadlock condition.

To solve this deadlock, java provides us with a keyword called static. Using the static keyword you can directly call a method without creating an object in Java. That’s the reason why we use a static keyword before the main() method in our program. You can use this keyword not just for main() but for any method which you want to call without creating an object of it.

‘this’ keyword in Java

Whenever you have the same name for instance variable and for local variable then in that case we use this keyword. We have already seen this keyword in practice while we created our own constructor and passed the value of the speed variable at the time of object created.

Inside this class, we have declared a variable speed which is known as an instance variable. When we are creating our own constructor by passing in a variable speed as a parameter then this variable is called a local variable. Our aim here is to assign the value of local variable speed to the instance variable speed. Since both of these variables have the same name then how would you differentiate between them? This can be done with the help of this keyword.

Whenever we use this keyword on a variable it will tell the Java compiler that this variable is an instance variable and the value of the local variable needs to be assigned to this instance variable.

Super keyword in Java

The super keyword is present inside each and every constructor. You will not explicitly find the super() written inside the constructor but by default, it will be there. During inheritance, the super keyword will be used to call the default constructor of the parent class from the child class. If you want to call a constructor other than the default constructor of the parent class then you have to write the super keyword and pass in the parameters accordingly based on which constructor of the parent class you want to call from the child class.

//static keyword example

import java.io.*;

 class Vehicle{
     public Vehicle(){ 

    } 

    public  Vehicle(int i){     
        System.out.println("You called a constructor with 1 parameter of Parent class.");     
    }
 }

 class Car extends Vehicle{
     public Car(){ 

    } 

    public Car(int i){     
        //This will call the second constructor of Vehicle class     
        super(i);     
        System.out.println("Calling vehicle class constructor"); }
     }

 public class MainClass{
     public static void main(String args[]){
         Car myCar = new Car(10);
     }
 }

Output:
You called a constructor with 1 parameter of Parent class. 
Calling vehicle class constructor

final keyword in Java

The final keyword can be used with a variable, method, or class.

final keyword with variable

Whenever you want to keep the value of the variable constant throughout the execution of the program then in that case you can use the final keyword. For example, every car will always be having 4 wheels. No matter what happens this value will never change. So what we can do is we can make the wheels variable as final in our program and give it a value of 4. Now, this value will remain the same you cannot change it later.

final keyword examplefinal int wheels = 4;

final keyword with a class

Now let’s see why we even need to make our class as final. Let’s say, we have 3 classes, first is the Main class, second is the Car class (child class) and third is the Vehicle class (It is a parent class. The vehicles can represent cars, bikes, trucks, etc).

final keyword example

import java.io.*;

class Vehicle{
    void accelerate(){
        System.out.println("move...");
    }
}

class Car extends Vehicle{

}

public class MainClass{
    public static void main(String args[]){
        Car myCar = new Car();
        myCar.accelerate();
    }
}

Output:
move...

In the above code, notice that after creating an object of the Car class even though the accelerate() method is not present inside the Car class still, we are able to access it with the help of inheritance. Now to avoid using any methods or variables of a class by another class (i.e to disable inheritance) we can make that class has final. In this case, we will make the Vehicle class final using the final keyword.

// final keyword example

final class Vehicle{
    void accelerate(){
        System.out.println("move...");
    }
}

Now no other class will be able to access the methods of this class.

final keyword with a method

We will take the same example which we have used for understanding the final keyword with class, but this time we will have another accelerate() method inside our Car class as well.

// final keyword example

import java.io.*;

class Vehicle{
    void accelerate(){
        System.out.println("move...");
    }
}

class Car extends Vehicle{
    void accelerate(){
        System.out.println("move my car...");
    }
}

public class MainClass{
    public static void main(String args[]){
        Car myCar = new Car();
        myCar.accelerate();
    }
}

Output:
move my car...

In this case, we are overriding the accelerate() method inside our Car class. The overriding a method simply means that the method is already present inside a parent class (in this case Vehicle class) and then you are also creating a method with the same name and signature inside the child class (in this case Car class). In this way, you can override the contents inside the accelerate() method of the parent class with the accelerate() method of the child class. To avoid this we can make the method present inside the Vehicle class (parent class) as final so that no other class can override its methods.

// final keyword example

class Vehicle{
    final void accelerate(){
        System.out.println("move...");
    }
}

That’s all for this blog post. In the upcoming blogs of the object oriented programming series in Java, we will see the 4 pillars of object oriented programming paradigms i.e Polymorphism, Inheritance, Encapsulation, and Abstraction of the object oriented programming concepts in java.

Thanks for the read. If you like the content then support us on Patreon. Your support will surely help us in writing more of such content.

Let’s take a look at these basic recommendations. Some of the principles below are Python-specific, but most are not.

Measure twice and cut once

I think that’s the most important principle of all. If you learn only one principle from this post, it should be this one. We, developers /architects/ managers people struggle with lack of attention, stupid mistakes and misprints, personal problems, bad moods, and cold coffee. None of this is relevant — the problem has to be solved. For me as an engineer, this principle means choosing the right solution to the problem, choosing the right approach to the problem, choosing the right tools to solve the problem, confidence in the built solution.

Choosing here means putting some thought into it, find the necessary resources, put together the right team, thinking about design, thinking about the approach, set tasks, control the result, and bear responsibility for this. This is “Engineering as is”. I think that I myself am not ready to describe it with correct words.

Don’t Repeat Yourself (DRY)

It’s a rather simple but very useful principle which says that repeating the same thing in different places is a bad idea. First of all, it is related to the necessity of further support and modification of the code. If some code fragment is duplicated in several places inside a program, there is a high probability of two catastrophic situations:

• When making even small changes to the source code, you need to change the same code in several places. It will require additional time, effort, and attention(often it is not easy).

• The first item follows the second one. You or another developer from your team may accidentally miss one of the changes(it can happen simply by merging branches in vcs) and face the subsequent bugs in the application. These bugs can be frustrating to you because you have heard that such a bug has already been fixed.

In this regard, there is a recommendation — if any code is found in the listing more than twice, it should be placed in a separate way. This is a general recommendation. In fact, you should think about creating a separate method even if you encounter a repetition a second time.

Occam’s Razor

It’s a very common idea, which came to programming from philosophy. The principle got its name from the English monk William of Oakham. This principle says: “Entities are not to be multiplied without necessity”. In engineering, this principle is interpreted as follows: there is no need to create unnecessary entities without necessity.

Thus, it is always a good idea to think first about the benefits of adding another method/class/tool/process, etc. After all, if you add another method/class/tool/process etc. and you don’t get any advantages other than increased complexity, what is the point?

Keep It Simple Stupid (KISS)

This is a very similar principle to the above, but it has a slightly different meaning. This principle says that the code must be as simple as possible without complex structures, otherwise, it will complicate debugging and maintenance of the code.

You Aren’t Gonna Need It (YAGNI)

A problem that many programmers suffer from. The desire to implement at once all the necessary (and sometimes even unnecessary) functionality from the very beginning of the project. That is, when a developer adds all the possible methods to the class from the very beginning and implements them, and may even never use them in the future. Thus, according to this recommendation, first of all, implement only what you need, and later, if necessary, extend the functionality. This way, you will save effort, time, and nerves on debugging the code which is not really needed.

Big Design Up Front

Before starting to develop functionality, you should first think about application architecture and design the entire system to sufficiently small details, and only then proceed to implementation according to a predefined plan. The Principle has a right to exist, but lately, there has been quite a lot of criticism of it. It is first of all connected with the obsolescence of the plan during designing and working out. In this connection, it is necessary to make the subsequent changes still. But it also has undeniable advantages, at correct designing, it is possible to reduce considerably cost of further debugging and correction of errors. Besides, such information systems, as a rule, are more laconic and architecturally correct.

Avoid Premature Optimization

"Premature optimization is the root of all evil (or at least most of it) in programming"

- Donald Knuth

Optimization is a very correct and necessary process to speed up the program as well as to reduce system resource consumption. But everything has its own time. If optimization is carried out at the early stages of development, it can do more harm than good. First of all, it is connected with the fact that the development of an optimized code requires more time and effort for development and support. In this case, you quite often have to check the correctness of the chosen development approach at first. That’s why at first it is more profitable to use a simple but not the most optimal approach.

And later on, when estimating how much this approach slows down the work of an application, move on to a faster or less resource-intensive algorithm. In addition, for as long as you initially implement the most optimal algorithm, the requirements may change and the code will go to the garbage. So there is no need to waste time on premature optimization.

Principle Of Least Astonishment

This principle means that your code should be intuitive and obvious, and not surprise another developer when reviewing the code. For example, if the method is called “making cookies” but you get potatoes as a result, that code is bad (obviously). Besides, you should try to avoid side effects and document them if you cannot avoid them.

S.O.L.I.D.

“SOLID” is actually a group of object-oriented design principles. Each letter in “SOLID” represents one of the principles, which are:

• Single responsibility states that every module or class should have responsibility for a single part of the functionality provided by the software and that responsibility should be entirely encapsulated by the class;

• Open-closed states that software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification;

• Liskov substitution states that the inherited class should complement, not replace, the behavior of the base class;

• Interface segregation states that no client should be forced to depend on methods it does not use;

• Dependency inversion says that programmers should work at the interface level and not at the implementation level.

Law of Demeter

The basic idea of this principle is to divide the areas of responsibility between classes and encapsulate the logic within a class, method, or structure. Several recommendations can be distinguished from this principle:

• The classes or entities should be independent

• You should try to reduce the number of connections between different classes (so-called coupling).

• The associated classes must be in one module/package/directory (also known as cohesion.

Following those principles, the application becomes more flexible, understandable and easy to maintain.

Conclusion

Fellow developers let’s be engineers! Let’s think about design and build robust and well-implemented systems, rather than growing organic monsters. Listed principles are highly correlated and connected in their essence. Of course, I didn’t create them, but a small reminder does not hurt, at least my memory is definitely not perfect.

This Article is written by Kirill B and originally published at luminousmen.com. We thank Kirill for allowing us to publish this article on LionGuestStudios.com.

That’s all it is. Thanks for the read. If you like the best software engineering principles which we discussed then support us on Patreon. Your support will surely help us in writing more of such content.

Before understanding the stacks data structure, you should have a good understanding of arrays and linked lists because only with the help of these two data structures can we implement stacks.

In general, for implementing any data structure, whether it is stacks, queues, trees, etc., we have to use either arrays or a linked list.

If you can predict the size of the data structure (how much memory it will need) then you can use an array, otherwise, you can dynamically allocate the memory using linked lists.

Concept of Stacks Data structure

Consider a stack as a series of plates kept one above the other, vertically, from bottom to top.

Let’s say there are five plates, P1, P2, P3, P4, and P5, and you want to organize them in the form of a stack (i.e. putting them one above the other), then how would you do it?

Obviously, you will take the first plate, P1, and on top of it, you will put the plate P2, and then the next plate, and so on, until you put the last plate on, i.e. P5.

This whole thing forms a stack of plates which is illustrated by the following diagram.

And, whenever you want to access or take out a particular plate, you have to first see if the plate you want to access is at the top or not.

A stacks data structure is also known as last-in-first-out (LIFO) meaning the element which is inserted last into the stack will be removed first from the stack.

Operations on the Stack

• Push: To insert an element on to the stack.

• Pop: To delete an element from the stack.

Implementation of a Stack

There are two ways in which we can implement the stacks data structure.

1. Using an array

In this representation, we will be implementing the stack using an array whose index starts with 0.

Before inserting or deleting an element, there are two conditions that we have to check, the first is the overflow condition and the second is the underflow condition.

The overflow condition simply checks whether the stack is full or not. If it is already full, then you can’t insert a new element on to the stack.

The underflow condition checks whether the stack is empty or not because if the stack is already empty and if we are trying to delete an element that does not even exist as the stack is already empty, we will definitely get an error.

These are some corner case conditions that we have to check to make sure that our program works perfectly in any situation without any errors.

// Checking the Overflow condition & pushing the element onto the stack 
void push (int item) {

    // MAX – 1 represents the top of the stack
    // Checks if stack full or not    
    if (top == MAX - 1) {
        printf(“Overflow! The Stack is already full.”);
    }
    else {
        top = top + 1;
        Stack[top] = item;
    }
}


// Checking the Underflow condition & deleting the elements from the stack
int pop () {
    int temp;

    // Checks if stack is empty or not
    if (top == -1) {
        printf(“Underflow! The stack is already empty.”);
        return -1;
    }
else {
    temp = stack[top]; // Storing current value of stack in temp
    top = top – 1; // Decrementing the pointer
    }  
return temp;
}

In the stack, when we pop an element, we are not actually deleting the element from the stack as we do in a linked list. Here, we are only decrementing the top pointer and the value inside that particular stack block will still be there.

The time complexity for both insertion and deletion of an element in an array takes O(1), i.e. constant time.

2. Using the linked list

In this representation, we will be implementing the stack data structure using a linked list.

As we know, the linked list consists of various nodes and each node has two things. One is the data and the other is the pointer that points to the next node.

But, before inserting an element, we first have to create a new node and then add that node to a linked list. Here, also, we have to check the overflow and underflow conditions.

// Struct of a single node in a linked list 
struct node { 
  int i; 
  struct node *link; 
}; 

// Inserting an element 
void push (int item) {

  //Creating a single node 
  struct node *p = (struct node *) malloc(sizeOf(struct node)); 

  // Checking for Overflow condition 
  if (p == NULL) { 
    printf("Error of malloc."); 
    return; 
  }

  p -> data = item; 
  p -> link = head; 
  head = p; 
} 

// Deleting an element 
void pop () { 
  int item; 
  struct node *p; 

  // Checking the Underflow condition 
  if (head == NULL) { 
    printf("Underflow"); 
    return -1; 
  }

  item = head -> i; 
  p = head; 
  head = head -> next; 
  free(p); 
}

The time complexity for both insertion and deletion of an element in a linked list also takes O(1), i.e. constant time.

A linked list data structure consists of various nodes, and each node contains two things: One is the data, and the other is the pointer, which will point to the next node. A linked list basically can have n nodes, and each node is connected to its next node with the help of a pointer. There are two types of linked lists: Singly linked lists (SLL) and Doubly linked lists (DLL).

In a Single linked list, we have a single pointer that’ll point to the next node and, therefore, it is called a singly linked list. In a DLL, we have two pointers: One pointer will point to the next node, and another will point to the previous node. That’s why we call it a doubly linked list.

In C programming, we use structures to create a linked list. The structure is a data type inside which we can define variables with different data types (e.g., int, char, pointer, etc.).

For creating a linked list, we’ll define the structure of our linked list (using the struct data type), which will represent what a single node in a linked list will look like. And then we’ll actually create a linked list by assigning memory to use using the malloc() function.

Structure of a linked list Data Structure:

struct node
{
    int data;
    struct node *p;
};

The above code represents the structure for our linked list data structure which contains two things. First is a variable, data, which will hold the integer value inside it. And the second is struct node *p, which is a pointer that’ll point to the next node in a linked list. Here, struct represents the structure data type, and node is the name of that structure. You can give whatever name you want to the structure.

Now, you may be having a question: Why does the pointer have the same data type as the structure? The reason behind this is the nodes in a linked list are self-referential, which simply means the pointer in a node will point to another node of the same type (in this case, the struct node).

Note that after writing the above code, the linked list data structure won’t be created — nor will any memory be assigned to it. It’s just a template that’ll define the structure of our linked list (how our linked list will look like).

Now, let’s write a code to create a linked list by assigning it some memory using the malloc() function.

struct node *new = (struct node *) malloc(sizeof(struct node));

The above line of code will create a node in memory followed by a pointer called new, which will be pointing to the newly created node.

Previously, while creating a template for our node, we have given its name as a struct node. Thus, to allocate the memory, first we have to find out the size of that data type and then pass it to the malloc function to allocate memory for it.

This is how it’ll look like.

Operations Performed on an SLL

1. Insert an element in the linked list.

• Before inserting a node (element) into a linked list, you first have to create a node by using malloc.

• Also, before inserting a node (element), you first have to check whether the head is pointing to the NULLor not — otherwise, it will give a segmentation fault.

if (head == NULL) {
    return;
}

• Consider the following example:

• Now, there are three ways in which we can insert this node in the above linked list data structure.

a. Insert node at the beginning

For inserting a node that we’ve created that’s being pointed by a pointer called new at the beginning of the linked list, we have to write the following code.

new ->link = head; 
head = new;

What this will do is: It’ll first store the starting address of the node that’s being pointed by the pointer head into the node that’s being pointed by pointer new.And then it’ll assign the address of the new pointer to the head pointer.

If you directly assign the address of new pointer to the head pointer to insert the node at the beginning before storing the address of the head pointer to the new pointer, then the entire linked list will be lost because, in this case, there’s no pointer that’ll be pointing to that memory location where the starting node of our linked list is present.

This might be somewhat confusing at first to understand, so I suggest you read it a number of times and try to understand it visually.

b. Insert node in the middle

Now to insert the node in the middle, we first have to think about where we’ll be inserting the new node.

Let say we want to insert the newly created node after the second node in the above linked list. For that, we have to reach the second node and then store whatever the second node is pointing too into the new->link. And then, we’ll insert the node at the location.

//created a new pointer 't'
struct node *t = head;

//Loop through till we reach the node which has value 2 in it.
while(t->data != 2) {
    t = t->next;
}

//After finding 2 in data store whatever t is pointing too to new->link
new->link = t->link;

//Then insert node pointed by new at the position
t->link = new;

c. Insert node at the end

For inserting a node at the end, we first have to find the end of the linked list data structure. The ending node or the last node in a linked list will always have a NULL(also represented as \0) in this next part. From the above linked list, we can say the node that has a value of 5 is the last node because its next is NULL.

To reach the end, we first have to check whether t->next is null of not. If null, then we can insert the node at the position. Otherwise, keep moving forward until we reach t-> next is null.

while(t->next != NULL) {
    t = t->next;
}

// Insert newly created node at the end
t->next = new;

// Then change its next part to '\0' which represents the end of the list.
new->next = "\0";

2. Traversing a linked list data structure

• Traversing means visiting every node in a linked list.

• For traversing, instead of using the actual pointer, which is currently pointing to the linked list, we have to create another pointer (say, t). By using that, we can traverse the list. Because if we move the current pointer, then there’s a chance we may lose some of the nodes in a linked list.

• Let’s understand this with an example. Say we have a linked list, as shown below. So let’s traverse it.

Example of a linked list

Code for traversing the above linked list:

struct node {
    int data;
    struct node *next;
};

void main() {
    struct node *t;
    t = head;

    //while 't' is pointing to something run this loop
    while (t) {
        printf("%d"\n, t->data);
        t = t->next; //point to the next node.
    }    
}

Output:

1
2
3
4

Here, first, we have a template for our node which defines what we have in our linked list data structure. Secondly, we have the main function inside, for which we’ve created a new pointer t of type struct node (a pointer that we’ll use to traverse the list) and a while loop which will print the data inside the list and then increment the pointer.

In this, we are now touching the head pointer. If we do this, then we may lose some of the nodes inside our linked list as we have no pointer at the starting position of the list.

After creating another pointer — say, t —you have a choice. You can either move t or head. it doesn’t matter which because now you have two pointers at the starting position of the linked list.

3. Delete an element from the linked list

• Before deleting a node (element), you first have to check whether the head is pointing to the NULL or not. Otherwise, it’ll give a segmentation fault.

• Whenever you’re deleting an element from the linked list that you’ve created using the malloc() function, you also have to free it up by using a free() function. It’s not compulsory to free the space after deleting an element, but it’s a good practice to do so.

• Also, create a temporary pointer — say, t — to hold the node that you want to delete, and then do the other operations. Otherwise, the node that you want to delete will get lost.

Conditions to check:

if (head == NULL){
    return;
} 

if (head-> next == NULL){
    free(head);
    head =NULL;
    return;
}

There are three ways to delete a node in the same way as insertion in a linked list data structure.

a. Delete the node at the beginning

To delete the node at the beginning, create a new pointer t, and make it point to the head. Now, we have to move the position of the head pointer one step ahead using head = head->next. Then free up the t to delete the first element in a linked list.

struct node *t = head;
head = head->next;
free(t);

b. Delete the node in the middle

Here, we have to identify which node we want to delete. After that, create a new pointer, and make it point to the position where the head pointer is pointing.

Let say we want to delete a node whose data part has the value 3. Then, check if t->next->data is 3or not. If the data part, has a value of 3, then create another pointer — say, p —to hold the next part of the node whose value is 3. After that, free the location that’s currently pointed by the t pointer, and then assign the address of pointer p to t->next.

struct node *t = head;

// loop through till we get the value of the data part as 3 
while (t->next->data != 3) {
    t = t->next;
}

//create another pointer which will hold the next part of the list
struct node *p = t->next->next;
free(t->next);
t->next = p;

c. Delete the node at the end

When we’re deleting a node at the end, then we have to stand two steps back and check whether the second element is null or not.

while ( t->next->next != NULL) {
    t = t->next;
}

free(t->next);
t->next = NULL;

The figure below explains the above code:

Searching for an element in a linked list takes a long time O(n) because in the worst case, we have to traverse ‘n’ elements. And in the best case, we can find the element in the first attempt, so time complexity will be O(1).

When searching for an element in an array, it takes O(1) times (considering the array is sorted); otherwise, it’ll take O(n) times only.

Thanks for reading and if you like the content then support us on Patreon. Your support will surely help us in writing more of such content.

Google is currently working on a new operating system, code name Fuchsia OS. The project was started in 2016 and its source code was made available on the Fuchsia official website in 2019 as well as the documentation. The Fuchsia project is built on top of the Zircon kernel.

The Google Nest Hub is the first product that runs on Fuchsia OS. The source code of Fuchsia is available to download for the public (more specifically for the developer’s community).

In this article, we will talk about the Fuchsia operating system, why Google is developing it?, will it replace Android? and the step-by-step process of downloading and building google’s new fuchsia operating system using the source code. The reason behind writing this article is to help developers set up the development environment for Fuchsia correctly so that they can play with the operating system as well as if the project feels interesting to them then they can make some meaningful contributions towards the growth of the project.

There is no doubt that the Fuchsia documentation itself is easy to get through. But there are some things in the documentation which might be confusing or difficult to understand for beginners developers and that’s where this article will come into the picture. You can perform the steps mentioned below either on a 64-bit Linux machine (any distribution will work) or on a 64-bit MAC. Windows and ARM64 Linux are not supported. I have used a Linux machine (Ubuntu) for downloading, building, and flashing the Fuchsia OS.

Previously, I have written an article about the Android open source project (AOSP) Android 11, If you are interested in that do check it out.

Will Fuchsia OS replace android oS?

The Android OS is a popular and widely used OS that runs on billions of devices. But the problem with Android is that lots of manufacturers do not provide the latest updates to their previously manufactured devices (< a year old). This creates a huge security issue. Also, the Linux kernel (even though it’s optimized for low-powered devices), causes some performance issues.

Since the Android OS itself is improving in terms of features, bug fixes, and security patches but these things are not reaching the end-users. And very few devices are able to take advantage of these things. To resolve all such issues, Google is trying to build another operating system that can provide both security as well as performance. But this time they are not just targeting phones or tablets they are also focusing on all the other types of devices like Desktops, Laptops, and MAC’s as well.

Ultimately, Google is a business-driven company, profits are always on the higher priority. If a product can’t generate the profits as expected then they literally scrap those products. And this is not just about Google, almost every product-based company does this. This doesn’t mean that the Android OS is going away anytime soon. The Fuchsia project is still at the early stages of its journey and only time will tell whether it will replace Android or not.

Layers of Fuchsia OS

The Fuchsia OS consists of 4 layers. At the bottom, we have the kernel itself but this time Google has developed its own kernel in-house which is known as the Zircon kernel. The Zircon kernel is made open source (/zircon/kernel).

On top of the zircon layer, we have the Garnet layer which contains the device drivers (networking, graphics, etc) and the software installer. This layer also contains Escher (graphics renderer), Amber (software updater), and Xi code (Text and code editor).

The Peridot is the third layer that handles Fuchsia’s modular application design. It also has a Ledger that is used to sync files across devices. This layer also provides artificial intelligence support called Maxwell which dynamically optimizes the performance of your device based on how you use your phone by enabling or disabling some of its features. At the top, we have the Topaz layer which supports the UI which is designed with Flutter. Armadillo is the name of the Flutter main UI.

To build the Fuchsia OS you will need to download 3 packages, curl, unzip, and git. You can easily download and install these packages by running the following command inside the terminal.

sudo apt-get install curl git unzip

Before starting out, first, we have to check whether the system on which we will be building the Fuchsia source code will be able to successfully build the Fuchsia source code or not. For that, Fuchsia provides us with a tool called ffx platform preflight. The below command will download and run the tool.

curl -sO https://storage.googleapis.com/fuchsia-ffx/ffx-linux-x64 && chmod +x ffx-linux-x64 && ./ffx-linux-x64 platform preflight

In my case, everything is in green except the 2nd and the 3rd warning. If you get the third warning you can run the two commands which are shown below the warning and it will fix that warning. After that, you can again run the above command to check the status. You can ignore the second warning, here it’s unable to detect the Nvidia graphics card but it is able to detect Intel’s integrated graphics which is fine.

Download the Fuchsia OS source code

Since the Fuchsia OS is not that large in size, therefore the process of downloading the Fuchsia source code will hardly take around 40 – 60 min. It’s not like Android source code which is large in size that takes almost half of the day for the download process to complete.

To download the Fuchsia source code, you can create a new directory anywhere on your system and then go inside that directory as shown below.

mkdir fuchsia_source && cd fuchsia_source

And then run the below command which will create a directory called fuchsia and inside this directory, it will download the entire source code of the Fuchsia OS. Make sure you have around 60GB of free space.

curl -s "https://fuchsia.googlesource.com/fuchsia/+/HEAD/scripts/bootstrap?format=TEXT" | base64 --decode | bash

The download process is now complete. Now you have to add the bin directory to the PATH. For that, go inside your bash file (gedit ~/.bashrc) and paste the below two lines at the bottom of the bash file.

export PATH="~/fuchsia_source/fuchsia/.jiri_root/bin:$PATH"
source ~/fuchsia_source/fuchsia/scripts/fx-env.sh

After that, update the environment variables using source.

source ~/.bashrc

To check if everything is set up correctly, go inside the fuchsia directory using cd and run the below commands. If you get no errors which mean everything has been set up correctly.

// Run below commands inside fuchsia directory
jiri help
fx help

Configure and Build the Fuchsia OS source code

For building the source code, we first have to select the product (core or workstation) and the board (x64 or qemu-x64). The core is a product that has minimum features were as the workstation product will have all the features. You can select any one of them, for this tutorial we will use the workstation product with the qemu-x64 board. To set the workstation and the qemu-64 as a target run the following command.

fx set workstation.qemu-x64

After selecting the target device, we can start building the Fuchsia source code as follows.

The building process will take around 1-2hrs to complete.

Flashing Fuchsia OS on the Fuchsia Emulator (FEMU)

We have now reached the final stage where we will be flashing and running the Fuchsia OS on the emulator. The emulator which we will be using is known as Fuchsia Emulator (FEMU). This emulator is available inside the source code itself.

If you don’t want to connect the fuchsia emulator with the external network then you can simply run the following command. Make sure that you are inside the fuchsia directory while running the below command.

fx vdl start -N

If you want to provide internet access to the fuchsia emulator then you can run the below command.

fx vdl start -N -u scripts/start-unsecure-internet.sh

After the operating system boots up, this is how it will look like.

You can play with the terminal by running the Fuchsia command and access any website using the built-in web browser.

To learn more about the Fuchsia commands and how it works you can visit Explore Fuchsia on fuchsia.dev website.

This was the entire process of downloading, building, and flashing Fuchsia OS on the emulator. Thanks for the read. If you like the content then support us on Patreon. Your support will surely help us in writing more of such content.

Android Open Source Project (AOSP) is a project maintained by Google from where we can get the source code for the Android operating system. Since it is an open-source project anyone can download the android source code, compile it onto their machine, and can easily make some modifications to the source code. Currently, the latest version of Android is Android R (also known as Android 11 or Red Velvet Cake). You can get the source code for any version of android from the AOSP like Android R, Q, P, etc.

Video 1: Download and Build AOSP Android 11 custom ROM from AOSP on Linux from scratch

In this blog post, we will see how we can download the source code for Android 11, how to build or compile it and run it on the emulator or on the physical device using the Android Open Source Project.

There might be few reasons why you may need to download the android 11 source:

• To Flash custom ROM on to your phone: If your phone’s manufacturer is not providing the latest android released for your phone and you are eager to use and test the latest feature provided by the android platform then in that case you may need to download the android source code.

• Contributing to Android Open Source Project (AOSP): If you are a developer and looking to contribute code to the AOSP, then in that case you get the android source code.

• Creating your own version of android: In case, if you want to make your own version of Android like Cyanogenmod or something like that then also you can get the source code.

System Requirements:

To download and build the AOSP project you should have a 64-bit version of either Linux (18.04 or greater) or Mac OS installed. Here, RAM plays a very crucial role when it comes to building / compiling the android source code.

According to the official docs, it is recommended that you should have at least 16GB of RAM. If you want to build an older version of android then 8GB may work for you. I tried android 10 (android-10.0.0_r20) with 8GB of RAM but I faced “java heap out of memory error” but it got fixed when I increased the Java heap size.

But when I was building for Android 11 (android-11.0.0_r17) with 8GB of RAM at that time also I faced the same memory-related error. So, I tried many different things but the issue still exists. Then I increased the RAM to 16GB and the build was successful.

• OS: A 64-bit Linux or Mac, Windows is not supported.

• Ram: 16 GB preferred

• Free Disk Space: 250 – 300GB free space

The Open JDK comes prebuilt with AOSP, so no need to install it separately.

Installing Required packages:

Just copy the below command and paste it into your terminal. This will install all these packages which are required for working with android source code.

sudo apt-get install git-core gnupg flex bison build-essential zip curl zlib1g-dev gcc-multilib g++-multilib libc6-dev-i386 lib32ncurses5-dev x11proto-core-dev libx11-dev lib32z1-dev libgl1-mesa-dev libxml2-utils xsltproc unzip fontconfig
sudo apt update 
sudo apt upgrade

Downloading the Android 11 Source Code

The process of downloading the Android Open Source Project (AOSP) source code takes quite a while to complete, so make sure that you have a good internet connection so that you can finish it in less time. On average it should take you around 7–10 hrs to download the android source code.

Let’s first create a directory with the name aosp11 inside which you can download the android 11 source code.

//Created a new directory and cd into it 
mkdir aosp11 && cd aosp11

You are now inside the aosp11 directory. Now you have to configure the name and email address associate with your account by running the following commands. Here, replace words inside the quotation with your real git accounts details.

git config --global user.name "Your Name" 
git config --global user.email "you@example.com"

Let’s now download the repo tool. From your home directory run the following commands one by one.

cd .. //Currently, you are in aosp11 dir, this will take you back to home dir 
mkdir ~/bin 
PATH=~/bin:$PATH 
curl https://storage.googleapis.com/git-repo-downloads/repo > ~/bin/repo 
chmod a+x ~/bin/repo

To get the Android 11 source code we first have to initialize the repo tool inside our current working directory. This will create a .repo subdirectory inside our current working directory.

Here, you can even specify the branch which you want to download using the -b tag (this is optional). If you don’t specify the branch then it will by default take the master branch.

But in this case, we want to get the Android 11 source code so we will specify the android 11 branch using the -b tag and initialize the repo.

Now to get the tag for android 11, we have to visit the source code tags and builds page available on android official docs. This is where you choose which android version to download. In this case, we will download android 11, you can choose whatever version of android you want to by choosing the appropriate tag from the above page.

repo init -u https://android.googlesource.com/platform/manifest -b android-11.0.0_r17

The android-11.0.0_r17 is the latest version of Android 11 available for download. In the future, if some other versions of android are released (android S or android 12, etc) then this is the command where you have to make changes by selecting the appropriate tag and then initialize the repo with the above command.

During repo init, if you face any python related issues like /usr/bin/env: ‘python’: No such file or directory then to fix it run the following command.

sudo ln -s /usr/bin/python3 /usr/bin/python

After some time, you should see a message “Enable color display in this user account?” Select y and press enter.

You should see another message “repo has been initialized in /home/user/aosp11” which confirms that you have initialized the repo.Now is the time to download the AOSP Android 11 source code locally to your working directory. To download run the following command. Make sure you are inside the asop11 directory and then run this command.

repo sync

For me, it took 7hrs to download the Android 11 source code. For you, it might take even more, so sit back and relax till it completes. In the end, you should see the message which is shown in the image below.

Compiling or Building the Android 11 Source Code

This is the crucial part when it comes to building the android source code as you might face some error during this process. But no worries, I will also provide solutions to these common errors.

First, you have to initialize the environment.

source build/envsetup.sh

Then you have to choose a target device (using lunch command) on which you will be installing the operating system like mobile, watch etc. In this case we will be building android 11 for a 64-bit android mobile device.

lunch

Now, we will select the second option aosp_arm64-eng from the list which is a 64bit version of android 11 for a mobile device. You can even choose option1 for 32-bit devices. After selecting the 2nd option it will show you the exact details related to that build.

To start the compilation or building process run the below command.

m -j4

The ‘m’ stands for “make” which will compile the source code into an appropriate machine code. The ‘j4’ represents no. of CPU cores (here, 4 means 4 cores) which you want to allocated for building. You can even increase it to a higher number depending upon how many cores your computer has. To check for no. of the core run nproc in the terminal.

During this process, your system might get hanged or become unresponsive which is completely normal so don’t panic, leave it as it is. Depending upon your system configuration this process will take you around 10-15hrs to build the android open source project code.

Common errors during AOSP building process and their solution

• libncurses.so.5: cannot open shared object file: No such file or directory:

Solution: Run this command sudo apt-get install libncurses5 and then try to recompile the source code.

• Exception in thread “main” java.lang.OutOfMemoryError: Java heap space:

Solution: Run this command export JAVAOPTIONS=-Xmx8g this will increase your heap size to 8GB. and recompile the source code. If you still face the error then run the make clean command and then again try recompiling the source code. This should solve your problem.

Finally, if you get the below message then congratulations you have made it. You now have successfully build the android 11 custom rom and now is the time to flash it onto your phone or emulator.

Flashing AOSP android 11 custom rom on emulator

Video 2: Flashing AOSP android 11 custom rom on emulator

In order to start the emulator make sure that the virtualization option is enabled on bios. The emulator is already been added to your path while building the aosp project. So, just the below command and it will flash the android 11 custom rom on the emulator.

emulator

Flashing AOSP android 11 custom rom on a physical device

In order to perform this process you first have to unlock your phone’s bootloader by going inside “Developers Options” inside settings. Note that this will void your phone’s warranty, do it on your own risk. If you are unable to see the “Developers Options” then click on “Build Number” inside settings under About phone for 5 times to enable this option. After that install the below two packages.

Now connect your phone to your computer and run the below commands.

Note that this will wipe out your data completely and flash the android 11 ROM on your device. There is no guarantee that this will successfully flash your device. And if it fails while flashing then your device will be of no use anymore. Make sure that you don’t your primary phone for flashing.

adb reboot bootloader
fastboot flashall -w

That’s all it is. Thanks for the read. If you like the content then support us on Patreon. Your support will surely help us in writing more of such content.