Skills and Characteristics of a Systems Analyst by a Systems Analyst

Last December 8, 2011, we had the chance to interview and ask questions about the skills and characteristics of a systems analyst need to develop in order to be more effective in any design modeling process. It was a great conversation with our professor last semester, and also a proud systems analyst, none other than Prof. Ariel Pabilona.

Before knowing about the skills and characteristics of a systems analyst, let us first define what a systems analyst is. According to United States Department of Labor, Bureau of Labor Statistics, systems analysts use IT tools to help enterprises of all sizes achieve their goals. They may design and develop new computer systems by choosing and configuring hardware and software, or they may devise ways to apply existing systems' resources to additional tasks. According to Wikipedia.com, a system analyst can do the following:

·      Plan a system flow from the ground up.

·      Interact with customers to learn and document requirements that are then used to produce business requirements documents.

·      Write technical requirements from a critical phase.

·      Interact with designers to understand software limitations.

·      Help programmers during system development, ex: provide use cases, flowcharts or even Database design.

·      Perform system testing.

·      Deploy the completed system.

·      Document requirements or contribute to user manuals.

·      Whenever a development process is conducted, the system analyst is responsible for designing components and providing that information to the developer.

Now that we have defined what a systems analyst is, and have already understood what he or she does, let us now discuss the requirements on how to become a systems analyst.

According to Mr. Pabilona, A system analyst has a range of functions, including research of problems, planning of solutions, recommendation of systems and software and coordination of developments necessary to meet business and other requirements.

In addition, they act as a liaison between vendors, IT professionals and end users, as well as often being responsible for design considerations, translation of user specific requests into technical specifications, cost analysis and development, as well as implementation time lines.

Typical problems solved by system analysts include cost-efficiency of inventory holding, evaluation of customer needs, such as ordering times, etc, and efficient analysis of financial information.

Skills

As well as requiring technical skills and knowledge, including knowledge of hardware, software and a whole range of techniques involved in system design, planning, programming, development, testing and application, a system analysts also has to have business skills, including knowing about organizational structures, and management techniques; traditions, plans, strategies and values of an organization and functional work processes. To become a technical person, only a few courses offer the process to have the knowledge required to become a system analyst, and some of those courses are Bachelor’s degree in Computer Science, Information Science, and Engineering. According to money.usnews.com, some businesses favor degrees in management information systems, which is likely to be in the middle region of being technical and business minded people. To gain business skills knowledge, a systems analyst must

·      know every function performed by each employee of a business organization which is one of the most important tasks a system analyst has to do;

·      work well with the workers of the organization a system analyst works with, he must basically know the general plan of the organization;

·      know the organizational structure is an important work to do for a system analyst;

·      manage the organization which pertains to the management of every resource the organization have; and

·      know the whole process itself, and having the skill to look outside the box while also considering the inside of the box is a key skill for a system analyst.

People skills, including an understanding of how people learn and think, work, respond to change and communicate. Understanding people is a skill only available to open minded persons. As a system analyst, he must deal with the people of the organization he is working for. And as the system analyst analyses the system, he must think like the people who will use the system he is making. A system analyst must consider how long the users will be able to learn to use the functionality of the system. Situations like when employees encounter changes that they are incapable of solving on their own should be considered by a system analyst, thus, having to know how to react to change. Communication and interpersonal skills are, in fact, crucial to obtain information, motivate other individuals and achieve cooperation, as well as understanding the complex processes within an organization if necessary support is to be provided. As system analyst gathers information on the system that he analyses, he must have the skills to communicate effectively with the other people. He must know how to motivate them in telling him what kind of information he needs from them. And with cooperation that is a helpful thing for the company, he might be able to understand the complexity and workings of the organization in order to provide necessary support. Having to do all these things, a system analyst must be really good in interpersonal and communication things.

Qualities and Characteristics

