Tools and Technologies

To achieve this, I used the most recent version of Android Studio in combination with:

Frontend: Jetpack Compose

When developing apps in Android Studio, the recommended framework is Android’s Jetpack Compose. It is a modern toolkit for building native UIs and simplifies and accelerates UI development on Android.

Backend / Database: Jetpack Room

Jetpack Room is a persistence library introduced as part of the Android Jetpack suite to simplify working with SQLite databases. It provides an abstraction layer over SQLite, allowing more robust database access while still enabling the full power of SQLite.

Translation: ML Kit

With Android Studio’s ML Kit Translation API, users can translate text in over 50 different languages without the need for an internet connection, and it is completely free to use for development.

Project Scope

My goal is to develop an intuitive app that lets users learn new words in different languages.

The app should contain:

• Start Page
  • Before users can begin learning, they need to set a name and their nationality so ML Kit knows which language to translate into.
• Overview of folders and cards
  • Users can create multiple folders with different language settings and visuals. In these folders, they can see their added cards.
• Add folders
  • Adding folders should be easy, and folders should also be easily distinguishable. To achieve this, users can set a name (e.g., German vocabulary), a color, the foreign language (e.g., German), and change the local language if needed (default is the user’s nationality).
• Add cards
  • Adding cards is the most important feature of this app. Users add a new word and have two optional fields for example sentences and tags.
• Automatic translation
  • For ease of use (and to experiment with Android’s APIs), the new word is automatically translated into the user’s language.
• Quiz mode
  • With quiz mode, users can test their skills using three different modes: Random, Bookmarked, and Recall (a list of incorrectly answered cards).

Beyond the Initial Scope

Additionally, I implemented several features that further improve the app’s functionality:

• User edit page: Allows users to edit their name, nationality, and app theme.
• Light and dark mode: Added for additional customization.

Overall, the implementation of this project during my first semester was very successful and involved learning many new technologies. Both frontend and backend are fully implemented and can be further extended in the upcoming semesters.

The post Language Learning App appeared first on Mobile USTP MKL.

OnTime is a cross-platform time tracking app in which the user can create clients that the user works for with projects and tasks. The application consists of a calendar, overview pages for clients, project and tasks to view, create, edit, and delete. Additionally, it also combines all the data on a dashboard page, where the user can see their working hours, how much money they have made, and how the worked hours are distributed. 

So why do I need it? It’s simple: I’m greedy, and I don’t want to pay for a SaaS that needs to be subscribed to to get all the features. Websites like Toggl or ClickUp already offer a great service with their freemium versions, but the features that would make my life simpler are blocked behind a paywall. 

So the goal is simple: create a time tracking app with clients, projects and tasks that can track your time with a calendar and a real-time recorder.

Techstack

React

React is a JavaScript library designed for building user interfaces, particularly for modern web applications that require fast, interactive experiences, and is used for this project. There are a lot of web development frameworks, and I picked React for one reason: its popularity. A lot of companies use React for their websites, and since I do not have the most experience with React, I wanted to learn it with this project.

MUI

For a clean and consistent design throughout the project, I decided to use MUI. MUI is a React UI component library that helps to build modern interfaces quickly. It’s based on Material Design, a design system created by Google that defines how elements like buttons, cards, colors, spacing, and animations should look and behave. Since I was using it in another project in university, it seemed like a good idea to use it in this project as well.

Tauri

Tauri is a toolkit that can be used with various programming languages to develop cross-platform applications. It is used for building applications using a combination of Rust tools and HTML rendered in a WebView and can be extended with additional functionalities. You can easily compare Tauri to Electron, but instead of bundling a full browser like Electron does, Tauri uses the system’s native webview (for example, WebView2 on Windows or WebKit on macOS). This makes Tauri applications much smaller and more memory-efficient.

A Tauri app typically consists of:

• A frontend built with a web framework (Vue, Svelte, Angular or in this case React).
• A backend written in Rust, which handles system-level tasks like file access, networking, or OS integration.

Tauri’s cross-platform development supports Windows, macOS, Linux, Android and iOS, which makes it a perfect fit for time tracking anywhere you are.

Supabase

Supabase is an open-source, serverless backend platform and a popular alternative to Firebase. It enables developers to build optimized and high-performance applications using a PostgreSQL database with an easy and minimal configuration. Supabase operates as a serverless backend. This allows applications to be set up and scaled without the need to create or manage a custom server. Additionally, Supabase is built on SQL (Structured Query Language), offering the full range of features and advantages associated with relational databases, different from Firebase’s NoSQL-based approach.

Supabase Features

Supabase comes with a prebuilt authentication/user management system handled by the package with no need for third-party tools. 

Supabase projects come with a preconfigured PostgreSQL database, giving developers access to the full set of features that Postgres offers. This functionality can be extended by enabling additional database extensions, which can be added easily with a few clicks in the settings.

