Striking a Balance: Finding a Compromise between the Social and the Scientific

Balance and compromise are common vocabulary; one hears them used regarding all aspect of life. However, to strike a balance or compromise is often a more odious task than presumed. Through the exploration of four texts “The No-Nonsense Guide to International Development” by Margaret Black, “Beyond the comfort Zone” by Jo Rowlands, contrasting with “What is Engineering”, and “Mindsets in Engineering” by Riley, it causes one to question how a balance and compromise can be struck between the Social mindset and the Science mindset regarding Global Development. First, I will discuss the rolls of social and science in development, second I will state why these two mindsets need be more intertwined and conclude by briefly discussing the challenges ahead for striking a balance between the Engineer and the Social Scientist.

The role of social science is often hard to define as it encompasses many different strategies of problem solving; with various combinations of research methods and tactics, that are further convoluted by each social scientists personal milieu, there exists a wide rage of opinions and solutions surrounding all development issues (Rowlands). While the ability to perceive many different aspects of a situation, and offer varying solutions and opinions may make it impossible to come to a conclusion, it helps insure problems are not given solutions that are ineffective.

Contrary to the social scientists roundabout problem solving, engineers are given a problem and set directly to find a solution. They use their ingenuity, with their mathematical and scientific skills to come to an appropriate solution that suits the needs and fiscal constraints of their contractor (Text: What is Engineering). Their roll in technological development is of utmost importance as, without this scientific advance, the world could not progress.

It is clear that social aspects and scientific aspects go hand in hand, but are often viewed as starkly different. Without using tools from both mindsets, accomplishing development tasks is next to impossible. For example, in “The No-Nonsense Guide to International Development”, Margaret Black uses the construction of a water dam in Northern India to demonstrate how this engineered development project did not result in a positive outcome. Black believes that “the essence of 'development', as most people understand the term, is that it should combat poverty. Yet many of these projects adversely affect poor people and inflict poverty on others who were not poor before”(Black). In the case of the dam,the engineer could view the project as a success: it fulfilled the goal it set to accomplish. To the social scientist however,(like Margaret Black) it was a catastrophe, further hindering the lives of the impoverished, the very people for whom development is supposed to help.

From this is it clear that while engineers are there to give a solution, their solution is not always the most appropriate without the understanding of the social implications that come from the social scientists concept of the needs, and wants of the people in that particular social setting. This is a direct result of problem 'solving' without exploring socio-cultural aspects and thinking of possible adverse implications these solutions could have on a society.

The essence of the challenge ahead revolves around how does one combine these mindsets in order to be more effective in development projects? Unfortunately, engineers are assigned to a job and paid to fulfill that task. Is it even possible to orient a conscious social prospective into this predominately privately funded field? (Riley). Whether it is integrating social justice into the scientific schooling, or imposing government regulations and guidelines, I do not know.

Little Lion Man - Mumford and Sons (cover)

I'm really glad I've been picking up my guitar more frequently.

here's a little cover for ya!

Passport Stamps

for a university friend.

I made this for a friend in Queen's Engineering.

Wall Art from my Old House

Later to be painted, these fish were in my room at 299.

Going back to Kingston for a final year

Arcade Fire's amazing ONLINE video

http://thewildernessdowntown.com/

this is fantastic. I love people that combine mediums... it's artistic and technologically savvy.

The transition from television to web is soon upon us and why not have fun with their integration while we can?!

Binary Search Tree Assignment for Data Structures Class 235

The following has two classes: Tree and BinarySearchTreeHeightCalculator

/**
* BinarySearchTreeHeightCalculator by Jaimmie Riley
*
*/

//allows the program to generate random integers
import java.util.Random;

public class BinarySearchTreeHeightCalculator
{
public static void main(String[]args){
//Class to 'Tree' class by creating a new binary tree
Tree binTree = new Tree ();
//generates a random number
Random number = new Random();
int i;
//iterates 100 times to add 100 random numbers to the binary tree
for(i = 1; i<100; i++){
int randNum = number.nextInt(101);
if(randNum == 0){//ensures numbers inserted to tree are 1-100
i--;//ensures 100 numbers are placed into the tree
}//end if
else{
binTree.insert(randNum);//calls function in Tree to insert numbers into
//the binary tree.
}//end else
}//end for

//calls a function in Tree that will calculate the Right height and Left height
//of the binary tree. It will then print out the results.
binTree.calculateHeights();
}//end main
}


/**
* Tree by Jaimmie Riley with code by Doug Wightman
*
*/
/******************************Doug's Code Starts*************************************/
public class Tree
{
private class Node
{
public Node left;
public Node right;
public int data;

Node( int data ) {
this.data = data;
this.left = null;
this.right = null;
} //end Node
}//end class Node

private Node head;

public Tree() {
head = null;
} //end public Tree

/******************************Doug's Code ends*************************************/

//Function to insert an integer into a binary tree
public void insert(int num){
//if this is the first node, creating a node to add the numer
if(head == null) {
head = new Node(num);
}//end if
else {
//creates a place-holder for the root note of the binary tree
Node traverse = head;
while (traverse != null){
//Go left if the number is smaller than the placeholder
if(num < traverse.data){
if (traverse.left == null){
traverse.left = new Node(num);
return;//exit function
}//end if
else{
//advance the placeholder to the node to it's left
//until a null is found, and a new node can be added
traverse = traverse.left;
}//end else
}//end if
//Go right if the number is larger than the placeholder
else{
//if there is space for a new node to the right of the binary tree
// attach the node with the number
if (traverse.right == null){
traverse.right = new Node(num);
return;//exit function
}//end if
else{
//advance the placeholder to the node to it's right
//until a null is found, and a new node can be added
traverse = traverse.right;
}//end else
}//end else
}//end while
}//end else
}//end insert

//function used to calculate the height of tree.
//the height of the tree is calculated when this function calls countingHeight
public void calculateHeights(){
Node rightHeight = head.right;
Node leftHeight = head.left;
int rightCount;
int leftCount;

//1 must be added to the count, to include the node
//to the right of the root node in the height count
if(rightHeight != null){
rightCount = 1;
}//end if
else{
rightCount = 0;
}//end else

//1 must be added to the count, to include the node
//to the left of the root node in the height count
if(leftHeight != null){
leftCount = 1;
}//end if
//if there is no left node the neight is 0
else{
leftCount = 0;
}//end else

//calls recursive function, countingHeight, that calculates
//the height of the right-side of the tree
rightCount += countingHeight(rightHeight);

//calls recursive function, countingHeight, that calculates
//the height of the left-side of the tree
leftCount += countingHeight(leftHeight);

System.out.println("The Right-Height of the tree is: " + rightCount);
System.out.println("The Left-Height of the tree is: " + leftCount);
}//end calculateHeights

//This recursive function is used by the function calculatingHeights
//to calculate the right height and the left height of the binary search tree
public int countingHeight(Node current){
if(current == null){
return 0;
}//end if
else{
return Math.max(countingHeight(current.left), countingHeight(current.right) + 1);
}//end else
}//end countingHeight

} //end Tree