This article explores MySQL data types, like integers, decimals, strings, and dates, used to define the information stored in table columns. Selecting the correct data type is crucial for ensuring data integrity, optimizing storage and performance, and performing calculations and comparisons. Alexander S. Ricciardi April 29, 2025 In relational databases, information is organized in tables referred to as schemas, the table rows act as records, and the columns act as attributes. To manage and manipulate these tables, developers use Structured Query Language (SQL), with MySQL being the most popular relational database management system (RDBMS). In the context of MySQL, selecting the appropriate data types for table columns, in other words, the data attributes, is essential for the RDBMS and the applications relying on it, as it directly impacts data integrity, storage efficiency, query performance, and the accuracy of data operations like calculations and comparisons. This article explores the data types available in MySQL, discusses their uses, and illustrates the importance of choosing the correct type. MySQL Data Types In the context of MySQL, data types define the nature of the information that can be accepted and stored within each specific column of a table. MySQL provides a wide range of data types, each designed to fit a specific kind of data characteristics, such as storage space and allowed values. See the table below for more information. Table 1 MySQL Data Type Note:  The table lists the different MySQL. Data from “An introduction to MySQL data types” by Ellingwood (n.d.). The Importance of Data Type Selection   Selecting the right data type in RDBMS is very important as it ensures that the data is stored efficiently and accurately (Sakshijain1, 2025). It impacts several aspects of RDBMS functionality, such as data integrity, storage, and query, as well as operations such as SUM  and AVG  calculation performed on numeric types, or DATEDIFF and DATE_ADD  operations performed on temporal data types.   The following examples illustrate the impact of selecting appropriate data types versus inappropriate ones.   MySQL script below creates an events table to store concert dates: CREATE TABLE Events ( event_id INT AUTO_INCREMENT PRIMARY KEY, event_name VARCHAR(100), event_start DATETIME, -- Using DATETIME type ticket_price DECIMAL(8, 2) -- Using DECIMAL for currency ); INSERT INTO Events (event_name, event_start, ticket_price) VALUES ('Spring Gala', '2025-05-15 19:00:00', 75.50), ('Summer Concert', '2025-07-20 20:30:00', 45.00), ('Autumn Workshop', '2025-10-10 09:00:00', 120.00); Note that the column event_start was defined having a DATETIME data type, which allows performing temporal operations, for example, finding events happening in the next 90 days. The following code snippet queries/retrieves the name and start date/time for all events listed in the Events table where the events are scheduled to start on or after today's date and on or before the date 90 days from today. This logic works because the event_start column was defined as a DATETIME data type. SELECT event_name, event_start FROM Events WHERE event_start BETWEEN CURDATE() AND DATE_ADD(CURDATE(), INTERVAL 90 DAY); Another example of properly using data types is defining DECIMAL(8, 2) for ticket_price. This allows calculating the average ticket price without potential floating-point rounding errors: SELECT AVG(ticket_price) FROM Events; Now, if event_start  were stored as  VARCHAR(20)  (e.g., 'May 15, 2025 7PM'), using a function similar to DATE_ADD  would be very difficult and prone to errors due to the text formats. Similarly, storing ticket_price  as VARCHAR (e.g., ‘$75.50’, ‘$40.25’) and when using functions like AVG()  or SUM() . Although MySQL implicitly converts the VARCHAR to the DOUBLE  type, the output of the conversion is not always what is expected, as AVG(ticket_price)  (calculating ticket price average) will compute as 0.0 . This happens because MySQL will read the first character for the values, ' $ ' (which is not a number), and interpret the entire expression as not being numeric and translate VARCHAR  data type values to the DOUBLE data type value of 0.0 .   For example, when using a column: score_text VARCHAR(20), Storing the folowing data: ‘100' 'p85' 'Failed' '90 points' '70' and performing the following operation on the column (Computing scores average): SELECT AVG(score_text) The MYSQL code line above will first convert the VARCHAR data to DOUBLE data, resulting on the following: 100.0 -- ‘100’ 0.0 -- ‘p85’ 0.0 -- ‘Failed’ 90.0 --’90 Points’ 70.0 -- ‘70’ Note that MySQL will generate warnings for the rows containing 'Failed'  and '90 points' . And then it will performed the following calculation ( 100.0 + 0.0 + 0.0 + 90.0 + 70.0) / 5 = 345.0 / 5 = 52.0   This average output is probably not what was expected, or it is meaningful, because the non-numeric value 'Failed' was converted to 0 , lowering the calculated average compared to the average of only the actual numerical scores.   Another example, in scientific measurements where precision is crucial, DECIMAL is preferred over approximate numeric data types like FLOAT . Let’s say we add reagents with masses like 1.1250g, 0.0750g, and 2.5000g. When using the FLOAT data type to compute ExperimentComponents_Approx, these values will be stored as close approximations, not the exact numbers, as 1.1250 , 0.0750 , and 2.5000 are defined as FLOAT ; each value is rounded to the nearest representable binary fraction. Then, when calculating the total mass: SELECT SUM(mass_grams) FROM ExperimentComponents_Approx; The computation output will be slightly off due to the “accumulated representation errors” (binary rounding error), resulting in 3.7000000000000002 or 3.6999999999999997 instead of exactly 3.7000 . For instance, in laboratories or manufacturing quality control settings, this discrepancy could result in incorrect solution concentrations, failed reactions, or items not meeting specifications.   However, when using DECIMAL(10, 4) in ExperimentComponents_Exact guarantees that 1.1250 , 0.0750 , and 2.5000 are stored precisely, as the computations are performed in base-10 with no hidden representation error. Then, when calculating the sum: SELECT SUM(mass_grams) FROM ExperimentComponents_Exact; This computation outputs an exact result of 3.7000 with an exact decimal precision of 4. This precision and accuracy in scientific calculations are essential for meeting a correct product quality standard or scientific specification.   Note that the numeric DOUBLE data type (8 bytes) outperforms the FLOAT data type (4 bytes) by offering roughly twice the bit-width, about 15 to 17 decimal digits versus 7 for the FLOAT . However, the DOUBLE type still has some inexact precision when compared to the DECIMAL type, which has exact precision.   Therefore: Use DECIMAL whenever exact decimal precision is needed (e.g., important financial calculations with a high volume of transactions or calculations, quality-control measurements, laboratory concentrations). Use DOUBLE when precision matters, but it does not have to be exact. Use FLOAT when a slight rounding error is acceptable.   In summary, MySQL provides a set of data types that can be used to store various kinds of information, from numbers and text to dates and spatial data. Selecting the most appropriate data type is crucial, as it significantly impacts data integrity, storage usage, query speed, and the accuracy of operations. References:   Ellingwood, J. (n.d.). An introduction to MySQL data types . https://www.prisma.io/dataguide/mysql/introduction-to-data-types   Sakshijain1 (2025, January 30). SQL data types. GeeksForGeeks . https://www.geeksforgeeks.org/sql-data-types/

This article explains how to manipulate data using MySQL tables and the Data Manipulation Language (DML) commands: INSERT to add new rows, UPDATE to modify existing rows, and DELETE to remove rows, providing syntax and illustrated examples for each. Alexander S. Ricciardi April 30, 2025 One of the core functions of a Relational Database Management System (RDBMS) is to allow users to manipulate data, such as inserting data into a table, modifying that data, and then deleting whatever data they no longer want to store. These RDBMS functions are handled by the Data Manipulation Language (DML), a subset of the Structured Query Language (SQL), and implementations of SQL like MySQL (Murach, 2019). Note that the Data Definition Language (DDL) is also a subset of SQL, which handles the definition or modification of the structure of database objects (schemas) like tables and indexes. In other words, DML is used to manipulate the data within schemas, and DDL is used to manipulate the schemas. This article focuses on the DML operations ( INSERT , UPDATE , and DELETE ) used to manipulate data within MySQL tables, providing examples. DML Operations   The DML operations for modifying data in MySQL tables are handled by the statements (also referred to as commands): INSERT , UPDATE , and DELETE . The INSERT  command adds new rows of data. The UPDATE  command modifies data in existing rows. The DELETE  command removes rows entirely. Note that these commands manipulate rows, not columns. However, the command SELECT  is used for querying and retrieving data from a table based on the table column (Watt & Eng, 2014).   These commands (INSERT , UPDATE , DELETE ) are often used in combination with the SELECT  command and the WHERE  clause to manipulate data by querying the table columns and selecting rows based on a specific condition(s). Note that the WHERE  clause is responsible for filtering rows, also called records, based on specific conditions (Kathuria, 2021).   Data Manipulation Examples   To illustrate the examples on how to use the INSERT , UPDAT E, and DELETE  commands, the following products table is going to be used.   Figure 1 Products Table   Note:  The figure table illustrates a product table of various types of guitars.   The INSERT Commands   The INSERT  command is used to insert rows/records (to store new data) in tables. Different syntax variations of the INSERT command exist in MySQL: Using VALUES INSERT INTO table_name (column1, column2, ...) -- the columns list VALUES (value1a, value2a, ...), -- Values for the first row (value1b, value2b, ...), -- Values for the second row (value1c, value2c, ...), -- Values for the third row ... (value1n, value2n, ...); -- Values for the last row Using SET INSERT INTO table_name SET column1 = value1, column2 = value2, ... ; With the SET  command, only one value can be inserted by column. Using SELECT INSERT INTO table_name (column1, column2,...) SELECT source_column1, source_column2,... FROM source_table WHERE condition; Here, SELECT  is used to insert columns from a source table column where a condition is met. INSERT  Example using the products table:   Figure 2 INSERT Example Note: The figure illustrates the SQL code for inserting a new guitar item in the products table.   The UPDATE Commands   The UPDATE  command is used to update existing rows/records' values (to modify existing data) in tables. Syntax: UPDATE table_name SET column1 = new_value1, column2 = new_value2 WHERE ‘condition’; -- The condition determines which rows are updated The WHERE  clause is used to update specific records' values based on a specific condition. UPDATE  Example using the products table:   Figure 3 UPDATE Example Note:  The figure illustrates the SQL code for adding +10 to the discount_percent for all items with a category_id = 1.   The DELETE Commands   The DELETE  command is used to delete rows/records (to delete existing data) in tables. Syntax: DELETE FROM table_name WHERE ‘condition’; -- Specifies row(s) to delete Note: The figure illustrates the SQL code for deleting all items with a category_id = 1   DELETE  Example using the products table:   Figure 4 DELETE Example Note: The figure illustrates the SQL code for deleting all items with a category_id = 1.   Hazards of Using UPDATE and DELETE   When using the UPDATE  and DELETE  commands, users need to be extremely careful, as these commands are very powerful and consequently come with significant risks. Accidentally misusing these commands can result in widespread data corruption or data loss. Some of these hazards include Missing or incorrect WHERE clause resulting in the UPDATE  or DELETE  commands being intentionally applied to all rows. Data loss caused by incorrect logic or use of the WHERE clause condition and the UPDATE command, which may be potentially fixed, and the DELETE  command, which often results in irreversible loss of data.   To summarize, the INSERT , UPDATE , and DELETE commands are DML operations in MySQL for adding, modifying, and removing data within tables. The INSERT syntax can take various forms. The UPDATE and DELETE commands require particular attention due to their potential to modify or destroy existing data on a large scale.   References:   Kathuria, H. (2021, November 9). How to write a WHERE clause in SQL . Learn SQL. https://learnsql.com/blog/where-clause-in-sql/   Murach, J. (2019). Chapter 1: An introduction to relational databases. Murach’s MySQL (3rd ed.).  Murach Books. ISBN: 9781943872367   Watt, A., & Eng, N. (2014). Chapter 16 SQL Data Manipulation Language. Database Design – 2nd Edition . Open textbooks, British Columbia University Open Campus. https://opentextbc.ca/dbdesign01/chapter/chapter-sql-dml/

