Project 2 Programming

Sesiones 1 y 2: Representación de problemas mediante el modelado de la realidad

(ampliación de 1º Bach)
Abstracción, secuenciación algorítmica. Detección y generalización de patrones. (ampliación de
1º Bach)

Task: Read these examples, in groups try to analyze and understand them.w

"Problem representation by reality modeling" in the realm of programming refers to the

practice of creating an abstraction or simplified representation of a real-world problem in
order to understand and solve it more effectively through programming.
In essence, it consists of analyzing a real problem and designing a logical and coherent
structure that captures its most important aspects. This structure can take the form of a
model, diagram, set of rules or any other representation that helps to understand the problem
and design a computational solution.
The process of reality modeling involves:
1. Identification of key elements: Select the essential aspects of the problem that
should be represented in the model. This involves identifying the most relevant
entities, relationships, and properties.
2. Abstraction: Simplifying the problem by eliminating unnecessary or irrelevant
details for the programming goal. Abstraction allows you to focus on what is
important to solve the problem through code.
3. Definition of relationships: Establish how the different parts of the problem
relate to each other. This can involve cause-and-effect relationships, hierarchies,
interactions, dependencies, etc.
4. Model Design: Create a visual or conceptual representation of the modeled
problem. This could be a flowchart, class diagram, entity-relationship diagram, or
other representation that makes sense for the problem at hand.
5. Translation to code: Once you have the model, you proceed to translate it into
programming code. This involves implementing the data structures, algorithms,
and logic that reflect the designed model.
6. Validation and tuning: Test the resulting code to make sure it solves the
problem correctly and efficiently. If necessary, adjustments are made to the model
or code to improve performance.
7. Maintenance: As the problem evolves or new requirements arise, the model
and code may need to be modified to maintain the effectiveness of the solution
over time.

In summary, problem representation by reality modeling is a crucial approach in

programming, as it helps programmers understand, address, and solve complex
problems by creating abstract models that capture the essence of the problem and guide
the creation of solutions in code form.

Example 1: Task Management

Imagine you're developing a personal task management app. You should design a model
that represents the tasks, their properties, and the interactions between them.

1. Identification of key elements:

o Entities: Task
 o Properties: Task Title, Description, Creation Date, Due Date, Priority,
Status (Pending, Completed, in Progress), etc.
o Relationships: No complex relationships are required in this case.
2. Abstraction:
o There is no need to model the graphical interface of the
application.
o You can simplify task statuses to three: pending, completed, and in
progress.
3. Defining relationships:
o In this case, the relationships are simple and do not require
complex structures.
4. Model design:

Here is a simple representation using a class diagram:

+--------------------+
| Task|
+--------------------+
| - Title|
| - Description|
| - Creation date. |
| -Expiration Date. |
| - Priority|
| - State|
+--------------------+

5. Translation to code:

You can implement the Task class in a programming language such as Python:

class Tarea:

def __init__(self, titulo, descripcion, fecha_creacion, fecha_vencimiento,

prioridad, estado):

self.titulo = titulo

self.descripcion = descripcion

self.fecha_creacion = fecha_creacion

self.fecha_vencimiento = fecha_vencimiento

self.prioridad = prioridad

self.estado = estado

6. Validation and tuning:

Instantiates the Task class, changes states, adds dates and priorities, and verifies that
data is stored and displayed correctly.

7. Maintenance:

As you develop more functionalities, you could add the ability to filter and sort
tasks, set reminders, etc..

Example 2: Library Management

Let's say you're designing a management system for a library. You want to model the
reality of how book lending and collection management work.

1. Identification of key elements:

- Entities: Book, User, Loan

- Properties: Book Title, Author, User Name, Loan Date, Return Date, Loan Duration,
etc..

- Relationships: A book can be lent to several users, a user can borrow several books, a
loan is associated with a book and a user, etc..

2. Abstraction:

- Simplify the physical details of the library, such as its architectural design.

- No need to model the exact physical location of each book on the shelves.

3. Defining relationships:

- A book has a one-to-many relationship with borrowing.

- A user has a one-to-many relationship with loanss.

4. Model design:

You can create a class diagram that represents entities and their relationships. Here is a
simplified version:

+-----------------+ +----------------+ +---------------+

| Book| | Loan| | User|

+-----------------+ +----------------+ +---------------+

 | - Title| | -Start Date | | - Name|

| - Author| | - End Date | | - ID |

| | | - Book| | |

+-----------------+ | - User| +---------------+

+----------------+

5. Traducción a código:

You can implement classes in a programming language like Python:

class Libro:

def __init__(self, titulo, autor):

self.titulo = titulo

self.autor = autor

class Usuario:

def __init__(self, nombre, id):

self.nombre = nombre

self.id = id

class Prestamo:

def __init__(self, libro, usuario, fecha_inicio, fecha_fin):

self.libro = libro

self.usuario = usuario

self.fecha_inicio = fecha_inicio

self.fecha_fin = fecha_fin

6. Validation and tuning:

Instantiate classes, make loans, repayments, and make sure date calculations are
correct.

7. Mantenimiento:
 As the system evolves, you could add features like expiration notifications, loan
history, etc..

Example 3: Weather Forecasting

Let's consider the task of creating a weather forecasting application. You want to
model the real-world aspects of weather data and provide accurate predictions.

1. Identification of Key Elements:

o Entities: Location, Weather Data, Forecast
o Properties: Latitude, Longitude, Temperature, Humidity, Wind
Speed, Forecast Date, etc.
o Relationships: A location has associated weather data and
forecasts.
2. Abstraction:
o You don't need to model complex atmospheric physics;
simplified data is sufficient.
o Ignore specific data sources and algorithms used for weather
prediction.
3. Definition of Relationships:
o A location has a relationship with weather data and forecasts.
4. Model Design:

Create a simplified class diagram:

+-------------------+ +-------------------+ +----------------------+

| Location | | WeatherData | | Forecast |
+-------------------+ +-------------------+ +----------------------+
| - Latitude | | - Temperature | | - ForecastDate |
| - Longitude | | - Humidity | | - WeatherData |
| | | - WindSpeed | +---------------------+
+-------------------+ +--------------------+

5. Translation to Code:

Implement the classes in a programming language such as Python:

class Location:

def __init__(self, latitude, longitude):

self.latitude = latitude

self.longitude = longitude

class WeatherData:

def __init__(self, temperature, humidity, wind_speed):

 self.temperature = temperature

self.humidity = humidity

self.wind_speed = wind_speed

class Forecast: def __init__(self, forecast_date, weather_data):

self.forecast_date = forecast_date

self.weather_data = weather_data

6. Validation and Adjustment:

Create instances of the classes, simulate weather data, and verify that forecasts are
generated accurately.

7. Maintenance:

As the application evolves, you could integrate external data sources, refine prediction
algorithms, and enhance user interactions.

Task: (In groups) We are going to organize a running race and we need you to represent the
problem through reality modeling. Try to do it following the same steps as in the previous
examples.

Task: (In groups) Represent a problem of your choice through reality modeling. Try to do it
following the same steps as in the previous examples.

Task: Create a table with the common symbols of flowcharts and their meaning. Resource:
https://es.wikipedia.org/wiki/Diagrama_de_flujo

Task (in groups): Flowchart for an Expense Calculator

Imagine you're developing a mobile app to help users track their daily spending. You
should create a flowchart that models the logic behind the expense entry and totals
calculation.

1. Description of the Problem:

Design a flowchart that allows users to enter a list of expenses and then calculate and
display the total expenses.
 2. Requirements:
o Users can enter multiple expenses in the form of positive
numbers.
o The expense entry process should be repeatable and finished when the
user decides.
o After the expense entry is complete, the application must calculate and
display the cumulative total.
o If the total expenses exceed a certain threshold (for example, $100),
display a warning message.
3. Suggested Steps:
 Display a welcome message.