Design

The design was made in Figma using variables and styles for a consistent experience. Even though a solid visual experience was not a requirement for the project, I wanted to fulfill my own requirements since I want to use this application once it’s fully finished. Here are some design examples:

Learnings

At the start of the project, I had a clear plan on how to start and keep up the progress for this project. Which can be seen in this picture:

Sadly, instead of starting with the backend and then the design with the website, I started developing the calendar components. This led to me having to refactor the calendar later on because the database in the backend was handling the types differently. After having a working prototype of the components, I was able to redesign these with a consistent design.

Additionally, the Figma course in the first semester helped immensely with building a consistent and visually pleasing design. The work on this project really improved my confidence in using Figma and putting it all together in React.

Furthermore, even though I would not say that I particularly enjoyed using React, I learned a great deal about its framework architecture and how to use the different hooks correctly. In addition, I was able to get a solid understanding of how to structure and reuse components, which significantly improved the readability and maintainability of my code.

Conclusion

In conclusion, the development of OnTime was challenging, but I learned a lot. A substantial amount of work went into implementing the calendar functionality, as many existing calendar components were either with not enough features or customizability for the project’s requirements or locked behind paywalls. Building custom solutions for these components needed careful planning, refactoring, and iteration.

Overall, the project was a very valuable experience in full-stack application development, UI design, and architectural decision-making. While OnTime already fulfills its core purpose, there are many possible future improvements, such as an offline mode, invoice generation, workspaces, and multi-user support. These additions would further enhance the application’s usability and scalability.

The post OnTime – Semester Project 1 appeared first on Mobile USTP MKL.

This paper discusses recent developments in Simultaneous Localization and Mapping (SLAM) combined with the use of Artificial Intelligence (AI). SLAM makes it possible for robots to build maps of unknown environments while tracking their position, but with traditional methods robots often struggle in dynamic or unstructured settings due to unclear or moving objects. Recent advances in AI and its integration into SLAM address these issues by improving feature extraction, predictive modeling, and adaptability. Convolutional and Graph Convolutional Networks enhance robustness and scalability, while transformer architectures enable efficient trajectory planning. Obstacle detection and avoidance in real-world scenarios are further reinforced by deep reinforcement learning. AI-driven innovations also introduce multi-modal sensor fusion, semantic mapping, enhanced loop closure detection, and collaborative multi-agent frameworks. Comparative studies reveal that AI-enhanced SLAM shows a higher accuracy and robustness across varied scenarios.

The post State of the Art of AI-Enhanced SLAM appeared first on Mobile USTP MKL.

Both platforms promise fast and easy development, built-in authentication, real-time data, and scalable infrastructure. But can they deliver on these promises and when should I use what? Both are valid choices for your next project but they have their differences in some fundamental ways: data modeling, query flexibility, pricing transparency, and how much you can customize as your app grows. Those differences matter, especially once you move beyond a prototype. But first: what is Supabase actually and what can it do?

What is Supabase

Supabase is a serverless, open-source backend platform that is designed to help developers build scalable, high-performance applications with minimal setup. It’s built on top of PostgreSQL, it provides a fully managed, production-ready database along with essential backend features such as authentication, storage, and real-time data without relying on other services. This means that you don’t need to configure or maintain a custom backend server, allowing you to move faster and focus on product development.

As a serverless solution, Supabase handles infrastructure concerns like provisioning, scaling, and security automatically. It also allows the user to get direct access to a powerful SQL database that uses PostgreSQL for structured data modeling, complex queries, joins, and transactions.

With Supabase, you get a managed backend with features like:

• SQL database: PostgreSQL with support for advanced queries, joins, and JSON data.
• Authentication: Secure, built-in user management.
• Realtime updates: Live data synchronization using WebSockets.
• Storage: Easy-to-use storage for files and media.
• Edge functions: Custom serverless functions for handling app logic.

Firebase

Similar to Supabase, Firebase is a backend-as-a-service solution offered by Google, which assists developers in the development of applications without the need for them to handle the infrastructure on their own. Firebase also offers a set of features such as authentication, real-time databases, cloud functions, file storage, and analytics. This solution is designed with the objective of providing ease of use and rapid development.

At the heart of the Firebase platform are the NoSQL databases, namely the Realtime Database and the Cloud Firestore, which organize and store the data in the form of documents and collections, unlike traditional relational databases in the form of tables. Although the NoSQL databases provide a degree of flexibility and ease of development, especially when real-time updates and data access patterns are concerned, handling complex relationships and queries in a scaled-up application might be a challenge.

Supabase takes a different approach to backend development. Like mentioned above, it’s an open-source, serverless framework that centers around PostgreSQL. Supabase offers its features with just one Postgres database.

Supabase vs Firebase

Data model