A good systems analyst should consequently have excellent knowledge and skills of techniques and tools used within technology, business and people, as well as an ability to adjust to and comprehend constantly advancing technology and business methods. These qualities and characteristics should be developed by a systems analyst in order for him or her to design systems that can cope up with the constant change that happens on the technology and on the environment. To become adaptive to the change is not really easy for the change in the present is happening very fast. Today, you don’t know anymore what the current big technology that is being developed is.

A good systems analyst should be a logical and critical thinker who is inquisitive, patient and persevering, methodical and broad minded. In addition, he must be able to communicate with a variety of individuals from varying backgrounds in order to achieve and motivate, as well as maintain cooperation between all parties involved. Being logical, he or she will be able to design that is not just good in terms of the appearance but in terms of the usefulness and efficiency of the system. A systems analyst can also solve difficult problems that may be able to provide change to an organization and to do that, he or she must know a lot of strategies for the system to become reliable to the users.

In addition, Mr. Pabilona says that other characteristics a systems analyst must possess are the following:

·      The system analyst must be able to communicate in writing and orally.

Communication is very important in the phases of the development of a system. A system analyst must constantly communicate to all the users of the system he or she is making and to the company boss. He or she must tell them what is happening and report the current state of the system. Even after the system is finished creating, the system analyst must also know to communicate to the company for further need to update the system if needed.

·      The analyst must easily get along with people.

Getting along with people is crucial in the data gathering phase of the system development. The system analyst must have the charisma in which he or she can communicate and get along with the people he or she works with for him to have an easy and efficient job in gathering data for the system. Getting along with people well will also build good working relationships with the other people that will leave an impression to them that he or she is a good systems analyst. And when he or she works in another company, the former company may vouch for your attitude and skills in being a good system analyst.

·      The analyst must be a good listener and be able to react to what people say.

A systems analyst must be wise enough to tell when to just listen and when to react to the things that other people do that affects the life of the system development. If the users have some issues with using the system, he or she must be prepared to take the words of the client. He must be open minded in having people criticize what he or she is doing, and when misunderstanding happens, he or she can handle and explain to them clearly what the real thing is.

·      The analyst must be knowledgeable of technology. The analyst is not expected to know the intricacies of programming, but a decent general knowledge of concepts and terms is essential.

In analysis and design of systems, being a programmer is not really a requirement. What is required is just the basic knowledge in the different fields of computers. He must be able to know what is the essential part needed to know for him or her to be able to create systems for businesses. He must somehow understand all about computers and peripheral devices or hardware, communications networks and connectivity, database and Database Management Systems (DMBS), programming languages, and operating systems and utilities.

·      The analyst must be knowledgeable of business. The analyst is not expected to be an expert in business but a decent understanding of the client's world is required.

As for the fact that system analyst works with business, basically and obviously, he or she must know the business itself. The future of the business lies in the hands of the system analyst. The system he creates can make the business boom or break. Therefore, to become a business minded person is a requirement to become a system analyst. A systems analyst must understand business functions performed by the organization; know the strategies, plans, traditions and values of the organization; be aware of the organizational structure; realize the organization management techniques; and understand functional work processes. All of these must be understood by a systems analyst.

                To sum it up, the following are the skills, characteristics, and qualities of a good systems analyst:

·      Understanding written sentences and paragraphs in work related documents.

·      Writing computer programs for various purposes.

·      Determining causes of operating errors and deciding what to do about it.

·      Analyzing needs and product requirements to create a design.

·      Communicating effectively in writing as appropriate for the needs of the audience.

·      Conducting tests and inspections of products, services, or processes to evaluate quality or performance.

·      Giving full attention to what other people are saying, taking time to understand the points being made, asking questions as appropriate, and not interrupting at inappropriate times.

·      Using logic and reasoning to identify the strengths and weaknesses of alternative solutions, conclusions or approaches to problems.

·      Talking to others to convey information effectively.

·      Identifying complex problems and reviewing related information to develop and evaluate options and implement solutions.

