Combating Corruption with AI

Corruption has long been a significant hurdle in Indonesia’s path to progress. It siphons resources away from essential public services, undermines trust in government institutions, and stifles economic growth. To address this, I would implement advanced AI systems to analyze and detect any indications of corruption and gratification. By leveraging machine learning and big data, these AI systems could monitor financial transactions, contracts, and government projects in real time.

Whenever a suspicious activity is detected, a notification would be sent to a specialized task force, ensuring immediate action. This technology-driven approach would help secure the nation’s resources from being exploited by corrupt individuals. Furthermore, those found guilty of corruption would face severe consequences, extending to their extended family and anyone who benefited from the illicit activities. This would serve as a powerful deterrent, ensuring that the nation’s wealth is preserved and used for the common good.

Revolutionizing Education for a Brighter Future

Education is the cornerstone of any nation’s progress, and in Indonesia, it holds the key to unlocking the potential of our youth. With the money saved from eradicating corruption, I would invest heavily in building schools and educational facilities across the country, particularly in underserved areas. This would ensure that every Indonesian, regardless of their socioeconomic background, has access to quality education.

Subsidized fees would be provided for the poor and marginalized communities, allowing them to pursue their educational aspirations without financial barriers. Additionally, I would establish specialized schools for gifted Indonesian students who have the potential to think outside the box and develop innovative solutions to our nation’s challenges. By nurturing these young minds, we can cultivate a generation of leaders, thinkers, and innovators who will drive Indonesia’s future success.

Transforming Waste Management with Technology

Indonesia’s waste management system has long needed an overhaul. Improper disposal methods, such as burning waste, contribute to pollution and health issues across the country. To address this, I would implement an end-to-end technological solution that covers every aspect of waste management, from collection and sorting to recycling and disposal.

Advanced sensors and AI could be employed to optimize waste collection routes, ensuring that no waste is left uncollected. Recycling plants would be upgraded with state-of-the-art technology to maximize efficiency and minimize environmental impact. Furthermore, I would enforce strict penalties for those who burn waste or engage in other harmful disposal practices. By embracing technology in this way, we can create a cleaner, healthier environment for all Indonesians.

A Smoke-Free Future

In addition to these initiatives, I would take bold steps to address another public health concern: smoking. Smoking in public places not only harms the smoker but also exposes others to secondhand smoke, posing significant health risks. I would implement severe punishments for those who smoke in public spaces, and eventually, I would work towards banning cigarettes altogether. This may seem extreme, but the long-term benefits for public health would be immeasurable.

Conclusion

Indonesia stands at a crossroads, with the potential to become a global leader in innovation and progress. We can build a stronger, more prosperous nation by leveraging technology to combat corruption, revolutionize education, and transform waste management. With bold ideas, unwavering commitment, and the power of technology, Indonesia’s future is bright, and the possibilities are endless.

Understanding and solving graph problems involves several key steps: understanding graph theory basics, learning about different types of graphs and common graph algorithms, and applying problem-solving strategies.

Before we jump in further, let’s learn the key concepts around graphs.

Key Concepts

• Nodes (Vertices): These represent the entities or objects in the graph. For example, in a social network, nodes could represent people.
• Edges: These are the connections between nodes. They can be directed (showing a one-way relationship) or undirected (showing a bidirectional relationship). For instance, in a transportation network, edges might represent roads or flights between cities.
• Weights: In weighted graphs, edges have values (weights) that represent the cost, distance, or time associated with the connection. For example, in a graph representing a road network, weights could represent distances between cities.
• Paths and Cycles: A path is a sequence of edges that connect a series of nodes, while a cycle is a path that starts and ends at the same node without retracing any edge.

Graph Representations

Adjacency Matrix: A 2D array where cell (i, j) indicates if there's a direct connection between node i and node j. Useful for dense graphs.

adj_matrix = [
    [0, 1, 1],
    [1, 0, 0],
    [1, 0, 0]
]

Here’s how to interpret and visualize it:

• The matrix is a 3 x 3 matrix representing a graph with 3 nodes.
• The element at position (i, j) indicates whether there is an edge between node i and node j. In an undirected graph, the matrix is symmetric.