o Set the total expense variable to 0.
o Start a loop for expense entry:
o Ask the user to enter an expense.
o Add the expense to the cumulative total.
o Ask the user if they want to enter another expense.
o Check if the total expenses exceed the established threshold. If so,
display a warning message.
 Show the cumulative total of expenses and a farewell message.

4. Flowchart Design:

Design a flowchart that represents the steps mentioned above. Use symbols such as
rectangles for processes, diamonds for decisions, and arrows to indicate the sequence
of actions.

Sesión 3 Sostenibilidad e inclusión como requisitos del diseño del software. (ampliación de 1º
Bach)
Task: Read this text, create a diagram and prepare a presentation in group about it. Each group
will present one section:
Sustainability and Inclusion as Software Design Requirements

Sustainability and inclusion are two critical aspects that should be considered as fundamental
requirements in software design. These elements ensure that technological solutions are
beneficial for both the environment and a wide range of users. Here's a description of how
these requirements can be incorporated into software design:

1. Sustainability:

Sustainability in software design involves creating solutions that minimize their

environmental impact and promote responsible practices in their development, operation, and
disposal. Some key considerations are:
 - Energy Efficiency: Designing software that uses minimal resources, such as energy and
memory, for its operation.
- Responsible Resource Usage: Reducing the amount of data and resources consumed during
software execution, which can include algorithm optimization and reducing server loads.
- Modular Design and Updates: Developing software in a modular way so that updates are
easier and require fewer resources.
- Electronic Waste Minimization: Designing systems that can be upgraded rather than
replaced entirely to reduce electronic waste generation.
- Lifecycle Consideration: Assessing the environmental impact throughout the entire lifecycle
of the software, from design to disposal.

2. Inclusion:

Inclusion in software design involves creating solutions that are accessible and useful for a
wide range of users, including individuals with disabilities and diverse abilities. Some important
guidelines are:

- Accessibility: Designing user interfaces that are easy to use for individuals with visual,
auditory, cognitive, and motor disabilities.
- User Diversity: Considering the needs of different user groups, cultures, and contexts to
ensure that the software is useful for everyone.
- Universal Design: Creating solutions that are intuitive and effective for the majority of
users, minimizing the need for specific adaptations.
- Accessibility Testing: Conducting regular tests to ensure that the software complies with
recognized accessibility standards.
- Incorporating Feedback: Listening to and responding to user feedback to improve the
experience and address unmet needs.

Incorporating sustainability and inclusion as requirements in software design demonstrates a

commitment to social responsibility and the creation of technological solutions that have a
positive impact on the world and people's lives.

Sesión 4 Lenguajes de programación. Objetos y Eventos. (ampliación de 1º Bach)

Lenguajes compilados e interpretados. (específica de 2º Bach)

Task: Read this text, create a diagram and prepare a presentation in group about it. Each group
will present one section:
Programming Languages, Objects, and Events

In the realm of programming, the concepts of programming languages, objects, and events are
fundamental for creating efficient software with interactive functionalities. Here is a
description of each of these concepts:

1. Programming Languages:

Programming languages are formal systems used to communicate instructions to a

computer. These languages allow programmers to write human-readable source code, which is
then translated into machine language that the computer can understand. Examples of
programming languages include Python, Java, C++, JavaScript, and many more. Each language
has its own syntax and rules that dictate how instructions should be written.

2. Objects:
 Objects are fundamental elements in object-oriented programming (OOP), which is a
programming paradigm that focuses on organizing code into coherent units called "objects."
Each object is an instance of a class, which is a template or definition that describes the
properties (attributes) and behaviors (methods) the object will have. Objects allow effective
modeling of real-world entities in code and promote reusability and modularity.

3. Events:

Events are occurrences that happen within a software program, such as mouse clicks, key
presses, or changes in data. Events can be generated by the user or the system and trigger
specific responses in the program. Programming languages and environments often provide
mechanisms for detecting and handling events. Event-driven programming is common in
interactive applications, such as graphical user interfaces and web applications.

