DEV Community: Samuel S

Create your own genAI apps fast using PartyRock

Samuel S — Fri, 23 May 2025 08:31:48 +0000

Hello everyone! Today I want to talk about Generative AI (GenAI). The development of GenAI is growing rapidly and becoming more mature. We’re all familiar with prompting-based GenAI apps like ChatGPT by OpenAI and Gemini by Google.

But…
Have you ever thought about creating a GenAI-based app that's simple, fast, and easy to build—without worrying about backend code, AI models, or heavy cloud costs?

Well, PartyRock by AWS might be just the solution you're looking for!

What is PartyRock?

PartyRock is an AI app builder from Amazon Web Services (AWS) that allows anyone—even those with no coding background—to create AI-powered applications in just minutes.

You simply drag and drop components, add your prompts, and... voilà! You’ve built an app that can generate text, answer questions, or even write poems.

Why is PartyRock Exciting?

No Coding Needed Perfect for everyone—whether you're a developer or just GenAI-curious.
Prompt-Based
You design how your app works with text-based instructions—just like using ChatGPT, but in a more interactive format.
Fast to Build, Easy to Share Once your app is ready, it’s instantly accessible via a web link. Share it with anyone, anytime.
Powered by AWS Bedrock Under the hood, PartyRock leverages advanced GenAI models like Claude, Titan, or Meta’s LLaMa via AWS Bedrock—so it's powerful and responsive.

Examples of Apps You Can Build

A Simple AI Translator
Instagram Caption Generator
Resume Assistant
YouTube Content Idea Generator
Product Review Sentiment Analyzer

All of this can be built just by entering prompts and designing the UI. No server deployments, no API key headaches—not even JSON required!

Can It Be Integrated into Other Apps?

Absolutely.
If you're an Android developer, you can embed your PartyRock app in a WebView.
If you need an API version, you can prototype your idea with PartyRock and later build a more advanced version using AWS Bedrock APIs.

Sounds fun? ready to try?

Try it for yourself at here

Fake news detection with Keras and Python

Samuel S — Fri, 23 May 2025 07:56:55 +0000

In the digital age, where information spreads faster than ever, fake news has become a real threat. Whether it's misleading headlines or entirely fabricated stories, false information can influence public opinion, sway elections, or even endanger lives. To combat this, I built a sample of machine learning-based fake news detection model using TensorFlow and Natural Language Processing (NLP).

Overview

This project demonstrates a practical implementation of Fake News Detection using TensorFlow, leveraging Natural Language Processing (NLP) techniques and deep learning. The model is trained to classify whether a given news article is real or fake, which is a crucial task in today's information-driven society.

Technologies Used

TensorFlow 2.x – for building and training the neural network
Keras – high-level API for defining the model
Natural Language Processing (NLP) – tokenization, stopword removal, vectorization
Scikit-learn – for preprocessing, splitting datasets, and evaluating model accuracy
Pandas & NumPy – for data manipulation
Matplotlib – for result visualization

Features

Binary classification: Fake (1) vs. Real (0)
Dataset preprocessing: stopwords, stemming, tokenization
Deep learning model using LSTM layers
Training and validation performance tracking
Organized Jupyter notebook for easy understanding
Model evaluation with confusion matrix, accuracy, and loss visualization

Dataset

The model uses a labeled dataset of news articles consisting of:

Title and Text
Label: 1 for fake news, 0 for real news

You can easily swap in another dataset or extend it with more complex sources for multilingual or multi-category classification.

Model Performance

The model achieves good accuracy in distinguishing real and fake news articles after training with appropriate preprocessing and regularization. Detailed metrics and visual plots are available in the notebook for transparency and fine-tuning.

This is sample code for detect_fake_news.py

import pandas as pd
import tensorflow as tf
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from sklearn.model_selection import train_test_split
import json
import os

MAX_LENGTH = 500
VOCAB_SIZE = 10000
USER_DATA_PATH = "user_training_data.csv"
FAKE_CSV_PATH = "data/Fake.csv"