To become a systems analyst is not an easy process and is not an easy job also. There are a lot of skills, characteristics, and qualities a person must possess to become a good systems analyst. He must know a lot of things related to computers and business which are both very broad areas of study. Understanding one field takes time, more will it take to study both. Some people may have possessed one or two skills, characteristics, or qualities to become a system analyst, it is still not enough. And even if others possess all the skills, characteristics, and qualities required are present to a person, if they do not apply it, then it is useless. And being just becoming a systems analyst is also not enough; he or she must develop and enhance all the skills, characteristics, and qualities for him or her to be called a good systems analyst. For those who became systems analyst, I salute them with all my heart, for I know and partly understand for now the burden and sacrifices they took to reach their goal of becoming a good system analyst.

Evidence:

Sources:

     http://en.wikipedia.org/wiki/Systems_analyst

      http://bls.gov/oco/ocos287.htm

      http://money.usnews.com/money/careers/articles/2010/12/06/best-careers-2011-computer-systems-analyst

Sorting Algorithms

Selection Sort

Selection sort is one of the O(n²) sorting algorithms where the minimal value is put in the start of the array. This sorting algorithm is inefficient on large lists, and generally performs worse than the similar insertion sort due to its computational complexity.

In selection sort, the array of inputs is imaginatively divided into two parts, the sorted and unsorted part. At the beginning, the sorted part is empty and the unsorted part is the whole array. In every loop, the algorithm looks for the smallest number from the unsorted array and then would swap it to the first element of the unsorted part. The loop stops until the unsorted part is empty.

Example. {10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45}

The C++ codes for the selection sort are the following:

void selectionSort(int arr[], int n) {
      int i, j, minIndex, tmp;    
      for (i = 0; i < n - 1; i++) {
            minIndex = i;
            for (j = i + 1; j < n; j++)
                  if (arr[j] < arr[minIndex])
                        minIndex = j;
            if (minIndex != i) {
                  tmp = arr[i];
                  arr[i] = arr[minIndex];
                  arr[minIndex] = tmp;
            }
      }
}

###########

Insertion Sort

Insertion sort is a simple sorting algorithm in which, just like the selection sort, belongs to the O(n²) sorting algorithms. It is a comparison sort in which the sorted array is built one entry at a time.It is much less efficient on large lists than more advanced algorithms such as quicksort, heapsort, or merge sort. However, it has a simple implementation and is efficient for small data sets.

Insertion sort works like selection sort. The array is also divided imaginatively into two parts. The sorted part is the array containing the first element and the unsorted part contains the rest of the inputs. In every loop, the algorithm inserts the first element from the unsorted part to its right position in the sorted part. And the loop ends when the unsorted part is empty.

Example. {10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45}

The C++ codes for the insertion sort are the following:

void insertionSort(int arr[], int length) {
      int i, j, tmp;
      for (i = 1; i < length; i++) {
            j = i;
            while (j > 0 && arr[j - 1] > arr[j]) {
                  tmp = arr[j];
                  arr[j] = arr[j - 1];
                  arr[j - 1] = tmp;
                  j--;
            }
      }
}

###########

Bubble Sort

Bubble sort is a simple and well-known sorting algorithm. Bubble sort belongs to O(n²) sorting algorithms, which makes it quite inefficient for sorting large data volumes. Bubble sort is stable and adaptive.

Bubble sort works by comparing pair of adjacent elements from the beginning of an array and tests them if they are in reversed order. If the current element is greater than the next element, then the algorithm swaps them. The algorithm stops when there are no more elements to be swapped.

Example. {2 3 4 5 1}

The C++ codes for the insertion sort are the following:

void bubbleSort(int arr[], int n) {
      bool swapped = true;
      int j = 0;
      int tmp;
      while (swapped) {
            swapped = false;
            j++;
            for (int i = 0; i < n - j; i++) {
                  if (arr[i] > arr[i + 1]) {
                        tmp = arr[i];
                        arr[i] = arr[i + 1];
                        arr[i + 1] = tmp;
                        swapped = true;
                  }
            }
      }
}

