Software Development Fundamentals

Software Development Fundamentals General Software Development Application Life-Cycle Management

This is the typical Life-Cycle management for an application. Is a key process to help us. The first step is Requirements. Before we decide to create a software, we need to envision a product, a software. Once we come up with the idea, we need to find the requirements: features, what to do, the result we want, etc. Normally this requirements are documented to explain what are the specifications and goal of our application. After this, we need to create the Design. Different ways to program, different architecture to achieve what we want to do. We are creating a design how the application work and how we are going to create it. Storyboards can be used to see how the application flows on the user interface. Next we go to Development, the people who write the code. They create a Technical Specification, a document that dictates how we are going to actually create the functionality in code. What technologies to use, what data structures to implement, how to access data, etc. Then we have Test. We have testing during the development process, to test part of code (small parts). Then we have the test team. They look at the functional specification, know and understand what the program is supposed to do and then write automated test routines to check the functionalities. There is also user acceptance test were users test our final code.

The next phase is Maintain. After we release our application, we need to maintain. We can record pieces of information about how it operates, for performance checking, search for bugs, etc. Is important to maintain our code. Fix bugs, launch new versions, check for security, etc.

Application Specification Sometimes it can be called functional specifications, but is the part of the life-cycle process. The more important parts for a software developer are Feature List and Feature Overview. The Feature List gives the description of what we want to have as a result, and what to do to end there. For example, checking a price:

It only explains what we want to do, not how to do it. We go deeper on feature overview. Feature Overview shows us what problems we want to solve and how to get there. This documents are normally created on the 2 first steps of the life-cycle of our application. On the Design phase we decide what the user will see and not see.

Core Programing Computer Storage This explains how a computer stores information and it processes information. Computers use binary concept, 0 and 1, on or off. Physically we are dealing with the presence of voltage or no voltage. We need to have representations for Character Sets, symbols that make up the words and letters we use. We represent them with series of 0 and 1, bits and bytes. A 0 or a 1 is a bit. When we start to aggregate them we start to have bytes, megabytes, gigabytes, etc.

When a computer runs a program, can’t run it directly from a storage device. It has to access that information directly in computer memory (RAM). We only can use a certain amount of memory, not an unlimited amount. That gives us some restrictions. We also have ASCI charts, which is a way to represent special symbols, punctuation marks, letters and numbers on our binary system. Our programming languages today are on a hinger level, so we don’t program in 1 and 0’s. Programming language allows to write code using a similar syntax to English, and the compiler in the background that takes those instructions and exports into a binary version that the computer can understand. Also depending on the CPU we are using, we need specific instruction sets.

Variables, Constants and Data Types 

Variable – provides a temporary, named storage location in computer memory. Computers deal with memory addresses. With variables, name storage locations, we save this information to that memory address, but the computer does all the mapping. Just need to remember the name of the variable. Can change values of a variable.



Constant – either a named storage location or literal value. Cannot be changed during program execution. We can still assign a value to a constant but we need to do it when we create the constant. Can read the value, but not change during execution. Literal constants are something like number 1, letter C, etc. We can’t change those values. 1 will always be 1, etc. We can store a constant in a variable. For example number = 1, where number is the variable and 1 the constant.



Data Types – numeric, character, special

We use specific data types because the computer needs to know that because of the operations we might want to perform with our data. For

example using + with text and number. Mathematically we can0t do it, so the computer doesn’t know what to do. Also when the compiler sees the data type it knows how much memory to set aside for that variable.

Data Structures We need to store multiple pieces of potentially related information. Some of the data structures available are:    

Arrays Stacks Queues Dictionaries

Arrays An array is a collection of similar data types accessed by index. For example we have this array example:

We can’t forget that they store the same data type. Normally we have strings, numeric values, or in OOB, a collection of objects. We can define an array as a random access data structure, so we can access the values in this array at any time, in value, in any order, using the index value. The index start at 0. The index does not relay to the value on that index. Data structures will be represented by a variable, so we need to name this data structure. We have a single name that represents multiple items. To create an array of strings, we will use the following code:

We create a new array called myArray, with data type string before the name. The order of the array is determined by the order we put the values into the array.

Stack Stack is a collection of objects, accessed by pop and push. We use stacks on some specific programing scenarios. On a stack of trays, we can’t access the last tray without damaging the structure. To get to a specific tray, we need to remove all the others on to top of that one. So when we look at a stack, we can consider when we put values on the stack, we push the values to the stack. When we take a value off the stack, we pop the value from the stack. We put the values on the top of the stack, so it keeps pushing the first values down. Is a FILO (First In Last Out) data structure. This is an example of a stack, called myStack.