Firebase supports a NoSQL, document-oriented data structure well-suited for hierarchical or event-oriented data. Supabase supports relational SQL, which provides support for schemas, joins, transactions, and consistency.

Querying and logic

It allows complex queries and business logic to be implemented directly in the database through SQL, constraints, and triggers. Firebase uses more client-side logic and Cloud Functions for complex operations.

Scalability & Control

Whereas Firebase abstracts infrastructure almost completely, which is easy to set up but makes it difficult to customize, Supabase provides more visibility and flexibility, which includes direct database access and the ability to host it on your own infrastructure.

Vendor lock-in

Firebase is highly integrated with Google Cloud. Supabase values portability and focuses on using open standards and tools that make it easy to migrate in and out.

Use Cases

Supabase is well suited for:

• SaaS platforms with relational data and role-based access control
• Data-intensive applications such as analytics dashboards and internal tools
• Projects that require complex queries, transactions, or strong data integrity
• Teams that value open source, portability, and long-term flexibility
  

Firebase is well suited for:

• MVPs and prototypes that need to ship quickly
• Real-time applications like chat, presence, or collaborative tools
• Frontend-heavy apps with simple data relationships
• Teams already invested in the Google Cloud ecosystem
  

Choosing Between Supabase and Firebase

The choice between Supabase and Firebase ultimately depends on how your application handles data and how much control you want over your backend. Firebase is very good at simplicity and speed, while Supabase shines when structure, scalability, and flexibility become more important over time.

Conclusion

Choosing a backend platform is one of the most important decisions you’ll make when starting you fullstack application. It decides not only how fast you’ll progress and deliver your first version, but also how well your application can scale and how complex your data model can become.

Firebase and Supabase are both good options to choose from and remove a lot of the traditional backend complexity. Firebase is good for rapid development, especially for real-time, frontend-driven applications. Supabase, on the other hand, offers a more structured and transparent approach, built around the concept of open-source and PostgreSQL, making it a strong choice for applications that need simple data models and long-term flexibility.

As always, there is no universally “better” option… Only the better fit for your project. If you need to move fast with minimal setup and simple data relationships, Firebase is a solid choice. If your application relies on relational data, complex queries, and future-proof architecture, Supabase provides a powerful and scalable foundation.

Ultimately, the best backend is the one that aligns with your application’s needs today while still supporting where you want it to go tomorrow.

Sources

1. https://bejamas.com/hub/serverless-database/supabase
2. https://somindadhaniya.medium.com/what-is-supabase-the-open-source-firebase-alternative-developers-love-ef63f15e0e48
3. https://www.newline.co/@zaoyang/what-is-supabase-and-how-it-can-replace-your-entire-backend–62b84205
4. https://supabase.com/
5. https://supabase.com/docs/guides/getting-started/architecture
6. https://www.postgresql.org/about/
7. https://firebase.google.com/
8. https://medium.com/firebase-developers/what-is-firebase-the-complete-story-abridged-bcc730c5f2c0

The post What is Supabase and when to use it appeared first on Mobile USTP MKL.

Idea

The goal of TreeFund is to provide an easy and transparent way for people to contribute to environmental restoration projects in St. Pölten. Its main focus is supporting tree planting initiatives and teaching new generations how to help our planet. The idea is to connect with individuals who want to make a difference and focus on their specific needs. People will first encounter TreeFund through posters and flyers placed around the city. A QR code on each will lead directly to the TreeFund website, where users can learn more, get involved, and track the impact of their contributions.

Implementation

As the first step in the implementation process, I created a user persona: Lisa Gruber, a student at the University of Applied Sciences St. Pölten.

Lisa is deeply environmentally conscious and eager to contribute to positive change. However, she often feels frustrated by the impersonal nature of many existing donation platforms. She wants to see the real impact of her actions and connect with initiatives that align with her values on a local level.

To personalize this process, the user (Lisa) first contacts TreeFund via a form describing their personal needs and where they want to see a part of the world a little greener. Only after the user is happy and the tree planting effort is accepted by the city, the payment process begins. 

To attract younger customers the design follows a minimalist aesthetic with clean whites and greens to emphasize the simplicity and positivity of the project’s goal. The design was first created in Figma with inspirations like Ecosia and TreeApp. My goal was to stick to a strict number of TailwindCSS colors. The website switches between Stone-50 and -100 for the background and Lime-400, -500, -600 and -800 for the green accents.

After the design process, the actual website was implemented using React, Next.js, Tailwind CSS, and Lucide for icons.

Link to the Web Application: https://fhstp-print2mobil.vercel.app/

Disclaimer: This is a personal project created for educational and illustrative purposes. It is not affiliated with any existing environmental organizations. The aim is to demonstrate how web technology can be used to promote sustainability and environmental awareness.

The post PrintToMobile | TreeFund appeared first on Mobile USTP MKL.