Forem: Nikko Ferwelo

I built an app using flutter that lets you save any bookmark on any app

Nikko Ferwelo — Wed, 05 Nov 2025 14:07:51 +0000

📌 The Problem

You know that feeling when you find an amazing article, but you're in the middle of something? You bookmark it, promising to read it later... and then it disappears into the black hole of your browser's bookmark bar, never to be seen again.

Or worse — you're on mobile, trying to save a link, and you have to:

Copy the URL
Open your bookmark app
Create a new bookmark
Paste the URL
Hope you remember to add tags later

There had to be a better way.

🚀 Enter: Save It Later

After months of development (and countless "why isn't this working?" moments), I've built Save It Later — a modern bookmark and reading app that actually makes sense.

Think Pocket or Instapaper, but built for 2024 with the features you actually want.

✨ What Makes It Different

🎯 Save From Anywhere

Browser share sheet? ✅
Floating action button for instant saves? ✅
Multi-paste URLs (paste 10 links at once)? ✅
Android widget for quick access? ✅ (Just added!)

📱 Actually Works Across Devices

Save on your phone, read on your tablet, organize on your desktop
Firebase-powered cloud sync (when you're ready to go premium)
Offline-first architecture — everything works even without internet

🎨 Clean Reading Experience

Distraction-free reading mode that strips ads and clutter
Beautiful Material Design 3 UI
Dark mode that doesn't hurt your eyes
Customizable fonts and themes

🗂️ Smart Organization

Folders and tags (because sometimes you need both)
Powerful search that finds what you're looking for
Smart collections with automatic categorization
Archive and favorites — keep your list clean

📊 For the Data Nerds

Analytics dashboard showing your reading habits
Track what you save, when you read it, and more
Premium feature, but worth it if you're curious about your patterns

🛠️ Built With Modern Tech

I built this with Flutter because:

Cross-platform from day one (iOS, Android, Web, Desktop)
Beautiful UI is actually achievable
Performance that doesn't suck

The Stack:

Flutter for the UI
SQLite for local storage (fast, reliable, offline-first)
Firebase for cloud sync and authentication
RevenueCat for subscription management
Provider + Riverpod for state management
Material Design 3 for that modern feel

🎁 What I Learned (The Hard Way)

1. Offline-First is Harder Than You Think

Building a reading app that works offline means caching everything — images, content, metadata. But when you have thousands of saved items, cache management becomes... interesting.

Solution: Implemented a smart cache management system that balances storage and performance.

2. Content Extraction is Tricky

Not every website plays nice. Some have weird HTML structures, some block scraping, some have paywalls. Getting reliable content extraction required a lot of edge case handling.

Solution: Multiple extraction strategies + fallback mechanisms + user feedback loop.

3. Cross-Platform Sync is Complex

Making sure data syncs correctly across devices, handling conflicts, and keeping everything in sync is... a challenge.

Solution: Firebase Firestore with careful conflict resolution + optimistic UI updates.

4. Widget Development is Different

Just added Android widget support. Turns out, widgets have their own lifecycle, limited interactions, and require native code. Not as simple as I thought!

Solution: Native Kotlin code for widget updates + Flutter plugin for communication.

📈 Current Status

✅ Core features working smoothly
✅ Android widget just launched
✅ iOS app in the works
✅ Premium features with RevenueCat integration
🔄 Browser extension planned (Chrome first, then Firefox)

🎯 Why You Should Try It

It's actually useful — I use it daily to save articles, Reddit posts, and random links I find
It's fast — Optimized for performance, even with thousands of saved items
It's beautiful — Material Design 3 makes it feel modern and polished
It respects your privacy — Offline-first means your data stays local (cloud sync is opt-in)

💡 What's Next?

I'm planning to add:

Browser extension (Chrome, then Firefox) for one-click saving
Desktop apps (Windows, macOS, Linux) using Flutter
Better search with full-text search within articles
Export/Import functionality
Collaborative collections (share folders with friends)

🤝 I Want Your Feedback

I've been building this in a vacuum (mostly), and I'd love to hear from other developers:

What features would make you switch from Pocket/Instapaper?
What's your biggest pain point with current bookmark apps?
Any Flutter-specific tips for performance optimization?
Widget development best practices? (I'm new to this)

🚀 Try It Out

The app is available on:

Google Play Store https://play.google.com/store/apps/details?id=com.saveitlater.app
App Store https://apps.apple.com/us/app/save-it-later-bookmarks/id6752220740

Or check out the code on GitHub (if you're into that sort of thing).

TL;DR: Built a modern bookmark/reading app with Flutter. It's fast, beautiful, and actually works offline. Just added Android widget support. Looking for feedback from fellow devs!

What do you think? Would love to hear your thoughts in the comments below! 👇

flutter #mobile #android #ios #appdevelopment #productivity #bookmarks #reading #opensource #flutterdev #materialdesign #firebase

Must-Have Apps of 2024

Nikko Ferwelo — Mon, 04 Nov 2024 15:22:36 +0000

Looking for the best apps this year? Here's your curated list of game-changers that deserve space on your phone!

Age Calculator: Date of Birth ⭐ 4.8/5 Transform how you track life's moments with this sleek tool.

Calculate exact age (years, months, days)
Zodiac insights & compatibility
Birthday countdowns
Event planning
Dark/Light mode
Free with premium features

📱 Download now:

iPhone: https://apps.apple.com/app/age-calculator-birth-date/id6737156552
Android: https://play.google.com/store/apps/details?id=com.nikko.ferwelo.birthdate_calculator

Productivity Champions 💪

Notion (4.7/5): Your all-in-one workspace

iOS: https://apps.apple.com/app/notion-notes-projects-docs/id1232780281
Android: https://play.google.com/store/apps/details?id=notion.id

Canva (4.9/5): Design made easy

iOS: https://apps.apple.com/app/canva-design-photo-video/id897446215
Android: https://play.google.com/store/apps/details?id=com.canva.editor

Social & Entertainment 🎮

BeReal (4.6/5): Authentic social sharing

iOS: https://apps.apple.com/app/bereal-your-friends-for-real/id1459645446
Android: https://play.google.com/store/apps/details?id=com.bereal.mobile

TikTok (4.8/5): Short-form video king

iOS: https://apps.apple.com/app/tiktok/id835599320
Android: https://play.google.com/store/apps/details?id=com.zhiliaoapp.musically

Health & Wellness 🧘‍♀️

Nike Training Club (4.9/5): Free premium workouts

iOS: https://apps.apple.com/app/nike-training-club/id301521403
Android: https://play.google.com/store/apps/details?id=com.nike.ntc

Calm (4.8/5): Meditation & sleep stories

iOS: https://apps.apple.com/app/calm/id571800810
Android: https://play.google.com/store/apps/details?id=com.calm.android

Must-Have Tools 🛠️

Spotify (4.7/5): Music & podcasts

iOS: https://apps.apple.com/app/spotify-music-and-podcasts/id324684580
Android: https://play.google.com/store/apps/details?id=com.spotify.music

Duolingo (4.8/5): Language learning

iOS: https://apps.apple.com/app/duolingo-language-lessons/id570060128
Android: https://play.google.com/store/apps/details?id=com.duolingo

Pro Tip 💡
Start with Age Calculator to track your milestones, then explore others based on your needs!
Featured App Spotlight: Age Calculator 🌟
Try our top pick for 2024:

iOS: https://apps.apple.com/app/age-calculator-birth-date/id6737156552
Android: https://play.google.com/store/apps/details?id=com.nikko.ferwelo.birthdate_calculator

Apps2024 #Technology #MustHaveApps #Productivity

Want to try these apps? Start with Age Calculator and level up your digital life! 🚀

🎉 After a Year of Hard Work, My Birthday App is Here! But I Need Your Support 😢

Nikko Ferwelo — Wed, 30 Oct 2024 17:46:05 +0000

Hey, Dev.to community! 👋

After a year of late nights, countless coffee cups, and endless coding sessions, I’m thrilled to announce that I’ve launched my app, Birthday Date Calculator! 🎂✨

The Journey

Building this app has been a labor of love. I started with a simple idea: to create a tool that helps people celebrate birthdays in a fun and organized way. I wanted to make it easier to calculate ages, set reminders, and never miss a birthday again.

Challenges Faced

Throughout the past year, I faced challenges like:

Designing an intuitive user interface
Learning new technologies
Debugging (lots of it!)

But every obstacle was a learning experience, and I'm proud of the final product!

Features of Birthday Date Calculator

Here's what you can expect from the app:

Easy Age Calculation: Just input the birthdate, and you’ll get the age instantly!
Birthday Countdown: Know exactly how many days are left until that special day!
Reminders: Set alerts to ensure you never forget a birthday again.

The Challenge

Despite all the hard work I’ve put into this app, I’m facing a challenge: no one seems to be downloading it! 😔 I genuinely believe it can bring joy to many, and that’s why I’m reaching out to you, the amazing Dev.to community.

How You Can Help

If you love celebrating birthdays (who doesn’t?), I would be incredibly grateful if you could check out my app. Your support means the world to me, and I would appreciate any feedback or suggestions you might have!

👉 Download Birthday Date Calculator

Conclusion

Thank you for taking the time to read about my journey and my app! I’m excited to hear your thoughts and hopefully get some downloads. Let’s make every birthday unforgettable together! 🥳💖

Feel free to share this post or tag friends who might be interested!

Stop Using Traditional Loops in Java: Use Streams and `forEach` 🚀

Nikko Ferwelo — Tue, 08 Oct 2024 14:41:28 +0000

Hey fellow developers! 👋

As a Java developer, I’ve spent countless hours iterating over collections. For many years, traditional loops like for, while, and do-while were my go-to methods. However, since the arrival of Java Streams in Java 8, I’ve found myself moving away from these old habits. Here’s why I believe it’s time to stop using traditional loops and embrace the modern way of doing things with Streams and the forEach method. 🌟

The Traditional Loop 🌀

We all know the classic for loop, right? Here’s a straightforward example of summing elements in an integer array using a traditional loop:

int[] numbers = {1, 2, 3, 4, 5};
int sum = 0;

for (int i = 0; i < numbers.length; i++) {
    sum += numbers[i];
}
System.out.println("Sum: " + sum);

This method works, but let’s face it—it can get cumbersome. The potential for off-by-one errors is always lurking, and it often leads to more code than necessary. 😅

Why I Moved Away from Traditional Loops 💡

1. Readability Matters 📖

One of the first things I noticed when I started using Streams is how much more readable my code became. Instead of getting lost in the control flow of a loop, I could focus on what I wanted to achieve. For instance, summing the same array can now be done in just one line:

int sum = Arrays.stream(numbers).sum();
System.out.println("Sum: " + sum);

This clarity is invaluable, especially when working in teams or revisiting my own code later. 🙌

2. The Power of `forEach` ⚡

The forEach method is another fantastic addition to the Java Collections Framework. It allows you to perform an action for each element in a collection without the boilerplate of a traditional loop. Here’s how you can use it to print each element in the array:

Arrays.stream(numbers).forEach(n -> System.out.println(n));

This approach is clean, concise, and eliminates the need for explicit iteration logic. 🔥

3. Functional Programming Awesomeness ✨

Streams also introduced me to the joys of functional programming. I love how I can chain operations together without cluttering my code. Here’s an example of filtering even numbers and summing them:

int sumEven = Arrays.stream(numbers)
                    .filter(n -> n % 2 == 0)
                    .sum();
System.out.println("Sum of even numbers: " + sumEven);

This fluent style looks cleaner and feels more intuitive. 😊

4. Going Parallel Made Easy 🌍

Another game-changer has been the ability to easily perform parallel processing. By simply switching to a parallel stream, I can harness the power of multi-core processors without writing complicated code:

int parallelSum = Arrays.stream(numbers)
                        .parallel()
                        .sum();
System.out.println("Parallel Sum: " + parallelSum);

This is a great way to boost performance for large datasets with minimal effort. ⚙️

5. Reducing Common Loop Errors ❌

Let’s not forget about the pitfalls of traditional loops. Infinite loops, off-by-one errors, and maintaining state can complicate things. With Streams and forEach, many of these issues are minimized. The declarative approach allows me to focus on what I want to achieve rather than how to achieve it, which reduces the risk of mistakes. 🚫

When Traditional Loops Still Make Sense 🤔

That said, traditional loops aren’t completely obsolete. There are still scenarios where they might be the better choice:

Fine-Grained Control: If you need precise control over the iteration process.
Performance-Critical Sections: In some cases, the overhead of Streams might not be suitable for performance-critical code.
Legacy Code: If you’re dealing with older systems that rely heavily on traditional loops, it may be easier to stick with what’s already in place.

Conclusion 🎉

In conclusion, while traditional loops have served us well, the introduction of Streams and the forEach method has transformed the way we work with collections in Java. They offer improved readability, enhanced functional programming capabilities, and convenient parallel processing

making our code cleaner and more efficient.

So, the next time you sit down to write a loop, ask yourself: could a Stream or forEach do this better? Embrace the change, and I promise you’ll find your coding experience more enjoyable. Happy coding! 💻❤️

Connect with me:
LinkedIn: https://www.linkedin.com/in/nikko-ferwelo-358b11213

GitHub: https://github.com/NullVoidKage

🚀 Understanding the Differences: DTO, DAO, and POJO in Java

Nikko Ferwelo — Wed, 02 Oct 2024 11:18:38 +0000

Hey there, fellow developers! 👋
**
Navigating the landscape of Java development can be challenging, especially when it comes to understanding the various design patterns and data structures. Three important concepts you’ll often encounter are **DTO, DAO, and POJO. In this blog, we'll explore these terms, their purposes, and help you decide when to use each one.

Let’s dive in! 🚀

🔗 What is a POJO?

POJO stands for Plain Old Java Object. A POJO is a simple object that does not adhere to any specific framework or requirement. It typically represents data and encapsulates it in fields along with getters and setters.

Use Case:

Choose POJOs for simple data representation without any framework constraints.

Pros:

Simplicity: No need to implement interfaces or extend classes.
Flexibility: Can contain any fields and methods as required by the business logic.
Encapsulation: Helps manage and manipulate data effectively.

Cons:

Lack of structure: Can lead to less maintainable code if not managed properly.
No built-in validation: POJOs don’t inherently enforce any validation rules.

Example:

public class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

🔗 What is a DTO?

DTO stands for Data Transfer Object. A DTO is an object that carries data between processes. It is particularly useful when you want to transfer data across different layers of an application or over the network.

Use Case:

Use DTOs when you need to transfer data without including business logic.

Pros:

Optimized for data transfer: Reduces the number of method calls.
No business logic: Keeps the focus on data representation.
Serializable: Suitable for network communication.

Cons:

Overhead: Can introduce additional layers of complexity.
Requires mapping: Often requires conversion from and to POJOs or entities.

Example:

public class UserDTO {
    private String name;
    private int age;

    public UserDTO(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

🔗 What is a DAO?

DAO stands for Data Access Object. A DAO is a design pattern that provides an abstract interface for accessing data from a persistent storage mechanism (like a database).

Use Case:

Choose DAOs for encapsulating data access logic and managing CRUD operations.

Pros:

Data abstraction: Provides a clear separation between business logic and data access.
Supports CRUD operations: Facilitates database interactions.
Testable: Makes it easier to mock data access for unit tests.

Cons:

Complexity: Can add complexity if not designed properly.
Performance overhead: Might introduce performance bottlenecks if not optimized.

Example:

import java.util.List;

public interface UserDAO {
    void saveUser(User user);
    User getUserById(int id);
    List<User> getAllUsers();
    void updateUser(User user);
    void deleteUser(int id);
}

🚧 Key Differences Between DTO, DAO, and POJO

Feature	POJO	DTO	DAO
Purpose	Represents data	Transfers data	Accesses and manages data
Business Logic	May contain business logic	No business logic	Contains data access logic
Layer	Any layer	Typically between layers	Data access layer
Serialization	Not designed for serialization	Designed for serialization	Not related to serialization
Usage	Used throughout the application	Used to transfer data	Used for database operations

🧩 When to Choose POJO

You need simple data representation without framework constraints.
You want to encapsulate related properties and behaviors.

🧩 When to Choose DTO

You need to transfer data between layers or processes.
You want to keep data representation separate from business logic.

🧩 When to Choose DAO

You need to abstract data access from your business logic.
You want to implement CRUD operations in a consistent manner.

🚀 Practical Applications

POJO: Best suited for modeling simple data entities. Examples include user profiles and product information.
DTO: Ideal for API responses or data sent over the network. Examples include user data sent to a frontend application.
DAO: Used for encapsulating database operations. Examples include user repositories or service layers.

🧠 Conclusion

Understanding the differences between DTO, DAO, and POJO is crucial for building efficient and maintainable Java applications. Each serves its own purpose, and your decision should depend on your project requirements and architecture needs.

I hope this blog helps clarify these important concepts in Java! If you have any questions or suggestions, feel free to drop them in the comments below. Happy coding! 💻

Connect with me:
LinkedIn: https://www.linkedin.com/in/nikko-ferwelo-358b11213

GitHub: https://github.com/NullVoidKage

🚀 Flutter vs React Native: Which One Should You Choose?

Nikko Ferwelo — Fri, 06 Sep 2024 16:18:46 +0000

Hey there, fellow developers! 👋

Choosing the right framework for mobile app development can be challenging, especially when the two top contenders—Flutter and React Native—both offer powerful features for building cross-platform apps. In this blog, we'll compare these two frameworks and help you decide which one fits your project needs.

Let’s dive in! 🚀

🔗 What is Flutter?
Flutter is an open-source UI software development kit (SDK) created by Google. It allows developers to build natively compiled applications for mobile, web, and desktop from a single codebase. Flutter uses the Dart programming language and is known for its fast development cycles and stunning visuals.

Use Case: Choose Flutter if you want a rich UI with custom designs, animations, or want to target multiple platforms with a single codebase.

Pros:

Hot reload for fast development.
Rich set of customizable widgets.
High performance with direct compilation to native code.
Strong support from Google and growing community.

Cons:

Larger app size.
Dart language may not be familiar to many developers.
Smaller community compared to React Native.

Example:

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: Text("Flutter App")),
        body: Center(child: Text("Hello, Flutter!")),
      ),
    );
  }
}

