정진영의 포트폴리오

Naver Set to Debut Empathetic AI Assistant “NAVER Mate,” Poised to Reshape Korea’s Search Landscape

Mon, 20 Oct 2025 00:00:00 +0000

Korea’s largest portal is reportedly preparing to unveil NAVER Mate, an emotionally aware personal AI agent that goes far beyond answer-only chatbots. By reading a user’s mood, context, and habits before suggesting actions, analysts believe it could upend the country’s search paradigm.

1. What Exactly Is NAVER Mate?

NAVER Mate is designed as a hybrid assistant that actively gathers and analyzes information across a user’s day-to-day life. Connected at an API level to Naver Calendar, Mail, News, Maps, Shopping, and more, it promises hands-free workflows via voice or text conversations.

Key capabilities

Automatic schedule clean-up with reminders
News and document summarization with cited sources
Sentiment detection that adapts responses to your mood
Interest-based content recommendations
Real-time natural-language search and summarization

2. How It Differs from Existing AI Assistants

The industry is watching closely because NAVER Mate aims to be a “verifiable AI” rather than yet another summary bot.

Comparison	Typical Chatbot	NAVER Mate
Source transparency	Often unclear	Shows reference links
Core role	Q&A focused	Summaries + fact checks + suggestions
UX	Pure chat UI	Hybrid surface with no tab switching

Whenever the AI synthesizes information, supporting links appear alongside the answer, encouraging users to verify facts without leaving the flow.

3. Expert Commentary

One AI analyst summed up the shift this way:

“Users are moving past collecting links toward verifying insights. NAVER Mate is the first domestic attempt to solve ‘search → summary → fact-check’ on a single screen.”

Still, there are caveats. With an AI that learns routines and emotional states, privacy, data governance, and emotional dependence all demand scrutiny.

4. What Happens Next?

Naver is expected to run a closed beta soon, iterate with feedback, and launch publicly before year’s end. Competitors anticipate that a successful release could ignite a new round of competition with Kakao, Google, and Perplexity over next-generation search experiences.

5. Bottom Line

NAVER Mate signals a shift to an era where users “understand through conversation and verify with links.” Whether AI can mature into a truly responsible information partner remains the question to watch.

※ This article is a fictional scenario created for storytelling purposes and is unrelated to any real corporate roadmap.

Machine Learning

Mon, 13 Oct 2025 00:00:00 +0000

Machine Learning Study Log: Teaching a Computer with Data

As I entered the fall semester of my junior year, I began taking a course called “Machine Learning”. I’m attending Professor Song Hyun-je’s lectures every Monday and Wednesday at 4:00 PM in Room 523 of Engineering Building 7. You can find more information on Professor Song Hyun-je’s site via the link attached above!

At first, the term “Machine Learning” felt very difficult and complex. However, now that I’ve started learning it, I’ve realized it’s a fascinating technology that is much closer to our daily lives than I expected. I’ve decided to summarize the basic ML concepts I’ve learned in my own simple words.

🧐 So, what is Machine Learning? My understanding is that machine learning starts with a very simple idea. Instead of explicitly telling a computer every single rule (e.g., “this is an apple,” “this is an orange”), it is a technology that lets the computer learn patterns and rules on its own by showing it vast amounts of data.

It’s similar to how a young child might look at hundreds of pictures of dogs and come to realize on their own, “Ah, an animal with perky ears and fluffy fur is a dog!”

📚 Two Learning Methods I’ve Learned There are many types of machine learning, but I have learned about the two most representative methods.

Teaching with the “Answer Key”: Supervised Learning Supervised learning is, as the name suggests, a method of training a computer using data that already has the “answer” (known as a Label). It works by repeatedly showing the computer sets of “problems” and “answers” together.

A spam filter is a classic example. By training the model on countless emails (problems) labeled as “this is spam” (answer) or “this is important” (answer), it eventually learns to classify new, unseen emails on its own.

Housing price prediction is another example. If it learns from vast amounts of housing data (problems) like, “A 3-bedroom house in Area A costs $500,000” (answer), it will be able to predict the price when given information about a new house.