###########

Shell Sort

Shell Sort is one of the oldest sorting algorithms which is named from Donald Shell in 1959. It is fast, easy to understand and easy to implement. However, its complexity analysis is a little more sophisticated. Shell sort is the generalization of the insertion sort which exploits the fact that insertion sort works efficiently on input that is already almost sorted.

Shell sort algorithm does not actually sort the data itself but it increases the efficiency of other sorting algorithms, normally is the insertion sort. It works by quickly arranging data by sorting every nth element, where n can be any number less than half the number of data. Once the initial sort is performed, n is reduced, and the data is sorted again until n equals 1.

Choosing n is not as difficult as it might seem. The only sequence you have to avoid is one constructed with the powers of 2. Do not choose (for example) 16 as your first n, and then keep dividing by 2 until you reach 1. It has been mathematically proven that using only numbers from the power series {1, 2, 4, 8, 16, 32, ...} produces the worst sorting times. The fastest times are (on average) obtained by choosing an initial n somewhere close to the maximum allowed and continually dividing by 2.2 until you reach 1 or less. Remember to always sort the data with n = 1 as the last step.

Example. {10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45}

The C++ codes for the insertion sort are the following:

void shellsort (int[] arr, int length, int n) {
    int i, j, k, h, v;
    for (k=0; k < length; k++) {
        h=arr[k];
        for (i=h; i<n; i++) {
            v=arr[i];
            j=i;
            while (j>=h && arr[j-h]>v) {
                arr[j]=arr[j-h];
                j=j-h;
            }
            arr[j]=v;
        }
    }
}

Source:

http://en.wikipedia.org/wiki/Selection_sort

http://www.algolist.net/Algorithms/Sorting/Selection_sort

http://en.wikipedia.org/wiki/Insertion_sort

http://www.algolist.net/Algorithms/Sorting/Insertion_sort

http://en.wikipedia.org/wiki/Bubble_sort 

http://www.algolist.net/Algorithms/Sorting/Bubble_sort

http://en.wikipedia.org/wiki/Shell_sort

http://www.inf.fh-flensburg.de/lang/algorithmen/sortieren/shell/shellen.htm

http://goanna.cs.rmit.edu.au/~stbird/Tutorials/ShellSort.html

Principles of Algorithm Analysis

Empirical Analysis deals with the analysis and characterization of the behavior of algorithms. It compares the performance of two algorithms by actually running them; meaning it is an analysis based on observations on executing them and not by getting results theoretically. With that, it requires a correct and complete implementation of the algorithm to be used.

Empirical analysis or empirical testing is useful because it may uncover unexpected interactions that affect performance, as it uses benchmarking which assess the relative performance of each algorithm every time it is implemented. With the continuous assessment of the algorithm, it could be optimized thoroughly and much more improvements could be made.

###########

Analysis of Algorithm is how is to determine the amount of resources (such as time and storage) necessary to execute a program. It provides theoretical estimates for the resources needed by any algorithm which solves a given computational problem. These estimates provide an insight into reasonable directions of search for efficient algorithms. In other words, it helps us know what and how much resources we need to efficiently solve a problem and to do it at low cost.

It may not be always possible to perform empirical analysis. Thus, we can resort to the analysis of algorithm, which is basically a mathematical analysis. Mathematical analysis may be theoretical that in such a way it could not actually solve the problem, but the point is that it is the most accurate way of analyzing an algorithm theoretically.

Mathematical analysis is actually more informative and less expensive but it can be difficult if we do not know all the mathematical formulas needed to analyze an algorithm. Thus, to do this process, one must have any skills in mathematics even it is just enough to be able to do the proper analysis of algorithms.

###########