This article explains the process of migrating a relational database from Microsoft SQL Server to MySQL, noting key differences between the platforms. It details the four essential steps for a successful migration: assessment and planning, schema conversion, data migration, and subsequent application modification. Alexander S. Ricciardi April 19, 2025 Often, a business decision to migrate their Relational Database Management System (RDBMS) from Microsoft SQL Server (SQL Server) to MySQL is driven by Information Technology (IT) cost savings. SQL Server comes with licensing costs that can be substantial, particularly for businesses with a large number of machines (H, 2024). On the other hand, while owned by Oracle, MySQL is distributed under an open-source (GPL) license. It offers a free community edition and an optional commercial license. This post gives a brief overview of the difference between SQL Server and MySQL, and explores, as the database administrator for a database investments business, four steps required to implement a migration from SQL Server to MySQL. Before migrating an RDBMS from SQL Server to MySQL is important to understand the difference between the two database systems. For example, MySQL runs comfortably on Windows, Linux, macOS, and other Unix systems, while SQL Server is primarily optimized for Microsoft/.NET technology stack and has recently expanded, since 2016, to run on Linux systems (H, 2024). The table below lists the main differences between the two RDBMSs. Table 1 MySQL vs. SQL Server Note: The table lists the main differences between SQL Server and MySQL. From “MySQL vs SQL Server: Which is the Right Database For You?” by Richman (2023). For our investment business example,  the RDBMS is migrating from SQL Server to MySQL, and with the fact that MySQL is compatible with Windows and Linux operating systems (OSs), the primary OSs that SQL Server also runs on, means that the operating system used by the business is not an issue. Nonetheless, as listed in Table 1, substantial differences exist between the two database systems; therefore, it is essential to assess the complexity of the existing RDBMS to plan the migration, translate the schema from SQL Server's T-SQL dialect to MySQL's SQL dialect, migrate the data from SQL Server schema to newly created (translated) MySQL schema, and once the schema migration is completed is essential that the application that use SQL Server is modified to function correctly with the new MySQL RDBMS. Assessment and Migration Planning Assessing the existing SQL Server RDBMS is the first step in migrating the system. This includes discovering and inventorying the system by identifying all SQL Server instances, these instances' versions (e.g., 2012, 2016, 2019), and editions (e.g., Standard, Enterprise, Express) (GoReplay, 2024; Rifai, 2024). It is also essential to document the database sizes and configuration settings (collation, compatibility level) as well as the server hardware used (CPU, RAM). This will help to mitigate T-SQL conversion to MySQL's SQL problems, identify unsupported SQL Server features in MySQL, and identify potential hardware performance issues when using MySQL. Then, based on the information gathered during the assessment process, formulate a migration strategy, such as a trickle migration strategy and a Big Bang migration strategy. The trickle strategy migrates databases and applications in groups, starting with the less complex and low-risk databases and application groups to the more complex and high-risk ones (Kutay, n.d.). This wave approach to migration reduces risks and allows the migration team to troubleshoot and refine the migration process before migrating to the more complex or most critical databases and application groups. The Big Bang strategy. On the other hand, migrate databases and applications simultaneously over a single period. This approach is simpler to manage than the trickle strategy but comes with higher risks, as a failure could jeopardize the entire migration project and may necessitate the entire process to be rolled back.  Note that for our example of an investment business migrating its SQL server to MySQL, the schema and procedural code are complex because the system must process complicated and sophisticated financial transactions. Therefore, the trickle migration strategy is best suited for this example as its phased group approach reduces the risks associated with migrating complex schema and procedural code. When using the trickle migration approach, the following steps are performed in stages (or waves), starting with low-risk databases and application groups and progressing to the more complex and high-risk ones.   Schema Conversion This step involves translating SQL Server's T-SQL dialect to MySQL's SQL dialect. That is, translating the T-SQL table structures, views, indexes, and procedural code (Islam & Thiagarajan, 2017). There are two primary approaches to this process, which are manual conversion and automated conversion. As its name indicates, the manual conversion approach requires developers to manually rewrite the SQL Server schema definitions and procedural code to MySQL syntax and definitions. On the other hand, the automated approach uses software tools that automatically convert SQL Server schema definitions and procedural code to MySQL syntax and definitions. Although much faster than the manual conversion approach, this approach is less accurate. Often, migration teams opt for a combined strategy that uses automated conversion software for the bulk of the schema and simpler procedural code, followed by a manual conversion of the more complex procedural code and a review and testing of the procedural code and schema output by the automated conversion.  For our investment business example, the hybrid approach is acceptable and advisable due to the substantial system complexity and size, as a manual-only conversion will be extremely time-consuming, and an automated one will not be suitable for complex procedural code involving complicated financial transactions. Data Migration The schema conversion is followed by migrating the data. The most important aspect of this phase is choosing the right data migration technique based on the database size and acceptable downtime. The two primary data transfer methods are offline and online. The offline data migration implies taking the source database (SQL Server database) offline or stopping application ‘updates’ and ‘adds’ referred to as writes, performing a bulk data transfer (using export/import, backup/restore adaptations), and once the data and application functionality is transferred bringing the new database online (MySQL Database). This approach is simpler than online but requires potentially significant downtime, which may not be suitable for applications that require high availability (GoReplay, 2024). Online data migration, on the other hand, uses Change Data Capture (CDC) and replication tools (like AWS DMS, Azure DMS if supported, Estuary Flow, Striim) to transfer an initial data bulk load while capturing ongoing changes from the SQL Server and applying these changes in near real-time the MySQL system minimizing downtime but introduces substantial complexity to the migration process. For our example, due to the financial nature of the business, continuous operation and minimal disruption are essential. The online data migration utilizing Change Data Capture (CDC) tools is the best choice. Application Modification This step is often implemented in coordination with the data migration step. The applications that previously used the SQL Server must be modified to use correctly the new MySQL RDBMS. This requires implementing application changes that adapt the application logic to the new database environment and testing the application functionality against the MySQL database. These changes imply modifying connection strings, updating drivers, reconfiguring Object-Relational Mappers (ORMs), and rewriting application-embedded T-SQL (Rubin, 2016; Nisnevich, 2020). These changes are not optional clean-up tasks; they are crucial for a successful migration. This step, for our investment business example, is complex and requires significant effort and time, especially when rewriting application-embedded T-SQL, reconfiguring ORMs, and testing the modifications to ensure that the application logic correctly accesses the data and handles the financial transactions.  Summary Migrating a database from SQL Server to MySQL is a lengthy and complex process that requires a good understanding of the differences between the two RDBMS. The migration follows four crucial steps: assessment and strategic planning (including choosing between trickle and big bang approaches), schema translation (often employing a hybrid manual/automated technique), data migration (selecting offline or online methods based on downtime needs), and application modification. As illustrated with the investment business example, implementing a successful migration is often business-specific; in other words, it depends on the specific context. For our investment business example, the OS(s) used by the business will not affect migration, as MySQL is compatible with them. The trickle migration strategy is best suited given the system's complexity and size. The hybrid schema conversion approach is acceptable and advisable due to the system’s substantial complexity and size. The online data migration utilizing CDC tools is the best choice as it minimizes downtime and makes changes in near real-time. Time and resources should be allocated to modifying the application(s) used by the business to ensure that its business logic correctly accesses the data and handles the financial transactions as expected. References: GoReplay (2024, November 24). Your comprehensive SQL Server migration checklist: tools, steps, and load testing insights. GoReplay. https://goreplay.org/blog/demystifying-sql-server-migrations-tools-steps-and-best-practices/ H, J. (2024, July 8). MySQL vs MS SQL server: Key similarities and differences. Dreamfactory. https://blog.dreamfactory.com/ms-sql-server-vs-mysql Islam, A., R, & Thiagarajan,  A. (2017, October 5). Migrating a SQL Server database to a MySQL-compatible database engine. AWS. https://aws.amazon.com/blogs/database/migrating-a-sql-server-database-to-a-mysql-compatible-database-engine/ Kutay, J. (n.d.). An introduction to database migration strategy and best practices. Stiim. https://www.striim.com/blog/an-introduction-to-database-migration-strategy-and-best-practices/ Nisnevich, A. (2020, April 18) Migrating a ASP.NET application from SQL Server to MySQL. AlexNisnevich Blog. https://alex.nisnevich.com/blog/2020/04/18/migrating_asp_net_mysql.html Richman, J. (2023, April 5). MySQL vs SQL Server: Which is the right Database for you? Estuary. https://estuary.dev/blog/mysql-vs-sql-server/ Rifai, B. (2024, April 3). Automate SQL Server discovery and assessment to accelerate migration to AWS. AWS. https://aws.amazon.com/blogs/database/automate-sql-server-discovery-and-assessment-to-accelerate-migration-to-aws/ Rubin, A. (2016, June 23). Migrate from MS SQL Server to MySQL. Percona. https://www.percona.com/blog/migrate-from-ms-sql-server-to-mysql/