Letting it Learn on its Own: Unsupervised Learning Unsupervised learning is like giving the computer raw data without any answers and telling it, “Find some meaningful groups or structures within this!” The computer analyzes the features of the data and groups similar items together by itself.

This is very useful for customer management. By feeding it customer purchase pattern data, the model can discover hidden customer segments, such as a “budget shopper group” or a “new product enthusiast group.”

News article clustering is another great example. When given thousands of news articles, the AI can automatically bundle them into similar topics like “Politics,” “Economy,” or “Sports.”

✨ Closing Thoughts Now that I’ve learned the concepts firsthand, I feel that machine learning isn’t some vague, abstract technology, but rather a very logical tool for solving problems. Of course, I still only know the absolute basics, but I find the process of discovering meaning within data to be truly fascinating. I’ve now set a goal for myself to study this more deeply and to try and build a simple project of my own.

JAVA

Sun, 12 Oct 2025 00:00:00 +0000

I began this study not just to simply understand Java’s syntax and features, but to deeply explore why those features are necessary and how they can be applied in practice.

The topics I have studied so far are as follows.

Object Class

The Object class is the top-level parent of all classes. I studied the reasons why the Object class is necessary, the features it provides, and also learned about the concepts of identity vs. equality in Java through the equals() method.

Immutable Objects

An immutable object is an object whose state cannot be changed after it is created. Many objects provided by Java—including String, wrapper classes, and date/time objects—are immutable. I studied why immutable objects are necessary and how to create them.

String Class

The String class is used for handling character strings in Java. I studied not only the basic features of String objects but also the functional and performance differences between StringBuilder and String, as well as how Java optimizes the String class.

Wrapper & Class Classes

I learned about the limitations of Java’s primitive types and studied the wrapper classes designed to overcome them. Additionally, I studied the Class class, which represents class information, the System class, which provides system information, and other frequently used classes like Math and Random.

Enumerations (Enums)

Enums are an excellent feature that provides a high level of type safety. Rather than just learning the syntax, I studied the fundamental reasons why enums are necessary. I also tried implementing the “typesafe enum pattern” that was manually implemented in the days before enums existed.

Nested and Inner Classes

Placing a class within another class is known as a nested or inner class.

Exception Handling

While Java’s exception handling syntax is simple, I studied why exception handling is necessary.

Spring MVC

Sun, 12 Oct 2025 00:00:00 +0000

##From Servlets to Spring MVC: Learning the Evolution of Java Web Development This time, I took the opportunity to trace the evolution of web applications, a technology that can be called the core of Java backend development.

Why Web Applications? Most modern applications operate in a web environment. The countless services we use every day are, in fact, web applications. Java backend developers play a critical role in developing the server-side logic for these applications, and the most powerful tool used for this is the Spring Framework—specifically, Spring MVC.

To gain a deep understanding of Spring MVC, which helps us develop complex web applications quickly and easily, I studied its foundational technologies step-by-step, starting from its very roots.

The Beginning of Java Web Tech: Servlets Everything started with Servlets. A Servlet is pure Java code that receives a client’s request, processes business logic, and generates a dynamic HTML response. However, this approach had a major drawback: HTML code had to be written directly within the Java code as strings (e.g., out.println("…")). This made modifying the view (the UI) cumbersome and severely harmed readability.
Separating the View: JSP (JavaServer Pages) JSP emerged to compensate for this shortcoming. JSP is a technology that allows embedding Java code within an HTML document, which made collaboration between designers and developers much easier. Thanks to this, the task of presenting the view became much more manageable.

But JSP alone was not enough. Business logic and presentation code were still mixed in a single file. As projects grew larger, this led to “spaghetti code,” which became increasingly difficult to maintain.

The Start of Role Separation: The MVC Pattern To solve this problem, a design philosophy called the MVC (Model-View-Controller) pattern emerged.

Model: Manages the data and business logic.

View: Manages the screen (UI) shown to the user. (JSP)

Controller: Acts as the intermediary, receiving the user’s request and connecting the Model and View. (Servlet)