Interpreting the Matrix

1. Node 0: Connected to Node 1 and Node 2 (because both adj_matrix[0][1] and adj_matrix[0][2] are 1).
2. Node 1: Connected to Node 0 (because adj_matrix[1][0] is 1).
3. Node 2: Connected to Node 0 (because adj_matrix[2][0] is 1).

Visual Representation

The graph can be visualized as follows:

   0
  / \
 1   2

Explanation

• Node 0 has edges to both Node 1 and Node 2.
• Node 1 and Node 2 are only connected to Node 0, and they are not connected to each other.

Adjacency List: A list where each node has a list of connected nodes. This is space-efficient for sparse graphs.

adj_list = {
    0: [1, 2],  
    1: [5, 6],     
    2: [3, 4],
    3: [],
    4: [7],
    5: [],
    6: [],
    7: []       
}

Here’s how to interpret and visualize this graph:

• Node 0 connects to Nodes 1 and 2.
• Node 1 connects to Nodes 5 and 6.
• Node 2 connects to Nodes 3 and 4.
• Node 3 has no outgoing edges.
• Node 4 connects to Node 7.
• Nodes 5, 6, and 7 have no outgoing edges.

Visual Representation

The graph can be visualized as follows:

      0
     / \
    1   2
   /|   |\
  5 6   3 4
           \
            7

This directed graph shows:

• 0 → 1 and 0 → 2: Node 0 points to Nodes 1 and 2.
• 1 → 5 and 1 → 6: Node 1 points to Nodes 5 and 6.
• 2 → 3 and 2 → 4: Node 2 points to Nodes 3 and 4.
• 4 → 7: Node 4 points to Node 7.

Edge List: A collection of all edges in the graph, each represented as a pair of nodes. Simple but not as efficient for querying connections.

edge_list = [
    (0, 1),  # Edge from Node 0 to Node 1
    (0, 2),  # Edge from Node 0 to Node 2
    (1, 5),  # Edge from Node 1 to Node 5
    (1, 6),  # Edge from Node 1 to Node 6
    (2, 3),  # Edge from Node 2 to Node 3
    (2, 4),  # Edge from Node 2 to Node 4
    (4, 7)   # Edge from Node 4 to Node 7
]

Visual Representation

The graph can be visualized as follows:

      0
     / \
    1   2
   /|   |\
  5 6   3 4
           \
            7
            

Explanation

• (0, 1): Node 0 → Node 1
• (0, 2): Node 0 → Node 2
• (1, 5): Node 1 → Node 5
• (1, 6): Node 1 → Node 6
• (2, 3): Node 2 → Node 3
• (2, 4): Node 2 → Node 4
• (4, 7): Node 4 → Node 7

The edge list provides a straightforward representation of the directed edges in the graph, showing how each node connects to others.

Applications

Graphs are used in numerous applications, including:

• Social Networks: Modeling relationships and connections between users.
• Web Page Link Analysis: Understanding how pages are linked to each other.
• Routing Algorithms: Finding the shortest path in navigation systems.
• Recommendation Systems: Suggesting products or content based on user preferences and interactions.

Understanding graphs and their properties is crucial for solving many computational problems and for developing algorithms that efficiently manage and analyze complex networks.

Imagine living in a house where no one ever takes out the trash. The place would quickly become unlivable, right? The same concept applies to the world of programming. In the vast digital landscapes we create, garbage collection is the process that keeps our “homes” clean, ensuring our applications run smoothly and efficiently. But what exactly is garbage collection, and why is it so important?

What is Garbage Collection?

Garbage collection (GC) is an automatic memory management feature found in many programming languages, such as Java, Python, and C#. Its main job is to identify and dispose of objects that are no longer needed by a program, freeing up memory resources for future use. This helps prevent memory leaks and ensures that applications don’t consume more memory than necessary.

The Garbage Collection Process

To understand how garbage collection works, let’s break it down into simple steps:

1. Allocation: When a program needs memory, it requests it from the system. This memory is allocated to store objects created during the program’s execution.
2. Identification: The GC identifies which objects are no longer in use. These are objects that no longer have any references pointing to them, meaning they can’t be accessed by the program anymore.
3. Reclamation: The GC reclaims the memory occupied by these unused objects, making it available for new objects that the program might create.