🔗 What is React Native?
React Native is an open-source framework developed by Facebook. It enables developers to build mobile apps using JavaScript and React. Instead of compiling into native code, React Native bridges JavaScript with native components, allowing you to write once and run on both iOS and Android.

Use Case: React Native is ideal if you're already familiar with JavaScript and React, and need to build apps quickly with a shared codebase.

Pros:

Write in JavaScript, a widely used language.
Large community and plenty of libraries.
Can integrate with existing native code.
Reusable components across platforms.

Cons:

Performance can lag in complex apps compared to Flutter.
Updates can sometimes lag behind native platform changes.
Native modules may require additional effort.

Example:

import React from 'react';
import { Text, View } from 'react-native';

const App = () => {
  return (
    <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
      <Text>Hello, React Native!</Text>
    </View>
  );
};

export default App;

🚧 Key Differences Between Flutter and React Native

Programming Language:

Flutter uses Dart, while React Native uses JavaScript. If you're already experienced in JavaScript, React Native might be easier to pick up.

Performance:

Flutter has the edge in performance since it compiles directly into native code. React Native relies on a JavaScript bridge, which can cause performance bottlenecks for complex apps.

UI Components:

Flutter’s widget system provides more flexibility and customization. It allows for pixel-perfect designs, which makes it ideal for highly custom UI/UX designs. React Native relies on native components, which can limit some design capabilities.