Successfully releasing an Android app on the Google Play Store necessitates a preparatory process involving several key tasks. These include gathering essential materials like cryptographic keys and icons, configuring the app for release by setting IDs and cleaning the project, building a signed and optimized version (preferably AAB), preparing necessary servers, and thoroughly testing the final build before publication. Alexander S. Ricciardi April 13, 2025 The Google Play Store is the primary channel through which Android developers distribute their apps. It is an ecosystem that allows them to publish, manage, monetize, and promote their apps globally. To successfully release the app and publish it in the store, the developer should prepare it to be deployed; this is merely a suggestion, but it is more like a requirement. To prepare an app for release, the developer needs to configure, build, and test a release version of the app (Android Developers, n.d.a). This post explores the tasks required to prepare an Android app for release. Android Package Kit (APK) Before preparing an Android app for release, it is important to understand what the Android Package Kit (APK) is. An APK file contains all the necessary components to run an app on an Android device (Gillis, n.d.). It Includes: AndroidManifest.xml . An Android manifest that describes the name, version, access rights, library and other contents of the APK file. assets/ . App assets and resource files. classes.dex . Compiled Java classes in the DEX file format run on the device. lib/. Contains platform-dependent compiled code and native libraries for device-specific architectures, such as x86 or x86_64. META-INF/ . Contains the app certificate, manifest file, signature, and a list of resources. res/ . Contains resources; for example, images that are not already compiled into resources.arsc. resources.arsc . Contains pre-compiled resources used by the app. Figure 1 Android App Release Tasks Note: The figure illustrates the main tasks to prepare your app for release. From “Prepare your app for release” by Android Developers (n.d.a). Release Tasks As shown in Figure 1, the tasks are a set of chronological steps that need to be followed to properly release an Android app; the task set includes gathering materials, configuring the app, building an APK or Android App Bundles (AAB) file, preparing remote servers, and testing the app for release. Gathering Materials The first task of preparing an app for release is to gather the essential materials and resources. This needs to be done before configuring the app, and it requires preparing an End-User License Agreement (EULA), getting a cryptographic key, and having an App icon (Android Developers, n.d.a). EULA is a mandatory requirement for publishing on the Google Play Store. It is a legal contract between the developer and the users. It describes the terms and conditions of use. The following link is a generic example of an EULA made for the Steelcase company: Mobile Application End User License Agreement by Steelcase (2017). Note, this is just an example, and should be used as an example, not as a legal EULA document for your app. A cryptographic key is required for publishing an Android app. The key is an app unique digital signature that is used to verify the identity of the app’s author. It is a security measure that is used to verify that the app has not been tampered with or corrupted since it was signed. This key is mandated by the Google Play Store, and without it, apps cannot be installed or updated on Android devices. App icons are also required as they are used to launch the app on Android devices. “A launcher icon is a graphic that represents your application. Launcher icons are used by Launcher applications and appear on the user’s Home screen” (Stuff MIT, n.d.). App Configuration for Release The second step for preparing an Android app for release is to configure the app for deployment. This includes. An app ID, which is the package name that will be used over the life of the app (Stuff MIT, n.d.). For example, ‘ com.example.myapp ’, which usually follows the reverse domain name convention, this ID will be used to update, identify, and integrate the app with another service. Note that once the ID is set, after the app is distributed, the ID cannot be changed. Turning off debugging and logging (if used), it is essential to deactivate logging and disable the debugging option before building an app for deployment. To deactivate logging, the Log methods in the app’s source files need to be disabled. To disable debugging android:debuggable attribute needs to be removed from the tag in the app’s manifest file, or by setting the android:debuggable attribute to false in the manifest file. Additionally, any log files or static test files need to be removed. If used, any debugging tracing calls added code, such as startMethodTracing() and stopMethodTracing() need to be removed. It is also important to clean up the app’s project directories from stray and orphaned files by reviewing jni/ , lib/ , and src/ directories. For example, the jni/ directory needs to contain only source files associated with the Android NDK. The lib/ directory needs to contain only third-party library files or private library files. The src/ directory needs to contain only the source files for your application ( .java and .aidl files). The src/ directory should not contain any .jar files. Additionally, private or proprietary data files that the app does not use need to be removed. For example, in the res/ directory, old drawable files, layout files, and values files that are no longer used by the app need to be removed. In the lib/ directory, test libraries need to be removed. In the assets/ directory and res/raw/ directory, check for raw asset files and static files that may need to be updated or removed before release. Build the App for Release The next task is to build the APK file, also called a release-ready APK file, or Android App Bundle (AAB) file; both file formats should be signed and optimized (Android Developers, n.d.a). To sign the app for release to the Google Play Store means that the app needs to possess a unique cryptographic key. The cryptographic key was addressed previously in the Gathering Materials section of this post. Google strongly recommends using the AAB file format for new applications. An AAB file is a publishing format that includes all your app's compiled code and resources; it also defers APK generation and signing to Google Play (Android Developers, n.d.b). Note that when using Android Studio or the Gradle build system from the command line, the build process is entirely automated. To build an Android app release with Android Studio, the following YouTube video is a good source of information How to Create Singed AAB file in Android Studio (2023 Update) by The Code City (2023). The following YouTube the entire process of deploying an Android app on Google Play Store: How to Publish an Android App to Google Play | Updated 2024 by MJSD Coding (2024). Prepare Severs This task is relevant to the app release if the app relies on any external servers or services for its core functionality (Android Developers, n.d.a). Preparing the server for release involves verifying that the servers are secure, that they can handle the expected number of users (user load), and are configured for production use. This applies to apps using API calls to fetch data from a source that is not controlled by the app developer. Testing For Release The final task is testing of the app release build. This is done by testing it on the device and network conditions. Ideally, the app UI should at least be capable of handling one handset-sized device and one tablet-sized device. Google recommends using its Firebase Test Lab platform (Firebase, n.d.) to test Android apps across a variety of different devices and Android OS versions. Summary Preparing an Android app for release on the Google require a set of multiple steps, these tasks include understanding the structure of an APK and AAB file formats, gathering essential materials like a cryptographic key, EULA, and app icon; configuring the app by setting a unique ID, disabling debugging/logging, and cleaning project directories; and finally, building a signed and optimized release version, preferably as an AAB file format. Following these preparation tasks are essential for a smooth and successful app launch. References: Android Developers (n.d.a). Prepare your app for release . Android. https://developer.android.com/studio/publish/preparing Android Developers (n.d.b). About Android App bundles . Android. https://developer.android.com/guide/app-bundle Firebase (n.d.). Firebase Test Lab. Google. https://firebase.google.com/docs/test-lab Gillis, A. S. (n.d.). APK file (Android Package Kit file format) . Tech Target Networks. https://www.techtarget.com/whatis/definition/APK-file-Android-Package-Kit-file-format#:~:text=Contents%20of%20an%20Android%20Package,resources%20used%20by%20the%20app. MJSD Coding (2024, September 3). How to publish an Android app to Google Play | Updated 2024 [Video]. YouTube. https://www.youtube.com/watch?v=d8uEdeMgikU Steelcase (2017). Mobile application end user license agreement [PDF]. Steelcase. https://www.steelcase.com/content/uploads/2018/01/mobile_app_eula_ssa_19oct2017.pdf Stuff MIT (n.d.). Launcher icons . Massachusetts Institute of Technology. https://stuff.mit.edu/afs/sipb/project/android/docs/guide/practices/ui_guidelines/icon_design_launcher.html# The Code City (2023, August 2) How to create singed AAB file in Android Studio (2023 Update) [Video]. YouTube. https://www.youtube.com/watch?v=qMAtgMP0xyg

This article provides an overview of testing types necessary before releasing an Android app, detailing functional tests like unit, integration, UI, and end-to-end to ensure correct behavior. It also briefly touches upon non-functional testing, which assesses aspects like performance and usability, highlighting the importance of both for a high-quality release. Alexander S. Ricciardi April 13, 2025 Before releasing your Android app to the public, it is important to test your app's consistency by verifying its correctness, functional behavior, and usability before you release it publicly (Android Developers n.d.). It is two major types of testing, functional and non-functional. This post focuses on functional testing types by providing an overview of them and briefly explores non-functional types. Functional Testing Types Unit Testing Unit testing is one of the prevalent functional texting types, they should make up approximately 70% of your total number of tests. Unit testing involves testing individual units or components of your app in isolation (GAT Staff Writers, 2024). In other words, they verify small portions of the code app like individual methods or classes. They do not require an Android emulator or device as they are executed on the developer's PC or workstation using Java Virtual Machine (JVM) (BrowserStack, 2025a). This makes the test ideal for testing business logic. The most comely used tool for unit testing is JUnit, other tools are Mockito and Truth. Integration Testing Integration testing is implemented on components or modules that have been unit tested (Singh, 2024). The goal of the test is to observe data flow and identify defects in it. In other words, it examines how unit tested components work together to identify defects (BrowserStack, 2025a). The most common tools used for integration testing are Robolectric, JUnit, Mockito, and Truth. UI Testing User Interface (UI) testing is used to verify both the appearance and functionality of the UI by evaluating the visual elements, layout, responsiveness, and overall user experience (BrowserStack, 2025a). This involves behavior testing which examines how the UI responds to user actions and screenshot testing which is used to validate the visual accuracy of the UI across different devices (screen sizes and resolutions). The most commonly used tools used for UI testing are Espresso and UIAutomator. End-to-End Testing End-to-end (E2E) is used to verify an application's entire workflow from start to finish by simulating real-world scenarios. It verifies that all components of the application, including the user interface, business logic, data persistence, and external connection (API), function correctly together (BrowserStack, 2024b). The most common tools used for E2E Espresso and UIAutomator. Other tools are Appium which has cross-platform capabilities; and BrowserStack and LambdaTest which are cloud based testing platforms that offer a wide range of real device testing. Non-Functional Testing Type s Non-functional testing is used to verify aspects of a software application that are not directly related to its specific functions or features, but rather how well the system operates overall (GAT Staff Writers, 2024). In other words, it focuses on the quality of the software, such as performance, security, usability, and reliability. Non-functional testing is composed of a set of tests that includes performance testing that evaluates the speed, responsiveness, and stability of the app under different conditions; usability testing which is used to assess how easy is the app to use; compatibility testing which is used to verifies consistent functionality of the app across different devices and OS versions; accessibility testing which is used to access if the app is usable for users with disabilities; regression testing is used to test updates for bugs; and smoke testing is used to quickly check of the app’s functionalities after a build. Summary Before successfully releasing an Android app, rigorous testing is required. Testing such as functional testing (unit, integration, UI, end-to-end), which checks what the app does, ensuring correct functionality at all levels; non-functional testing (performance, security, usability, etc.), which focuses on how well the app performs. Combining both approaches ensures that the app is free of bugs, that it is user-friendly, and secure. References: Android developer (n.d.). Fundamentals of testing Android apps. Android. https://developer.android.com/training/testing/fundamentals BowserStack (2025a, March 18). What is Android unit testing? BowserStack. https://www.browserstack.com/guide/android-unit-testing BowserStack (2024b, June 28). End To End testing: Tools, types, & best practices. BowserStack. https://www.browserstack.com/guide/end-to-end-testing GAT Staff Writers (2024, May). What is Android testing - Types, tools and best practices. Global App testing. https://www.globalapptesting.com/blog/what-is-android-testing Singh, R. (2024, June 13). 12 mobile app testing types: A thorough exploration for QA professionals. Headspine. https://www.headspin.io/blog/types-of-mobile-app-testing