def train_model(extra_texts=[], extra_labels=[]):
    # Load base datasets
    df_fake = pd.read_csv(FAKE_CSV_PATH)
    df_fake['label'] = 0

    df_true = pd.read_csv("data/True.csv")
    df_true['label'] = 1

    df = pd.concat([df_fake[['text', 'label']], df_true[['text', 'label']]])

    # Load and include user data if available
    if os.path.exists(USER_DATA_PATH):
        user_df = pd.read_csv(USER_DATA_PATH)
        df = pd.concat([df, user_df], ignore_index=True)

    # Append new user data if provided
    if extra_texts and extra_labels:
        new_data = pd.DataFrame({"text": extra_texts, "label": extra_labels})
        df = pd.concat([df, new_data], ignore_index=True)

        # Append new data to Fake.csv if it is labeled as fake news
        fake_data = new_data[new_data['label'] == 0]  # Only append if label is fake
        if not fake_data.empty:
            fake_data.to_csv(FAKE_CSV_PATH, mode='a', header=False, index=False)

        # Save new data to user_training_data.csv
        new_data.to_csv(USER_DATA_PATH, mode='a', header=not os.path.exists(USER_DATA_PATH), index=False)

    df.dropna(inplace=True)

    # Tokenize and train model
    tokenizer = Tokenizer(num_words=VOCAB_SIZE, oov_token="<OOV>")
    tokenizer.fit_on_texts(df['text'])
    sequences = tokenizer.texts_to_sequences(df['text'])
    padded = pad_sequences(sequences, maxlen=MAX_LENGTH, padding='post', truncating='post')
    X_train, X_test, y_train, y_test = train_test_split(padded, df['label'], test_size=0.2, random_state=42)

    model = tf.keras.Sequential([
        tf.keras.layers.Embedding(VOCAB_SIZE, 16, input_length=MAX_LENGTH),
        tf.keras.layers.GlobalAveragePooling1D(),
        tf.keras.layers.Dense(24, activation='relu'),
        tf.keras.layers.Dense(1, activation='sigmoid')
    ])

    model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
    model.fit(X_train, y_train, epochs=5, validation_data=(X_test, y_test))

    model.save('fake_or_true_news_model.keras')
    with open("tokenizer.json", "w") as f:
        f.write(tokenizer.to_json())

    print("✅ Model trained and saved successfully.")

Full Sample Code

ReactJS Datatable

Samuel S — Wed, 23 Apr 2025 13:18:48 +0000

In web applications—especially reporting or monitoring applications—we often need to display a large amount of data from an API. To make data loading faster, we typically design our APIs to support pagination.

In classic JavaScript _frameworks like _jQuery, we are familiar with using DataTables to display paginated data tables. But how do we use DataTables in ReactJS?

First, we create react application by executing in our terminal/CMD

npm create-react-app react-demo-datatable

Then in our terminal/CMD we have to install datatable package.

npm install react-data-table-component

Don't forget to install lodash.debounce package for our search data table. lodash.debounce is a utility function from the Lodash library that delays a function’s execution until after a specified amount of time has passed since it was last called. i will prevent Too many API calls (e.g. every user type) to Maximalize performance issue.

npm install lodash.debounce

Then let's adjust our App.js to look like this:

import React, { useState, useEffect } from "react";
import DataTable from "react-data-table-component";
import debounce from "lodash.debounce";

// Dummy local dataset
const localData = [
  {
    NO_RESI: "PLMAA16157522113",
    RECEIVER_NAME: "John Doe",
    RECEIVER_DIVISION: "IT",
    CREATED_DATE: "2025-04-11",
    STATUS_NAME: "Complete",
    STATUS: "002",
  },
  {
    NO_RESI: "PLMAA16157522112",
    RECEIVER_NAME: "Jane Doe",
    RECEIVER_DIVISION: "Finance",
    CREATED_DATE: "2025-04-10",
    STATUS_NAME: "On Progress",
    STATUS: "001",
  },
  // Add more dummy items here
];

const statusOptions = [
  { key: "001", status: "On Progress" },
  { key: "002", status: "Complete" },
];

const columns = [
  { name: "No Resi", selector: (row) => row.NO_RESI, sortable: true },
  { name: "Receiver", selector: (row) => row.RECEIVER_NAME, sortable: true },
  { name: "Receiver Division", selector: (row) => row.RECEIVER_DIVISION, sortable: true },
  { name: "Created Date", selector: (row) => row.CREATED_DATE, sortable: true },
  { name: "Status", selector: (row) => row.STATUS_NAME, sortable: true },
  {
    name: "Action",
    cell: (row) => (
      <button className="bg-blue-500 text-black px-3 py-1 rounded hover:bg-blue-600">
        Detail
      </button>
    ),
  },
];

const customStyles = {
  headCells: {
    style: {
      backgroundColor: "#919492",
      color: "#333",
      fontWeight: "bold",
      fontSize: "14px",
    },
  },
};