Types of Garbage Collection Algorithms

Different programming languages use different garbage collection algorithms. Here are a few popular ones:

1. Mark-and-Sweep: This algorithm involves two phases. In the mark phase, the GC traverses the object graph, starting from the root references, and marks all reachable objects. In the sweep phase, it reclaims the memory occupied by unmarked objects.
2. Reference Counting: Each object has a count of the number of references pointing to it. When the reference count drops to zero, the object can be safely deleted. However, this method has a drawback: it can’t handle cyclic references.
3. Generational GC: This approach is based on the observation that most objects have a short lifespan. It divides objects into generations and collects younger objects more frequently than older ones. This improves efficiency by focusing efforts on areas where garbage is most likely to accumulate.

Why Garbage Collection Matters

Effective garbage collection is crucial for several reasons:

1. Performance: By automatically managing memory, GC helps prevent memory leaks, which can slow down or crash applications.
2. Developer Productivity: GC frees developers from manually managing memory, allowing them to focus on writing code that solves actual problems.
3. Security: Automatic memory management reduces the risk of security vulnerabilities caused by improper memory handling, such as buffer overflows.

Common Garbage Collection Challenges

Despite its benefits, garbage collection is not without challenges:

1. Pause Times: During garbage collection, the application might pause, which can be problematic for real-time systems requiring consistent performance.
2. Overhead: Garbage collection consumes CPU resources, which might impact the overall performance of the application.
3. Complexity: Understanding and tuning GC can be complex, especially for large-scale applications with demanding performance requirements.

Tips for Effective Garbage Collection

Here are a few tips to help you make the most of garbage collection in your applications:

1. Profile and Monitor: Use profiling tools to monitor memory usage and GC activity. This can help identify potential memory issues and optimize GC performance.
2. Optimize Code: Write efficient code that minimizes unnecessary object creation. Reuse objects when possible to reduce the burden on the GC.
3. Tune GC Settings: Many programming languages allow you to customize GC settings. Experiment with different configurations to find the optimal balance between performance and memory usage.

Conclusion

Garbage collection is an essential part of modern programming, keeping our digital environments clean and efficient. By understanding how it works and adopting best practices, we can ensure that our applications remain fast, reliable, and secure. So next time you run your code, take a moment to appreciate the unsung hero working behind the scenes: the garbage collector.

Happy coding!

First thing first, what does this error message, “FATAL ERROR: JavaScript heap out of memory”, mean?

The “FATAL ERROR: JavaScript heap out of memory” error occurs when a JavaScript application exceeds the memory limit allocated to its heap by the Node.js runtime. This heap is where JavaScript objects are stored and managed during program execution. You can read further explanation on JavaScript Memory Management here.

Ok, now we know what the error message means, let’s learn what are the things that can cause it:

1. Memory Leaks: Memory leaks occur when objects are continuously created without being properly disposed of, causing memory usage to gradually increase over time until it reaches the heap limit.
2. Large Data Processing: Applications that process large amounts of data or perform intensive computations may consume more memory than is available in the allocated heap.
3. Recursive Functions: Recursive functions that don’t have proper termination conditions can lead to stack overflow errors, which can ultimately result in memory exhaustion.
4. Inefficient Code: Inefficient algorithms or data structures can cause excessive memory usage, especially when dealing with large datasets.

Here’s an example code that will result in the heap out-of-memory issue:

Here’s how you can add a termination condition to stop the recursion after a certain depth. This way, it shouldn’t result in the heap OOM issue.

Now that you have encountered the issue, how should we handle it?

1. Increase Heap Size: One approach is to increase the maximum heap size available to the Node.js runtime using the --max-old-space-size flag. For example, node --max-old-space-size=4096 app.js set the maximum heap size to 4GB.
2. Memory Profiling: Use memory profiling tools like Chrome DevTools’ Memory tab or Node.js’s built-in --inspect flag with Chrome DevTools to identify memory-intensive areas in your code and optimize them.
3. Code Optimization: Review and optimize your code for memory efficiency. This includes optimizing data structures, reducing unnecessary object creation, and properly disposing of resources when they’re no longer needed.
4. Streaming and Chunking: When processing large datasets, consider using streaming or chunking techniques to process data in smaller, more manageable pieces rather than loading everything into memory at once.
5. Memory Management Libraries: Utilize memory management libraries like node-memwatch or heapdump to monitor memory usage and detect memory leaks in real-time.