We use the .Push method to stack objects into our stack. At the end we iterate into the stack and use .Pop to pop a value out of the stack. Also we need to explicit convert the item to string (.ToString) in order to print it correctly. Remember that the last item is the first one getting out of the stack (FILO). When we pop the value from the stack we are literally taking it off. The stack sizes decreases while we pop values out.

Queue A queue is a collection of objects, accessed by queuing and dequeuing. Similar to a line at the motor vehicle license branch.

This is considered a FIFO (First In First Out data structure). The first piece of data going into the queue is the first piece of data out of the queue. You access that information through different methods that pull the items off to the queue. This is an example of a queue:

We add values to the queue using .Enqueue, giving it the order as we add items to the queue. In C# we can use .Peek to see the first item on the queue. To retrieve items from the queue we use .Dequeue and we don’t give it a value. A queue always give us the first item (FIFO). When we dequeue an item from the queue we decrease the number of items in the queue.

Dictionary A dictionary is a collection of objects that are accessed by using a key. For examples:

It’s similar to an array, but instead of accessing this values through an index like we did with the array, we access them through the use of a key. It’s easier to use the key instead of and index, because we give this key a name we need. For example using it with names, etc. This a dictionary sample:

We create a variable Dictionary, with strings. We add values to the dictionary using the key. We access the item by using the key instead of the order we put the values in or by the index.

Algorithms We can think of an algorithm as a mathematically formula or a recipe, etc. We should think that an algorithm is a solution to a problem. We have a problem and we will take steps to solve that problem, like we use a recipe, adding ingredients, mixing, cook, and check if it’s OK. If not, make some decision until is good to eat. We have a flow in a recipe, as we have in an algorithm. We need to look at a problem logically. We can have for example a bubble sort, and that is an algorithm that we use to compare 2 values, compare them, and then swap if the first is greater than the second until we reach the end of the list, looping until we get to the end of the list. Is the most inefficient way to sort values.

Decision Structures We use the diamond boxes to illustrate a decision. We ask questions as we code, and the program will answer that questions. For taking decisions we can use:  

If, If-else, If-else-if Switch or Select Case

This allows to evaluate a condition, take a look at whether it’s true or false, and take an action based on that. This is essentially what decision making do. Allows to change the flow of the code.

The condition happens inside the {}. The code inside the if will execute if the condition is true. We use = to assign a value. We use == as a comparison operator.

We use if-else to take action if the comparison is true, and then take some action is false. If it’s not true it will execute the else part of the code. In this case the code will run always something, if it’s true or false.

In this case we have 2 conditions, and if it’s not true, we will execute the last part, the last one else. To avoid problems with a long nesting of if else code, we can use switch. Switch gives a cleaner way of checking multiple conditions and execute code based on that. This is our example of a switch.

We check our condition first, on the switch(*condition*), and we compare it to the case statements used bellow. In this case we will evaluate switchCondition = 3 against case 1, 2, 3 and have a default value (default is optional). Default value will be used when no condition is met on the cases. We must use break at each case to get out of the switch statement.

Repetition In this section we will analyze parts of programs that repeats or loops, and repetition is something we will use in programming a lot. Bubble sort is something that repeats for example. We will cover:    

For loops While loops Do-while loops Recursion

For loops

For loop is a structure that do something repeating until a condition is false. With will loop while condition is true. We will use a sentinel value that will allows us to terminate the loop. We have to do something to the sentinel value so it doesn’t run infinitely. We declare an initialization value, and int and give value of 0. Then we will have the condition that we check to see if we loop again or exit the loop. At the end we increment our condition value (sentinel value), saying that it ran 1 time, in this example.

While loops

While the condition is true, it will run our loop, until our condition is false. But, in this case we need to increment the value on our loop, so it doesn’t loop forever.

Do-While loops

On a do-while loop we have the do portion of code, that iterates and also increments our condition value. At the end of the code we will declare

the while, the condition for our code to loop. We only do the condition check at the end of the loop so the code will always run before checking the condition. Even if the condition is not met in the beginning, it will run the code once.

Recursion

We declare a long variable, and then we do a function call. We will call the Factorial function declared bellow on our code example. We pass a value of 10 to our function. Then we will do our factorial function. If our value equals 0, we will return one, we will exit our code. We call recursion because we will call the same code again in the return n * Factorial (n – 1). At the end we will take the values of the stack and will start multiplying them and return our value.