The article explores data persistence options within the Android ecosystem, focusing on SQLite and the Room Persistence Library. It compares these two approaches, highlighting their strengths and weaknesses to help developers choose the most suitable solution for their application's specific data storage needs, ultimately impacting performance and user experience. Alexander S. Ricciardi Mrach 9, 2025 Data persistence is the corner stone for building functional and robust applications within the Android ecosystem. Therefore, choosing the right data persistent solution for a specific application is essential, as it can significantly influence an app's performance, maintainability, and, consequently, the user experience. This article explores SQLite database and the Room Persistence Library. Data Persistence in Mobile Applications Data persistence in mobile applications can be defined as the capability of an application to store data locally with the goal of being retrieved even after the program is terminated and restarted (MongoDB, n.d.; Cuello, 2023). This is essential for preventing data losses, remembering the application state after the user left the application (e.g. in video game user progression), for offline functionality, and for better performance if the data is retrieved locally rather than from a server. In other words, data persistence is essential for building functional and robust Android applications that provide a good user experience. Storing Data Locally in Android When storing data locally, Android offers several options. Storage options like sharing preferences that use share key-values pairs, internal storage that stores files on-device, external storage that stores data in removable media such as SD cards, SQLite databases that store data relational databases, and the Room Persistence Library that uses SQLite databases through an abstraction layer to store data (Android Developers, n.d.). Depending on the needs of the application, one method may be more suitable than another. For example, for simple data, Shared Preferences or DataStore may be enough; on the other hand for larger datasets or complex data structures, SQLite or Room are better options. The following table describes the various Android storage options and their use cases. Table 1 Android Data Storage Options Note: The table provides descriptions of the various Android storage methods and their use cases. Data from “Data and file storage overview” by Android Developers (n.d.). Understanding The Differences Between SQLite and Room Persistence Library SQLite on Android can store data on the user's device (Chaitanyamunje, 2025). It is an open-source database that stores relational data in the form of tables. It is widely used, and its lightweight overhead makes it ideal for environments with limited resources such as mobile phones. SQLite uses the CRUD (Create, Read, Update, Delete) SQL approach to manipulate data. On the other hand, Room Persistence Library is an abstraction layer built on top of SQLite, it provides an object-oriented approach to managing persistent data by automatically converting data objects (the abstraction layer) to relational data that can be stored using SQLite and converting relational to object data that can be used by the application. Room significantly reduces boilerplate code compared to straight SQLite implementations. A boilerplate is code used to perform common database operations; for example, converting between database tables and Kotlin objects. As described above, the approaches are different, one uses a direct SQL query-based approach and the other one provides an object-oriented abstraction that handles the SQL operations. The question that can be asked is when is it better to use one approach over the other? For applications with simple data requirements probably would be due to very light overhead compared to Room. On the other hand, Room would be better for applications with complex data models or larger datasets. The table below lists the major differences between SQLite and Room Persistence Library. Table 2 SQLite vs Room Persistence Library Note: The table lists the differences between SQLite and Room Persistence Library based on various features. From several sources (Android Developers, n.d.; Mbano, 2022; Zincircioğlu, 2023; Naniewicz, 2024) To summarize, in mobile Applications, data persistence is the capability of an application to store data locally with the goal of being retrieved even after the program is terminated and restarted. To implement data persistence, the Android ecosystem offers several options such as sharing preferences, internal storage, external storage, SQLite, and the Room Persistence Library. While SQLite offers a direct, lightweight approach to managing local data, Room Persistence Library provides an object-oriented abstraction layer that reduces boilerplate code and seamlessly integrates with the Android ecosystem. Therefore, when implementing a data persistent solution is essential to understand the difference between the available storage options and how they align with the specific needs of the application. References: Android Developers (n.d.). Data and file storage overview. Android Developer. https://developer.android.com/training/data-storage#:~:text=If%20you%20have%20data%20that's,contains%20more%20than%202%20columns). Chaitanyamunje (2025, January 6). How to create and add data to SQLite database in Android? GeeksForGeeks. https://www.geeksforgeeks.org/how-to-create-and-add-data-to-sqlite-database-in-android/ Cuello, C. (2023, September 17). What is data Persistence? A complete guide. Rivery. https://rivery.io/data-learning-center/data-persistence/ Mbano, U. (2022, April 16). Android Room versus SQLite — Which is best? DVT software engineering. Medium. https://medium.com/dvt-engineering/android-room-versus-sqlite-which-is-best-32ff651bc361MongoDB (n.d.). What is Data Persistence? MongoDb. https://www.mongodb.com/resources/basics/databases/data-persistence Naniewicz, R., (2024, February 8). Check out why Room is a retrofit for SQLite. Netguru. https://www.netguru.com/blog/check-out-why-room-is-a-retrofit-for-sqlite Zincircioğlu, S. (2023, May 25). RoomDB vs SQLite : Exploring database options for Android development. Medium. https://medium.com/huawei-developers/roomdb-vs-sqlite-exploring-database-options-for-android-development-1120151e6737

The article provides an overview on how to incorporate multimedia elements into Android applications. It covers essential aspects such as handling permissions for accessing device resources, displaying images using ImageView and Image composable, and playing audio and video with MediaPlayer, VideoView and Jetpack Media3. Alexander S. Ricciardi March 16, 2025 Incorporating images, audio, and video into an Android app often involves implementing permissions to display images and play videos. This is usually necessary to meet the project's requirements or enhance the user’s experience. This post provides an overview on how to integrate images, audio, and video into Android apps. Permissions To integrate images, audio, and video within an Android app, handling permissions is essential because multimedia functionalities require access to sensitive resources like the camera and external storage. Thus, understanding what the necessary permissions are and how to implement them is crucial. Additionally, before they can be implemented, the permissions have to be allowed by the user. To implement a camera permission, for example, to capture or record videos, an app needs to request access to the camera (Android Developers. n.d.a). This request can be declared in the AndroidManifest.xml file as follows: To implement storage permissions to access media files stored on the device, the storage-related permissions need to be declared, and the files must reside in the ediaStore.Images, MediaStore.Video, or MediaStore.Audio (Android Developers. n.d.b). For apps used in Android 10 (API level 29) and higher, scoped storage is the recommended. With scoped storage, apps have access to their own app-specific directories and can access media files through the MediaStore API. For Android 9 and lower, or not wanting to use scoped storage, the READ_EXTERNAL_STORAGE (read only) and the WRITE_EXTERNAL_STORAGE (write only) permissions need to be declared in the AndroidManifest.xml file as follows: Image, Audio, and Video To display images using XML, the ImageView element is used to display images from various sources such as from drawable, local storage, and networks. To use ImageView with a drawable, simply drag the ImageView widget into your activity's layout, and then a pop-up dialog will appear, allowing you to choose from the available drawables (Rishu_mishra, 2025). When using Composable, the Image composable provides a way to display images. You can load images from different sources, including drawables, bitmaps, and painters (Android Developers. n.d.c). To play audio, the MediaPlayer class allows to play audio. It supports various audio sources, including local files, streams, and resources (Adityamshidlyali, 2024) To play videos, the VideoView is a UI element allows playing video content. It supports videos from various sources, including local files, resources, and network URLs (Google Developers, n.d.). Another alternative to MediaPlayer and VideoView, Jetpack Media3 is an Android library for media that enables apps to display rich audio and visual experiences (Android Developers. n.d.d). To summarize, integrating into an Android app, images, audio, and video requires handling permissions and the use of different tools. Permissions like CAMERA, READ_EXTERNAL_STORAGE, and WRITE_EXTERNAL_STORAGE need to be declared in the AndroidManifest.xml file and allowed by the user. For displaying images, ImageView in XML layouts or the Image composable can be used for that purpose. Audio can be managed by using the MediaPlayer class, while for video playing, VideoView can be used. An alternative for audio and video playing is to use the Jetpack Media3 library. References: Adityamshidlyali (2024, August 12). MediaPlayer class in Android. GeeksForGeeks. https://www.geeksforgeeks.org/mediaplayer-class-in-android/ Android Developers (n.d.a). Capture an image. Google. https://developer.android.com/media/camera/camerax/take-photo Android Developers (n.d.b). Access media files from shared storage . Google. https://developer.android.com/training/data-storage/shared/media Android Developers (n.d.c). Add images to your Android app. Google. https://developer.android.com/codelabs/basic-android-kotlin-compose-add-images#0 Android Developers. (n.d.d). Introduction to Jetpack Media3. Google. https://developer.android.com/media/media3 Google Developers (n.d.). 13.1: Playing video with VideoView. Advanced Android development. Google. https://google-developer-training.github.io/android-developer-advanced-course-practicals/ Rishu_mishra (2025, January 28). ImageView in Android with example. GeeksForGeeks. https://www.geeksforgeeks.org/imageview-in-android-with-example/