Ecosystem & Community:

React Native has a larger community and more third-party libraries, making it easier to find solutions to problems. Flutter’s community is growing rapidly, but it’s still smaller in comparison.

Development Speed:

Both frameworks offer features like hot reload, but Flutter’s comprehensive widget catalog often reduces the need for third-party dependencies, potentially speeding up development.

🧩 When to Choose Flutter

You need highly custom UI and animations.
You want to develop for web, mobile, and desktop using a single codebase.
You prefer direct access to native performance.

🧩 When to Choose React Native

You’re already proficient in JavaScript and React.
You want access to a larger ecosystem of libraries.
You need to quickly prototype or build an MVP.

🚀 Practical Applications

Flutter: Best suited for apps that require high performance and intricate, custom UI designs. Examples include Google Ads and Reflectly.
React Native: Ideal for projects where speed to market and leveraging existing web technology is key. Examples include Instagram and Airbnb.

🧠 Conclusion
Both Flutter and React Native are excellent choices for cross-platform mobile development. Your decision should depend on your project requirements, design needs, and language preferences. Flutter shines in performance and custom UI, while React Native excels in speed and a vast JavaScript ecosystem.

I hope this blog helps clarify the differences between Flutter and React Native! If you have any questions or suggestions, feel free to drop them in the comments below. Happy coding! 💻

