Forem: Hamza

Why People use Typing365?

Hamza — Sun, 21 Sep 2025 04:22:57 +0000

In a world increasingly dependent on digital communication, strong typing skills are no longer a “nice to have”, they’re essential. Whether you're a developer writing code, a content creator crafting articles, or just someone who spends a lot of time in front of a keyboard, speed and accuracy matter. That’s where Typing365 comes in: a desktop typing-practice app designed to help users improve their typing speed, precision, and overall efficiency. Here’s a look at what makes it compelling and why many people choose it.

What Is Typing365?

Typing365 is a Windows-based application focused on helping users master touch typing. It offers:

Multiple formats of typing exercises (classic literature, tech articles, single words, custom text) so you can practice with varied content.
https://typing365.app/
Real-time feedback on both speed (words per minute, or WPM) and accuracy.
https://typing365.app/
Progress tracking, including streaks, charts, error analysis, and other metrics to help identify weaknesses.
https://typing365.app/
Support for multiple languages, useful for multilingual users or those learning a new language.
https://typing365.app/
Competitive features: live typing races, global leaderboards, achievements.

Key Reasons Why People Use Typing365

Here are the main advantages users report, and what sets it apart.

Native Desktop Experience
Many web-based typing tools are good, but they require a browser and internet connection. Typing365 is a native app for Windows. That means better performance, less distraction, and often more reliable tracking.
typing365.app
Comprehensive Feedback & Analytics
It’s not enough just to type fast — you also need to see where you make errors, which keys or key combinations are slowing you down, and how consistency is improving (or not). Typing365 provides detailed metrics, error-analysis, and trends over time so you can target weaknesses.
typing365.app
Motivation via Gamification
Features like streaks, competitions, leaderboards, and personal goals help make practice more engaging. For many people, this makes the difference between practicing once in a while, and forming a habit.
typing365.app
Varied Material & Real-World Relevance
Not everyone types code. Not everyone types essays. Some type chat messages; others type technical articles; still others type in more than one language. Typing365 caters to different contexts: literature, news, custom text, multilingual practice. That variety helps people build flexible typing skills.
typing365.app
Distraction-Free Environment
Because it's a dedicated app, users aren’t tempted by browser tabs, ads, or other distractions. This can help with focus, which is especially important when trying to build muscle memory.
Offline & Always-Available Practice
Even though some tools require internet access, Typing365 being desktop-based gives more reliability across different settings. Users can practice anytime, or whenever they have access to their PC.

Who Benefits Most

Developers / Programmers, For writing code, fast typing helps reduce friction. While code often involves symbols and specific formatting (indentation, brackets, etc.), general typing speed and accuracy help with comments, documentation, or writing at the terminal.
Writers / Content Creators, Blog posts, articles, reports: fast typing helps you get thoughts out quickly without getting bogged down by the mechanics of typing.
Students & Multilingual Learners, Those who type in multiple languages, or who are learning a new one, will find value in Typing365’s multilingual support and varied practice texts.
Anyone Wanting to Improve Productivity, Even outside tech, faster & more accurate typing improves overall productivity: less time correcting typos, less fatigue, smoother workflow.

Typing365 is more than a tool to measure how fast you can hit keys; it’s about evolving your typing practice into a well-informed, habit-forming, and even fun experience. For developers, writers, multilingual users, or anyone who spends time typing, the speed gains, accuracy improvements, and confidence boost can be significant. If you want to stop fighting the keyboard and start letting your ideas flow, it might be worth giving Typing365 a try.

Try The App Now : https://typing365.app/

or you can Directly get it from store : https://apps.microsoft.com/detail/9nd9jrkt3f16?referrer=appbadge&mode=direct&hl=en-US&gl=EG

Why TypeWin Rebranded to Typing 365

Hamza — Sun, 14 Sep 2025 15:09:15 +0000

Rebranding is never just about a new logo or domain. It’s a strategic decision that reflects where your product is heading and how you want users to perceive it. Recently, we made the choice to evolve our app’s identity from TypeWin to Typing 365.

1. Clarity Over Cleverness

The original name TypeWin was short, catchy, and tech-sounding. But it often created confusion:

Was it about “typing to win”?

Was it a Windows-only app?

Was it a game or a productivity tool?

In branding, clarity beats cleverness. Typing 365 instantly tells new users:

It’s about typing.

It’s about consistency and daily practice (365 days a year).

👉 Lesson: Your brand name should communicate your core value proposition without requiring explanation.

2. From Tool to Habit

When we started, TypeWin was positioned more like a "typing tool." Over time, our vision grew: this wasn't just about practicing occasionally, it was about helping people build a long-term skill and habit.

The word 365 conveys:

Daily practice.
Commitment.
A year-round challenge.

It aligns the app with lifestyle and self-improvement brands, not just “utilities.”

👉 Lesson: Rebranding can signal a shift from a product mindset (“we built a tool”) to a lifestyle mindset (“we support your growth every day”).

3. Global Scalability

“TypeWin” carried some unintended limitations:

“Win” sounded Windows-specific, which confused macOS users.

Some users associated it with gaming (“win a match”), not skill-building.

For non-English speakers, it didn’t translate well.

Typing 365 is universal, easy to pronounce, and works across languages. It scales better as we expand globally.

👉 Lesson: A name that scales internationally avoids roadblocks when entering new markets.

4. SEO & Discoverability

In today’s world, discoverability is survival. “TypeWin” struggled against generic search terms like Type Windows or Windows Typing.

With Typing 365, we immediately gained:

Better SEO alignment with typing-related queries.

Stronger memorability (“365” ties it to routine).