The article compares three popular HTTP clients, Retrofit, Volley, and OkHttp for making network requests in Android apps developed with Kotlin and Jetpack Compose. It highlights the strengths and weaknesses of each client, providing guidance on selecting the best option based on project needs, and emphasizes the importance of asynchronous request handling and error management for a robust application. Alexander S. Ricciardi March 9, 2025 Developing an Android app frequently involves implementing some data fetching functionality and sending data to servers within the application (Coditive, 2024). This often means making network requests asynchronously and handling network errors. When using a combination of Kotlin and Jetpack Compose, several popular HTTP (Hypertext Transfer Protocol) clients can be used to perform network requests. This post explores three of the most commonly used clients: Retrofit, Volley, and OkHttp, and their strengths and weaknesses, and discusses when to use each one. Clients for Network Requests The most popular HTTP clients for making network requests while using Kotlin and Jetpack Compose are Retrofit, Volley, and OkHttp. HTTP client is a software that allows applications to communicate with web servers and APIs over the internet. It handles network requests, responses, and connections within the HTTP protocol system, including managing headers, methods (GET, POST, PUT, DELETE). Retrofit Retrofit was developed by Square, and it is a type-safe HTTP client (Kostadinov, 2024). It is an abstraction that allows making API calls through declarative interfaces and handles parsing JSON into Java/Kotlin objects using libraries like Gson or Moshi. The table below lists and describes different aspects and features of Retrofit. Table 1 Retrofit Aspect and Features Note: The table lists various aspects and features of the Retrofit HTTP client for Kotlin and Java. Data from several sources (Square, n.d.a; GeeksForGeeks, 2025; Kramer, 2024; Kostadinov, 2024; Anna, 2024) Volley Volley is another HTTP client developed by Google, it was designed in 2013 to make networking easier and faster in Android apps (Vartika02, 2025). It is well-suited for applications making frequent, small network requests. The table below lists and describes different aspects and features of Volley. Table 2 Volley Aspect and Features Note: The table lists various aspects and features of the Retrofit HTTP client for Kotlin and Java. Data from several sources (Google, n.d.; Vartika02, 2025; AbhiAndroid, n.d.) OkHttp OkHttp was developed by Square, it is a powerful and efficient HTTP client for Kotlin and Java, it was used as the foundation for both Retrofit and Volley (Gouda, 2024). It can also be used directly, providing more control on network requests than Retrofit and Volley. The table below lists and describes different aspects and features of OkHttp. Table 3 OkHttp Aspect and Features Note: The table lists various aspects and features of the OkHttp HTTP client for Kotlin and Java. Data from several sources (Square, n.d.b; Gouda, 2024; Baeldung, n.d.) Each client has its pros and its cons. When choosing the best client for the application developers need to consider factors such as the complexity of the project, the frequency of the requests, the size of the requests, and control vs. convenience to select the client that fits best with those needs. The table below compares the clients by key features and characteristics. Table 4 HTTP Client Comparison Note: The table below compares the clients by key features and characteristics. No matter what client is implemented within an application, network requests should never be executed on the main threads. Doing so can result in the app freezing and poor user experience. Best practices dictate the use of asynchronous mechanisms such as Kotlin Coroutines to avoid blocking the app's main thread. Kotlin Coroutine is a concurrency design pattern that simplifies code executing asynchronously (Android Developers, n.d.). The design provides several advantages including its lightweight nature, built-in cancellation support, and improved memory management. In addition to implementing asynchronous mechanisms for executing network requests, it is essential to handle network errors properly to create an overall robust application and a good user experience. Strategies such as robust network exception handling, thorough testing, retry mechanisms, and user feedback should be implemented and designed when integrating network request mechanisms within the application. To summarize, when developing an Android app with Kotlin and Jetpack Compose, common HTTP clients for integrating network requests are Retrofit, Volley, and OkHttp. Choosing the right HTTP client depends on the specific needs of the project. Regardless of the chosen library (client), developers need to implement asynchronous execution for network requests by using designs such as Kotlin Coroutines. This is essential for not freezing the app during network calls and for a good user experience. Additionally, implementing network error handling is also essential for building a robust application that can use network request mechanisms effectively. Therefore, understanding how to integrate HTTP clients with asynchronous programming and error handling is crucial for designing a successful Android development that incorporates network requests. -Alex References: AbhiAndroid (n.d.) . Volley tutorial with example in Android Studio . AbhiAndroid. https://abhiandroid.com/programming/volley#gsc.tab=0 Android Developers (n.d.). Kotlin coroutines on Android. Android. https://developer.android.com/kotlin/coroutines Anna. (2024, November 16). Retrofit in Android. Medium. https://medium.com/@anna972606/retrofit-in-android-15fa724a8fa6 Baeldung (n.d.). A guide to OkHttp. Baeldung. https://www.baeldung.com/guide-to-okhttp Coditive. (2024, November 24). Understanding retrofit: Simplifying Android networking. Medium. https://medium.com/@coditive/understanding-retrofit-simplifying-android-networking-ef37f72f9cb8 Kramer, N. (2024, May 14). Retrofit tutorial for Android beginners. Daily.dev . https://daily.dev/blog/retrofit-tutorial-for-android-beginners Kostadinov, D. (2024, December 11). When to use Retrofit and when to use KTOR: a guide for Android developers. Medium. https://proandroiddev.com/when-to-use-retrofit-and-when-to-use-ktor-a-guide-for-android-developers-918491dcf69a GeeksForGeeks (2025, February 18). Introduction to Retrofit in Android. GeeksForGeeks. https://www.geeksforgeeks.org/introduction-retofit-2-android-set-1/ Google (n.d.). Volley. GitHub. https://google.github.io/volley/ Gouda, M. (3034, December 5). Comprehensive guide to OkHttp for Java and Kotlin. ScrpFly. https://scrapfly.io/blog/guide-to-okhttp-java-kotlin/ Square (n.d.a). Retrofit. GitHub. https://square.github.io/retrofit/. Square (n.d.b). OkHttp. GitHub. https://square.github.io/okhttp/ Vartika02 (2025, January 6). Volley library in Android. GeeksForGeeks. https://www.geeksforgeeks.org/volley-library-in-android/

This article documents the author's first experience developing an Android application using Kotlin and XML, detailing the creation of a "Hello Android" app that features a bouncing text animation and a toggle button to control it. The author reflects on the challenges of learning Kotlin, understanding the Android project structure, connecting UI elements to code, and implementing a background thread for the animation, providing a beginner's perspective on fundamental Android development concepts. Alexander S. Ricciardi February 24, 2025 Learning platform-based application development is not an easy endeavor. In this article, I reflect on my first exposure to Android app development using Kotlin and XML, providing an overview of a simple "Hello Android" application. I describe the application's functionality and testing scenarios, including the pseudocode, Kotlin code, and output screenshots. I also reflect on the obstacles faced during development and the skills I acquired. App Description The app is a simple Hello Android Application written in Kotlin. It displays a simple animation where a TextView ("Hello Android!") bounces around within the screen's boundaries. It also provides a toggle button allowing the user to stop and restart the text animation. Additionally, the program uses a background thread to run a text animation within an infinite loop. This loop updates the TextView's position and, when hitting a screen boundaries, the text bounces and changes color. This ‘hands-on’ animation approach is implemented for learning purposes, it is generally better and good practice to use Android API’s built‑in animation classes (like those in AnimationUtils). Furthermore, to initialize the application, I used the Empty View Activity Template from Android Studio. Then I modify the files to implement the text animation and my icon. The source code files for this application can be found on my GitHub page in the following repository Module-1-Critical-Thinking . The app was developed using the Android Studio IDE (Integrated Development Environment). Project Map: CTA1 Hello Android App.docx (this file, App documentation) MainActivityPseudo.txt (Main Activity pseudocode) The project used files from the Android Studio’s Empty View Activity template. Additionally, only the template files that were modified to accommodate the functionality of the application are listed below: MainActivity.kt (Kotlin code, application logic) Main_activity.xml (XML code, main UI layout) Value string.xml (resource file storing strings) The following files have been overridden or modified to accommodate my icon. If you do not want to use my logo, do not use these files. The template will automatically use the Android icon. Value color.xml theme.xml (this file was not modified or overridden, but it is part of the value folder) drawable ic_launcher_background.xml ic_launcher_foreground.xml mipmap-anydpi-v26 ic_launcher.xml ic_launcher_round.xml mipmap folders (hdpi; mdpi; xhdpi; xxhdpi; xxxhdp – different variation of my icon) Reflection This is my first time using Kotlin and Android Studio to create a program. Installing Android Studio was straightforward. Learning about Kotlin from the textbook and doing research about it was rewarding. The following is an overview of Kotlin based on what I have learned from the textbook and my research. Kotlin is often described as the most succinct language, meaning that is the least error-prone programming language (Horton, 2019). Android SDK (Software Development Kit) is written in Java. Moreover, Kotlin is fully interoperable with Java, meaning that Java libraries and frameworks can be easily integrated into Kotlin code, and Java projects also can be easily migrated to Kotlin. It is an Object-Oriented Programming language (OOP). It includes null safety, preventing null pointers. It allows function extensions, that is adding functionality to existing classes without modifying their source code. It allows data classes which are classes primarily used to hold data. It can implement coroutines, making asynchronous programming much easier such as handling network requests. (Ricciardi, 2025) Furthermore, it is generally preferred for Android app development over programming languages like C++ and Java. The table below lists some of the advantages Kotlin has over C++ and Java. Table 1 Kotlin’s advantages over C++ and Java Note: The table lists the advantages that Kotlin has over C++ and Java when developing Android based Apps. From “Why Kotlin is preferred for Android app development” by Ricciardi (2025). As described previously, I chose to create a “Simple Hello Android APP” by modifying the Empty View Activity Template from Android Studio and implementing a background thread to run a text animation within an infinite loop. This loop updates the TextView's position and, when the text hits a screen boundary the text bounces and changes color. This was done to practice implementing variables and loops using Kotlin. Kotlin Variables Handling Kotlin uses type inference, type check, and smart-cast, meaning that, when type referring, the compiler automatically deduces the data types of variables and expressions, eliminating the need for explicitly declaring variable types (App Dev Insights, 2023). Type checks are performed in two ways by using the ‘is’ operator and its negation ‘!is’. These operations return a Boolean, that is return true if the condition is met. For example, if a variable ‘is’ of the data typed checked the condition will return true if not it will return false. Smart-cast allows the compiler to cast a variable to a specific type within a code block, without the need for explicit type checks and casts; for example, ' print(x.length) // x (a string) is automatically cast to String '. Furthermore, Kotlin uses two different keywords to declare variables, ‘val’ and ‘var’ (Developers, n.d.). ‘val’ is used to declare static variables, variables that never change, and ‘var’ is used to declare non-static variables, variables whose value can change. Kotlin's syntax is very similar to Java, and transitioning from Java to Kotlin for this assignment was traits forward. The part that was most challenging for me was learning the Android Project Structure, that is how the project files are interconnected using the Android Manifest file and Gradle build configurations My Android Project File Structure Learning my project file structure dependencies was essential for me to understand how different parts of the application interact and to implement a functional code. Below is a breakdown of the key components and their description: Figure 1 Hello App Structure on Android Studio Note: The figure illustrates the Hello App file structure in Android Studio. Note that the MainActivity.kt and activity_main.xml are the core files of the application. The MainActivity.kt file contains the Kotlin source code dictating the logic for the application, in this example the logic for the bouncing text background animation thread and the toggle button. The activity_main.xml contains the XML code that defines the user interface layout, including the TextView for the " Hello Android! " text and the ToggleButton . The ic_launcher files have been modified or overridden to accommodate my personal icon. The color.xml file has been modified to integrate a color background for my icon. The strings.xml file has been modified to store the ToggleButton text describing its state and the bouncing_text (“ Hello Android !”) Pseudocode and Koltin Code Implementing the animation of the bouncing text was not very difficult as I had implemented this functionality in other programming languages, more specifically Java and Python. The most difficult part was understanding how to get the elements from the UI so they could be integrated into the application logic ( MainActivity.kt ). The Android environment uses ‘id’ to accomplish it. For example, to get the size of the screen (‘ View ’) to set the boundaries of the text animation, I use the ‘ id ’ of the element ‘View’ from the activity_main.xm l layout file after I imported it and set it as the application content view using this following line of code ' setContentView(R.layout.activity_main)' Below is a Kotlin code snippet demonstrating how this process is done: Code Snippet 1 Using Ids to Connect Logic and UI // Set content view, the UI from the activity_main.xml layout file setContentView(R.layout.activity_main) // Layout's views attribute from activity_main.xml layout file val container = findViewById( R.id .main) // The root container (ConstraintLayout) // The TextView that will bounce val textView = findViewById( R.id .bouncingText) // Button to start/stop the animation val toggleButton = findViewById( R.id .toggleButton) Note: The Kotlin code snippet illustrated how UI (layout) and Logic are connected using ids. This code is part of the onCreate function. The other challenging part was understanding the functionality of the ' ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main))' method within the onCreate function, to keep it simple, the code functionality avoids overlaps between window insets (UI element of the app behind system elements) with system UI elements (e.g. Status Bar, Navigation Bar). If the app's content overlaps with the system UI elements, it can lead to poor user experience. Figure 2 Main Activity Pseudocode Note: The figure illustrates a snapshot of pseudocode implementing the logic of a text view bouncing and changing color within a container (presumably a screen). The animation runs in a background thread. Additionally, the code implements a toggle button to stop and restart the animation. Furthermore, this pseudocode was created with an Android application perspective in mind and is intended to be translated into Kotlin. Please see MainActivityPseudo.txt file, the complete code here: Module-1-Critical-Thinking . Figure 3 Main Activity Kotlin (MainActivity.kt) Note: The figure illustrates a snapshot of Kotlin code implementing the logic of a text view bouncing and changing color within a container (a screen). The animation runs in a background thread. Additionally, the code implements the logic of a toggle button to stop and restart the animation. Please see MainActivity.kt file , the complete code here: Module-1-Critical-Thinking . Code Snippet 4 Main Activity XLM Layout UI (main_activity.xml) ========================================================================== This file is a resource file written in XML that defines the user interface layout, including the TextView for the "Hello Android!" text and the ToggleButton. It is part of the Simple Hello Android App Author: Alexander Ricciardi Date: 02/14/2025 Requirement: Kotlin and XML Program Description: This is a simple Hello Android Application written in Kotlin. It displays a simple animation where a TextView ("Hello Android!") bounces around within the screen's boundaries. It also provides a toggle button allowing the user to stop and restart the text animation. ========================================================================== --> Note: The XML snippet illustrates the UI layout of the application. Please also see main_activity.xml file for the code. To connect the elements from the UI, this file (main_activity.xml), to the application logic, Android uses elements’ ‘ids ’; for example the ‘TextView’ element as an ‘id’ associated with ‘ bouncingTex t’ as illustrated by the following code lines: Figure 4 Connecting Variables Note : The figures illustrate how variables interconnect within the Andriod ecosystem. Screenshots This section demonstrates the output of the applications using GIF format images. Figure 5 Bouncing Text and Toggle Button Note: The figure GIF animation depicts the ‘ Hello Android! ’ text bouncing and changing color, from black to dark green after bouncing off the edge of the screen. It also depicts the user clicking on the toggle button to stop and restart the animation. Note that the button text all changes from ‘ Stop Animation ’ to ‘Start Animation ’ when first clicked and then from ‘ Start Animation ’ to ‘ Stop Animation ’ when clicked again. Figure 4 Icon and Home Buttons Note: The figure GIF animation depicts a user using the ‘Home’ and the application icon buttons. Note that the animation seems not to be fluid, this is due to the GIF animation looping, not the application animation itself. Summary The "Simple Hello Android App" project provided me with a good foundation for understanding Android development using Kotlin and XML. The process of creating the bouncing text animation and the toggle button helped me to become more familiar with Kotlin, how it is used to implement the application logic (MainActivity.kt), and how it interconnects with the XML UI design (using ConstraintLayout, TextView, and Button in activity_main.xml), and the application resources (e.g. strings.xml). Understanding the Android project structure, connecting UI elements to Kotlin code via resource ‘ids’, and managing a background thread for animation, were the most challenging parts of the project. Ultimately, the project provided me with a solid grasp of fundamental Android concepts and its ecosystem. References: App Dev Insights. (2023, December 16). Kotlin Type inference, Type check, Smartcast - App Dev Insights . Medium. https://medium.com/@appdevinsights/kotlin-type-inference-type-check-smartcast-49c5f98fac1b Developers (n.d.). Learn the Kotlin programming language. Android. https://developer.android.com/kotlin/learn Horton, J. (2019). Android programming with Kotlin for beginners. Packt Publishing. ISBN: 9781789615401 Ricciardi, A. (2025, February 14). Why Kotlin is preferred for Android app development . Level Up Coding │ Medium. https://medium.com/gitconnected/why-kotlin-is-preferred-for-android-app-development-c1d8f10ad95c