Conclusion:

The “FATAL ERROR: JavaScript heap out of memory” error can be challenging to deal with, however with a better understanding of its causes and effective strategies for handling it, you can ensure that your JavaScript applications run smoothly and efficiently. By optimizing your code, monitoring memory usage, and employing memory management techniques, you can mitigate the impact of this error and deliver a more reliable user experience.

People Come and Go:

First things first, people are like the ebb and flow of the tides — even with careful selection, enthusiasm can wane. It’s a bit disheartening when team members leave towards the project’s end, but considering it’s a side project, we’ve learned not to take it too personally. Lesson one: don’t let external factors dictate your feelings; it’s all part of the journey. For future Project Zusammen ventures, a strategy to encourage commitment might be on the horizon.

Preparation is Key:

Lesson two underscores the importance of preparation. Initially, we underestimated the need for solid project planning, but the arrival of mentors later in the project shifted our perspective. Before diving into code, we’re now committed to understanding what we’re building, ensuring the team grasps the flow, even if we lack dedicated roles like a product manager or UI/UX designer. Learning beyond our software engineering scope pays off in a better development experience.

Choosing the Right Framework:

Lesson three is all about flexibility in tech. Instead of sticking to React Vite or Python Flask, we’re contemplating other options like React alternatives or Python FastAPI/Django for our next project. It’s a lesson in adaptability and finding the right tools for the job.

Database Dilemmas:

Lesson four hits us with database complexities. Flask DB migration headaches led us to ponder alternatives, like MongoDB, a NoSQL database. It’s less rigid, making updates smoother, especially in a group setting. Aiming for simplicity, maybe ditching MySQL for future projects could be the way to go.

Deployment Dilemmas:

Lesson five brings us to deployment decisions. With limited resources, we aimed for free or nearly free plans, resulting in both good and not-so-great providers. It’s a reminder that the right deployment choice is crucial for success.

Micro-Management Matters (to a certain extent):

Lesson six touches on micro-management, especially for industry newcomers. Starting with guidance and resources, transitioning to autonomy is the goal. Pair programming has proven to be an effective tool in this process.

Communication is Crucial:

Lesson seven is a fundamental truth — communication is key. Asynchronous work and adapting to different communication styles keep our collaborative efforts on track, steering us towards our project goals.

Embracing Uniqueness:

Lastly, lesson eight brings a reminder that people are unique. Understanding diverse personalities and communication styles fosters a collaborative environment. It’s not about judging but stepping into each other’s shoes to build robust interpersonal relationships.

Closing Thoughts:

These lessons, woven into the fabric of our ongoing Project Zusammen, guide us forward. What other lessons do you think we could learn from our project? Share your insights, and let’s continue learning together!

Understanding Relational Databases (SQL)

1. What is SQL?
Structured Query Language (SQL) is the standard language for managing and manipulating relational databases. It provides a powerful set of commands for creating, retrieving, updating, and deleting data.

2. Key Concepts:

• Tables: Data is organized into tables, each with its own set of columns and rows.
• Schema: Describes the structure of the database, including tables, fields, and relationships.
• Queries: SQL queries allow you to interact with the database, retrieve information, and perform operations.

3. Learn by Doing:

• Set up a local database using tools like MySQL or PostgreSQL.
• Practice writing basic and complex SQL queries to manipulate data.
• Understand normalization and denormalization for effective database design.

Exploring NoSQL Databases

1. What is NoSQL?
NoSQL databases provide a flexible, schema-less data model, making them suitable for diverse data types and dynamic schemas. We’ll focus on two popular types: document-oriented (MongoDB) and key-value stores (Redis).

2. MongoDB — Document-Oriented Database:

• Documents: Data is stored in JSON-like documents, allowing for nested structures.
• Scalability: MongoDB excels in horizontal scalability, making it suitable for large-scale applications.
• Use Cases: Ideal for content management systems, e-commerce, and applications with rapidly changing data.