Big-Oh Notation describes the behavior of a function for big inputs. It tries to capture the core of a function. It also describes the limiting behavior of a function when the argument tends towards a particular value or infinity, usually in terms of simpler functions. By mathematical representation, it is defined as f(n) = O(g(n)) which is read as "f of n is big oh of g of n". To understand easier, let's have examples on different common orders of growth of big-oh.

O(1) or O of a Constant:  
bool IsFirstElementNull(String[] strings){
       if(strings[0] == null)
            return true;
       return false;
}
O(1) describes an algorithm that will always execute in the same time (or space) regardless of the size of the input data set.

O(N):
bool ContainsValue(String[] strings, String value){
       for(int i = 0; i < strings.Length; i++)
            if(strings[i] == value)
                  return true;
      return false;
}
O(N) describes an algorithm whose performance will grow linearly and in direct proportion to the size of the input data set. 

O(N²):
bool ContainsDuplicates(String[] strings){
      for(int i = 0; i < strings.Length; i++){
            for(int j = 0; j < strings.Length; j++){
                  if(i == j) // Don't compare with self
                        continue;
                  if(strings[i] == strings[j])
                        return true;
            }
      }
      return false;
}

O(N²) represents an algorithm whose performance is directly proportional to the square of the size of the input data set. This is common with algorithms that involve nested iterations over the data set. Deeper nested iterations will result in O(N³), O(N⁴) etc. 

O(2^N):
O(2^N) denotes an algorithm whose growth will double with each additional element in the input data set. The execution time of an O(2N) function will quickly become very large.

O(log N) or Logarithms:

Binary search is a technique used to search sorted data sets. It works by selecting the middle element of the data set, essentially the median, and compares it against a target value. If the values match it will return success. If the target value is higher than the value of the probe element it will take the upper half of the data set and perform the same operation against it. Likewise, if the target value is lower than the value of the probe element it will perform the operation against the lower half. It will continue to halve the data set with each iteration until the value has been found or until it can no longer split the data set.

This type of algorithm is described as O(log N). The iterative halving of data sets described in the binary search example produces a growth curve that peaks at the beginning and slowly flattens out as the size of the data sets increase e.g. an input data set containing 10 items takes one second to complete, a data set containing 100 items takes two seconds, and a data set containing 1000 items will take three seconds. Doubling the size of the input data set has little effect on its growth as after a single iteration of the algorithm the data set will be halved and therefore on a par with an input data set half the size. This makes algorithms like binary search extremely efficient when dealing with large data sets.

Source:
http://en.wikipedia.org/wiki/Empirical_algorithmics
http://en.wikipedia.org/wiki/Algorithm
http://www.cs.umsl.edu/~sanjiv/cs278/lectures/analysis.pdf 
http://en.wikipedia.org/wiki/Analysis_of_algorithms 
http://www.c2.com/cgi/wiki?BigOh 
http://xw2k.nist.gov/dads/HTML/bigOnotation.html 
http://en.wikipedia.org/wiki/Big_O_notation 
http://rob-bell.net/2009/06/a-beginners-guide-to-big-o-notation/ 

Union-Find Algorithms

Union-Find Algorithm is an algorithm used for systematically maintaining, joining or connecting different sets. Each set may have one or more elements and the set is represented by the value of its root. This algorithm performs two useful operations:

• Find - it determines which set an element is in or by calling this function, returns the root of the set.
• Union - it joins or merges two different sets into a single set.

This algorithm is also used to solve partitioning problems or deciding when to make partitions of a given multiset.

To show visually how union-find algorithm works, here is a link of an applet that implements the said algorithm.

http://research.cs.vt.edu/AVresearch/UF/

Source:
http://en.wikipedia.org/wiki/Disjoint-set_data_structure    
http://www.users.csbsju.edu/~lziegler/CS239/UnionFind.html 
http://www.cs.cmu.edu/~avrim/451/lectures/lect1016.pdf