This article examines the recent advancements in quantum computing, specifically Google's Willow and Microsoft's Majorana 1 Quantum Processing Units (QPUs), and explores the profound impact that the combination of quantum computing and AI will have on society, including potential benefits and risks. Alexander S. Ricciardi February 24, 2025 In the era of AI, quantum computing can be as transformative a technology as AI itself. Google introduced the Willow quantum processor in December 2024 and Microsoft's Majorana 1 topological chip in February 2025. Both chips are Quantum Processing Units (QPUs); however, their approaches to quantum computing differ significantly. Whatever quantum computing technology comes to dominate in the near future, the combination the AI and quantum computing technologies will bring about an era reminiscent of science fiction movies that will have a profound transformative impact on humanity. This sparks today, a mix of extreme excitement and deep concerns. Although quantum computing combined with AI offers the potential for unprecedented positive technological advancements, it can also lead to very serious negative consequences. This is a reminder of the tension that can exist between the "can do" of science and engineering and the "should do" of ethical and political analysis (Winston & Edelbach, 2014). This post provides an overview of quantum computing, examines Google's Willow and Microsoft's Majorana 1 Quantum Processing Units (QPUs), discusses the benefits and risks of quantum computing, especially when combined with artificial intelligence (AI), and explores the ethical questions "can do" versus "should do" regarding these technologies. Overview of Quantum Computing Quantum computing uses the quantum mechanics superposition and entanglement principles to perform computations. Unlike classic computing which uses bits (1s and 0s) to encode information, quantum computing uses qubits (0s, 1s, and superposition). Bits represent two possible states of a system ‘1’ and ‘0’ (Microsoft, n.d.a). On the other hand, qubits represent the possible quantum states of a system, and a quantum system can be in three different states one of them is superposition which allows a quantum system to exist in multiple states simultaneously. In other words, a qubit can be in a superposition of 0 and 1, allowing multiple computations in parallel by processing all possible states of the qubits at once. This will allow, theoretically, to compute answers to problems that would be impossible to solve using even the most powerful supercomputers that humanity could ever build (Domain of Science, 2024). However, quantum chips are very vulnerable to noise which generates errors in qubits. Before the Willow and Majorana 1 QPU chips noise was the obstacle to achieving reliable quantum computation. Both chips address the noise problem, each using its own approach. While Google Willow's approach focuses on error correction, using a combination of software and hardware, to mitigate the noise and decoherence, Microsoft's Majorana 1’s approach uses quantum topology to resist noise and decoherence at the chip level by using a novel topoconductor material. Google labels the Willow chip as an experimental device, while Microsoft describes the Majorana 1 as a prototype with the potential to scale to a million qubits on a single chip,` claiming that the first fully functional quantum computer would be a reality within a few years. The table below compares the features of the chip and their error rates. Table 1 Willow Features vs Majorana 1 Note: The table compares the different features and error rates of the Willow QPU from Google and Majorana 1 QPU from Microsoft. From several sources (Nayak, 2025; Domain of Science, 2024; Trueman, 2025; Microsoft, 2025b) As shown in Table 1, both chips are state-of-the-art; however, Microsoft’s Majorana 1 appears to have an advantage due to its topological design, which provides more stability, scalability, and error resistance and has the potential to be implemented within a fully functional quantum computer within a few years rather than a decade. Benefits of Quantum Computing and Impact on AI Once fully functional quantum computers become a reality, they will transform various fields and elevate AI capacities to levels impossible to imagine, unveiling possibilities beyond what we can currently comprehend. For example, quantum computers can simulate with ease molecular behavior and biochemical reactions which when combined with AI could massively speed up the research and development of life-saving new drugs and medical treatments. For a similar reason, it could immensely accelerate the discovery of new materials such as advanced composites, superconductors, etc. revolutionizing industries like energy, manufacturing, and environmental science. They could have a considerable impact on AI research and training by accelerating training runs and optimization, enhancing model complexity and creativity, and improving the robustness and generalization of the AI model (Fowler, 2024). As well as improving data processing for AI training, enhancing encryption and security within AI applications, and combining quantum computing with neural network architectures (Kiessling, 2024; Quantinuum, 2025) Quantum Computing Risks and Ethical Issues However, quantum computing also raises several risks and ethical issues such as data security and cybersecurity which are already an issue due to the "harvest now, decrypt later" attack, where malicious actors collect encrypted data today with the intention of decrypting it later when quantum computers become available (Bown, n.d.). Additionally, quantum computing could exacerbate inequities between rich and poor countries by limiting access to advanced computing power (Boger, n.d.). Moreover, it could bring into existence AI systems so powerful that they could outsmart humans, potentially leading to a complete loss of control and even posing an existential risk to humanity. "Can Do" and "Should Do" Both Google’s Willow chip and Microsoft’s Majorana 1 chip promise to bring immense benefits to humanity and they exemplify the "can do" spirit of scientific research, technological innovation, and engineering, sitting at the boundary of humanity’s understanding, knowledge, and technological capabilities. However, the ethical "Should do" question arises: should humanity develop such technology that, if combined with AI, could bring catastrophic consequences like loss of control and existential risk? This ethical question cannot be answered without considering its geopolitical counterpart: "Should we develop such technology and combine it with AI, knowing that if we do not, someone else will anyway? In the technological AI/Quantum Computing race in which the US and China are locked, the countries perceive the "Should do" statement not as a question with a choice but as a must driven by national security and global dominance. References: Boger, Y (n.d.). Ethics and quantum computing. Scientific Computing World. https://www.scientific-computing.com/article/ethics-quantum-computing Brown, L. (n.d.). Understanding quantum risk: The threats posed by quantum computing. GRC Viewpoint. https://www.grcviewpoint.com/understanding-quantum-risk-the-threats-posed-by-quantum-computing/ Chamber, A. (2025, February 20). Microsoft unveils Majorana 1, its first quantum processor chip. Technology Record. https://www.technologyrecord.com/article/microsoft-unveils-majorana-1-its-first-quantum-processor-chip Domain of Science (2024, May 13). Microsoft's Topological quantum computer explained [video]. YouTube. https://www.youtube.com/watch?v=ihZXl33t8So&t=17s Fowler, G. (2024, May 14). How quantum computing will impact generative AI. Medium. https://gafowler.medium.com/how-quantum-computing-will-impact-generative-ai-779ba190cf18 Kiessling, C. (2024, December 20). Quantum computing and AI – 
A superpower in the making? Roland Berger. https://www.rolandberger.com/en/Insights/Publications/Quantum-computing-and-AI-A-superpower-in-the-making.html Microsoft (n.d.a). Superposition . Explore quantum. https://quantum.microsoft.com/en-us/insights/education/concepts/superposition Microsoft (2025b, February 19). Microsoft’s Majorana 1 chip carves new path for quantum computing . Microsoft. https://news.microsoft.com/source/features/innovation/microsofts-majorana-1-chip-carves-new-path-for-quantum-computing/ Nayak, C. (2025, February 19). Microsoft unveils Majorana 1, the world’s first quantum processor powered by topological qubits. Microsoft. https://azure.microsoft.com/en-us/blog/quantum/2025/02/19/microsoft-unveils-majorana-1-the-worlds-first-quantum-processor-powered-by-topological-qubits/ Neven, H. (2024 December 9). Meet Willow, our state-of-the-art quantum chip. Google Blog. https://blog.google/technology/research/google-willow-quantum-chip/ Quantinuum (2025, January 22). Quantum computers will make AI better. Quantinuum. https://www.quantinuum.com/blog/quantum-computers-will-make-ai-better Spinq (2024, December 18). Meet Willow, Google's latest breakthrough in quantum chip. Spinq. https://www.spinquanta.com/newsDetail/92ad47a1-99c1-4e01-a8ee-0074c42d9384 Trueman, C, (2025, February 15). Google CEO: Practical quantum computers likely still a decade away. DCD. https://www.datacenterdynamics.com/en/news/google-ceo-practical-quantum-computers-likely-still-a-decade-away/ Winston, M., & Edelbach, R. (2014). Society, ethics, & technology (5th ed.) . Wadsworth Cengage Learning.