Domain name availability (https://typing365.app/) that fits the brand.

👉 Lesson: Branding isn’t just about emotion; it’s also about being findable.

Changing from TypeWin to Typing 365 wasn’t about abandoning our roots. It was about evolving our identity to better match our mission: helping people improve their typing every single day, year-round.

Check Typing 365 Website for more : https://typing365.app/

TypeWin vs MonkeyType: A Developer's Perspective on Typing Test Platforms

Hamza — Sat, 05 Jul 2025 09:15:05 +0000

As developers, our typing skills directly impact our productivity and coding efficiency. While there are numerous typing test platforms available, two have gained significant traction in the developer community: TypeWin and MonkeyType. After extensive testing and analysis, I'll break down the key differences and explain why TypeWin offers a superior experience for serious typists.

The Accuracy Revolution: Zero Fault Tolerance

The most significant differentiator between TypeWin and MonkeyType lies in their approach to error handling. TypeWin implements a zero fault tolerance system, meaning every keystroke must be correct to proceed. This approach might seem harsh initially, but it's precisely what makes TypeWin superior for developing real-world typing skills.

Why Zero Fault Tolerance Matters

When you're coding, debugging, or writing documentation, accuracy isn't optional, it's essential. A single misplaced character can break your entire application. TypeWin's strict accuracy requirements train you to type correctly the first time, building muscle memory that translates directly to more efficient coding sessions.
MonkeyType, while popular, allows you to continue typing even after making mistakes. This creates a false sense of progress and doesn't adequately prepare you for real-world scenarios where precision matters most.

Real-World Text vs. Artificial Content

TypeWin's Practical Approach
TypeWin stands out by offering real texts for practice sessions. Instead of random word combinations or artificially generated content, you'll find yourself typing actual paragraphs from books, articles, and documents. This approach provides several advantages:

Contextual learning: Real sentences with proper grammar and punctuation
Natural flow: Authentic text patterns that mirror actual writing
Meaningful practice: Content that engages your mind while training your fingers
Diverse vocabulary: Exposure to varied writing styles and terminologies

The MonkeyType Limitation

MonkeyType primarily relies on random word lists and basic quote collections. While this might seem sufficient for raw speed training, it fails to prepare you for the complexity of real-world typing scenarios that developers encounter daily.

Native Windows Integration vs. Web-Based Limitations

TypeWin's Desktop Advantage
As a native Windows application, TypeWin leverages the full power of the Windows 11 ecosystem. TypeWin offers a unique experience that seamlessly blends learning, racing, excitement, and self-improvement. Crafted with precision, this native app harnesses the power of Windows 11, featuring a sleek Fluent UI and optimized performance for a buttery-smooth, lightning-fast typing experience.

Key benefits include:

Offline functionality: Practice anywhere, anytime without internet dependency
System integration: Seamless Windows 11 experience with Fluent UI
Performance optimization: Native code execution for lightning-fast response times
Resource efficiency: Lower memory footprint compared to browser-based solutions

MonkeyType's Web Constraints

While MonkeyType's web-based approach offers convenience, it comes with inherent limitations:

Internet dependency for full functionality
Browser overhead affecting performance
Limited system integration capabilities
Potential for distractions from other browser tabs

Comprehensive Analytics and Progress Tracking

TypeWin's Detailed Insights

TypeWin provides comprehensive statistics after every session, offering detailed analysis of your performance including speed, accuracy, and error patterns. This lets you see not just how fast you type, but how you improve session by session. See where you stand globally or within your region. The leaderboard motivates you to keep pushing forward and improving your rank.
The platform includes:

Session-by-session improvement tracking
Global and regional leaderboards
Detailed error analysis
Personalized improvement recommendations 5.Performance certification for professional use

MonkeyType's Basic Metrics

While MonkeyType does provide basic statistics, its analysis lacks the depth and actionable insights that TypeWin offers. The focus remains primarily on raw speed metrics rather than comprehensive skill development.

The Competitive Edge: Racing and Community

TypeWin's Multiplayer Experience
Enhance your typing skills and challenge other typists in ranked races in various languages and climb the leaderboard! TypeWin's competitive racing feature adds an engaging social element that motivates continuous improvement.

Features include:

Real-time multiplayer races
Ranked competitive system
Multi-language support
Community challenges and tournaments

MonkeyType's Limited Social Features

While MonkeyType has some community features, they lack the comprehensive competitive structure that TypeWin provides.

Why Developers Should Choose TypeWin

Professional Development
TypeWin's accuracy-focused approach directly translates to better coding practices. When you're trained to type correctly the first time, you'll spend less time debugging typos and more time solving complex problems.

Real-World Preparation
The platform's use of authentic texts better prepares you for typing actual code, documentation, and professional communications.

Productivity Enhancement
Native Windows integration means TypeWin works seamlessly with your existing workflow, while offline functionality ensures you can practice anywhere.

Measurable Progress
Comprehensive analytics help you identify specific areas for improvement, making your practice sessions more targeted and effective.

Professional Credibility
TypeWin's certification features can provide tangible proof of your typing skills for professional applications.

Conclusion

While MonkeyType has gained popularity as a casual typing test platform, TypeWin represents the next evolution in typing skill development. Its combination of zero fault tolerance, real-world text practice, native Windows integration, and comprehensive analytics makes it the superior choice for developers and professionals who demand accuracy and efficiency.
The question isn't whether you can type fast—it's whether you can type accurately and efficiently in real-world scenarios. TypeWin's approach ensures that every practice session builds skills that directly translate to improved productivity in your development work.
For developers serious about improving their typing skills and overall productivity, TypeWin offers a comprehensive, professional-grade solution that goes beyond simple speed testing to deliver genuine skill development.

Ready to experience the difference? Download TypeWin from the Microsoft Store and discover why accuracy-focused typing training is the future of professional skill development. https://typewin.app/

Let me know your thoughts about both platforms!

Ready to Level Up Your Typing? Meet TypeWin! 🚀

Hamza — Thu, 05 Jun 2025 18:53:20 +0000

If you’re someone who spends hours in front of a keyboard, whether coding, writing, or just messaging friends, you might be surprised at how much your typing speed affects your productivity.

The average person types anywhere between 10 to 50 WPM (words per minute), but imagine how much more you could get done with just a little improvement! 🚀 With focused daily practice, even small gains in speed and accuracy can make a big difference in your workflow.

📊 Fun Typing Stats
A recent survey by onlinetyping.org (March 2025) surveyed over 56,000 volunteers, the results were fascinating:

👩‍🎓 Among students:

35.51% type between 30–40 WPM

36.89% are below 30 WPM

Only 1.73% type faster than 60 WPM!

💻 Among programmers:

73.42% type between 40–70 WPM

Only 3.4% are below 30 WPM

9.35% break the 70+ WPM mark!

✨ Why We Built TypeWin
We wanted to create a typing experience that doesn’t feel like homework, it should feel like a game, a challenge, and an achievement all in one. That’s exactly what TypeWin is all about.

Now available on the Microsoft Store, TypeWin brings a fresh, exciting way to practice and improve your typing. Whether you're just getting started or chasing a new personal best, this app is built to make every session rewarding.

👉 Visit our website:

Typing 365 - Free Typing Speed Test & Practice App for Desktop

Free desktop typing test. Practice to boost WPM and accuracy with multilingual tests, live races, and detailed stats. Get it on Microsoft Store.

typing365.app

🚀 Features You’ll Love:
✅ Detailed Typing Stats
Know exactly where you stand, accuracy, WPM, typos, and more.

✅ Race Mode
Compete against yourself or other typists around the world. It’s addictive! 🔥

✅ Global Leaderboard
Climb the ranks and represent your country.

✅ Word Precision Training
Pinpoint tricky words and master them.

✅ Multi-Language Support
Expand your skills across different languages.

✅ Offline & Online
No internet? No problem. Your progress syncs to the cloud when you’re back online.

✅ Modern, Minimal UI
Clean, beautiful, distraction-free, focus on what matters.

Currently for Windows only, but stay tuned, a web version is in the works to bring this fun experience to even more users. 🌍

Tried it already? We’d love to hear your feedback, what you liked, what could be better, and how you’re progressing! Drop your thoughts below. 📝👇

Check Out My New CV as a Full Stack .NET Developer!

Hamza — Fri, 03 Jan 2025 09:17:24 +0000

🚀 Excited to Share My New CV! 🚀

I'm thrilled to present my updated CV, showcasing my journey as a Full Stack .NET Developer. Over the past few years, I have gained hands-on experience in developing scalable web applications using ASP.NET Core, Blazor, SignalR, Entity Framework, and much more. I've worked on exciting projects like 'Noshi', a food ordering app, and 'The-Mart', an e-commerce platform, which allowed me to hone my skills in both backend and frontend development, 'TailsBlaor' a Component Library for Blazor Applications!

💡 Key Highlights:

Proficient in building responsive UIs with HTML, CSS, and Blazor. Expertise in ASP.NET Core for backend development and building robust APIs.
Skilled in real-time communication with SignalR and JWT authentication for secure applications.
Hands-on experience with SQL Server, Entity Framework, and Azure for cloud deployments.
Passionate about creating developer content and sharing knowledge through YouTube videos on .NET development.

I’m now looking forward to new opportunities where I can apply my skills, learn from others, and continue growing as a developer. Feel free to check out my CV and reach out if you know of any exciting roles or projects! 💼

Links :

LinkedIn : LinkedIn
Github : Github
Portfolio : Portfolio
resume : pdf | cv

Explaining the Delegates Concept !

Hamza — Fri, 13 Dec 2024 09:36:14 +0000

Delegates are the type that defines a method signature, and can hold a reference to one or more methods with that signature.
They are often described or called as a Type-Safe function pointers because they allow methods to be passed as a parameter, assigned to variable, or invoke dynamically all while ensuring type-safe..🔒

What are the Key Points of the Delegates 🗝️ ?

Method Signature : A delegate specifies return type and the parameters of the method it can refer to.
Type-Safe : Delegates ensures that the method they reference has the correct signature.
Multicast : A single delegate can reference multiple methods and invoke them sequentially. This is known as multicast delegate.
Encapsulation : Delegates encapsulates the methods and it's behavior making them useful for defining callback mechanism.

So what is the Syntax of Delegates ?!

// 1. Declare a Delegate..
public delegate void MyDelegate(string message);

// 2. Create a method matching the Delegate's signature
public class Program {

  public static void DisplayMessage(string message) {
    Console.WriteLine(message);
  }

  public static void Main() {
    // 3. Instantiate the delegate
    MyDelegate del = DisplayMessage;

    // 4. Invoke the delegate
    del("Hellow, World!");
  }

}

Let's talk about the common uses !
There are 3 common uses :

Event Handling
Callback mechanism
LINQ and Functional programming

Let's explain them one by one

1- Event Handling : Delegate are the foundation of events in C#, They allow subscribing and unsubscribing to events using methods.

public delegate void Notify();

public class EventExample {
  public event Notify OnNotify;

  public void TriggerEvent() {
    OnNotify?.Invoke(); // Safely invoke the delegates if it has subscribers 
  }
}

2- Callback mechanism : Passing a method to another method to be executed later.

public class Calculator {
  public void PerformOperation(int x, int y, Action<int> callback) {
    int result = x + y;
    callback(result);
  }
}

public class Program {
  public static void Main() {
    Calculator calc = new ();
    calc.PerformOperation(2, 3, Console.WriteLine); // Pass Console.WriteLine as a Delegate
  }
}

3- LINQ and Functional Programming : Delegates like Func, Action, Predicate are heavily used in LINQ to define custom logic.

What are the built-in Delegates ??

Action : Represents method with no return value but with parameters.

Action<string> print = Console.WriteLine;
print("Hello, World!");

Func : Represents a method with a return value and parameter.

Func<int, int, int> add  (x,y) => x + y;
Console.WriteLine(add(3,4));

Predicate : Represents a method that return bool and it takes a single parameter.

Predicate<int> IsEven = x => x % 2 == 0;
Console.WriteLIne(IsEven(4));

Advantages of Delegates

Flexibility => Enables dynamic methods invokation
Loose Coupling => Promotes code extensibility by allowing methods to be assigned dynamically
Reuseability => Encourages creating modular and reuseable code

That's it for now! Keep coding and stay awesome. Catch you later Nerds!

ASP.NET Interview Questions: Part 1 - (10 Q & A)

Hamza — Thu, 12 Dec 2024 22:25:43 +0000

1. What is the .NET Framework?

The .NET Framework is a comprehensive software development platform developed by Microsoft.
It includes a runtime environment called Common Language Runtime (CLR) and rich set of class libraries. It supports multiple programming languages such as C#, VB.NET, and F# and offers features like memory management, security and exception handling.

The .NET Framework is primarily used to create applications for Windows, But with the introduction of .NET Core and .NET 5, it can also be used to develop cross-platform applications as well.

2. What is Common Language Runtime (CLR)?

The Common Language Runtime (CLR) is the execution environment provided by the .NET Framework. it manages the execution of .NET applications, providing services like memory management, Code verification, Security, garbage collection, and exception handling.

One of the key features of the CLR is the Just-In-Time (JIT) compiler.
When a .NET application is executed, The CLR uses the JIT compiler to convert the intermediate language (IL) code into a native machine code. This process happens during the execution, ensuring platform-specific optimization.

3. Explain the difference between Value types and reference types in .NET ?

In .NET data types are split up into 2 types :

Value Types
Reference Types

The primary difference between them lies on how they store their data and how they handle it in memory.

-> Value Types directly contain their data and are stored on the stack.
They include primitive types such as :(int/bool/float/double/char/decimal/enum).
When a value is assigned to a new variable a copy of the value is made, Therefore, changes made to one variable do not affect the other

int x = 10;
int y = x;
y = 20;
// Here x is not effected, x still 10 and y equal 20.

-> Reference Types on the other hand, store a reference to the actual data, which is stored on the heap. They include types such as :
(class/interface/delegate/string/array).
When a reference type is assigned to a new variable, the interface is copied, not the actual data. Therefore changes made to one variable will affect the other, as they both point to the same data.

class Person {
  public string Name {get; set;}
}

Person person1 = new Person {Name = "Resh"};
Person person2 = person1;
person2.Name = "Mezz";

Console.WriteLine(person1.Name); // output : Mezz;
Console.WriteLine(person2.Name); // output : Mezz;

Understanding the difference between value types and reference types is crucual for efficient, Memory management and performance optimization in .NET Applications.

> 4. What is the purpose of the System.IO namespace in .NET ?

The System.IO namespace in .NET is a fundamental part of the framework that provides classes and methods for handling input/output (I/O) operations.
These operations include reading from and writing to files, data streams, and communication with devices like hard drives and network connections.

The System.IO namespace includes a variety of classes that allows developers to interact with the file system and handle data streams efficiently. Some of the key classes include :

File : Provides static methods for creating, opening, deleting, and moving files.

Directory : Provides static methods for creating, moving and enumerating through directories and subdirectories

FileStream : Provides a stream for a file, supporting both synchronous and asynchronous read and write operations.

StreamReader and StreamWriter : These classes are for reading from and writing to character streams.

BinaryReader and BinaryWriter : These classes are for reading from and writing to binary streams.

> 5. How does the concept of attributes facilitate metadata in .NET?

Attributes in .NET are powerful constructs that allow developers to add metadata---additional descriptive information---to various elements in the code, such as classes, methods, properties and more...
This metadata can be accessed at runtim using reflection, allowing for dynamic and flexible programming.

Attributes have square brackets [] and are placed above the code elements they are related to. They can be utilised to control bahavior, provide additional information or introduce extra functionality.

[Serializable]
public class ExampleClass {
  //Some code...
}

in the example above, the [Serializable] attribute is used to indicate that ExampleClass class can be serialized, a capability often curcial for storage or network transmission.

in addition to using predefined attributes such as Serialization, compilation, marshalling, etc...
.NET allows creating custom attributes to meet specific needs. This makes attributes a versatile and integral part of .NET, promoting declarative programming and code readability.

> 6. What is the difference between an exe and dll file in .NET?

An exe (executable) file contains an application's entry point and is intended to be executed directly. It represents a standalone program

public class Program {
 public static void Main(string[] args) {
   //This is the entry level...
 }
}

On the other hand, a dll (dynamic-linl library) file contains ruseable code that can be referenced and use by mulitple applications.
It allows for code sharing and modular development.

public class Library {
  public void SharedMethod () {
    //This method can be used across different applications.
  }
}

At runtime, The Common Language Runtime (CLR) loads and executes the exe's code and loads the corresponding dll into memory as needed when a class to a dll's functionality is made.

> 7. Explain the concept of Serialization and Deserialization in .NET ?

Serialization is the process of converting an object into a stream of bytes to store or transmit it.

Deserialization is the reverse process of reconstructing the object from the serialized bytes.

These mechanisms allow objects to be persisted, transferred over a network, or shared between different parts of an application.

> 8. What are the different types of exceptions in .NET and how are they handled ?

There are various types of exceptions in .NET, all of which derive from the base System.Exception class. Some commonly used exceptions include System.ApplicationException, System.NullReferenceException, System.IndexOutOfRangeException, System.DivideByZeroException and more....

In .NET exceptions are handled by using try-catch-finally blocks:

Try : The try block contains the code segment that may throw an exception.

catch : The catch block is used to capture and handle exceptions if they occur. You can have multiple catch block for a single Try block to handle different exceptions types separately.

finally : The finally block is optional and contains the code segment that should be executed irrespective of an error occuring. This generally conatins cleanup code...

try{
int[] arr = {1,2,3}
Console.WriteLine(arr[3]); //This will throw an IndexOutOfRangeException..
}

catch(IndexOutOfRangeException ex){
Console.WriteLine("Exception : {ex.Message}")
}

finally{
Console.WriteLine("This line is always executed wether the exception is thrown or not");
}

> 9. What is the role of globalization and localization in .NET ?

Globalizationrefers to designing and developing applications that can adapt to different cultures, Language, and regions.
Localization is the process of customizing an application to a specific culture or locale.

In .NET, globalization and localization are supported through features like resource files, satellite, and the CultureInfo class, allowing applications to display localized and handle culture differenceses.

> 10. What is the difference between IActionResult and ActionResult in .NET ?

IActionResult is an interface that represents the result of an action method.
It provides flexibility as you can return any object that implements this interface.
ActionResult is a concrete implementation of IActionResult. It is a base class for results such as ViewResult, JsonResult, RedirectResult, etc... and provides additional type-safety and functionality.

That's it for now! Keep coding and stay awesome. Catch you later Nerds 👋

An Overview of the Main Class Types in OOP

Hamza — Tue, 10 Dec 2024 11:09:18 +0000

So in programming, Class types refers to the classification of classes based on their purpose, behavior, or implementation style.

Classes are blueprints for creating objects and can be organized into different types based on their use in Object-Oriented programming (OOP)

Here's the main types of classes :

1.Concrete Class :

This is the most common type of classes used to create objects directly. Not all methods and properties are required; a concrete class can define methods and properties. It may also leave some optional

public class Car {
  public string Make;
  public void Drive() {
    //Some code..
  }
}

2.Abstract Class :

This class type can't be instantiated directly, Designed to be a base class for other classes, May include Abstract method(without implementation), Derived class must implement the abstract method.

public abstract class Shape {
   public abstract double CalculateArea();
   public void Display() => Console.WriteLine("Shape..");
}

3.Interface Class :

An interface defines a contract that implementing classes must follow. It specifies what methods or properties must be implemented but does not enforce how they should be implemented. In traditional interfaces, all members are abstract (no implementation). However, modern programming languages like C# allow interfaces to include default implementations for some members.

public interface IDriveable {
  void Drive();
}

4.Static Class:

This type can't be instantiated, Contains only static members (methods, properties) which belong to the class itself rather than any object.

public static class MathUtilites {
  public static double Add(double a, double b) => a + b;
}

5.Sealed Class :

This class can not be inherited by other classes. used to prevent further derivation.

public sealed class Singleton() {
  public void ShowMessages {
    //Some code..
  }
}

6.Partial Class :

Split across multiple files. All parts are combined into a single class during compilation. Useful for large classes or auto-generated code.

//File 1
public partial class Customer {
  public void printDetails() {
    //Some code..
  }
}

//File 2
public partial class Customer {
  public void UpdateDetails() {
    //Some code..
  }
}

7. Generic Class :

This type defined with type parameters allowing code to be more reuseable and type safe.

public class Box<T> {
  public T content {get; set;}
}

8.Nested Class :

Defined within a class, and it can access the private members of the outer class.

public class OuterClass {
    private string secret = "Outer class secret";

    public class NestedClass {
        public void RevealSecret(OuterClass outer) {
            Console.WriteLine(outer.secret);
        }
    }
}

9.Record Class :

Immutable reference type. primarily used to store data. Provides built-in functionality for equality checks and copying.

public record person(string Email, int age);

That's for today, Catch you up later.

Keep Learning Nerds!

Explaining SOLID Principle !

Hamza — Thu, 05 Dec 2024 08:59:53 +0000

The Solid Principle 🗂️ is a set of five design principles in OOP that helps developers to create more maintainable, Flexible and Scalable software.

What is main focus of these principles? These principles aim to improve software design and encourage best practices.

So SOLID Principles is actually a 5 principles combined within "Solid".
Let's dive into them...!

1- S => Single Responsibility Principle (SRP)
2- O => Open/Closed Principel (OCP)
3- L => Liskov Substitution Principle (LSP)
4- I => Interface Segregation Principle (ISP)
5- D => Dependency Inversion Principle (DIP)

These are the 5 Principles, Now it's time to through each one..

1.Single Responsibility Principle

Definition : A Class should have one reason to change, Meaning it should have only one functionality.
Benefit : Reduces complexity and improve code maintainability by ensuring each class handles a single function.

If you don't feel it makes sense, Check the next example, otherwise just pass it

//Violate SRP
public class UserManager {

   public void AddUser(string Email , int Id) {
     //Some code....
   }

   public void SendEmailToUser(int Id) {
     //Some code....
   }

   public void SendReportToUser(string Email) {
     //Some code....
   }
}

Q1 : What do you think we should do to follow the SR (Single Responsibility) Principle ?.....

The last example use one class UserManager to do more than one function (AddUser , SendEmailToUser , SendReportToUser). In order to follow the SRP, Each class should preform only one function .

//Following the SRP

public class UserManager{
  public void AddUser(string Email , int Id) {
    //Some code..
  }
}

public class EmailService{
  public void SendEmail(int Id) {
    //Some code..
  }
}

public class ReportService{
  public void SendReport(string Email) {
    //Some code..
  }
}

2.Open/Closed Principle (OCP)

Definition : Software entities (Classes, Modules, Functions) should be able to extend, but not able to modify. So open for extension and closed for modification
Benefit : New functions can be added without alerting existing code, reducing the risk of introducing bugs..

Let's take an example of OCP violation


public class PaymentService {

  public void PaymentProccess(string paymentType) {

     if(paymentType == "PayPal") {
         //Some code....
     }  

     if(paymentType == "CreditCard") {
         //Some code....
     }  

     if(paymentType == "BitCoin") {
         //Some code....
     }  
  }
}

Q2 : What would you think the last example is breaking the OCP ?!

Let's now refactoring to OCP....

// #1: Create a interface
public interface IPaymentService {
  void process();
}

// #2: Implement Payment Classes
public class PayPalPayment : IPaymentService {
  public void Process() {
    //Some code.. 
  }
}

public class ICreditCardPayment : IPaymentService {
  public void Process() {
    //Some code..
  }
}

In this way, we made our code following the OCP, How that ?!
Before factoring to OCP.. We must add a if statement to check the paymentType, After refactoring to OCP, we can easily just add a class for processing a paymentType without changing the base code..!

public class BitcoinPayment : IPaymentService { 

   public void Process() {
     //Some code..
   }

}

3.Liskov Subsitution Principle (LSP)

Definition: Objects of the superclass should be replaceable with objects of subclass without affecting the correctness of the program. In other words, Let's say you have a superclass called [A] and subclass called [B], you should be able to use [B] wherever the [A] Class is used..
Benefit: Maintainability.. Base code would not change or effect when you add external code or function.


//Superclass
public class Bird {

   public virtual class Fly {
      Console.WriteLine("This bird is flying");
   }

}

//Subclass #1
public class sparrow : Bird {

  public override void Fly() {
    Console.WriteLine("The sparrow is flying");
  }

}

//Subclass #2
public class Penguin : Bird {
   //Surely penguins can't fly.. So we are passing incorrect info..
   public override void Fly {
      throw new NotImplementedException("Penguins can't fly!");
   }

}

This violate the LSP... because if we use the penguin class wherever the Bird object is expected.. The program will behave unexpectedly, because calling a Fly on a penguin class will throw an exception... penguins can't fly buddy 😂!!

Q3: Can you try to figure out how i'm going to achieve LSP??

public abstract class Bird {
  public abstract void Display();
}

//Create interface for flying behavior..
public interface IFlyable {
  void Fly();
} 

//Now we cant implement the subclass correctly...
public class sparrow : Bird, IFlyable {

  public override void Display () {
    Console.WriteLine("This is a sparrow!!");
  }

 public void Fly() {
    Console.WriteLine("This sparrow is flying");
  }
}

public class penguin : Bird {

  public override void Display () {
    Console.WriteLine("This is a pneguin!");
  }

}

4. Interface Segregation Principle (ISP)

Defintion : The Interface Segregation Principle states that a class should not be forced to implement interfaces it does not use. Instead, larger interfaces should be divided into smaller, more specific ones so that implementing classes only need to be concerned with the methods relevant to them
Benefit: Prevents classes from implementing irrelevant methods. Makes code more modular and easier to understand. Supports the Single Responsibility Principle (SRP) by focusing interfaces on specific behaviors.

Violating the principle :

public interface IAnimal {
    void Eat();
    void Fly();
    void Swim();
}

public class Dog : IAnimal {
    public void Eat() {
        Console.WriteLine("Dog is eating.");
    }

    public void Fly() {
        throw new NotImplementedException(); // Not relevant for a dog
    }

    public void Swim() {
        Console.WriteLine("Dog is swimming.");
    }
}

The last example violates the Interface Segregation Principle (ISP) because it forces the Dog class to implement methods (Fly) that are irrelevant or unnecessary for its behavior. This creates several problems.

let's try to refactoring to the principle:

public interface IEater {
    void Eat();
}

public interface ISwimmer {
    void Swim();
}

public class Dog : IEater, ISwimmer {
    public void Eat() {
        Console.WriteLine("Dog is eating.");
    }

    public void Swim() {
        Console.WriteLine("Dog is swimming.");
    }
}

by splitting the IAnimal interface into smaller, behavior-specific interfaces like IEater, IFlyer, and ISwimmer, each class can implement only the interfaces relevant to its behavior. This avoids the issues mentioned above and adheres to the ISP, making the codebase cleaner, more maintainable, and more flexible

5.Dependency Inversion Principle (DIP)

Definition : The High-Level modules should not depends on the Low-Level Modules..Both should depend on abstract (Interface/Abstract Classes)..
Benifit : Reduce tight coupling between components, making the system more flexible and more easier to refractor or reset..

That's it for now! Keep coding and stay awesome. Catch you later!

What is OOP ?!

Hamza — Mon, 02 Dec 2024 16:58:03 +0000

OOP stands for Object-Oriented Programming.

OOP is a programming model in computer science that relies on the concept of Classes and Objects.
It is used to structure a software program into a simple and reusable pieces of code, Called Blueprint (Usually called classes) which are used to create individual instances of objects.

CLASS's COMPONENTS:

1.Properties

Properties represent the attributes or data of an object. They define what an object 'Has'.
Properties typically include getters and setters methods to read and write values.

public class Car{
   public string Make {get; set;}
   public string Model {get; set;}
}

2.Fields

Fields are variables declared within a class, They represent the internal data or state of an object. Fields usually have private access modifiers and are accessed through properties or methods.

public class Car {
  private string _engineType; //Field

  public string EngineType {
  get{ return _engineType; }
  set{ _engineType = value; }
 }
}

3.Methods (Functions)

Methods define the actions or behaviors that an object can perform, They represent what an object can do.
Methods in a class can be instance methods (requiring an object instance to invoke) or static methods (which can be called without an object instance).

public class Car {
  public void StartEngine() {
     Console.WriteLine("Engine started");
  }

  public void StopEngine() {
     Console.WriteLine("Engine stopped");
  }
}

4.Constructors

A constructor is a special method used to initialize new objects. It is called when an object is created from the class. It can set initial values for the object's properties or fields.

public class Car {
  public string Make {get; set;}
  public string Model {get; set;}

  public Car(string make, string model) {
    Make = make;
    Model = model;
  }
}

5.Static Members 👨‍👩‍👦‍👦

Static Members (both fields and methods) belong to the class itself rather than any specific object instance. You can access static members using class name, not enough through an object instance.

public class Car {
  public static int TotalCarsCreated {get; set;}

  public Car() {
     TotalCarsCreated++;
  }

  public static void DisplayTotalCars() {
    Console.Writeline($"Total cars created : {TotalCarsCreated}");
  }
}

Example usage :

Car myCar = new ();
Car.DisplayTotalCars(); //output : Total cars created : 1

6.Destructors

A destructor is a special method used to clean up resources when an object is destroyed. This is less common in managed languages like C#, as garbage collection automatically handles memory management. However, destructors are still useful for releasing unmanaged resources.

Access Modifiers 🔒

Classes can define access modifiers that control the visibility and accessibility of their members (properties, field, methods, etc...).

-> Public : Accessible from anywhere
-> Private : Accessible only from the class itself
-> Protected : Accessible withing the class and derived classes
-> Internal : Accessible within the same assembly

private class Car{
  //your code
}

public class Car{
  //your code
}

protected class Car{
  //your code
}

internal class Car{
  //your code
}

CLASS as an ABSTRACT BLUEPRINT:

A Class acts as a Blueprint or Template for creating objects. It defines the properties(fields), Behaviours(methods), and the structure that its objects will have.
A Clss itself does not create an object directly; it is a definition of how the object will look and behave.

CONCRETE OBJECTS :

When you instantiate a class (using new keyword in C#), you create an object or an instance of that class.
These object are referred to as concrete objects because they are actual instances created from the class blueprint

public class Car{
   public string Make {get; set;}
   public string Model {get; set;}

   public void StartEngine()
   {
     Console.WriteLine("Engine Started");
   }
}

//Creating concrete objects from the class:
Car car1 = new Car{Make = "BMW" , Model = "x6"};
Car car2 = new Car{Make = "Mercedes" , Model = "G63"};

car1.StartEngine(); //output : Engine Stated
car2.StartEngine(); //output : Engine Stated

The Car class is the abstract blueprint (note that it doesn't represent actual car yet)

The Car1 and Car2 are concrete objects created from the Car Class

THE FOUR PILLARS OF OOP :

1.Encapsulation

Definition Bundling data(fields) and methods that operate on that data into a single unit(class) and restricting access to some of the object's components.
Purpose To hide the internal state and behavior of an object and expose only what is necessary.

public class BankAccount{
  private double balance;

  public void Deposit(double amount) {
  if(amount > 0 ) {
    balance += amount;
  }

  public double Getbalance() {
    return balance;
  }
}

Key Concept : Protects the object's integrity by preventing unauthorized access or modifications.

2.Inheritance

*Definition * Allows one class (child or derived class) to inherit the properties and behaviors (methods) of another class (parent or base class)

** *Purpose * Promotes code reuse and establishes a hierarchical relationship between classes.

public class Animal {
  public void Eat() {
    Console.WriteLine("Eating...);
  }
}

public class Dog : Animal {
  public void Bark() {
    Console.WriteLine("Barking");
  }
}

Key Concept : Enables the creatio of specialized classes based on existing ones.

3.Polymorphism

Definition Allows objects of different classes to be treated as objects of a common base class. The same interface or method can behave differently based on the object invoking it.

There are two types :

Compile-time Polymorphism (Method Overloading) : Multiple methods with the same name but different parameters.

public class Calculator {

  //This takes 2 integers..
  public int Add(int a , int b) {
    return a + b;
  }

 //This takes 3 integers..
  public int Add(int a , int b , int c) {
    return a + b + c;
  }

 //This takes 4 integers..
  public int Add(int a , int b , int c , int d) {
    return a + b + c + d;
  }

// Let's make instance of the Calculator class..
Calculator myCal = new();

Console.WriteLine(myCalc.Add(2,3)); //output : 5
Console.WriteLine(myCalc.Add(2,3,5)); //output : 10
Console.WriteLine(myCalc.Add(2,3,5,6)); //output : 16
}

So here it cames the Magic of the Polymorphism (Method Overloading), you just call the method can insert a values (must be 2 or 3 or 4 numbers as we declared before)...

2.Run-time Polymorphism (Method Overriding) : Methods in a derived class override the methods of a base class.

public class Animal {
  public virtual void MakeSound() {
    Console.WriteLine("Bla bla bla...");
  }
}

public class Dog {
  public override void MakeSound() {
   Console.WriteLine("Bark");
  }
}

Animal myDog = new();
myDog.MakeSound(); //output : Bark

Notice keyword Virtual in the base class, It is added so other child classes can override it (make it possible to be overridden).

4.Abstraction

Definition Simplifying complex reality by modeling classes appropriate to the problem and providing a clear separation between what an object does and how it achieves it.
*Purpose * To hide complex implementation details and show only the relevant parts.

public abstract class Shape {
  public abstract double CalculateArea();
}

public class Circle : Shape {
    public double Radius { get; set; }
    public override double CalculateArea() => Math.PI * Radius * Radius;
}

So These principles work together to provide a robust framework for designing flexible, modular, and maintainable software.

Encapsulation protects an object's state.
Inheritance promotes code reuse
Polymorphism provides flexibility through dynamic behavior
Abstraction hides complexity and provides clean interface.

To explore another approach to Object-Oriented Programming with a different explanation and style, check out my friend's insightful article

Introducing Object-Oriented-Programming

Rasheed K Mozaffar ・ Feb 9 '23

#dotnet #csharp #beginners #programming

That's it for now! Keep coding and stay awesome. Catch you later!

What is Feature Switching in .NET 9 ?!

Hamza — Fri, 22 Nov 2024 13:40:23 +0000

Today's topic is going to be about .Net 9 . Covering new features with examples 👌.

Let's get started!

Feature switching

So Feature Switching is basically like Feature Flagging, But with Microsoft built-in support.

That's awesome isn't ?

Imagine we have a class and a method called DoThing

public class Features
{
  internal static void DoThing()
  {
   Console.WriteLine("Do a Thing");
  }
}

So i want to enable this feature for specific execution or API Testing etc... Here it comes the Feature Switching.

internal static bool IsFeatureEnabled =>
       AppContext.TryGetSwitch("Feature.IsEnabled" , out var IsEnabled) && IsEnabled;

"Feature.IsEnabled" This is the Switch's name.
out var IsEnabled This is declaring a variable IsEnabled That will store the result of the method. The out Indicates that the value will be assigned to this vartiable.

Let's get back to our main class and try to call this method

using FeatureSwitching;

if(Feature.IsEnabled)
{
  Features.DoThing();
}

//output : Do a Thing

Here we still get the method called, Because i have to specify whether i want the method to be Enabled or Disabled (It's automatically Enabled)

How can we market and specify a method ?!

Let's add this to the feature class

[FeatureSwitchDefinition(Feature.IsEnabled)]

Make sure to use the Method's name "Feature.IsEnabled"

Now, Let's move to .csproj and specify the method 🏃‍♂️:

<ItemGroup>
     <RuntimeHostConfigurationOption Include="Feature.IsEnabled" Value="False" Trim="True"/>
</ItemGroup>

When you try now to run the code, you aren't going to see output because the switch is Disabled, other words False!

Try enabling the switch and let me know what you see!

Key Benefits 🗝️ :

Backward Compatibility
Granular Control
Configuration Management

Here's the end of today's article. See you later guys 👋!

SouthMart : My New Project is Here Finally

Hamza — Thu, 22 Aug 2024 00:31:33 +0000

What is SouthMart ?! What technologies are used ?

SouthMart is a multi-tenant e-commerce platform where users can sell or purchase a wide range of products. Similar to Amazon, AliExpress, or eBay, SouthMart provides a comprehensive online marketplace experience. In the end of this article there is an overview of the technologies used in developing this project:

Features Overview :

User Experience: Users can sign up or log in to easily browse through products, add or remove items from their cart, and proceed to checkout. Before placing an order, users are prompted to provide their location and select a payment method. Once an order is placed, users can track their order, receive an invoice, and view their order history.

Seller Experience: Sellers can request an account, which the admin can approve or reject. Upon approval, sellers can access a dashboard where they can manage their products, view sales data, and track orders.

Admin Management: Admins can review seller account requests and manage orders to ensure timely delivery.

1: Home Page

As you can see the navigation bar has Filter using categories or searching manual.

On the other side you have the profile :

Here as you can see you can get into the settings, or Track orders and surely you get your old orders. And also you can find your liked products in the Wish list.

If you are asking where the Cart is??

Easy.. Just click on (Your Cart).

Before we end the Home page, I made 3 Algorithms

Random Products Algorithm : This gets 10 products randomly
Best Selling Algorithm : Get the Top 10 selling products
Recently added products algorithm : Get the latest products added to the database
Popular Products Algorithm : Get the top liked products

2: Menu

So how does the menu work?
OK, Let's say you clicked on Phones category what would happen?

Great!

Now let's use the search bar , Note it is live-search results ;)

Note i just wrote The first letters 😁

Ok, Now i want to get into the product is that available??
Yeah sure...

wait wait wait is that Reviews??
Yep yep

Here you can add your opinion. but always remember be respectful ;)

What if i want to check other products from the same seller is that Ok?
Let me show you.

Then

Ok, now i will let you go through the site with your self , see you then!

Now for a project like this we surely need a complicated dashboard so the seller can manage and monitor his products.

So here i got to use 5 algorithms.

Get sales for last year
Get sales for current year
Get sales for last month
Get sales for current month
Get sales for last 24h

on top of the page you got the : Revenues / Gross Sales and the debit

Then in the middle right you got a table for the recently added products , on the left you have the chart.

Then in the bottom you have a notification table, that tells you if a product is out of stock.

Also there is Add product page

And also you can alway check your products and edit them or delete them.

At the end we have orders tracker

what if i want to check the order details?
i got you , just click on action and click on Order details

Finally we have the profile page

This website took me 3 weeks to achieve this features and designs and system's security.

THIS PROJECT IS FOR TRAINING PURPOSES

The Stack :

ASP.NET Web API - Handles the backend services, including authentication, data processing, and business logic.
Blazor WebAssembly - Powers the client-side application, providing a rich, interactive user experience directly in the browser.
HTML, CSS, JavaScript - Core web technologies for structuring and styling the front-end, with JavaScript handling dynamic behaviors.

Technologies :

LINQ - For querying collections and databases in a concise and readable manner.
Entity Framework Core - The ORM (Object-Relational Mapper) that manages database access and operations.
SQL - The database language used for storing and retrieving data.
Razor - A syntax for combining C# and HTML to generate dynamic web content.
AutoMapper - For mapping between different object models, such as DTOs and entities.
Dependency Injection - Ensures modularity and easy testing by injecting dependencies where needed.
JWT Authentication - Provides secure user authentication with token-based authorization.
Bootstrap (optional) - For responsive design and styling (if used in your project).

Project source : https://github.com/Hamza-Bek