DevLog ⚡

A personal code snippet archive and developer journal, built as a desktop application.

DevLog is a lightweight, offline-first desktop tool that gives developers a single place to store reusable code snippets and keep a running development journal — all with local persistence, syntax-highlighted code viewing, and a clean, VS Code–inspired dark UI.

Note: The application's source code, UI text, and console output are written in Turkish — this was an intentional choice by the team. Only this description is in English.

Team

This project was built by a team of three:

Name
Myrza Kalybek
Mehmet Sami Soydan
Rahkat Turdybek

Overview

Developers constantly rewrite the same boilerplate, forget where they saved a useful snippet, or lose track of what they worked on and why. DevLog solves this with two connected workspaces in one app:

• Kod Arşivi (Code Archive) — a searchable library of code snippets, each tagged with a title, programming language, and custom tags, viewed with full syntax highlighting.
• Günlük (Dev Log) — a personal development journal for recording daily notes, decisions, and progress, with the ability to link entries directly to saved snippets.

All data is stored locally in a SQLite database, so the app works fully offline with no account or internet connection required.

Features

• Create, edit, and delete code snippets with language and tag metadata
• Live syntax highlighting in an embedded web view (highlight.js, Atom One Dark theme)
• Toggle between read mode and edit mode for both snippets and log entries
• Full-text search across snippets and log entries
• Link snippets directly inside journal entries for quick cross-referencing
• One-click copy-to-clipboard for snippet content
• Export all data to a portable, human-readable JSON backup file
• Persistent local storage via an embedded SQLite database — no server, no setup
• Polished, dark-themed desktop UI inspired by VS Code

Tech Stack

Layer	Technology
UI	JavaFX 21 (FXML + CSS)
Code rendering	Embedded WebView + highlight.js
Language	Java
Persistence	SQLite (via sqlite-jdbc)
Data interchange	Gson (JSON export/import)
Packaging	jpackage — portable, self-contained Windows executable with a bundled Java runtime (no separate JDK install required)

Architecture

DevLog follows a strict layered architecture, enforced as a one-way dependency chain:

UI Layer  →  Service / Repository Layer  →  Model Layer

• UI Layer — FXML files define the layouts; MainController and AddSnippetController handle user interaction, validate input, and delegate to the service/repository layer. Long-running work is kept off the UI thread using background threads and Platform.runLater so the interface never freezes.
• Service Layer — JsonService handles exporting/importing data between the SQLite database and a portable JSON backup file.
• Repository Layer — DatabaseHelper, SnippetRepository, and LogRepository handle all SQLite CRUD operations and transaction management.
• Model Layer — Entry is the shared base class (id, title, content, timestamp), extended by Log and Snippet (which adds language and tags). Models are intentionally passive — they hold data only and contain no database or business logic.

This separation keeps each layer independently testable and replaceable — for example, the storage backend or export format could be swapped without touching the UI code.

The project also ships MimariRapor.java ("Architecture Report"), a standalone console tool the team wrote to self-document this same layered structure — running it prints a plain-text breakdown of each layer plus Mermaid diagrams for the architecture and a typical save-snippet sequence flow.

Data flow example (saving a new snippet)

User fills in snippet form and clicks "Save"
  → UI builds a new Snippet object
  → Repository issues an INSERT into SQLite
  → Database confirms the write (commit)
  → UI confirms success to the user

Database Schema

CREATE TABLE IF NOT EXISTS snippets (
    id TEXT PRIMARY KEY,
    title TEXT NOT NULL,
    content TEXT,
    language TEXT,
    tags TEXT,
    created_at TEXT
);

CREATE TABLE IF NOT EXISTS logs (
    id TEXT PRIMARY KEY,
    title TEXT NOT NULL,
    content TEXT,
    created_at TEXT
);

Project Structure

devlog/
├── pom.xml
├── src/main/java/com/TK/devlog/
│   ├── Launcher.java              # Non-JavaFX entry point required by jpackage
│   ├── Main.java                  # JavaFX Application — boots the DB, loads the main window
│   ├── MimariRapor.java           # Standalone console tool documenting the layered architecture
│   ├── controller/
│   │   ├── MainController.java    # Main window logic (both tabs)
│   │   └── AddSnippetController.java
│   ├── model/
│   │   ├── Entry.java              # Base entity (id, title, content, date)
│   │   ├── Log.java                 # Journal entry
│   │   └── Snippet.java             # Code snippet (language, tags)
│   ├── repository/
│   │   ├── DatabaseHelper.java     # SQLite connection & schema setup
│   │   ├── SnippetRepository.java  # Snippet CRUD
│   │   └── LogRepository.java      # Log CRUD
│   └── service/
│       ├── JsonService.java            # JSON export/import
│       └── LocalDateTimeAdapter.java   # Gson date (de)serialization
└── src/main/resources/
    ├── fxml/    # UI layouts (main window, add-snippet dialog, add-log dialog)
    ├── css/     # Dark theme stylesheet
    └── web/     # highlight.js + template for syntax-highlighted code rendering

Getting Started

Run from source (recommended)

Requires JDK 21 and Maven.

git clone <this-repo-url>
cd devlog
mvn javafx:run

A local database.db SQLite file is created automatically in the working directory on first launch.

Run the prebuilt Windows app

A portable, self-contained Windows build (bundled JVM, no install needed) is also available as DevLog_Portable.zip — unzip it and run DevLog.exe.

Future Improvements

• Cross-platform packaging (macOS / Linux)
• Cloud sync / multi-device support
• Import from the JSON backup format
• Additional syntax themes and customizable UI colors

---

Built as a group project to explore layered application architecture, local data persistence, and desktop UI development with JavaFX.