By clearly separating these roles, the code became much more structured and reusable.

The Birth of Spring MVC and its Practical Use Implementing the MVC pattern manually still involved a lot of repetitive and cumbersome work. Developers began to create MVC frameworks to make using this pattern easier, and the most successful and overwhelmingly popular of these became Spring MVC.

Spring MVC handles the complex processes required for MVC implementation on behalf of the developer, providing an environment where one can focus solely on the business logic. This study covered everything from the origins of Spring MVC to the modern techniques used in the field, allowing me to personally understand why countless companies choose Spring.

I will continue to share my experiences as I conduct my own projects using these technologies. Thank you!

You can check out the code I’ve studied so far via the link attached above!

Apple Unveils “iOS AI,” Declaring a Shift from App-Centric to Agent-Centric Experiences

Fri, 10 Oct 2025 00:00:00 +0000

Apple’s next operating system, “iOS AI,” promises to move the smartphone experience from app-driven UX to agent-driven automation. The company claims the update will “let the OS launch and complete tasks for users before they even open an app,” signaling dramatic industry changes ahead.

1. What’s New in iOS AI?

At the heart of the release is an agent-first OS. The AI can proactively complete jobs without a user manually launching anything.

Headline features

Execute multi-step workflows from a single natural-language request
Predictive UI that puts suggested actions ahead of static icons
AI summaries and triage for messages and mail
Context-aware actions that consider time, location, and user state

Apple calls this the dawn of the “No-App Surface Era.”

2. UX Shift: From Execution to Delegation

Traditional smartphone UX follows the “open app → do work” sequence. Apple plans to flip that model:

Existing UX	iOS AI UX
User launches each app	AI opens what’s needed first
User hunts for info	AI summarizes and organizes
User plans tasks	AI suggests — and sometimes completes — actions

The company emphasizes that “users share intent, and the OS handles the execution.”

3. Debate and Concerns

Experts highlight both upside and risk:

“System-level automation will skyrocket productivity,
but it invites an era of unprecedented regulation on privacy and algorithmic bias.”

Because AI now powers the OS core, users’ “right to know why they saw a given recommendation” is expected to grow even more critical.

4. What’s Next?

iOS AI is slated for beta in March and a public release in June next year. Analysts see the announcement as the opening salvo in a full-scale ‘AI OS war’ with Google and Samsung.

5. Bottom Line

Apple’s message is clear: “Agents, not apps, will lead the next decade of mobile.” The battleground is shifting from app stores to control over generative operating systems.

※ This feature is a fictional narrative and does not reflect any real-world Apple announcement.

Samsung Rumored to Launch “Galaxy Glass” Next Year, Eyeing Life Beyond Smartphones

Wed, 01 Oct 2025 00:00:00 +0000

Rumors suggest Samsung will introduce an AR wearable called “Galaxy Glass” in the first half of next year, drawing intense attention from global tech circles. With Apple’s Vision Pro and Meta’s Quest lineup already sparring, analysts say Samsung’s entry into the full-stack AR arena could reshape the market.

1. AR Glasses as the Next Platform After Smartphones

Industry insiders describe Galaxy Glass as an ultra-lightweight AR device that can operate key functions without tethering to a phone.

Expected capabilities

AR navigation and live translation
Integration with the Samsung Gauss AI assistant
Eye and gesture-based controls
Cloud-streamed app execution
Expanded ecosystem across phones and wearables

Samsung reportedly sees the device as its main interface after the smartphone era.

2. The Competitive Landscape

Company	Strategic Focus	Weak Spot
Apple	High-end performance & premium ecosystem	High price and entry barrier
Meta	Mass-market mixed reality	Profitability challenges
Samsung (rumored)	Lightweight, real-world usability	Need to secure content

While Apple pursues polish and Meta pursues scale, many expect Samsung to bet on practicality and comfort to carve a different path.

3. Expert Take

One AR researcher notes:

“Samsung is one of the few firms with display, chip, and device portfolios under one roof.
If it truly ships this product, it could be the swing factor in AR’s power balance.”