Connect with me:
LinkedIn: https://www.linkedin.com/in/nikko-ferwelo-358b11213

GitHub: https://github.com/NullVoidKage

🚀 Understanding the Difference Between `filter` and `map` in Java Stream API

Nikko Ferwelo — Sat, 24 Aug 2024 05:49:46 +0000

Hey there, fellow developers! 👋

If you’ve been diving into Java’s Stream API, you’ve likely come across two essential operations: filter and map. While both are powerful tools for manipulating streams of data, they serve different purposes and are often used together in stream processing pipelines. In this blog post, we’ll break down the differences between filter and map, and explore how you can use them effectively in your Java projects.

Let’s get started! 🚀

🔗 What is `filter` in Java Stream API?

The filter method is used to screen out elements from a stream based on a given condition. It returns a new stream that contains only the elements that match the condition (or predicate) specified.

Use Case: You use filter when you want to include only those elements in your stream that satisfy a certain condition.

Syntax:

Stream<T> filter(Predicate<? super T> predicate)

Example:

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

List<String> filteredNames = names.stream()
                                  .filter(name -> name.startsWith("A"))
                                  .collect(Collectors.toList());

System.out.println(filteredNames); // Output: [Alice]

Explanation: In this example, filter is used to create a new stream that includes only the names starting with "A".

🔗 What is `map` in Java Stream API?

The map method is used to transform each element of a stream into another form. It applies a given function to each element and returns a new stream containing the transformed elements.

Use Case: You use map when you want to convert or transform the elements of a stream into another type or format.

Syntax:

<R> Stream<R> map(Function<? super T, ? extends R> mapper)

Example:

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

List<Integer> nameLengths = names.stream()
                                 .map(String::length)
                                 .collect(Collectors.toList());

System.out.println(nameLengths); // Output: [5, 3, 7, 5]

Explanation: In this example, map is used to transform each name into its corresponding length, resulting in a stream of integers.

🚧 Key Differences Between `filter` and `map`

Purpose:
- filter: Used to select elements based on a condition (i.e., it filters the elements).
- map: Used to transform or convert elements from one form to another (i.e., it maps the elements).
Input/Output:
- filter: Takes a Predicate as an argument and produces a stream with the same type of elements but with fewer elements.
- map: Takes a Function as an argument and produces a stream with a potentially different type of elements.
Result:
- filter: Produces a stream with elements that meet the filtering condition.
- map: Produces a stream with elements that are the result of applying a transformation function.

🧩 Combining `filter` and `map`

Often, filter and map are used together in a stream pipeline to first narrow down the elements and then transform them.

Example:

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

List<Integer> filteredNameLengths = names.stream()
                                         .filter(name -> name.length() > 3)
                                         .map(String::length)
                                         .collect(Collectors.toList());

System.out.println(filteredNameLengths); // Output: [5, 7, 5]

Explanation: Here, we first filter the names to include only those with more than three characters, and then we map each name to its length.

🚀 Practical Applications

Filtering and Mapping User Data:

   List<User> users = getUsers();

   List<String> usernames = users.stream()
                                 .filter(user -> user.getAge() > 18)
                                 .map(User::getUsername)
                                 .collect(Collectors.toList());

Explanation: Filter out users under 18, and then map the remaining users to their usernames.