Object-Oriented Programming Object-oriented programming is the most used by programmers nowadays, helping modeling real world objects into programming concepts. Before we used sequential programming than run top from bottom. OOP helps us in that.

Fundamentals of Classes We can considerer a class like a blueprint. As a common blueprint, it has very specific information about what we are going to build (number of windows, size, etc.). Also gives us the behaviors of what we are going to build. In the case of a car, it can accelerate, break, turn, etc. So a class includes data (attributes) and behavior. We create a mapping how this class will be in our code. Objects are created in code to represent the class.

The difference between the two is that the class is the blueprint, so we can’t “live” in the class, but the object is the instance of that blueprint and we can “live” in that object (example of the house). When we create a class file it includes all of the data, or what we refer to as the attributes (size, shape) and it includes all of the behaviors (what object is capable) of that specific class or object. We have the example of a class named Animal. The attributes are: type, weight and color – this are considered the data or the attribute of that particular animal class. Make noise and move are examples of the behaviors of the animal class. When we create the class, the attributes or the data that we’ll store in the class will be represented through variables and constants and can create data structures within it to represent collections of pieces of data that will actually be represented as well. In sum, classes are data and behavior all in one.

Introducing Encapsulation Creating data and behavior in a class is known as encapsulation. But it goes beyond, because we can actually hide data from the user. The user in this case is the programmer using that class in code. With that we create a black box. This term means that the user can take our black box, our code and use it without knowing how it does what it does. The behaviors is exposed through interfaces. They can’t manipulate what it do. They use it through the interface. We can also control what they do with the data. They can’t change values directly in the class. They must use our programming interface to set the values and retrieve the values. This gives us better control over the data users pass in and get back in on their system. This is the examples of a class, called Animal:



We name the class as Animal

 

We have the member variables, our attributes (type, weight and color). We have the data types to encapsulate our data. By declaring private, we can’t set this variables values or type directly. To change the values we use Properties, our “interface”, to get and set this specific private member variables. The property that access our variable, or attribute, starts with an uppercase.

Get is used to return the value, so we use the return statement. Set gets the value from something value, something in C# uses in its property methods that says this is the value that somebody has passed into set what the type is. We pass to type the value that the user set. Property is simply a way to gain access to the variable to set or retrieve its value. The data itself is stored in the local variable. We can make a value read only by not including the set. Let’s see a behavior, or instance methods:

Public keyword means that users are allowed to gain access to these because they are public.

Inheritance With inheritance, data and behavior are taken from another class. This creates the concept of super classes, sub classes or base classes and a derived class, etc. This means that the base class becomes the parent and the derived class or sub class becomes the class that does the inheriting. It collects the values from the parent/super class. Inheritance allows to create a class with a base that can be used across different subclasses. It provides base functionality for similar objects. Allows code reuse. Think of character traits inherited from a parent. With the animal class examples, we create that base class with the attributes, and then create animals like dogs, cats, etc., that have the same base (size, color, etc.). This characteristics and inherited from the parent, the super class. Super class has the aspects, functionality and attributes that we can reuse in sub classes. With that we don’t need to write the all code again. Let’s see an example: Using the Animal class, we create a class Dog, with Animal as base:

Even with no data, the Dog class inherited from the Animal class. This is demonstrated by the : Animal. We create a new dog, and we’ll say that equals a new dog.

This is the syntax for instantiating an object of the dog class. In OOP is referred as instantiation. Dog is the blueprint. Spot is the instance of a dog that we decided to create in our code. Because we use super/base class Dog, when we want to access to attributes of Spot, we will have the attributes of the class Dog.

We see here color, type and weight. Intelisense will give as all the functionality available to Spot. What we see is inheritance in action.

Polymorphism It’s another key of object-oriented programming. It means that we can have multiple versions, different versions, of the same thing. Polymorphism means that a behavior change, or an attribute change. Wesaw the inheritance and Spot having functionality of Animal class. But we can also make changes to our dog class that suits what we want to do. For example:

The class Dog inherited from Animal class. The animal class doesn’t have a Breed functionality. But we can code that in the Dog class and now Dog class as Breed property while Animal don’t. The class that inherits can me modified and have other properties that the base class doesn’t have. In the case of Animal, a specific type of animal can have different characteristics depending on the species. We don’ change our super class.

Polymorphism also allows us to change functionality. Here’s an example:

We add wagtail functionality that Dog class now has, but Animal class doesn’t. But we can also override a virtual method, in this case MakeNoise(). We can change the behavior of that virtual method. Animal has MakeNoise() as base, and we add “Bark” to the dog class by overriding our method. We change the functionality has we need on the subclass.