This article compares XML and Jetpack Compose for building Android UI layouts, it also explores the challenges of designing complex UIs and how Jetpack Compose's declarative approach and Kotlin-based toolkit offer more efficient solutions. Alexander S. Ricciardi February 22, 2025 In the context of Android app development, designing complex layouts presents a set of common challenges. This is true when using both XML and Jetpack Compose. Google’s parent company, Alphabet, owns Android, and Google manages it as a subsidiary. Google acquired Android in 2005 for just $50 million (Reynolds, 2017). Since then, Google has invested heavily in Android and guided the evolution of its ecosystem, making it the most popular mobile system in the world. This post provides a brief overview of Jetpack Compose and explores common challenges one can face when designing complex layouts in Jetpack Compose. Jetpack Compose Overview XML (Extensible Markup Language) has been the cornerstone of Android UI design since its early days in 2008 (Angelo, 2024). XML is a markup language used to structure and organize data, it supports information exchange between computer systems such as websites, databases, and third-party applications (AWS, n.d.). In the Android ecosystems, it is used to define User Interface (UI) layouts and elements. Developers use XML to specify the arrangement of buttons, text views, images, and other UI components. However, since declaring Kotlin the official programming language for Android app development in 2017, Google endorsed Jetpack Compose, a toolkit written in Kotlin, as the preferred solution for building complex Android app UIs, starting in early 2019 (Samojło, 2024; Angelo, 2024). See Table 1 for a list of the main differences between XML and Jetpack Compose. Table 1 XML vs Jetpack Compose Note: The table lists the main differences between XML and Jetpack Compose. From “XML vs. Jetpack Compose: A Comparison” by Angelo (2024) Compose toolkit is part of the Android Jetpack developer library from Google, a suite of toolkits that are used to create and manage UI, manage data, schedule background tasks, and more. The toolkit uses a declarative programming paradigm (Android Developers, n.d.a). This means that developers describe what your UI should contain, and the Jetpack Compose toolkit does the rest not needing to write anything in XML, everything is done through Kotlin code (Android Developers, 2022b). Compose layouts are built using Kotlin composable functions, which are functions that emit Units describing elements of a UI (Android Developers, n.d.c). In Kotlin, a Unit is a type that represents no meaningful value, similar to void in Java or C++. Additionally, Almost everything in Compose is a Layout such as Box, Column, Row, and BoxWithConstraints. The examples below illustrate how to use a Compose basic function and the Column Layout. Code Snippet 1 A Basic Composable Function - Kotlin @Composable fun ArtistCard() { Text("Alfred Sisley") Text("3 minutes ago") } Output Note: The code Snippet is an example of a basic Kotlin composable function. From “Compose layout basics” by Android Developers (n.d.c). Code Snippet 2 A Basic Composable Function Using A Column Layout - Kotlin @Composable fun ArtistCardColumn() { Column { Text("Alfred Sisley") Text("3 minutes ago") } } Output Note: The code Snippet is an example of a basic Kotlin composable function using a Column Layout. From “Compose layout basics” by Android Developers (n.d.c). Note that just by adding the @Composable annotation the compiler will treat the following function as a Composable function, and by encapsulating the Text element within the Column Layout, the text outputs automatically aligned vertically. The same code in XML and Kotlin could be the following: Code Snippet 3 Compose Code Translated to Kotlin and XML Kotlin: import android.os.Bundle import androidx.appcompat.app.AppCompatActivity class ArtistCardColumnActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.artist_card_column) } } XML: Note: The XML and Kotlin code snippets are the translations of the Compose code from Code Snippet 2. Note that just by adding the @Composable annotation the compiler will treat the following function as a Composable function, and by encapsulating the Text element within the Column Layout, the text outputs automatically aligned vertically. This shows one of the reasons why Jetpack Compose is generally preferred over XML as it is less verbose. However, XML integrates with Java and C++, whereas Jetpack Compose is exclusively Kotlin-based, so it’s important to consider the application’s needs when choosing between these two approaches. Additionally, large applications are more likely to adopt a hybrid approach, using both XML and Jetpack Compose; for example, an AAA or AA mobile video game is most likely to combine Kotlin, Java, and C++ with both XML and Jetpack Compose for UI/UX. Common challenges When Designing Complex Layouts ꟷ Jetpack Compose Whether using XML or Jetpack Compose within an Android application or a PC desktop application for that matter, designing complex UI/UX layouts has common challenges. Complex UIs/UXs need to balance functionality with usability, making the task of designing layouts a daunting one. Nonetheless, developers need to understand what those challenges are and how to address them. The table below is the results of my research on the matter, it lists the most common challenges in designing UI/UX and general solutions for any app and specific solutions for those built with Jetpack Compose. Table 2 Challenges and Solutions for Designing Complex App Layouts with Jetpack Compose Note: The table provides a list describing the most common challenges in designing UI/UX their general solutions for any app and specific solutions for those built with Jetpack Compose. From several sources (TechAffinity, 2023; Blair, 2024; Sakthivel, 2022, Android Developers, n.d.d). As shown in Table 1, Jetpack Compose provides modern solutions to common challenges in designing UI/UX, challenges like balancing complexity and simplicity, information overload, navigation difficulty, performance issues, and cross-platform consistency by offering a variated of tools. This affirms Google’s strategy for pushing Jetpack Compose as the ideal tool for building complex UI/UX layouts within the Android ecosystem. To summarize, Jetpack Compose is a powerful tool for Android UI development; it is concise, reactive, and Kotlin-based. Jetpack Compose offers more modern features than XML and is significantly less verbose, saving time, reducing code lines, and minimizing errors. Additionally, it addresses common challenges in designing UI/UX with effective solutions. Overall, Jetpack Compose a well-developed toolkit that reflects Google's vision for Android as a developer-friendly platform meant to guide the future of mobile app design. References: Android Developers (n.d.a). Thinking in Compose. Android. https://developer.android.com/develop/ui/compose/mental-model Android Developers (2022b, September 13). Intuitive: thinking in compose - MAD skills [Video]. YouTube. https://www.youtube.com/watch?v=4zf30a34OOA Android Developers (n.d.c). Compose layout basics. Android. https://developer.android.com/develop/ui/compose/layouts/basics#:~:text=Composable%20functions%20are%20the%20basic,each%20other%2C%20making%20them%20unreadable: Android Developers (n.d.d). Jetpack Compose Tutorial. Android. https://developer.android.com/develop/ui/compose/tutorial Angelo, A. (2024, April 29). XML vs. Jetpack Compose: A Comparison. https://blog.openreplay.com/xml-vs-jetpack-compose--a-comparison/ AWS (n.d.). What is XML? Amazon. https://aws.amazon.com/what-is/xml/#:~:text=Extensible%20Markup%20Language%20(XML)%20lets,might%20give%20suggestions%20like%20these: Blair, I. (2024, September 21). The best app layout ideas for amazing user experience. Buildfire. https://buildfire.com/best-app-layout-ideas/ TechAffinity (2023, March 15). 7 common app design challenges and ways to overcome them. TechAffinity Blog. https://techaffinity.com/blog/7-common-app-design-challenges-and-ways-to-overcome-them/ Sakthivel, K. (2022, April 11). Common app design challenges and their solutions. UXmatter. https://www.uxmatters.com/mt/archives/2022/04/common-app-design-challenges-and-their-solutions.php