Processing Transaction Data:

   List<Transaction> transactions = getTransactions();

   double totalAmount = transactions.stream()
                                    .filter(Transaction::isProcessed)
                                    .mapToDouble(Transaction::getAmount)
                                    .sum();

Explanation: Filter transactions that have been processed, and then map to their amounts and sum them up.

🧠 Conclusion

Understanding the difference between filter and map in Java Stream API is crucial for writing clean and efficient stream processing code. Use filter to narrow down your data, and use map to transform it. Combining these operations can lead to powerful data manipulation pipelines that are both readable and maintainable.

I hope this blog helps clarify the roles of filter and map in your Java development journey! Feel free to bookmark it for quick reference or share it with your fellow developers.

Got any questions or additional tips? Drop them in the comments below! Happy coding! 💻

Connect with me:

LinkedIn: https://www.linkedin.com/in/nikko-ferwelo-358b11213
GitHub: https://github.com/NullVoidKage

🚀Java Stream API Cheat Sheet for Developers

Nikko Ferwelo — Sat, 24 Aug 2024 05:47:14 +0000

Hey everyone! 👋

I’ve put together a concise Java Stream API Cheat Sheet to help you quickly reference important concepts, methods, and patterns in your Java projects. Whether you're an experienced developer or just getting started, this guide should serve as a handy resource for working with streams in Java.

Let’s dive in!

🔗 Core Concepts

Java Stream API: A powerful tool introduced in Java 8 for processing sequences of elements in a functional style.

Functional Interfaces: Core to the Stream API, allowing the use of lambda expressions. Some key interfaces include:

Predicate: Represents a boolean-valued function.
Function: Represents a function that takes an input and returns a result.
Consumer: Represents an operation that takes an input and returns no result.
Supplier: Represents a supplier of results.

📦 Creating Streams

Streams can be created from various sources:

From Collections:

   List<String> list = Arrays.asList("a", "b", "c");
   Stream<String> stream = list.stream();

From Arrays:

   String[] array = {"a", "b", "c"};
   Stream<String> stream = Arrays.stream(array);

From Values:

   Stream<String> stream = Stream.of("a", "b", "c");

From Files:

   Stream<String> lines = Files.lines(Paths.get("file.txt"));

🔗 Stream Operations

Stream operations are divided into intermediate and terminal operations:

Intermediate Operations (Lazy)

filter(): Filters elements based on a predicate.

  stream.filter(s -> s.startsWith("a"));

map(): Transforms each element.

  stream.map(String::toUpperCase);

flatMap(): Flattens nested streams.

  stream.flatMap(Collection::stream);

sorted(): Sorts elements.

  stream.sorted();

distinct(): Removes duplicates.

  stream.distinct();

Terminal Operations (Eager)

collect(): Collects the results into a collection.

  List<String> result = stream.collect(Collectors.toList());

forEach(): Performs an action for each element.

  stream.forEach(System.out::println);

reduce(): Reduces the elements to a single value.

  Optional<String> concatenated = stream.reduce(String::concat);

count(): Counts the number of elements.

  long count = stream.count();

findFirst(): Returns the first element.

  Optional<String> first = stream.findFirst();

💡 Common Patterns

Filtering and Collecting:

   List<String> filteredList = list.stream()
                                   .filter(s -> s.length() > 2)
                                   .collect(Collectors.toList());

Mapping and Reducing:

   int sum = list.stream()
                 .map(String::length)
                 .reduce(0, Integer::sum);

Grouping and Counting:

   Map<String, Long> grouping = list.stream()
                                    .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

🚀 Stream Characteristics

Parallel Streams: Split the stream into multiple threads for parallel processing.

  Stream<String> parallelStream = list.parallelStream();

Infinite Streams: Generate streams with no fixed size.

  Stream<Integer> infiniteStream = Stream.iterate(0, n -> n + 1);

📦 Advanced Topics

Custom Collectors: Create your own collectors for complex reduction operations.
FlatMap for Nested Structures: Flatten complex data structures.
Stream Pipelines: Combine multiple stream operations for powerful data processing.

🧩 Example Use Cases

Data Filtering: Filter a list of objects based on multiple criteria.
Data Transformation: Convert a list of objects to a different type (e.g., DTOs).
Aggregation and Summary: Calculate statistics like sum, average, or max.

⚙️ Commands and Tools

JDK: Ensure you’re using Java 8 or higher to utilize the Stream API.
IDE: IntelliJ IDEA, Eclipse, or Visual Studio Code for Java development.

🧠 Best Practices

Prefer Immutability: Streams encourage a functional style, so avoid mutating shared state.
Reuse Streams Cautiously: Streams can only be consumed once; consider creating new streams for multiple operations.

I hope this Java Stream API Cheat Sheet helps you in your development journey! 🚀 Feel free to bookmark it or share it with your fellow developers.

If you have any additions or suggestions, drop them in the comments below. Happy coding! 💻

Connect with me:

LinkedIn: https://www.linkedin.com/in/nikko-ferwelo-358b11213
GitHub: https://github.com/NullVoidKage

📝Microservices Interview Cheat Sheet

Nikko Ferwelo — Sat, 24 Aug 2024 05:45:47 +0000

1. Microservices Architecture 🏗️

Definition: A software architecture style where applications are composed of small, independent services that communicate over a network.
Advantages: Scalability, flexibility, independent deployment, resilience, and better fault isolation.
Challenges: Complexity in management, network latency, distributed data management, and need for strong DevOps practices.

2. Service Discovery 🔍

Definition: A mechanism to dynamically discover and connect services in a microservices architecture.
Tools: Eureka (Netflix), Consul (HashiCorp), Zookeeper (Apache).
Patterns: Client-side discovery, Server-side discovery.

3. API Gateway 🚪

Definition: An entry point for client requests, routing them to the appropriate services.
Responsibilities: Request routing, composition, and protocol translation.
Tools: Kong, NGINX, Zuul (Netflix).

4. Communication Patterns 💬

Synchronous Communication: Direct service-to-service communication, typically via HTTP/REST or gRPC.
Asynchronous Communication: Communication via messaging systems like RabbitMQ, Kafka, or AWS SQS.
Pattern: Request-Response, Event-driven, Publish-Subscribe.