3. Redis — Key-Value Store:

• Key-Value Pairs: Data is stored as key-value pairs, enabling fast data retrieval.
• In-Memory Storage: Redis primarily stores data in RAM, providing rapid access.
• Use Cases: Caching, real-time analytics, and messaging systems benefit from Redis’s speed.

Practical Steps for Mastery

1. Hands-On Projects:

• Create a simple web application and implement a relational database for user management.
• Build a real-time chat application using Redis for message queuing.

2. Online Resources:

• Explore online courses on platforms like Coursera and Udemy for in-depth learning.
• Leverage documentation and tutorials provided by SQL and NoSQL database vendors.

3. Engage with the Community:

• Join forums like Stack Overflow and participate in discussions to learn from the community.
• Attend meetups or webinars hosted by database experts.

Conclusion

Mastering the fundamentals of both relational databases and NoSQL databases empowers you to make informed decisions when architecting systems. Whether your project demands the structure of SQL or the flexibility of NoSQL, a comprehensive understanding of both ensures you’re well-equipped for the dynamic world of software development.

Embark on this learning journey, experiment with databases in practical scenarios, and don’t shy away from challenges. The knowledge gained will not only enhance your technical skills but also open doors to exciting opportunities in the ever-growing tech industry. Happy coding!

Introduction

Unit testing in React.js using Vite is a crucial aspect of building robust and reliable applications. In this guide, we’ll explore best practices for writing effective unit tests, covering scenarios such as rendering components with arguments, checking PropTypes, testing user interactions, mocking fetch data, and handling environment variables like API_URL.

1. Rendering Components with Arguments

When testing React components, it’s essential to ensure that they render correctly with given arguments. Let’s take a look at an example using the popular testing library, Jest, and testing-library/react:

// MyComponent.jsx

import React from 'react';
import PropTypes from 'prop-types';

const YourComponent = ({ arg1, arg2, onHandle }) => {
  return (
    <div data-testid="your-component">
      <p data-testid="arg1-element">{arg1}</p>
      <span data-testid="arg2-element">{arg2}</span>
      <button data-testid="clickable-element" onClick={onHandle}>
        Click me
      </button>
    </div>
  );
};

YourComponent.propTypes = {
  arg1: PropTypes.string.isRequired,
  arg2: PropTypes.number.isRequired,
  onHandle: PropTypes.func.isRequired,
};

export default MyComponent;

import { render } from '@testing-library/react';
import MyComponent from './MyComponent';

test('renders correctly with given arguments', () => {
  // Render the component with specified arguments
  const { getByTestId, getByText } = render(
    <YourComponent arg1="example" arg2={42} onHandle={() => {}} />
  );

  // Assert that the main container is present
  const mainContainer = getByTestId('your-component');
  expect(mainContainer).toBeInTheDocument();

  // Assert the presence of elements displaying the provided arguments
  expect(getByTestId('arg1-element')).toHaveTextContent('example');
  expect(getByTestId('arg2-element')).toHaveTextContent('42');

  // Assert the presence of the clickable element
  const clickableElement = getByTestId('clickable-element');
  expect(clickableElement).toBeInTheDocument();

  // Simulate a click event on the clickable element
  fireEvent.click(clickableElement);
});

2. Checking PropTypes

React PropTypes help catch potential bugs by validating the types of props passed to a component. Let’s incorporate PropTypes checks into our unit tests:

import PropTypes from 'prop-types';

MyComponent.propTypes = {
  argument: PropTypes.string.isRequired,
  // Add other propTypes as needed
};

test('checks propTypes', () => {
  const consoleError = jest.spyOn(console, 'error').mockImplementation(() => {});
  render(<MyComponent argument={123} />);
  expect(consoleError).toHaveBeenCalled();
});

3. Testing User Interactions

For components that involve user interactions, such as clicking or handling functions, it’s crucial to test if these interactions work as expected:

import { render, fireEvent } from '@testing-library/react';

test('handles onClick function correctly', () => {
  const handleClick = jest.fn();
  const { getByText } = render(<MyComponent onClick={handleClick} />);
  fireEvent.click(getByText('Click me'));
  expect(handleClick).toHaveBeenCalled();
});