export default function App() {
  const [data, setData] = useState([]);
  const [search, setSearch] = useState("");
  const [statusFilter, setStatusFilter] = useState("");
  const [loading, setLoading] = useState(false);

  const [totalRows, setTotalRows] = useState(0);
  const [perPage, setPerPage] = useState(10);
  const [currentPage, setCurrentPage] = useState(1);

  const filterLocalData = (page, size, searchText, statusKey) => {
    setLoading(true);

    let filtered = [...localData];

    if (searchText) {
      filtered = filtered.filter(
        (item) =>
          item.NO_RESI.toLowerCase().includes(searchText.toLowerCase()) ||
          item.RECEIVER_NAME.toLowerCase().includes(searchText.toLowerCase())
      );
    }

    if (statusKey) {
      filtered = filtered.filter((item) => item.STATUS === statusKey);
    }

    const start = (page - 1) * size;
    const paginated = filtered.slice(start, start + size);

    setData(paginated);
    setTotalRows(filtered.length);
    setLoading(false);
  };

  useEffect(() => {
    filterLocalData(currentPage, perPage, search, statusFilter);
  }, [search, statusFilter, perPage, currentPage]);

  const handlePageChange = (page) => {
    setCurrentPage(page);
  };

  const handlePerRowsChange = (newPerPage, page) => {
    setPerPage(newPerPage);
    setCurrentPage(page);
  };

  const debouncedSearch = debounce((val) => {
    setSearch(val);
  }, 500);

  return (
    <div className="w-full p-4">
      <div className="flex justify-between items-center mb-4 gap-4">
        <select
          className="p-2 border rounded"
          value={statusFilter}
          onChange={(e) => setStatusFilter(e.target.value)}
        >
          <option value="">All Status</option>
          {statusOptions.map((opt) => (
            <option key={opt.key} value={opt.key}>
              {opt.status}
            </option>
          ))}
        </select>

        <input
          type="text"
          placeholder="Search..."
          className="p-2 border rounded w-full max-w-md"
          onChange={(e) => debouncedSearch(e.target.value)}
        />
      </div>

      <DataTable
        columns={columns}
        data={data}
        progressPending={loading}
        pagination
        paginationServer
        paginationTotalRows={totalRows}
        onChangePage={handlePageChange}
        onChangeRowsPerPage={handlePerRowsChange}
        customStyles={customStyles}
      />
    </div>
  );
}

Our react project will look like this:

Code Rabbit - AI Code Reviewer for Git

Samuel S — Tue, 25 Mar 2025 13:58:32 +0000

Nowadays, AI really helps our work, especially in the world of software engineering. Did you know that there are AI-based tools that can help us review our code in GIT? yes, it is CodeRabbit.

If you want to try, you can visit:
https://www.coderabbit.ai/

First, you must sign up to create account.

I recommend you to sign up by your git account.

This is sign up dashboard. Then, we click Add Repositories

Choose where you want to choose to install. I will install at my **samseptiano **account

At bottom of page, select repos you want to integrate. you can choose to integrate all repos, or selected repos.

Then, I try to make a pull request from one branch to master.
Wait for minutes, soon Code Rabbit AI will give you some reviews about your pull request.

So easy to integrate, isn't it? please let me know if this tools ease you! :)

Koin Vs Hilt

Samuel S — Sun, 16 Mar 2025 06:14:45 +0000

In object-oriented programming (OOP), especially in Android Development, to make our program code cleaner and maintainable, one of the principles we are used to apply is SOLID. one of the points in the SOLID principle is Dependency Inversion.

One should depend upon abstractions, not concretions.

Inversion of Control (IoC) is a design pattern used to represent Dependency Inversion in real software.

That makes Dependency Injection popular.

What is Dependency Injection?

Dependency injection (DI) is a software engineering technique that involves making the interactions between objects as thin as possible through specific dependencies. This allows for loosely coupled code — or code that only depends on the required portion of a separate class — to run. And it reduces hard-coded dependencies and allows for cleaner, more flexible code.

some of most popular Dependency Injection frameworks are Koin and Hilt.

Then what's different?

Let’s start by talking about Koin first.

Koin stands out for its simplicity and flexibility. It is a simple DI framework that does not require annotations or code generation. Instead, it makes use of the Domain Specific Language (DSL) provided by Kotlin to specify dependencies and modules.

Koin’s ease of use is one of its benefits. Its minimum setup requirements and its ability to create dependencies with a clear, readable syntax are the aspects that make it stand out. Therefore, Koin is easy for developers who are new to DI.

On the other hand, this features of Koin might come with trade-offs in certain scenarios. Its runtime resolution might lead to potential issues during compile-time if dependencies are not properly configured. Additionally, Koin might not offer the same level of performance optimizations that some other DI frameworks, like Hilt, provide.

How to use Koin?

First, add dependencies to our project’s build.gradle file,