5. Data Management in Microservices 🗄️

Database per Service: Each service manages its own database schema, promoting data autonomy.
Challenges: Maintaining data consistency across services, distributed transactions.
Solutions: Eventual consistency, Saga Pattern, CQRS (Command Query Responsibility Segregation).

6. Circuit Breaker Pattern 🔄

Definition: A design pattern used to detect failures and encapsulate the logic of preventing a failure from constantly recurring.
Tools: Hystrix (Netflix), Resilience4j.
Usage: To prevent cascading failures and improve fault tolerance.

7. Service Resilience & Fault Tolerance 🛡️

Techniques: Retry logic, timeout settings, fallback methods.
Patterns: Bulkhead Pattern, Retry Pattern, Timeout Pattern.
Tools: Hystrix, Resilience4j.

8. API Versioning 📅

Definition: Managing changes in APIs without breaking existing client implementations.
Techniques: URI versioning, query parameter versioning, custom headers.
Strategy: Deprecate old versions and maintain backward compatibility.

9. Monitoring & Logging 🖥️

Importance: Critical for understanding the behavior and performance of microservices.
Tools: Prometheus, Grafana, ELK Stack (Elasticsearch, Logstash, Kibana), Zipkin (Distributed tracing).
Best Practices: Centralized logging, distributed tracing, metrics collection.

10. Security in Microservices 🔐

Techniques: OAuth2, JWT (JSON Web Tokens) for authentication and authorization.
Challenges: Securing inter-service communication, managing secrets.
Tools: Spring Security, Keycloak, Vault (HashiCorp).

11. Containerization & Orchestration 📦

Containers: Microservices are often deployed in containers for consistency across environments.
Tools: Docker, Podman.
Orchestration: Kubernetes for automating deployment, scaling, and operations of containers.

12. Continuous Integration/Continuous Deployment (CI/CD) 🚀

Importance: Automates the process of testing, building, and deploying microservices.
Tools: Jenkins, GitLab CI, CircleCI.
Best Practices: Automated testing, blue-green deployments, canary releases.

13. Event-Driven Microservices 🔔

Definition: Microservices that communicate through events, allowing loose coupling and scalability.
Tools: Kafka, RabbitMQ, AWS SNS/SQS.
Patterns: Event sourcing, CQRS.

14. Domain-Driven Design (DDD) in Microservices 📚

Definition: An approach to software development that focuses on modeling the business domain.
Concepts: Bounded Contexts, Aggregates, Entities, Value Objects.
Usage: Helps in defining service boundaries in a microservices architecture.

15. Testing Strategies 🧪

Types of Tests: Unit testing, integration testing, contract testing, end-to-end testing.
Tools: JUnit, TestNG, Postman, WireMock (for mocking services).
Best Practices: Automation, CI/CD integration, use of test doubles.

Final Tips

Understand the Basics: Know the core principles of microservices.
Hands-on Practice: Work with tools like Docker, Kubernetes, and Spring Boot.
Stay Updated: Microservices evolve quickly; keep up with the latest trends and best practices.

Good luck with your interview!

Connect with me:

LinkedIn: https://www.linkedin.com/in/nikko-ferwelo-358b11213
GitHub: https://github.com/NullVoidKage

🚀 Solving the Two Sum Problem: Multiple Approaches Using Java/Python

Nikko Ferwelo — Thu, 22 Aug 2024 13:24:29 +0000

The "Two Sum" problem is a popular coding challenge that tests your ability to find pairs in an array that sum up to a specific target. Let’s dive into various methods to solve this problem efficiently.

Problem Statement 🎯

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target. You may assume that each input would have exactly one solution, and you may not use the same element twice.

Example

Input: nums = [2, 7, 11, 15], target = 9

Output: [0, 1] (because nums[0] + nums[1] == 9)

1. Brute Force Approach ⚔️

Python:

def two_sum_bruteforce(nums, target):
    for i in range(len(nums)):
        for j in range(i + 1, len(nums)):
            if nums[i] + nums[j] == target:
                return [i, j]
    return []

Java:

public int[] twoSumBruteforce(int[] nums, int target) {
    for (int i = 0; i < nums.length; i++) {
        for (int j = i + 1; j < nums.length; j++) {
            if (nums[i] + nums[j] == target) {
                return new int[] { i, j };
            }
        }
    }
    return new int[] {}; // If no solution is found
}

Explanation:

Iterate over each pair of indices and check if their sum equals the target.

2. Hash Map Approach 📚

Python:

def two_sum_hash_map(nums, target):
    num_to_index = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in num_to_index:
            return [num_to_index[complement], i]
        num_to_index[num] = i
    return []

Java:

import java.util.HashMap;

public int[] twoSumHashMap(int[] nums, int target) {
    HashMap<Integer, Integer> numToIndex = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        int complement = target - nums[i];
        if (numToIndex.containsKey(complement)) {
            return new int[] { numToIndex.get(complement), i };
        }
        numToIndex.put(nums[i], i);
    }
    return new int[] {}; // If no solution is found
}

Explanation:

Use a hash map to store the index of each number.
For each element, check if its complement (target - current number) exists in the hash map.

3. Two-Pointer Approach 🏃‍♂️

Python:

def two_sum_two_pointer(nums, target):
    nums_with_index = list(enumerate(nums))
    nums_with_index.sort(key=lambda x: x[1])

    left, right = 0, len(nums) - 1
    while left < right:
        current_sum = nums_with_index[left][1] + nums_with_index[right][1]
        if current_sum == target:
            return [nums_with_index[left][0], nums_with_index[right][0]]
        elif current_sum < target:
            left += 1
        else:
            right -= 1
    return []

Java:

import java.util.Arrays;
import java.util.Comparator;

public int[] twoSumTwoPointer(int[] nums, int target) {
    int[][] numsWithIndex = new int[nums.length][2];
    for (int i = 0; i < nums.length; i++) {
        numsWithIndex[i][0] = i;
        numsWithIndex[i][1] = nums[i];
    }
    Arrays.sort(numsWithIndex, Comparator.comparingInt(a -> a[1]));

    int left = 0, right = nums.length - 1;
    while (left < right) {
        int currentSum = numsWithIndex[left][1] + numsWithIndex[right][1];
        if (currentSum == target) {
            return new int[] { numsWithIndex[left][0], numsWithIndex[right][0] };
        } else if (currentSum < target) {
            left++;
        } else {
            right--;
        }
    }
    return new int[] {}; // If no solution is found
}