Example of Objects and Events Usage: In a drawing application, you might have objects like
"line" and "circle," which are instances of the "Shape" class. Then, you can register events like
"mouse click" on the graphical interface, and when these events occur, create and display a
new instance of "line" or "circle" at the clicked position.

These concepts are essential to understanding how modern applications and software systems
are built. Programming languages allow writing instructions, objects allow modeling entities,
and event-based programming enables dynamic interaction between the user and the
software.

Compiled and Interpreted Languages

In the realm of programming, there are two primary categories of programming languages:
compiled languages and interpreted languages. Here's an explanation of each:

1. Compiled Languages:

Compiled languages are programming languages that are translated entirely into machine
code or a lower-level intermediate code by a compiler before being executed. A compiler is a
software tool that takes the entire source code of a program and converts it into an executable
file, which can be run directly by the computer's hardware. Examples of compiled languages
include C, C++, and Rust.

Advantages of Compiled Languages:

- Faster execution: Since the code is already translated to machine code, it tends to run
faster.
- Optimization: Compilers can apply various optimizations to the code during the compilation
process.

Disadvantages of Compiled Languages:

- Longer build times: Compilation is an additional step that can make the development cycle
longer.
- Platform-dependent binaries: Compiled programs may need different binaries for different
operating systems or hardware architectures.

2. Interpreted Languages:
 Interpreted languages are programming languages that are executed line by line by an
interpreter at runtime. An interpreter reads the source code of a program and executes it
directly, without the need for a separate compilation step. Examples of interpreted languages
include Python, JavaScript, and Ruby.

Advantages of Interpreted Languages:

- Faster development cycle: Since there's no need for a compilation step, development and
testing are often quicker.
- Platform independence: Interpreted programs are generally more portable, as the
interpreter can adapt to different environments.

Disadvantages of Interpreted Languages:

- Slower execution: Code execution can be slower as it's not precompiled to machine code.
- Lack of some optimization: Interpreters might not apply the same level of optimization as
compilers.

In recent years, the distinction between compiled and interpreted languages has become less
clear due to the introduction of techniques like Just-In-Time (JIT) compilation, which combines
elements of both approaches. Regardless, understanding these categories is important for
choosing the right language for a given project and understanding how the code will be
executed.

Sesión 5 Identificación de los elementos de un programa informático. Constantes y variables,

tipos y estructuras de datos, operaciones, operadores y conversiones, expresiones, estructuras
de control, funciones y procedimientos. (ampliación de 1º Bach)
Task: Read this text, create a diagram and prepare a presentation in group about it. Use
examples to explain the concepts. Each group will present one section:
Identification of Elements in a Computer Program. Constants and Variables, Data Types and
Structures, Operations, Operators, and Conversions, Expressions, Control Structures,
Functions and Procedures.
1. Constants and Variables:
Constants are values that remain the same throughout the program's execution, such as
numerical values or strings. Variables, on the other hand, are placeholders that can store and
represent different values as the program runs.

2. Data Types and Structures:

Data types define the kind of data that a variable can hold, such as integers, floating-point
numbers, characters, and more. Data structures, like arrays or linked lists, organize and store
multiple values together.

3. Operations, Operators, and Conversions:

Operations are actions performed on data, like addition or comparison. Operators are
symbols that represent these actions, such as + for addition or == for equality. Conversions
involve changing data from one type to another, like converting an integer to a floating-point
number.

4. Expressions:
Expressions are combinations of constants, variables, operators, and functions that represent
a value. For example, `x + y` is an expression that adds the values of variables `x` and `y`.

5. Control Structures:
 Control structures determine the flow of a program. They include conditional statements (if-
else), loops (for, while), and switches that allow the program to make decisions and repeat
tasks.

6. Functions and Procedures:

Functions and procedures are reusable blocks of code that perform specific tasks. Functions
return values, while procedures perform actions without necessarily returning a value. They
allow for modular and organized code.

Sesión 6 Operaciones básicas con bases de datos. Consultas, inserciones y modificación.