4. Mocking Fetch Data

To isolate your tests from external dependencies, such as API calls, use mocks to simulate data fetching:

import { render, waitFor } from '@testing-library/react';
import '@testing-library/jest-dom/extend-expect';

jest.mock('./api', () => ({
  fetchData: jest.fn(() => Promise.resolve({ data: 'mockedData' })),
}));

test('renders data fetched from API', async () => {
  const { getByText } = render(<MyComponent />);
  await waitFor(() => expect(getByText('mockedData')).toBeInTheDocument());
});

5. Handling .env for API_URL

To handle environment variables like API_URL, utilize Vite’s built-in support for .env files:

// .env.test
API_URL=https://test-api.example.com

In your test file:

import { render } from '@testing-library/react';

test('uses API_URL from .env.test', () => {
  process.env.API_URL = 'https://test-api.example.com';
  const { getByText } = render(<MyComponent />);
  // Your test logic here
});

Conclusion

By following these best practices and examples, you’ll be well-equipped to create effective unit tests for your React.js components using Vite. Embrace the power of testing to enhance the reliability and maintainability of your applications. Happy testing!

The Genesis:

Like many, my initial attempts at side projects faced distractions and eventual discontinuation. However, the mentor fellowship became a turning point. Serving as a tech mentor and facilitating as a coach for a full-stack web program, I witnessed the power of collaboration and the impact it had on the mentees.

Motivated by the desire to continue this journey, Project Zusammen was born. The vision was clear: create an environment where participants could learn, share, and collaboratively build web development projects that would serve as a valuable addition to their portfolios.

The Journey Unfolds:

Project Zusammen operates on asynchronous collaboration, with just one weekly meeting. This flexibility allows participants to engage at their own pace while adapting agile methodologies to suit the project’s needs. Key elements such as project boards, git flow, and other best practices are incorporated to ensure a holistic learning experience.

Project Highlights:

Announcing the project registration in December initially aimed to select three mentees. To my surprise, over 50 enthusiastic individuals signed up, accompanied by three mentors offering their support. The unexpected surge in interest led to the selection of 15 participants, divided into three groups.

Despite a somewhat impulsive beginning, the project quickly gained momentum. The initial mentorship team reorganized due to unforeseen circumstances, leaving me as the sole mentor. This presented challenges and lessons that will be instrumental in refining the project for future iterations.

Why Project Zusammen?

The name “Zusammen,” a German word meaning “together,” perfectly encapsulates the essence of the project. Project Zusammen is not just about coding; it’s about learning and having fun collectively. It emphasizes the value of collaboration, mutual growth, and the joy derived from working together towards a common goal.

Main Objectives:

1. Building Portfolios and Tech Interview Experience: Project Zusammen serves as a platform for participants to create meaningful projects that enhance their portfolios and provide hands-on experience, crucial for success in tech interviews.
2. Mentorship for Tech Community Empowerment: Through mentoring, Project Zusammen aims to empower aspiring developers by providing guidance, sharing experiences, and fostering a supportive community.
3. Mutual Learning: The collaborative nature of the project fosters an environment where both mentors and mentees learn from each other, gaining valuable insights and skills.

Conclusion:

Project Zusammen is more than just a side project; it’s a community-driven initiative that empowers developers on their journey. As we continue to iterate and improve, the project stands as a testament to the potential of collaborative learning, highlighting the importance of coming together to create something meaningful in the ever-evolving world of web development. Join us, and let’s code and learn zusammen!

If you’re passionate about web development and eager to contribute to a collaborative community, we welcome you to be a part of Project Zusammen. Whether you envision yourself as a mentee seeking valuable experience or a seasoned developer ready to mentor, your presence can make a significant impact. Reach out to me at fatma.janna.utp@gmail.com, and let’s embark on this learning journey together!

What was it, you ask? Well, I accused an online seller of selling a fake product based on my assumption. Yup, I wrote a bad review and claimed their product was dupe. Pretty stupid wasn’t it?

After some more research, I realised that it was a great mistake. I know I shouldn’t have done that. I should have just messaged the seller personally with a question instead.

