COLLABORATION
A collaboration is a society of classes, interfaces, and other
elements that work together to provide some cooperative
behavior that’s bigger than the sum of all its parts
Computing Innovation
Computing innovations, according to the College Board, are
innovations that use a program as a key part of their function. Put
simply, they wouldn't operate without a computer program making
them work. If you can use the word "computer" or "coded" when
describing this innovation, it's probably a computing innovation.
Another way to identify computing innovations is to think
about data. Does the innovation you're thinking of collect data and
use it when operating? If so, you've probably got a computing
innovation on your hands.
Computing innovations can be both physical and non-physical, and
they come in all shapes and sizes.
Examples of Computing Innovations:
Physical
Self-driving cars
Smart appliances (fridges/watches/toasters)
Tablets (Kindles/iPads)
Smart Phones
Gaming devices (Nintendo Switch/Xbox)
Robots (Roombas, for instance)
Non-Physical
Picture Editing Software (Photoshop/Adobe Lightroom)
Word Processors (Word/Pages/Google Docs)
Communication platforms (email/text messaging/video
conferences)
Digital video games (Dark Souls/Minecraft/Super Mario Kart)
Applications (iPhone Apps)
Even some concepts, like e-commerce or social networking, count
Collaboration in Computer
Science
While a lot of code-writing is independent by nature, the computer science field has a
lot more collaboration in it than you'd think. Programmers of all sorts have to work
with coworkers and bosses when dealing with large projects. They also have to work
with their clients to make sure what they're coding meets client needs. Different
people have different backgrounds, perspectives and ways of thinking. Here are some
ways such diversity is helpful when creating a computing innovation:
More hands working on a project can sometimes get it done faster than one person
can alone, (despite what the results of your last group project might indicate ).
Thanks to the multiple perspectives on deck, more discoveries can be made.
Collaboration in Computer
Science
Biases can be avoided during the development process, creating a
more inclusive innovation.
Working with users and clients specifically during the development
process can ensure that the finished product is one everyone is happy
with, saving both time and energy. Of course, collaboration only
works to its fullest when the final product represents all the different
ideas and contributions of the people that produced it. This isn't
always possible, but it's a goal to shoot for! Especially in AP CSP.
Collaboration Between Users and
Developers
During the creation of a computing innovation, users and developers
will communicate with each other. For example, video games will
have testers that check the product for bugs and report them to the
developers.
Often, this conversation begins even before the product is made.
Some companies will conduct market research to determine what
features would be best to include in their newest innovations. [link to
crowdsourcing]
However, communication doesn't stop there! Even after the product
is released, developers will often ask for feedback and offer areas for
users to report any problems they may have.
Computing Developments that Foster
Collaboration
Collaboration between programmers isn't a new concept. The
computer science field has several models designed to foster
collaboration, such as pair programming.
Pair programming is a programming model where two people share
one computer. One person codes while the other person oversees the
work, and the two often switch places.
At the same time, the internet makes collaboration between
developers easier. You can see a version of this in your own life: most
people today use Google Docs or Slides to work on shared projects.
Here are some examples for
programmers:
Project management tools: These tools allow programmers to track
tasks, assign work, and manage projects in real-time, with features
such as task tracking, project timelines, and collaboration features.
Examples include Basecamp and Trello.
Collaborative document editing tools: There are also programs
that allow you to code on the same coding document at the same
time. Examples include Microsoft's Visual Studio Live Share software.
Github and Bitbucket are famous examples of collaborative
development websites where multiple people can work on the same
project and share documents.
Ways to be a Good Team Player!
In the AP CSP class, there are times where you'll have to collaborate
with others to work on projects in class. The final Create project also
gives you the option to work with another person during the
development phases of the project.
Here are some tips, AP CSP-style, to make your collaborative team
the most successful it can be!
Create norms such as establishing team roles or policies to help
mediate any conflicts that might arise. It's important to have
everyone on the same page.
Ways to be a Good Team Player!
CTD
It's very easy for the stronger coders or more assertive people in a
team to take over the whole project, which can make a team
unbalanced. Practice consensus building within your team by
listening to every member within it and taking their perspectives into
consideration.
A team project is a team effort, and that means everyone in the
group needs to have a say. Sometimes, that might mean compromise.
Computing Innovations and Their Purposes
The purpose of a computing innovation is what it's designed to do.
Solving problems is one of the major purposes of computing innovations. For example,
text messaging and video-chat platforms solve the problem of needing to communicate
quickly over long distances.
This doesn't have to be a complicated problem like climate change or income inequality. To
go back to our adding program, that program solves the "problem" of needing to add two
numbers together. A computing innovation can also be a form of creative expression.
For example, making a video game, or creating a program that draws squares on a screen,
are examples of designing a computing innovation as a form of creative expression.
Having a clear purpose for a computing innovation is like having a good thesis for an
essay. It focuses the work of creating the innovation and establishes what the goals of the
innovation are. In short, it strengthens the coder's ability to make the thing they want to
make.
Programs and Code Segments
A program is a collection of instructions that a computing device executes, or carries
out. Programs are also known as software or applications
A program is like a cake recipe. Just as we can bake a cake by following each step of the
recipe, a computer operates by following each step the program tells it to do. Within a
program, you have code segments.
A code segment is a smaller collection of statements that are part of a program. It's like
the part of a cake recipe that tells you how to make the frosting.
There's no clear definition of what separates one code segment from another, so, in
theory, you can take any collection of lines to be a code segment. Each code segment is
made up of statements, or individual instructions.
It's like a line in your recipe that says, "Crack three eggs into the bowl." In summary, a
computer program is made up of code segments, which themselves are made up of
statements.
Program Inputs
Programs run on inputs, which are pieces of data that a computer
takes in and processes. For example, the two numbers you need to
add in an adding program are the inputs for that program.
These inputs can be directly submitted by the user or they can come
from other programs. The above example is a user-submitted input.
Types of Inputs
Auditory (ex: spoken words or music notes input into a sound processor)
Visual (ex: photos input into a photo editor)
Tactile (ex: strokes of a keyboard, swipes on a touchscreen)
Text (ex: words input into a translation program or numbers input into a calculator)
Program Outputs
If program inputs are data that a computer takes in, program outputs are the data
that the computer returns. In the adding program example, the program output is the
final sum that the program returns.
Types of Outputs
Outputs can be in any of the formats inputs can be in.
Auditory (ex: music that plays when you press a play button)
Visual (ex: an edited photo from a photo editor)
Tactile (ex: a video game controller vibrating in response to in-game movement)
Text (ex: translated text from a translation program)
Program Events
In order for a program to receive inputs, an event needs to happen. A program event is
simply an action that gives a program data to respond to.
For example, pressing the left arrow causes a video game's program to make an avatar go
left. Pressing the key is the event in this case.
Events cause programs to change how they're running. In the previous example, pressing
the left key caused a change. If the arrow hadn't been pressed, the avatar would've kept
moving in the direction it was before (or standing still, as the case may be.)
Examples of Common Events:
clicking a button
moving a mouse
starting a program
pressing a key
a timer running down to zero
Event-Driven Software
A lot of modern software is event-driven, which means that it's
designed to respond to events in order to run.
Let's go back to our adding machine example. You start the program,
which is an event. Then, you type the two numbers in and input
numbers into the program, another event. The program is designed
to respond based on these events, so it's considered event-driven. On
a larger scale, your phone's software is event-driven as a whole
because it responds primarily to your taps, clicks, and swipes.
Program Behavior
When you run a program, you expect it to perform in a certain way. This is known as a
program's behavior. Usually, program behaviors are defined by how a program will
respond to a user interacting with it.
It's important to think of what behavior you want your program to have before you
code it. In order to figure that out, you'll need to know what the purpose of your
program is, how program events will give inputs for the program to process, and
how the program will output information.
Even if the programmer doesn't define a program's behavior for a certain scenario,
the program will exhibit behavior in response to it anyways. That response is often to
crash.
Obviously, you don't want an adding program to crash your computer or return the
numbers multiplied together instead of added together.
Program Design and
Development
The development process for a program is how it's made. It consists
of the steps it takes to go from planning to programming and beyond!
Types of Development Processes
There are many different ways to create a program.
Traditionally, program development follows a set path. It is orderly and
intentional.
One of the most well-known frameworks for developing software is
known as the waterfall development model. It's characterized by a
step-by-step process, where one step flows naturally into another.
Waterfall development model
Over the years, new methods of creating programs were created,
such as the Agile and DevOps development methodologies.
These methods can offer a more flexible approach to development,
and help foster collaboration between developers and users. There
can also be variations within methods. For example, programmers
have created variations and modifications to the waterfall
development model over the years.
Some development processes aren't intentional.
They're exploratory in nature: the programmer experiments as they
go along. This can happen when a program doesn't have specific
guidelines behind it or when developers are under time constraints.
There are two general types of development processes that the
College Board wants you to know about: iterative and incremental
development processes.
Iterative and Incremental Development Processes
When you think of "iteration," think of repetition.
In an iterative development process, programmers develop working prototypes of their
programs and go back through the stages of their development method to make their programs
better.
In an incremental development process, programmers will break the program they're
working on into smaller pieces and make sure that each piece works before adding it to the
whole. Programs can be developed using both of these models, or any combination of the two.
For example, you can take a code segment of a larger program and revise it until you finish
developing it completely, then move on to another part of the program. You're using
an iterative process by revising that code segment to completion, but an incremental one for the
program at large.
The Drawing Board: Phases of Program
Development
The beginning steps for most development processes are the
planning phases. Lots of work goes into a program even before
anyone opens a code editor.
Investigation and Reflection
This is the game-plan stage of the development process. The goal of
this investigation is to make the goal of the programmers as clear as
possible.
In this stage, programmers establish what their purpose is and the
problem they're trying to solve. They figure out what their program
will need to do, and also what their program will need in order to
function properly.
They'll often have program specifications to help them with this
task. Program specifications are descriptions of the goals of the
program agreed on by both the programmers and the clients.
In order to get a clear picture during this stage, programmers have to
consult with many sources. If their program is for a client, the client
will be consulted to determine what they want. If they're working in a
group, they may have to consult each other to make sure all parts of
their program will work together. They may also have to do external
research to discover what sorts of programs are similar to the one
they're trying to make.
Ways Programmers Investigate:
collecting data through communication channels, such as surveys
user testing
conducting interviews with clients to assess what their needs are
direct observation of the project in action if the project has already
been through one or two loops of development In an iterative
process, this stage can also include a reflection aspect on ways the
project could improve or why something isn't working. With every
repetition, the questions to investigate and reflect on change. As a
result, they become more specific over time.
Designing Code
The design phase of the development phase details how to
accomplish the goals of the program.
This design phase may include:
brainstorming
planning and story-boarding
organizing the program into modules and functional components
creating diagrams that represent the layouts of the user interface
developing a testing strategy for the program
Program Requirements and Specifications
Through investigation, programmers are able to discover their
program's requirements. Program requirements describe how a
program works. What should a user be able to do? What does a user
need to provide for the program to work? These details are defined by
the program specifications.
Once the program specifications, defining the program
requirements, are written, programmers are free to start building,
prototyping and testing their programs to their hearts' contents.
While they're writing their programs, they'll need to record what
they're doing. They'll do this through the process of writing program
documentation.
Program Documentation
Program documentation, at its simplest, is a description of how
something in your program works. Sometimes, this description can
include how your program was developed, such as why you chose
one method of coding over another. The documentation could
describe a code segment, event, procedure, or even the whole
program itself. Think of documentation as notes and summaries for
your code.
Why is documentation used? Programmers document a program in
order to break it down and explain it.
They need to do this for a variety of
reasons.
Programs are complex things. It can be impossible to understand a
program just by reading the code alone, and that’s where
documentation comes in. Documentation is crucial for understanding
how every part of the program works.
Documentation also fosters collaboration. Someone other than the
original programmer may someday need to work with this code, and
documentation helps explain what's going on.
Documentation makes it possible to use code someone else wrote
without having to understand exactly how it works. Documentation
ensures that everyone (including the original programmer) knows
what a piece of code does.
Comments:
With this in mind, let's turn to a common form of program
documentation: comments. One of the most common forms of
program documentation is known as comments. Comments are
documentation written directly into the program itself.
Sourcing Your Work
As you travel further and further on the path of computer science
study, you may come across a situation where you're using code that
someone else helped make. Maybe you and a friend were working
together on the Create project. Maybe you had a group project. Maybe
you found this really nice code segment that does exactly what you
need...
Not so fast, buster! There are some things you need to do before using
code that other people helped create.
First, check with your teacher: are you allowed to use this code for
class?
Next, verify that you have permission to use this code. Code is often
licensed in a way that will tell you what your usage permissions are.
You may need to get the original coder’s permission.