dependencies {
    // Koin core features
    implementation 'org.koin:koin-core:3.2.0'

    // Koin Android features
    implementation 'org.koin:koin-android:3.2.0'
    implementation 'org.koin:koin-androidx-viewmodel:3.2.0'
}

Then, create Koin modules,

import org.koin.dsl.module

val myKoinModule = module {
    single { UserRepository() } 
    factory { UserViewModel(get()) }
    // Define other dependencies...
}

single: create an object that persistent with the entire container lifetime. It does not create a new instance with each call.
factory: create a new object each time. Short live. No persistence in the container

Then in Application class, initialize Koin by loading the modules,

class MyKoinApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        startKoin {
            androidContext(this@MyKoinApplication )
            modules(myKoinModule )
        }
    }
}

This is how we call at Activity

class HomeActivity : AppCompatActivity() {
    private val viewModel by viewModel<UserViewModel>()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // Use viewModel or other dependencies...
    }
}

how about Hilt?

Hilt, developed by Google and built on top of Dagger, is a powerful dependency injection (DI) framework tailored for Android. It simplifies DI by leveraging annotations and compile-time checks to ensure correctness and performance. Additionally, it integrates seamlessly with Jetpack libraries like ViewModel and WorkManager, making it easier to manage dependencies across different Android components.

One of Hilt’s biggest advantages is its strong alignment with the Android development ecosystem, making it a preferred choice for larger projects following architectural patterns like MVVM or Clean Architecture. However, its learning curve can be steep due to its reliance on Dagger and the specific annotations required. Compared to Koin, Hilt may also involve a more complex setup, but it offers better compile-time safety and performance benefits.

How to use Hilt

Add Hilt dependency at our project’s build.gradle file,

dependencies {
    // Other dependencies...
    implementation "com.google.dagger:hilt-android:$hilt_version"
    kapt "com.google.dagger:hilt-compiler:$hilt_version"
    implementation "androidx.hilt:hilt-lifecycle-viewmodel:$hilt_lifecycle_version"
    kapt "androidx.hilt:hilt-compiler:$hilt_lifecycle_version"
}

Enable Hilt to our Application

@HiltAndroidApp
class MyHiltApplication : Application()

Creating Hilt modules

@Module
@InstallIn(ApplicationComponent::class)
object MyModule {
    @Provides
    fun provideMyRepository(): MyRepository {
        return MyRepository()
    }

    @Provides
    fun provideMyViewModel(repository: MyRepository): MyViewModel {
        return MyViewModel(repository)
    }
}

Using dependencies in Activity/Fragment,

@AndroidEntryPoint
class MyActivity : AppCompatActivity() {
    private val viewModel: MyViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
    }
}

There is 3 different characteristics between Koin and Hilt:

Syntax and Configuration: Koin offers a simple and readable syntax without relying on annotations or code generation, while Hilt heavily depends on annotations like @Inject and @Module for dependency injection.

Learning Curve and Complexity: Koin is beginner-friendly with minimal setup, making it easier to adopt. In contrast, Hilt has a steeper learning curve due to its integration with Dagger and required annotations.

Performance and Optimization: Koin has faster build times and a smaller APK size since it doesn’t generate code, but it is slightly slower at runtime due to resolving dependencies dynamically. Hilt, using code generation, ensures better runtime performance but can lead to longer build times and a larger APK.

So when to use Koin and Hilt?

_Koin _is ideal for smaller projects due to its simplicity and flexibility, making code more modular and maintainable. However, for larger projects requiring deep integration with Android components, _Hilt _is preferable for its performance optimizations and alignment with Android architecture.

references:
https://medium.com/ibtech/hilt-vs-koin-f3532b5796eb
https://en.wikipedia.org/wiki/Dependency_injection
https://simple.wikipedia.org/wiki/SOLID(object-oriented_design)_
https://medium.com/@srimanikandan92/hilt-vs-koin-a-simple-guide-to-android-dependency-injection-ef77d00e7cf6

Getting started to Flutter Provider

Samuel S — Mon, 03 Apr 2023 05:04:28 +0000

What is Provider?

Provider is one of the many state management options when using Flutter. It’s one of the first state manager recommended by Flutter itself and one of the simplest. If you’re new to state management check out the official pages that describes the different state managers and how/when you should use it https://flutter.dev/docs/development/data-and-backend/state-mgmt/options.

What Provider can do?

Provider can be used with InheritedWidgetsand StatefulWidgets, or again, in place of them. It "does" two jobs:

Separates your state from your UI
Manages rebuilding UI based on state changes