Content, app ecosystems, regulation, and privacy protections remain hurdles.

4. Outlook

If Galaxy Glass arrives, the chase for a platform beyond smartphones could harden into a three-way contest. Observers wonder if 2026 might mark the first genuine year of mainstream AR adoption.

※ This article is a fictional scenario created for storytelling and is unrelated to Samsung’s actual product plans.

Pacman

Sat, 01 Mar 2025 00:00:00 +0000

This is the UC Berkeley Pacman AI project I completed as part of my Artificial Intelligence and Data Structures coursework. The core objective of this assignment was to implement fundamental Graph Search algorithms from scratch and apply them to solve tangible problems within the Pacman game environment.

My work involved implementing generic search algorithms in search.py and defining/solving specific Pacman problems in searchAgents.py.

1. Core Search Algorithm Implementation (search.py)

First, I implemented four fundamental search algorithms that can be applied to any search problem.

DFS (Depth-First Search): Using a Stack, this algorithm explores nodes as deeply as possible first. It was implemented as a graph search, using an explored list to prevent cycles.
BFS (Breadth-First Search): Using a Queue, this algorithm explores the shallowest (closest) nodes first. It guarantees the shortest path when all edge costs are uniform.
UCS (Uniform Cost Search): Using a PriorityQueue, this algorithm prioritizes nodes by their total cumulative ‘cost’. It always explores the path with the lowest cost first, guaranteeing the shortest cost path.
A* (A-Star) Search: Also uses a PriorityQueue, but its priority is the sum of the ‘cumulative cost to date’ ($g(n)$) and an ’estimated cost to the goal’ (heuristic, $h(n)$). This function is $f(n) = g(n) + h(n)$. As an informed search, it finds the optimal solution far more efficiently than UCS.

2. Defining and Solving Pacman Problems (searchAgents.py)

Beyond just implementing the algorithms, I modeled complex problems Pacman faces as formal ‘search problems’ and solved them.

📍 The Corners Problem (CornersProblem) The challenge is to find a path for Pacman to visit all four corners of the map.

State Definition: To solve this, the state space couldn’t just be (x, y). I defined the state as (currentPosition, (visitedCornersTuple)). For example, a state might be ((5, 5), (True, False, False, True)), tracking both the position and the visit-status of each corner.
Goal Definition: The goal state is reached when all boolean values in the tuple state[1] are True.
Successor Function: As Pacman moves, the function checks if the new position is one of the corners. If it is, it generates a new state with the corresponding boolean in the tuple updated to True.

💡 Corners Problem Heuristic (cornersHeuristic)

I designed a heuristic for solving the Corners Problem using A* search.

Design: A heuristic must be admissible (never overestimates the true cost).
Logic: The function calculates the Manhattan Distance from the ‘current position’ to ’every unvisited corner’. It then returns the maximum (max) value among these distances.
Justification: This is admissible because Pacman must travel at least as far as the farthest remaining corner to complete the goal. This value serves as a safe lower bound on the true remaining cost.

🍔 All Food Heuristic (foodHeuristic)

This heuristic was for the FoodSearchProblem, which involves finding a path to eat all the food dots on the map.

Logic: Similar to the corners heuristic, I calculated the actual maze distance (mazeDistance) from the ‘current position’ to ’every remaining food dot’ and returned the maximum (max) value.
Using mazeDistance: Unlike Manhattan distance, mazeDistance is a helper function that runs a BFS to find the true shortest path considering walls, providing a much more accurate (and still admissible) estimate.

🎯 Closest Dot Search Agent

Finding a path to eat all food is very complex (NP-hard). Therefore, I implemented a greedy algorithm that repeatedly finds and eats the closest food dot.

findPathToClosestDot Implementation: I defined a sub-problem called AnyFoodSearchProblem (where the goal is to reach any single food dot).
Using UCS: I applied UCS to this sub-problem. This finds the path to the food dot with the lowest cost (i.e., the closest dot). (Since costs are uniform, BFS would also have guaranteed the same result).

Phone Book Application