So, here’s the thing you should not do in public.

Judge/accuse/criticise someone in public even if that someone is a stranger or random person. You don’t know what side effect it will cause for doing such a thing.

Always remember that people are just unique and different. If others do not like what you like, it’s fine, completely normal. If you have some suspicious or bad feelings about something, do your research well. Think twice before sending that criticism/judgement. What will the person feel after reading it? Change your perspective, move your point of view. What if you were that person whom you judge? What would you feel if someone judged you? Let alone a stranger not knowing you in person.

So, yeah. I learnt a great lesson.

This is one of my principles that I should remind myself again and again.

Never accuse/criticise someone in public.

Do compliment people in public, and praise them with whatever they deserve. But never accuse/criticise someone in public.

So, how do I cope with this super guilty feeling? Let’s go back to the 10 10 rule mentioned by Ali Abdaal in his Feel Good Productivity book.

The 10 10 rule, what is it?

So you got a rejection letter after applying for a scholarship? Or you’ve gone through interviews but still ended up not receiving an offer? How would you feel about it? Sad, disappointed, regrets, like the world is ending?

It is normal to feel bad about not getting what you want/expect. But let’s see what happens in 10 minutes after you get that rejection letter. Still feel awful probably. OK, what about after 10 days? You will still remember it but it will be just ok. And then what will happen after 10 weeks, yeah probably it’s just another thing that happened in the past. What about after 10 years? Will you still remember this event? Probably not.

There it is, you change your perspective towards the future to not feel that bad about something because that thing is just an event that occurred in the past. And that is how you learn how to move on.

Thanks for reading, I hope you learn something from this article. See you on the next one. :)

1. Formal Writing Excellence:
   Avoid Short Forms: Ensure your scholarship essay maintains a formal tone by eschewing short forms like I’m, that’s, and you’re. Always use full terms to enhance readability. For instance, prefer “I am,” “that is,” “you are,” etc.
   Clarify Abbreviations: Introduce abbreviations like Digital Core Analysis (DCA) by providing the full term initially. This ensures clarity, especially when the selection committee may have diverse backgrounds. For example, “I want to pursue the Digital Core Analysis (DCA) course…”
2. Align with Selection Criteria:
   Align your essay with the specific criteria outlined by the scholarship provider. Use the Australia Awards Scholarship selection criteria as an example, which emphasises academic competence, potential outcomes, and leadership attributes. Connect potential outcomes with your chosen field of study to highlight your commitment to creating positive change.
3. Pay Attention to Language Spelling: Be conscious of language spelling based on the scholarship destination. Utilize Australian or British spelling for scholarships in Australia, British spelling for scholarships in the UK, and American spelling for other regions. Maintain consistency throughout your essay to showcase attention to detail.
4. Deductive Writing Style: Adopt a deductive writing style to answer questions at the beginning of each paragraph. Present your main idea early on to engage readers and maintain their interest. Remember, clarity and conciseness are key to keeping the selection committee engaged.
5. Understand the Essay Question: Thoroughly comprehend the essay question or instructions before writing. Carefully analyze each component to ensure your essay fully addresses all points. Take your time in understanding complex questions and consider seeking clarification if needed.
6. Avoid Relying Solely on Translators: If English is not your native language, use a translator cautiously. After translating, review and refine the content to ensure natural, coherent language. Overreliance on translators can compromise the quality of your essay.
7. Start Early and Conduct Research: Initiate the writing process early, even before the application opens. Research thoroughly about the scholarship, its requirements, and potential essay topics. Look for examples online to gain insights into effective essay structures and content.
8. Revise and Proofread: Allocate sufficient time for multiple revisions. Continuously refine your essay to enhance its quality. Before seeking external feedback, use tools like Grammarly to correct grammar and spelling errors. Present a polished essay that reflects your dedication and attention to detail.

Conclusion:

Crafting a compelling scholarship essay requires time, dedication, and meticulous attention to detail. By adhering to formal writing standards, addressing selection criteria, and employing clear and impactful communication, you can increase your chances of standing out and securing the scholarship you desire. Remember, making your writing accessible to a diverse audience is key to leaving a lasting impression on the selection committee.