Providers allow to not only expose a value, but also create/listen/dispose it. source

Dependencies

dependencies:
  flutter:
    sdk: flutter
  cupertino_icons: ^1.0.2
  provider: ^6.0.5

Let's Start Write our codes

1. Create Our Provider
create a file called notes_operation.dart, and add this code

class NotesOperation with ChangeNotifier {
  //List of notes
  List<Note> _notes = [];

  List<Note> get getNotes {
    return _notes;
  }

  NotesOperation() {
    //addNewNote('First Note', 'First Note Description');
  }

  void addNewNote(String title, String description) {
    //Note object
    Note note = Note(title, description);
    _notes.add(note);
    notifyListeners();
  }
}

It extends ChangeNotifier, a class that “provides change notification to its listeners”. So you can listen to an instance of a ChangeNotifierand being notified when it changes.
It exposes the list of notes value which start with empty list.
We will use the addNewNotefunction to add note.
When the note added to list, changes the class will notify its listener using notifyListeners().

Now we will need to add the Provider widget in our widget tree, in our case all the children of the homeScreen should display list of notes, so we sill need to wrap the HomeScreen widget in a Provider widget (in particular a ChangeNotifierProvider because we're using a ChangeNotifier). ChangeNotifierProvider needs a create parameter, it's the function that will be called to create our NoteOperation.

class HomeScreen extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      backgroundColor: Colors.blueGrey,
      floatingActionButton: FloatingActionButton(
        onPressed: () {
          Navigator.push(
            context,
            MaterialPageRoute(
              builder: (context) => AddScreen(),
            ),
          );
        },
        child: Icon(Icons.add, size: 30, color: Colors.blueGrey),
        backgroundColor: Colors.white,
      ),
      appBar: AppBar(
        title: Text(
          'Task Manager',
          style: TextStyle(
            fontSize: 25,
            fontWeight: FontWeight.bold,
          ),
        ),
        centerTitle: true,
        elevation: 0,
        backgroundColor: Colors.transparent,
      ),
      body: Consumer<NotesOperation>(
        builder: (context, NotesOperation data, child) {
          return ListView.builder(
            itemCount: data.getNotes.length,
            itemBuilder: (context, index) {
              return NotesCard(data.getNotes[index]);
            },
          );
        },
      ),
    );
  }
}

class NotesCard extends StatelessWidget {
  final Note note;

  NotesCard(this.note);

  @override
  Widget build(BuildContext context) {
    return Container(
      margin: EdgeInsets.all(15),
      padding: EdgeInsets.all(15),
      height: 150,
      decoration: BoxDecoration(
        color: Colors.white,
        borderRadius: BorderRadius.circular(15),
      ),
      child: Column(
        crossAxisAlignment: CrossAxisAlignment.start,
        children: [
          Text(
            note.title,
            style: TextStyle(fontSize: 20, fontWeight: FontWeight.bold),
          ),
          SizedBox(height: 5),
          Text(
            note.description,
            style: TextStyle(fontSize: 17),
          ),
        ],
      ),
    );
  }
}

Now we can display list of notes of out NotesOperation, to do so we need to use a Consumer widget.

The Consumer widget has a builder function that is called whenever the Provider needs to (basically when notifyListenersis called). The builder function has 3 parameters:

context: the context of this build
NotesOperation: our NotesOperation declared above. If the provider package doesn't find a parent with the correct Provider type it will throw an Exception.
child: you can optionally pass a child widget to the Consumer, that will be passed to the builder function in this parameter. This is here for optimization, if you have a big widget that doesn’t need the value exposed by the provider you can pass it as child and use it in the builder function.

Here’s an example of a text that display list of notes of our NotesOperation .

Consumer<NotesOperation>(
        builder: (context, NotesOperation data, child) {
          return ListView.builder(
            itemCount: data.getNotes.length,
            itemBuilder: (context, index) {
              return NotesCard(data.getNotes[index]);
            },
          );
        },
      )

Why don’t you just call setState?

The obvious question that could come to your mind is “Why don’t you just use a StatefulWidget with setState?”. Here are some of the reasons:

One of the main reasons to prefer Providerover Statefulwidgetsis that, using Provider, you will rebuild only the widgets that needs that value (the Consumers) while the other will not be rebuilt. Instead when you call setState the whole build function of the widget will be called.
You can use the values exposed by providers in other widgets without passing them. In our case, if you need to push a new Scaffold you can still use the mainColor with the Consumer because it will be a child of the Provider
You can have different Providers, that do different things using a MultiProvider
The allocation and disposal of objects is managed by the package and the objects are created lazily when they are needed.

full example: github