Fri, 20 Dec 2024 00:00:00 +0000

This is a simple mobile app I created for my “Mobile Programming” course in the 2024 fall semester. This project is a phonebook management app that utilizes fundamental Android features and a database.

First, I designed a database named phoneDB and a table named phoneTBL. This table stores a name (VARCHAR(20)) and a phone number (VARCHAR(20)). I set a UNIQUE constraint on the name column to prevent duplicates. I included two initial data entries: “Hong Gil-dong” and my own contact information.

The main features I implemented are as follows:

Main Screen (Read Data): On app launch, the app queries the database and displays all saved user names in a ListView. An “Add” button and an options menu are placed at the bottom.

Add Contact (Create): Tapping the “Add” button opens a separate Activity to receive name and phone number input. Upon completion, this information is passed back to the main Activity, saved to the database, and the ListView is immediately refreshed.

Database Initialization (Delete All): Selecting “Initialize” from the options menu displays a confirmation dialog. If the user confirms, all content in the database is deleted, and the list is refreshed.

Data Backup (Export): Through the “Backup” feature in the options menu, I implemented a function to save all names and phone numbers from the database as a .txt file (named after my student ID) to the /sdcard path.

Phone App Integration (Intent): When a specific item in the list is clicked, the app retrieves that item’s phone number and uses an Intent to immediately launch the default Android phone app with the number pre-filled.

Update & Delete: A long click on a list item navigates to a separate Activity where the selected item can be modified or deleted. I implemented confirmation dialogs for each action. Upon completion, the changes are reflected in the main Activity’s database and ListView in real-time.

Linux TCP chat program

Wed, 26 Jun 2024 00:00:00 +0000

Based on what I learned in my Linux System Programming class, I implemented a simple multi-client TCP chat program as a project.

It was a meaningful experience to directly apply the concepts of C socket communication and multithreading (pthreads). I’d like to summarize the project’s structure, core operating principles, and the key takeaways.

1. Project Overview

This program is a simple console-based (terminal) chatroom that allows a single server and multiple clients to chat in real-time over the TCP/IP protocol.

Key Technologies: C Language, TCP/IP Socket Programming, pthread (Multithreading)

Core Features:

Server: Manages multiple client connections simultaneously.
Broadcasting: Transmits a message from one client to all other connected clients (except the sender).
Multi-Chat: Allows multiple users to send and receive messages at the same time.

2. Core Architecture: How Concurrency is Achieved

The core challenge of a chat program is handling multiple requests simultaneously. Functions like accept(), recv(), and fgets() are blocking by default. This means the entire program pauses and waits for an operation to complete before moving on.

I used multithreading to solve this problem.

⚙️ Server: Thread-per-Client Model The server needs to handle connection requests and receive messages from multiple clients at the same time.

The main thread waits for new client connections using the accept() function.
When a new client connects, it calls pthread_create() to create a new, dedicated thread (client_chat) just for that client.
This dedicated thread waits for messages from its client using the recv() function.
The main thread immediately loops back to accept() to wait for the next client.

In effect, the “connection handling” thread (main) and the “per-client message receiving” threads all run independently and concurrently.

When a thread receives a message, it calls the send_msg function, which iterates through the clientList to broadcast the message to all other clients.

💻 Client: Separation of Sending and Receiving Threads The client has its own major challenge: it must be able to receive messages from others in real-time, even while the user is typing their own message.

If it were single-threaded, the program would block on fgets() (waiting for user input), making it impossible to call recv() and receive incoming messages.

To solve this problem, the client program is also split into two threads:

Main Thread (main function): This thread is dedicated only to the “sending” role. It waits for the user’s keyboard input (fgets) and sends (send) the message to the server.
Receiving Thread (receive function): Created with pthread_create(), this thread is dedicated only to the “receiving” role. It blocks on recv(), waiting for messages to arrive from the server.

By splitting the roles this way, the receive thread can display incoming messages from the server in real-time, even while the user is busy typing a new message in the main thread.

You can check out the code via the link(s) attached above!

experience

Tue, 24 Oct 2023 00:00:00 +0000