Explanation:

First, sort the array while keeping track of the original indices.
Use two pointers to find the pair that sums up to the target.

4. Optimized Space Approach 🔍

Python:

def two_sum_optimized(nums, target):
    seen = {}
    for i, num in enumerate(nums):
        diff = target - num
        if diff in seen:
            return [seen[diff], i]
        seen[num] = i
    return []

Java:

import java.util.HashMap;

public int[] twoSumOptimized(int[] nums, int target) {
    HashMap<Integer, Integer> seen = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        int diff = target - nums[i];
        if (seen.containsKey(diff)) {
            return new int[] { seen.get(diff), i };
        }
        seen.put(nums[i], i);
    }
    return new int[] {}; // If no solution is found
}

Explanation:

Iterate through the array while maintaining a hash map of the numbers seen so far.
Check if the complement of the current number exists in the hash map.

Conclusion 🌟

These methods offer various ways to solve the Two Sum problem, each with its advantages and trade-offs. Whether you prefer the straightforward brute force method or the efficient hash map approach, understanding these techniques will enhance your problem-solving skills.

Feel free to share your thoughts or additional methods in the comments!

Connect with me:

LinkedIn: https://www.linkedin.com/in/nikko-ferwelo-358b11213
GitHub: https://github.com/NullVoidKage

Happy coding! 🚀

🗂️ Understanding SQL Relationships: A Beginner's Guide

Nikko Ferwelo — Thu, 22 Aug 2024 13:19:47 +0000

In the world of SQL, understanding relationships between tables is crucial for designing efficient databases. SQL relationships help us to organize and link data in meaningful ways. This post will cover the key types of SQL relationships with examples to help you grasp the basics.

1. One-to-One Relationship (1:1) 🔗

In a one-to-one relationship, each row in Table A is linked to a single row in Table B, and vice versa. This type of relationship is useful for dividing a table into two for organizational or security reasons.

Example:

Consider a database for an employee system. Each employee has one unique address.

Tables:

Employee:

  CREATE TABLE Employee (
      EmployeeID INT PRIMARY KEY,
      Name VARCHAR(100)
  );

Address:

  CREATE TABLE Address (
      AddressID INT PRIMARY KEY,
      EmployeeID INT UNIQUE,
      Street VARCHAR(100),
      City VARCHAR(50),
      FOREIGN KEY (EmployeeID) REFERENCES Employee(EmployeeID)
  );

In this case, EmployeeID in the Address table is a foreign key that uniquely identifies a record in the Employee table.

2. One-to-Many Relationship (1:N) 📈

A one-to-many relationship means that a single row in Table A can be associated with multiple rows in Table B, but each row in Table B is linked to only one row in Table A. This is the most common type of relationship.

Example:

Imagine a database for a library where each author can write multiple books.

Tables:

Author:

  CREATE TABLE Author (
      AuthorID INT PRIMARY KEY,
      Name VARCHAR(100)
  );

Book:

  CREATE TABLE Book (
      BookID INT PRIMARY KEY,
      Title VARCHAR(100),
      AuthorID INT,
      FOREIGN KEY (AuthorID) REFERENCES Author(AuthorID)
  );

In this example, AuthorID in the Book table is a foreign key that references the Author table. Each author can have multiple books, but each book is written by only one author.

3. Many-to-Many Relationship (M:N) 🔄

A many-to-many relationship occurs when multiple rows in Table A are associated with multiple rows in Table B. This relationship requires a junction table (or associative table) to manage the associations.

Example:

Consider a database for a student enrollment system where students can enroll in multiple courses, and each course can have multiple students.

Tables:

Student:

  CREATE TABLE Student (
      StudentID INT PRIMARY KEY,
      Name VARCHAR(100)
  );

Course:

  CREATE TABLE Course (
      CourseID INT PRIMARY KEY,
      Title VARCHAR(100)
  );

Enrollment (Junction Table):

  CREATE TABLE Enrollment (
      StudentID INT,
      CourseID INT,
      PRIMARY KEY (StudentID, CourseID),
      FOREIGN KEY (StudentID) REFERENCES Student(StudentID),
      FOREIGN KEY (CourseID) REFERENCES Course(CourseID)
  );

In this setup, the Enrollment table connects students and courses. Each student can enroll in multiple courses, and each course can have multiple students.

4. Self-Referencing Relationship 🔄

A self-referencing relationship occurs when a table has a foreign key that references its own primary key. This is useful for hierarchical data, such as organizational structures or categories.

Example:

Consider a table for an organizational hierarchy where each employee may have a manager.

Table:

Employee:

  CREATE TABLE Employee (
      EmployeeID INT PRIMARY KEY,
      Name VARCHAR(100),
      ManagerID INT,
      FOREIGN KEY (ManagerID) REFERENCES Employee(EmployeeID)
  );

In this example, ManagerID is a foreign key that references the EmployeeID in the same table, creating a hierarchy.

Conclusion 🌟

SQL relationships are fundamental to designing efficient and logical databases. Understanding these relationships allows you to create well-structured schemas and manage data effectively. If you have any questions or need further examples, feel free to reach out!

Connect with me:

LinkedIn: https://www.linkedin.com/in/nikko-ferwelo-358b11213
GitHub: https://github.com/NullVoidKage

Happy querying! 🖥️

🚀 WebClient vs RestTemplate vs FeignClient: A Comparative Guide

Nikko Ferwelo — Thu, 22 Aug 2024 13:14:00 +0000

When building web applications in Java, choosing the right HTTP client library is crucial for interacting with external services. In the Spring ecosystem, three popular options are RestTemplate, WebClient, and FeignClient. Each has its own strengths and ideal use cases. Let’s dive into their features, differences, and when to use each.

1. RestTemplate 🌟