(ampliación de 1º Bach)
Instalación y uso de entornos de desarrollo. Funcionalidades. (ampliación de 1º Bach)
Herramientas de depuración y validación de software. (ampliación de 1º Bach)

Task: Read about these topics and make a presentation in group:

Basic database operations: queries, inserts, and updates.

1. Queries:

Queries are fundamental operations used to retrieve specific data from a database. They
allow you to request information that meets certain criteria, helping you extract relevant
insights from your data. Queries are often written in SQL (Structured Query Language), a
language specifically designed for managing and querying databases.

For example, imagine you have a database of customer information and you want to retrieve
the names and email addresses of all customers who have made a purchase in the last month.
The SQL query for this could look like:

```sql
SELECT first_name, last_name, email
FROM customers
WHERE purchase_date >= DATE_SUB(NOW(), INTERVAL 1 MONTH);
```

This query selects the first name, last name, and email of customers from the "customers"
table where the purchase date is within the last month.

2. Inserts:

Insert operations involve adding new data into a database. They are used when you have
new records or information that you want to include in your dataset. Insert operations help
you populate your database with fresh data.

Continuing the customer example, if a new customer named "Sarah" with email
"sarah@example.com" signs up, you could add her information to the "customers" table using
an SQL insert statement:

```sql
INSERT INTO customers (first_name, last_name, email)
VALUES ('Sarah', 'Smith', 'sarah@example.com');
```
 This SQL statement adds a new record with Sarah's information to the "customers" table.

3. Updates:

Update operations are used to modify existing data in a database. They allow you to make
changes to specific records or fields, ensuring your data stays accurate and up-to-date.

Imagine you have an "inventory" table with product information, including product names
and quantities. If you receive a new shipment of 50 units for the product with ID 123, you
could update the quantity in the database:

```sql
UPDATE inventory
SET quantity = quantity + 50
WHERE product_id = 123;
```

This SQL update statement increases the quantity of product ID 123 by 50 units in the
"inventory" table.

In summary, basic database operations include queries to retrieve information, inserts to add
new data, and updates to modify existing data. These operations are essential for managing
and maintaining the integrity of data in a database, enabling effective data-driven decision-
making and application functionality.
Task: Search a video tutorial of how to install “Visual Studio Code with Python” and create
document with the steps (including screenshots) to do it
Task: In groups, create a presentation of the basic use of Visual Studio Code and its features.
We will share our findings.

Sesión 7 Optimización y mantenimiento de software. (específica de 2º Bach)

Documentación técnica asociada al desarrollo del software. (específica de 2º Bach)
Task: Read this text and make a presentation in groups.
Optimization and Maintenance of Software

"Optimization and maintenance of software" refers to the ongoing processes of improving the
performance, efficiency, and functionality of software applications, as well as ensuring their
continued operation and support over time. This involves refining the code, enhancing features,
fixing bugs, and addressing evolving needs. Here's a breakdown of these two aspects:

1. Optimization:

Optimization involves making a software application run more efficiently and effectively. This
can include improving the speed at which the software executes, reducing memory usage, and
optimizing algorithms for better performance. Optimization aims to enhance user experience,
reduce resource consumption, and make the software more responsive.

- Code Optimization: Identifying and modifying code sections that are resource-intensive,
redundant, or inefficient to improve execution speed.
- Algorithm Optimization: Refining algorithms to make them faster or require fewer
resources for the same task.
- Database Optimization: Tuning databases to perform queries and updates more efficiently,
improving overall application speed.
 - Memory Management: Efficiently managing memory usage to prevent memory leaks and
improve system stability.

2. Maintenance:

Maintenance involves the continuous care and support of software throughout its lifecycle.
This includes addressing issues that arise post-launch, ensuring compatibility with new
technologies, and adapting to changing user requirements.

- Bug Fixes: Identifying and resolving errors (bugs) that users encounter during software
usage.
- Updates and Enhancements: Adding new features, improvements, or optimizations to keep
the software relevant and competitive.
- Security Updates: Patching vulnerabilities to protect the software from security threats.
- Compatibility: Ensuring that the software works correctly with new operating system
versions, browsers, or hardware.
- User Support: Providing assistance to users, addressing their inquiries, and helping them
resolve issues.