This article explores the potential impact of artificial intelligence (AI) on industries, highlighting its benefits, drawbacks, and ethical issues. It also examines from a computer science student’s perspective, how AI is reshaping the student’s education paths and possible career choices, by looking at opportunities within the AI-driven gaming sector and using the company Inworld AI as a case study. Alexander S. Ricciardi February 16, 2025 Open AI CEO Sam Altman revealed in a Q/A session at the University of Tokyo (UTokyo) that an internal OpenAI large reasoning model ranks 50th best coder in the world, and he predicted that by the end of 2025, a large reasoning model will rank 1st (UTokyo Center for Global Education, 2025). This article examines the benefits and drawbacks of Artificial Intelligence (AI), and how AI is impacting my education path and future career choices. It also explores career opportunities at a start-up AI company called Inworld AI. The term 'Artificial Intelligence' (AI) was first introduced in 1956 by John McCarthy, a professor at Dartmouth College. He used the term to name a summer workshop, Dartmouth Summer Research Project on Artificial Intelligence, organized to clarify and develop ideas about 'thinking machines' (Science and Technology (DDST), n.d.). Large language models (LLMs) are a type of AI that are trained on massive amounts of text data, they can understand and generate human-like text. LLMs came into the spotlight with the release of the chatbot ChatGPT by OpenAI in November 2022. Since then, the LLMs have evolved into large reasoning models such as o1, DeepSeek R1, and o3, having expert or PhD level capability in mathematics, physics, coding, and other STEM fields. They have also evolved into generative AI models capable of generating realistic images, videos, voices, and music. AI as it stands today is often defined as a transformative technology and a revolutionary force that is redefining numerous industries in the ever-changing landscape of modern technology (Zatzu et al., 2024). The potential for AI to be beneficial to humanity is immense; however, it will also fundamentally reshape how people live and work, presenting potential dangers and ethical issues. The Benefits and Drawbacks of AI – Ethical Concerns The table below lists several benefits as well as drawbacks and dangers of AI. Table 1 AI’s Benefits, Drawbacks, and Dangers Note : The table lists the main benefits, drawbacks, and dangers of AI. From several sources (Rowan University n.d.; St. George University 2024; Takyar, n.d.; Singh, 2025; University of Cincinnati, n. d.; Von Der Osten, 2023; Capitol Technology University, 2023; D’Antonoli, 2020; Thomas, 2024;Virginia Tech Engineer, 2023; Fardian, 2022;Georgieva, 2024) As shown by Table 1, AI has many benefits, as well as many drawbacks. My main ethical concern is how it is already used and will be used in the future to replace human workers. Salesforce, a major SaaS company, announced that in 2025 it will not be hiring any more software engineers amid significant productivity boosts from AI (Martin, 2024). Additionally, by the end of this year, 2025, agentic AI capable of autonomously executing complex tasks, and AGI (Artificial General Intelligence), AI capable of performing any intellectual task that a human being can, are predicted to be available and starting to be deployed. In a society where AI is more efficient, productive, and cheaper than its human counterpart, the potential for widespread job displacement and employment is a very serious concern as well as a serious political and ethical issue. AI Impacts in My Education Path and Future Career Choices I started my journey in computer science education in 2021, before LLM chat boxes like ChatGPT were a thing, meaning before they became available or had an impact. Now, as a senior at Colorado State University Global, I have changed my computer science degree focus from software engineering to a specialization in AI (Artificial Intelligence) and have decided to pursue further my education by pursuing a master's in AI. However, given how fast AI is evolving and how powerful AI systems are becoming, there is a good possibility that by the time I finish my education, my education will not matter as most software applications and potentially many other applications/tasks across many different fields, will likely be designed, implemented, and maintained by AI systems and a small team of humans. Nonetheless, I hope to work in implementing AI-LLM within applications, one of my dream jobs would be to integrate LLMs and AI within video games. AI Start-Up Company Inworld AI Several companies are at the forefront of AI integration within video games. These companies include Google DeepMind, Inworld AI, Rockstar Games, Electronic Arts (EA), NVIDIA, Unity Technologies, Epic Games, Houdini, and Latitude.io. Each company has a slightly different and interesting approach to integrating AI into video games. However, this post will focus on Inworld AI which specializes in creating and integrating AI-driven virtual characters also called NPCs (non-player characters). Inworld AI is the leading Character Engine for adding AI NPCs in video games (Inworld Team, 2024a). “A Character Engine is a development environment that offers a suite of tools and features that help game developers create and deploy real-time generative AI-powered NPCs in video games” (Inworld Team, 2023b). Inworld AI recently announced that they have formed a co-development partnership with Xbox/Microsoft to create AI NPCs with a wide range of emotions and behaviors. These NPCs will feature long-term memory, goals, actions, awareness of being in a game ('4th Wall' – remember past in-game interactions), configurable safety settings, and dynamic relationships. The NPC will also feature knowledge constraints to ensure that they only act on information appropriate for their character. Additionally, Inworld technology integrates well with popular game engines like Unity and Unreal Engine, developers utilize Inworld AI’s API for creating smart NPCs in games like Skyrim and RPGs developed by companies like Niantic and Netease Games (Weitzman, 2023). Gibbs (2022), CEO of Inworld, recognizes, in his blog post “Inworld’s commitment to safety,” that AI-driven creative technologies require careful consideration. He outlines Inworld's approach to safety through the following guidelines: Clear restrictions and guidelines with explicit rules and guidelines to control the content that can be created on the Inworld AI platform. Developer control, providing the tools and control to ensure the content that developers create is appropriate for their intended audience. Reporting and moderation of all conversations and characters on Inworld platforms, are subject to reporting and moderation processes. Extensive safety systems and integrated guard rails are built into all Inworld characters. Ongoing monitoring and improvement to continuously monitor and improve safety. Furthermore, Inworld's guidelines prohibit the creation of characters or content that promotes illegal activities, hate speech, violence, or the violation of user privacy. This approach aligns with the ethical guidelines adopted by most AI companies. These guidelines also align with my ethical values, making Inworld AI a company that a company that I would be proud to work for. As of February 2025, Inworld AI is rapidly growing and offers a variety of career opportunities, with positions ranging from financial controllers to recruitment officers. Additionally, it has several opportunities that are relevant to my AI specialization and my career goals. The table below lists those positions, along with their description and requirements. Table 2 Inworld AI Career Opportunities Software Engineering/AI, February 2025 Note: the table provides several Inworld AI career opportunities in software engineering/AI as of February 2025. Data from “A career at Inworld is a game changer” by Inworld AI (2024). With the exception of the Staff / Principal AI Researcher position, which requires a PhD, my education level after completing my master's will meet the minimum requirements for these positions. However, I would lack the required professional experience, as most are senior-level positions requiring 3 to 6 years of experience. This is understandable, as Inworld is a startup and needs to build its base employee pool with experienced professionals. Hopefully, by December 2026 (the estimated graduation date for my Master's in AI) internships or junior-level positions will be available. However, with the emergence of AI being capable of producing functional code in seconds, and often of better quality than expert coders, and with most junior software engineering positions are mostly focused on coding rather than design, Inworld AI having open junior software engineering seems uncertain, even if the company is very successful. Nonetheless, I hope pursuing and graduating with a master's in AI will give me an edge, making me more competitive in the job marketplace. Summary AI is transforming technology that brings immense benefit to humanity; however, it is fundamentally reshaping how people live and work, presenting potential dangers and ethical issues. As a student in computer science, my main ethical concern is how it is already used and will be used in the future to replace human workers, more specifically knowledge workers. AI has already impacted my education path and my career choices in a significant way. AI start-up companies such as Inworld are hiring software engineers and AI developers. However, by the time I graduate with my master’s in AI, I am not guaranteed that the job market will look the same, or that traditional software engineering roles will even be as widely available as agentic AIs are predicted to be more efficient and cost less than their human counterparts. Although the future seems concerning, I firmly believe that AI has the potential to “benefit all humanity” (OpenAI, 2023); however, it is up to humanity to ensure that it does. References: Capitol Technology University (2023, May 30). The ethical considerations of Artificial Intelligence. Capitol Technology University. https://www.captechu.edu/blog/ethical-considerations-of-artificial-intelligence D’Antonoli T., A. (2020, July 23). Ethical considerations for artificial intelligence: an overview of the current radiology landscape National Library of Medicine. Diagnosis Interventional Radiology, 26(5), p. 504-511.https://dirjournal.org/articles/doi/dir.2020.19279 Fardian, D. (2022, July 1) 5 biggest limitations of Artificial Intelligence. Glair AI. https://glair.ai/post/5-biggest-limitations-of-artificial-intelligence Georgieva, K. (2024, January 14). AI will transform the global economy. Let’s make sure it benefits humanity. IMF Blog. https://www.imf.org/en/Blogs/Articles/2024/01/14/ai-will-transform-the-global-economy-lets-make-sure-it-benefits-humanity Gibbs, K. (2023, November 9). Inworld’s commitment to safety. Inworld AI. https://inworld.ai/blog/inworlds-commitment-to-safety Inworld Team (January 02, 2024a). Future of AI in gaming: Generative AI companies . Inworld AI. https://inworld.ai/blog/future-of-ai-in-gaming-generative-ai-companies? Inworld Team (September 2023b). Why Character Engines are game engines for AI NPCs. Inworld AI. https://inworld.ai/blog/future-of-ai-in-gaming-generative-ai-companies? Inworld AI (n.d.). A career at Inworld is a game changer. Inworld AI. https://inworld.ai/careers Martin, H.(2024, December 18). Salesforce will hire no more software engineers in 2025, says Marc Benioff. Salesforce Ben. https://www.salesforceben.com/salesforce-will-hire-no-more-software-engineers-in-2025-says-marc-benioff/?utm_source OpenAI (2023, February). Planning for AGI beyond. OpenAI. https://openai.com/index/planning-for-agi-and-beyond/ Rowan University (2024). Ways AI can improve our world. Rowan University. https://irt.rowan.edu/about/news/2024/10/ai-benefits.html#:~:text=It%20can%20handle%20boring%2C%20repetitive,as%20images%2C%20text%20and%20music. Science and Technology (DDST) (n.d.). The birth of Artificial Intelligence (AI) research. DDST. https://st.llnl.gov/news/look-back/birth-artificial-intelligence-ai-research Singh, P. (2025, January 29). The transformative impact of Ai in finance: Key use cases. Appinventiv. https://appinventiv.com/blog/ai-in-finance/ St. George University (2024, March 26). 10 Innovative examples of AI in medicine. St. George University School of Medicine. https://www.sgu.edu/blog/medical/ai-in-medicine-and-healthcare/ Takyar, A. (n.d.). AI in education: Use cases, benefits, solution and implementation. Leeway Hertz. https://www.leewayhertz.com/ai-use-cases-in-education/ Thomas, M. (2024, July 25). 14 Risks and dangers of Artificial Intelligence (AI). Built In. https://builtin.com/artificial-intelligence/risks-of-artificial-intelligence University of Cincinnati (n.d.). 9 benefits of Artificial Intelligence (AI) in 2024. University of Cincinnati Online. https://online.uc.edu/blog/artificial-intelligence-ai-benefits/ UTokyo Center for Global Education (2025, February 5). Dialogue at UTokyo GlobE #14: Mr. Sam Altman and Mr. Kevin Weil (CEO and CPO of Open AI) [Video]. YouTube. https://www.youtube.com/watch?v=8LmfkUb2uIY&t=7s Virginia Tech Engineer (2023). AI—The good, the bad, and the scary. Virginia Tech. https://eng.vt.edu/magazine/stories/fall-2023/ai.html Von Der Osten, B. (2023, May 23). Artificial Intelligence Pros and Cons: What are the Advantages and Disadvantages of AI. Rock Content. https://rockcontent.com/blog/artificial-intelligence-pros-and-cons/ Weitzman, C. (2023, November 4). Inworld AI: Revolutionizing gaming with AI-driven NPCs. Speechify. https://speechify.com/blog/inworld-ai/ Zatzu, V., Shine E., A., Tharaka, J., M., Peter, D., Ranganathan, T., V., Alotaibi, S., S, Mugabi, R., M., Muhsinah, A., Ab, Waseem, M., & Nayik, G , A. (2024, December 30). Revolutionizing the food industry: The transformative power of artificial intelligence-a review. Food Chemistry: X, 24. https://doi.org/10.1016/j.fochx.2024.101867