Overview:
RestTemplate is a synchronous HTTP client that has been the standard in Spring for a long time. It’s simple to use and integrates well with Spring Boot.

Features:

Synchronous Calls: Makes blocking HTTP requests.
Simple API: Easy to use with straightforward methods for GET, POST, PUT, DELETE, etc.
Customizable: Allows for custom error handlers, interceptors, and message converters.

Example Usage:

import org.springframework.web.client.RestTemplate;

public class RestTemplateExample {
    private final RestTemplate restTemplate = new RestTemplate();

    public String getExample() {
        String url = "https://api.example.com/data";
        return restTemplate.getForObject(url, String.class);
    }
}

When to Use:

When working with legacy codebases.
For simple, blocking HTTP requests.
When synchronous behavior is acceptable.

2. WebClient 🌐

Overview:
WebClient is the non-blocking, reactive HTTP client introduced in Spring 5. It’s part of the Spring WebFlux module and is ideal for modern applications requiring high concurrency.

Features:

Asynchronous Calls: Supports non-blocking operations and reactive programming.
Rich API: Provides a more flexible and fluent API compared to RestTemplate.
Backpressure Support: Handles high loads and backpressure gracefully.

Example Usage:

import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

public class WebClientExample {
    private final WebClient webClient = WebClient.create("https://api.example.com");

    public Mono<String> getExample() {
        return webClient.get()
                        .uri("/data")
                        .retrieve()
                        .bodyToMono(String.class);
    }
}

When to Use:

For applications using reactive programming or WebFlux.
When you need non-blocking and asynchronous HTTP requests.
For high-performance applications with many concurrent requests.

3. FeignClient 🎯

Overview:
FeignClient is a declarative HTTP client that simplifies HTTP communication by creating interfaces that map to web services. It integrates seamlessly with Spring Cloud for microservices.

Features:

Declarative API: Define clients using Java interfaces and annotations.
Integrated with Spring Cloud: Works well with service discovery and load balancing.
Support for Load Balancing: Automatically integrates with Ribbon or other load balancers.

Example Usage:

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;

@FeignClient(name = "example-client", url = "https://api.example.com")
public interface ExampleClient {
    @GetMapping("/data")
    String getExample();
}

When to Use:

For microservices architectures where declarative clients are beneficial.
When you want to use Spring Cloud features like service discovery and load balancing.
For a clean and easy-to-maintain HTTP client interface.

Comparison Table

Feature	RestTemplate	WebClient	FeignClient
Synchronous/Asynchronous	Synchronous	Asynchronous	Synchronous
API Type	Imperative	Fluent & Reactive	Declarative
Reactive Support	No	Yes	No
Backpressure	No	Yes	No
Microservices Integration	Limited	Limited	Excellent
Ease of Use	Simple	Complex (for beginners)	Very simple

Choosing the Right Client

Use RestTemplate if you're maintaining legacy applications and do not require reactive features.
Use WebClient if you need a modern, non-blocking HTTP client with support for reactive programming.
Use FeignClient if you’re working within a Spring Cloud environment and prefer declarative client interfaces.

Each of these clients serves different needs, so consider your application’s requirements and architecture when making a choice.

Feel free to connect with me for more insights on HTTP clients or other programming topics!

Connect with me:

LinkedIn: https://www.linkedin.com/in/nikko-ferwelo-358b11213
GitHub: https://github.com/NullVoidKage

Forem: Nikko Ferwelo

I built an app using flutter that lets you save any bookmark on any app

📌 The Problem

🚀 Enter: Save It Later

✨ What Makes It Different

🎯 Save From Anywhere

📱 Actually Works Across Devices

🎨 Clean Reading Experience

🗂️ Smart Organization

📊 For the Data Nerds

🛠️ Built With Modern Tech

🎁 What I Learned (The Hard Way)

1. Offline-First is Harder Than You Think

2. Content Extraction is Tricky

3. Cross-Platform Sync is Complex

4. Widget Development is Different

📈 Current Status

🎯 Why You Should Try It

💡 What's Next?

🤝 I Want Your Feedback

🚀 Try It Out

Tags

flutter #mobile #android #ios #appdevelopment #productivity #bookmarks #reading #opensource #flutterdev #materialdesign #firebase

Must-Have Apps of 2024

Apps2024 #Technology #MustHaveApps #Productivity

🎉 After a Year of Hard Work, My Birthday App is Here! But I Need Your Support 😢

The Journey

Challenges Faced

Features of Birthday Date Calculator

The Challenge

How You Can Help

Conclusion

Stop Using Traditional Loops in Java: Use Streams and `forEach` 🚀

The Traditional Loop 🌀

Why I Moved Away from Traditional Loops 💡

1. Readability Matters 📖

2. The Power of forEach ⚡

3. Functional Programming Awesomeness ✨

4. Going Parallel Made Easy 🌍

5. Reducing Common Loop Errors ❌

When Traditional Loops Still Make Sense 🤔

Conclusion 🎉

🚀 Understanding the Differences: DTO, DAO, and POJO in Java

🔗 What is a POJO?

Use Case:

Pros:

Cons:

Example:

🔗 What is a DTO?

Use Case:

Pros:

Cons:

Example:

🔗 What is a DAO?

Use Case:

Pros:

Cons:

Example:

🚧 Key Differences Between DTO, DAO, and POJO

🧩 When to Choose POJO

🧩 When to Choose DTO

🧩 When to Choose DAO

🚀 Practical Applications

🧠 Conclusion

🚀 Flutter vs React Native: Which One Should You Choose?

🚀 Understanding the Difference Between `filter` and `map` in Java Stream API

🔗 What is filter in Java Stream API?

Syntax:

Example:

🔗 What is map in Java Stream API?

Syntax:

Example:

🚧 Key Differences Between filter and map

🧩 Combining filter and map

Example:

🚀 Practical Applications

🧠 Conclusion

Connect with me:

🚀Java Stream API Cheat Sheet for Developers

🔗 Core Concepts

2. The Power of `forEach` ⚡

🔗 What is `filter` in Java Stream API?

🔗 What is `map` in Java Stream API?

🚧 Key Differences Between `filter` and `map`

🧩 Combining `filter` and `map`