Optimization and maintenance are integral to the life cycle of software applications.
Optimizing software ensures that it performs well and efficiently, while ongoing maintenance
ensures that the software remains functional, secure, and aligned with changing user needs
and technological advancements. Both aspects contribute to the longevity and effectiveness of
software in meeting its intended purposes.

Sesión 8
Propiedad intelectual. Tipos de derechos, duración, límites a los derechos de autoría y licencias
de distribución y explotación. (ampliación de 1º Bach)
Importancia de la computación en el desarrollo igualitario de la sociedad. Sesgos en los
algoritmos. (ampliación de 1º Bach)
Task: Read this text, make a diagram and do a presentation in group:
Intellectual Property. Types of Rights, Duration, Limits to Copyright, and Distribution and
Exploitation Licenses

Intellectual Property (IP): Intellectual Property refers to creations of the mind, such as
inventions, literary and artistic works, designs, symbols, names, and images used in commerce.
IP is protected by laws, granting creators exclusive rights over their creations, which typically
include the right to use, distribute, and profit from them.

Types of Rights:

- Copyright: Protects original literary, artistic, and intellectual works. It grants creators the
exclusive right to reproduce, distribute, perform, and display their work.

- Patents: Protect inventions, granting the inventor exclusive rights to make, use, and sell the
invention for a specific period.

- Trademarks: Protect symbols, names, and slogans used to identify goods and services,
preventing confusion with others' products.

- Trade Secrets: Protect confidential business information, such as manufacturing processes,

formulas, and customer lists.
Duration:

- Copyright: Generally lasts for the creator's lifetime plus a certain number of years (varying by
jurisdiction).

- Patents: Typically last for 20 years from the filing date of the patent application.

- Trademarks: Can be renewed indefinitely as long as they are actively used and maintained.

Limits to Copyright:

Copyright protection is not absolute and has limitations, including "fair use" exceptions that
allow limited use of copyrighted material for purposes like education, commentary, or
criticism.

Distribution and Exploitation Licenses:

Creators can license their intellectual property to others for distribution and exploitation under
specific terms. Licenses can grant various rights, such as the right to use, modify, distribute, or
sell the work. Licensing agreements outline the conditions and limitations of use.

In summary, intellectual property encompasses a range of creations protected by various types

of rights, including copyrights, patents, trademarks, and trade secrets. The duration of
protection varies, and there are limits to copyright protection to balance exclusive rights with
societal benefits. Licensing allows creators to control how their works are distributed and used
by others, fostering innovation while protecting their interests.
Distribution and Exploitation Licenses in programming
In the context of programming and software development, "Distribution and Exploitation
Licenses" refer to legal agreements that govern how software can be used, distributed, and
commercially exploited by others. These licenses define the terms and conditions under which
developers and users can interact with the software. Let's explore this concept further:

Distribution Licenses:

Distribution licenses specify how software can be distributed to other parties. They outline
whether the software can be freely shared, sold, or redistributed. Some common types of
distribution licenses include:

- Open Source Licenses: These licenses allow developers to access, modify, and distribute the
source code of the software. Examples include the GNU General Public License (GPL) and the
MIT License.

- Proprietary Licenses: Proprietary licenses restrict how the software can be distributed. They
may require users to purchase a license or obtain permission from the copyright holder to
distribute the software.

Exploitation Licenses:

Exploitation licenses pertain to how the software can be commercially used or exploited. These
licenses may cover aspects such as:
- Commercial Use: Whether the software can be used for commercial purposes, such as in a
business environment, or if it's restricted to non-commercial use.

- Derivative Works: Whether users can create modified versions or derivative works of the
software and distribute them.

- Resale: Whether users can sell the software to others, and if so, under what conditions.

Examples:

- GPL (General Public License): This is an open-source license that allows users to freely use,
modify, and distribute software covered by the GPL. However, if modified versions are
distributed, they must also be open source under the GPL.

- Proprietary Software License: A proprietary software license might allow users to install and
use the software on a limited number of computers within their organization, but it prohibits
distribution to others.

- Creative Commons Licenses: These licenses apply to creative works like software, images, and
text. They offer a range of permissions, from allowing commercial use to requiring attribution
for the original author.

In summary, distribution and exploitation licenses in programming govern how software can be
shared, used, and commercially exploited. Developers and users must understand and adhere
to these licenses to ensure legal and ethical use of software products.

Sesión 9
Importancia de la computación en el desarrollo igualitario de la sociedad. Sesgos en los
algoritmos. (ampliación de 1º Bach)
Implicaciones éticas del Big Data y la Inteligencia Artificial. (específica de de 2º Bach)
Comunidades de desarrollo de software libre. (específica de 2º Bach)
Task: Read and discuss in groups this text, extract a few ideas and your opinion. And answer
these question:
1. How has computing technology contributed to bridging societal gaps and
promoting equitable development in various areas such as education and
healthcare?
2. Can you think of examples from your own experience or observation where
technology has helped underserved communities access resources and
opportunities?
3. In what ways do biases in algorithms pose challenges to achieving equitable
outcomes in decision-making processes? Can you provide specific instances where
biased algorithms may have unintended consequences?
4. How might the inadvertent biases in algorithms exacerbate existing societal
inequalities? Can you imagine scenarios where these biases lead to unfair
treatment or missed opportunities for certain groups?
5. What strategies and practices can be implemented to address biases in
algorithms and ensure that technological advancements lead to fair and inclusive
outcomes for all individuals, regardless of their background or identity?

Importance of Computing in the Equitable Development of Society

Computing and technology play a significant role that in promoting fair and balanced progress
across society. It highlights how advancements in computing can contribute to addressing
societal inequalities and ensuring that the benefits of technology are accessible to all members
of the population.
In today's world, technology has the power to bridge gaps and provide opportunities in various
fields, including education, healthcare, economy, and communication. Computing innovations
can empower underserved communities, enable access to information, and offer tools for
social and economic mobility. For instance, the proliferation of smartphones has brought
digital connectivity to remote and marginalized areas, providing access to essential services
and knowledge.
Biases in algorithms points out a crucial challenge in this development. Algorithms, which are
sets of instructions followed by computers to perform tasks or solve problems, can
unintentionally embed biases present in historical data. These biases can lead to unfair or
discriminatory outcomes, perpetuating inequalities in decision-making processes.
For example, in hiring practices, algorithms used for resume screening might unknowingly
favor certain demographic groups due to biased training data. This can result in unequal
opportunities for job applicants. Similarly, in criminal justice systems, biased algorithms could
lead to unfair predictions about an individual's likelihood to reoffend.
To ensure equitable development, it's essential to address and mitigate biases in algorithms.
This involves careful design, thorough testing, and ongoing monitoring of algorithms to identify
and rectify any biases that emerge. It's also crucial to diversify the teams creating these
algorithms to incorporate various perspectives and experiences, minimizing the chances of
unintentional bias.
In essence, the phrase emphasizes the potential of computing to drive balanced societal
progress while highlighting the importance of vigilant efforts to prevent biases in algorithms,
promoting a fair and inclusive technological landscape.

Task: Read this text and do a presentation in group:

The ethical implications of Big Data and Artificial Intelligence (AI) refer to the moral
considerations and potential challenges that arise from the use of vast amounts of data and
advanced AI technologies. As these technologies continue to shape various aspects of our lives,
they bring about significant questions and concerns that need to be addressed:

1. Privacy and Data Protection:

Big Data and AI often involve the collection and analysis of massive amounts of personal
data. The ethical concern revolves around how this data is obtained, stored, and used. There's
a need to ensure that individuals' privacy is respected, and their data is protected from
unauthorized access or misuse.

2. Algorithmic Bias and Fairness:

AI algorithms learn from historical data, and if that data contains biases, the algorithms can
inadvertently perpetuate those biases. This raises concerns of unfair treatment and
discrimination based on race, gender, or other characteristics. Ensuring fairness and mitigating
bias becomes crucial to avoid reinforcing societal inequalities.

3. Transparency and Accountability:

AI systems, especially complex ones like deep learning neural networks, can be challenging to
understand. Ethical considerations arise when decisions made by AI systems lack transparency.
There's a need to make AI systems more interpretable and to hold organizations accountable
for the outcomes of AI-driven decisions.
4. Autonomy and Human Control:

As AI systems become more sophisticated, there's a concern about the degree of autonomy
these systems should have. Ethical considerations involve determining the extent to which
humans should retain control over AI systems and decisions that impact individuals' lives.

5. Job Disruption and Economic Impact:

The deployment of AI in industries and workplaces can lead to job displacement, potentially
impacting individuals' livelihoods. The ethical challenge is to manage this transition in a way
that minimizes negative economic consequences and ensures that people have opportunities to
upskill and adapt.

6. Security and Misuse:

The potential misuse of AI and Big Data for harmful purposes, such as cyberattacks or the
creation of deepfake content, raises ethical concerns. Ensuring robust cybersecurity and
responsible use of AI technology becomes crucial.

7. Informed Consent and User Awareness:

In a world where personal data is constantly collected and analyzed, the ethical challenge is
to ensure that individuals provide informed consent and are aware of how their data is being
used. This transparency empowers users to make informed decisions about their digital
interactions.

In conclusion, as Big Data and AI continue to reshape our society, ethical considerations
become increasingly important. Addressing these ethical implications involves developing
guidelines, regulations, and best practices that prioritize the well-being, autonomy, and
fairness of individuals and communities in the era of technological advancement.

Task: Read this text and make a presentation in groups:

Open Source Software Communities
Open Source Software Communities are collaborative groups of developers, programmers, and
enthusiasts who work together to create, improve, and maintain software applications that are
made available to the public with an open-source license. Open-source software is
characterized by its accessibility, transparency, and the freedom it provides for users to view,
modify, and distribute the source code.

Key aspects of Open Source Software Communities include:

1. Shared Goals: Members of these communities share a common goal of creating high-quality
software that is freely available for anyone to use and contribute to. These goals often align
with the principles of transparency, collaboration, and innovation.

2. Open Collaboration: Collaboration is central to open-source projects. Developers from

around the world can contribute to the codebase, propose enhancements, report bugs, and
participate in discussions. This diverse collaboration results in a wide range of perspectives and
ideas.
3. Transparency: Open source emphasizes transparency in the development process. The
source code is openly accessible, allowing anyone to review and analyze it. This transparency
fosters trust and helps in identifying and fixing issues.

4. Licensing: Open-source software is typically distributed under licenses that grant users the
freedom to view, modify, and distribute the code. Different licenses have varying requirements,
such as attributing original authors or sharing modifications under the same license.

5. Community Governance: Many open-source projects have established governance

structures that guide decision-making, contributions, and the overall direction of the project.
These structures ensure that the project remains organized and follows the principles of the
community.

6. Version Control and Code Hosting: Version control systems like Git and platforms like
GitHub or GitLab facilitate collaborative development. Developers can contribute changes,
propose improvements, and manage the evolution of the software.

7. Code Reviews and Quality Assurance: Peer review is a common practice in open-source
development. Contributors review each other's code, offering feedback and ensuring code
quality before it's integrated into the project.

8. Documentation and Support: Open-source projects often maintain comprehensive

documentation to help users and developers understand how to use and contribute to the
software. Online forums, mailing lists, and chat platforms provide support and foster
communication.

9. Global Impact: Open Source Software Communities have a global reach. People from various
countries, backgrounds, and skill levels can participate, contributing to a diverse and inclusive
community.

Prominent examples of open-source communities include the Linux Kernel, the Apache
Software Foundation, Mozilla, and the Python programming language community.