diff --git a/evaluator/smalltalkEvaluator.go b/evaluator/smalltalkEvaluator.go
index 0682cd3..10b9c1e 100644
--- a/evaluator/smalltalkEvaluator.go
+++ b/evaluator/smalltalkEvaluator.go
@@ -14,13 +14,13 @@ func NewTestEvaluator() *Evaluator {
 
 func TestEval(codeString string) treeNodes.SmalltalkObjectInterface {
 	evaluator := NewTestEvaluator()
-	programNode, _ := parser.InitializeParserFor(codeString)
+	programNode := parser.InitializeParserFor(codeString)
 	return evaluator.EvaluateProgram(programNode)
 }
 
 func TestEvalWithScope(codeString string, scope *treeNodes.Scope) treeNodes.SmalltalkObjectInterface {
 	evaluator := NewEvaluatorWithGlobalScope(scope)
-	programNode, _ := parser.InitializeParserFor(codeString)
+	programNode := parser.InitializeParserFor(codeString)
 	return evaluator.EvaluateProgram(programNode)
 }
 
@@ -62,11 +62,7 @@ func (e *Evaluator) GetGlobalScope() *treeNodes.Scope {
 func (e *Evaluator) RunProgram(programString string) treeNodes.SmalltalkObjectInterface {
 	_, ok := e.programCache[programString]
 	if !ok {
-		initializedParser, err := parser.InitializeParserFor(programString)
-		if err != nil {
-			return treeNodes.NewSmalltalkString(err.Error())
-		}
-		e.programCache[programString] = initializedParser
+		e.programCache[programString] = parser.InitializeParserFor(programString)
 	}
 	evaluatorProgram := e.programCache[programString]
 	return e.EvaluateProgram(evaluatorProgram)
@@ -113,9 +109,6 @@ func (e *Evaluator) EvaluateToBool(programString string) bool {
 
 func (e *Evaluator) EvaluateToInterface(programString string) interface{} {
 	resultObject := e.RunProgram(programString)
-	if resultObject == nil {
-		return nil
-	}
 	switch resultObject.TypeOf() {
 	case treeNodes.NUMBER_OBJ:
 		return resultObject.(*treeNodes.SmalltalkNumber).GetValue()
@@ -124,11 +117,7 @@ func (e *Evaluator) EvaluateToInterface(programString string) interface{} {
 	case treeNodes.BOOLEAN_OBJ:
 		return resultObject.(*treeNodes.SmalltalkBoolean).GetValue()
 	case treeNodes.ARRAY_OBJ:
-		array, err := resultObject.(*treeNodes.SmalltalkArray).GetValue()
-		if err != nil {
-			return nil
-		}
-		return array
+		return resultObject.(*treeNodes.SmalltalkArray).GetValue()
 	default:
 		return nil
 	}
diff --git a/parser/smalltalkParser.go b/parser/smalltalkParser.go
index a65c459..4cfea43 100644
--- a/parser/smalltalkParser.go
+++ b/parser/smalltalkParser.go
@@ -1,7 +1,6 @@
 package parser
 
 import (
-	"errors"
 	"strconv"
 	"strings"
 
@@ -17,40 +16,37 @@ type Parser struct {
 	emptyStatements bool
 }
 
-func InitializeParserFor(expressionString string) (treeNodes.ProgramNodeInterface, error) {
+func InitializeParserFor(expressionString string) treeNodes.ProgramNodeInterface {
 	reader := talkio.NewReader(expressionString)
 	scanner := scanner.New(*reader)
 	parser := &Parser{scanner, nil, nil, false}
 
 	//initialize struct members
 	parser.step()
-	node, err := parser.parseExpression()
-	if err != nil {
-		return nil, err
-	}
+	node := parser.parseExpression()
 	if len(node.GetStatements()) == 1 && len(node.GetTemporaries()) == 0 {
-		return node.GetStatements()[0], nil
+		return node.GetStatements()[0]
 	} else {
-		return node, nil
+		return node
 	}
 }
 
-func (p *Parser) parseExpression() (*treeNodes.SequenceNode, error) {
-	return p.parseStatements(false)
+func (p *Parser) parseExpression() *treeNodes.SequenceNode {
+	node := p.parseStatements(false)
+	return node
 }
 
-func (p *Parser) parseStatements(tagBool bool) (*treeNodes.SequenceNode, error) {
+func (p *Parser) parseStatements(tagBool bool) *treeNodes.SequenceNode {
 	var leftBar int64
 	var rightBar int64
 	var args []*treeNodes.VariableNode
-	var err error
 	if p.currentToken.IsBinary() {
 		if p.currentToken.(scanner.ValueTokenInterface).ValueOfToken() == "|" {
 			leftBar = p.currentToken.GetStart()
 			p.step()
-			args, err = p.parseArgs()
-			if err != nil || !(p.currentToken.IsBinary() && p.currentToken.(scanner.ValueTokenInterface).ValueOfToken() == "|") {
-				return nil, errors.New("Parse error in parseStatements function.")
+			args = p.parseArgs()
+			if !(p.currentToken.IsBinary() && p.currentToken.(scanner.ValueTokenInterface).ValueOfToken() == "|") {
+				panic("Parse error in parseStatements function.")
 			}
 			rightBar = p.currentToken.GetStart()
 			p.step()
@@ -66,34 +62,26 @@ func (p *Parser) parseStatements(tagBool bool) (*treeNodes.SequenceNode, error)
 	node.SetLeftBar(leftBar)
 	node.SetRightBar(rightBar)
 	node.SetTemporaries(args)
-	parsedStatementList, err := p.parseStatementListInto(tagBool, node)
-	if err != nil {
-		return nil, err
-	}
-	return parsedStatementList, nil
+	return p.parseStatementListInto(tagBool, node)
 }
 
-func (p *Parser) parseArgs() ([]*treeNodes.VariableNode, error) {
+func (p *Parser) parseArgs() []*treeNodes.VariableNode {
 	var args []*treeNodes.VariableNode
 	for p.currentToken.IsIdentifier() {
-		parsedVar, err := p.parseVariableNode()
-		if err != nil {
-			return nil, err
-		}
-		args = append(args, parsedVar)
+		args = append(args, p.parseVariableNode())
 	}
-	return args, nil
+	return args
 }
 
-func (p *Parser) parseVariableNode() (*treeNodes.VariableNode, error) {
+func (p *Parser) parseVariableNode() *treeNodes.VariableNode {
 	if p.currentToken.IsIdentifier() {
-		return p.parsePrimitiveIdentifier(), nil
+		return p.parsePrimitiveIdentifier()
 	} else {
-		return nil, errors.New("we expect variable name here btw")
+		panic("we expect variable name here btw")
 	}
 }
 
-func (p *Parser) parseStatementListInto(tagBool bool, sequenceNode *treeNodes.SequenceNode) (*treeNodes.SequenceNode, error) {
+func (p *Parser) parseStatementListInto(tagBool bool, sequenceNode *treeNodes.SequenceNode) *treeNodes.SequenceNode {
 	returnFlag := false
 	var periods []int64
 	var statements []treeNodes.ProgramNodeInterface
@@ -102,16 +90,13 @@ func (p *Parser) parseStatementListInto(tagBool bool, sequenceNode *treeNodes.Se
 	}
 	for !(p.atEnd() || (p.currentToken.IsSpecial() && IncludesInString("])}", p.currentToken.(scanner.ValueTokenInterface).ValueOfToken()))) {
 		if returnFlag {
-			return nil, errors.New("End of statement list encountered")
+			panic("End of statement list encountered")
 		}
 		if p.currentToken.IsSpecial() && p.currentToken.(scanner.ValueTokenInterface).ValueOfToken() == `^` {
 			//TODO: smalltalk return statement ^
-			return nil, errors.New("we should not have smalltalk return statement eg ^ in our script")
+			panic("we should not have smalltalk return statement eg ^ in our script")
 		} else {
-			node, err := p.parseAssignment()
-			if err != nil {
-				return nil, err
-			}
+			node := p.parseAssignment()
 			statements = append(statements, node)
 		}
 		if p.currentToken.IsSpecial() && p.currentToken.(scanner.ValueTokenInterface).ValueOfToken() == `.` {
@@ -130,38 +115,27 @@ func (p *Parser) parseStatementListInto(tagBool bool, sequenceNode *treeNodes.Se
 	}
 	sequenceNode.SetStatements(statements)
 	sequenceNode.SetPeriods(periods)
-	return sequenceNode, nil
+	return sequenceNode
 }
 
-func (p *Parser) parseAssignment() (treeNodes.ValueNodeInterface, error) {
+func (p *Parser) parseAssignment() treeNodes.ValueNodeInterface {
 	if !(p.currentToken.IsIdentifier() && p.nextToken().IsAssignment()) {
 		return p.parseCascadeMessage()
 	}
-	node, err := p.parseVariableNode()
-	if err != nil {
-		return nil, err
-	}
+	node := p.parseVariableNode()
 	position := p.currentToken.GetStart()
 	p.step()
 	assignmentNode := treeNodes.NewAssignmentNode()
 	assignmentNode.SetVariable(node)
-	parsedValue, err := p.parseAssignment()
-	if err != nil {
-		return nil, err
-	}
-	assignmentNode.SetValue(parsedValue)
+	assignmentNode.SetValue(p.parseAssignment())
 	assignmentNode.SetPosition(position)
-	return assignmentNode, nil
+	return assignmentNode
 }
 
-func (p *Parser) parseCascadeMessage() (treeNodes.ValueNodeInterface, error) {
-	var err error
-	node, err := p.parseKeywordMessage()
-	if err != nil {
-		return nil, err
-	}
+func (p *Parser) parseCascadeMessage() treeNodes.ValueNodeInterface {
+	node := p.parseKeywordMessage()
 	if !(p.currentToken.IsSpecial() && (p.currentToken.(scanner.ValueTokenInterface).ValueOfToken() == ";" && node.IsMessage())) {
-		return node, nil
+		return node
 	}
 	receiver := node.(treeNodes.NodeWithRreceiverInterface).GetReceiver()
 	var messages []*treeNodes.MessageNode
@@ -172,24 +146,17 @@ func (p *Parser) parseCascadeMessage() (treeNodes.ValueNodeInterface, error) {
 		p.step()
 		var message *treeNodes.MessageNode
 		if p.currentToken.IsIdentifier() {
-			tmpMsg, err := p.parseKeywordMessageWith(receiver)
-			if err != nil {
-				return nil, err
-			}
-			message = tmpMsg.(*treeNodes.MessageNode)
+			message = p.parseKeywordMessageWith(receiver).(*treeNodes.MessageNode)
 		} else {
 			if p.currentToken.IsLiteralToken() {
 				p.patchNegativeLiteral()
 			}
 			if !p.currentToken.IsBinary() {
-				return nil, errors.New("message expected")
-			}
-			temp, err := p.parseBinaryMessageWith(receiver)
-			if err != nil {
-				return nil, err
+				panic("message expected")
 			}
+			temp := p.parseBinaryMessageWith(receiver)
 			if temp == receiver {
-				return nil, errors.New("message expected")
+				panic("message expected")
 			}
 			message = temp
 		}
@@ -199,7 +166,7 @@ func (p *Parser) parseCascadeMessage() (treeNodes.ValueNodeInterface, error) {
 	cascadeNode := treeNodes.NewCascadeNode()
 	cascadeNode.SetSemicolons(semicolons)
 	cascadeNode.SetMessages(messages)
-	return cascadeNode, nil
+	return cascadeNode
 }
 
 func (p *Parser) patchNegativeLiteral() {
@@ -224,49 +191,35 @@ func (p *Parser) patchNegativeLiteral() {
 	p.peekToken.SetStart(p.peekToken.GetStart() + 1)
 }
 
-func (p *Parser) parseKeywordMessage() (treeNodes.ValueNodeInterface, error) {
-	parsedBinary, err := p.parseBinaryMessage()
-	if err != nil {
-		return nil, err
-	}
-	return p.parseKeywordMessageWith(parsedBinary)
+func (p *Parser) parseKeywordMessage() treeNodes.ValueNodeInterface {
+	return p.parseKeywordMessageWith(p.parseBinaryMessage())
 }
 
-func (p *Parser) parseKeywordMessageWith(valueNode treeNodes.ValueNodeInterface) (treeNodes.ValueNodeInterface, error) {
+func (p *Parser) parseKeywordMessageWith(valueNode treeNodes.ValueNodeInterface) treeNodes.ValueNodeInterface {
 	var keywords []scanner.ValueTokenInterface
 	var arguments []treeNodes.ValueNodeInterface
 	isKeyword := false
 	for p.currentToken.IsKeyword() {
 		keywords = append(keywords, p.currentToken.(scanner.ValueTokenInterface))
 		p.step()
-		parsedBinary, err := p.parseBinaryMessage()
-		if err != nil {
-			return nil, err
-		}
-		arguments = append(arguments, parsedBinary)
+		arguments = append(arguments, p.parseBinaryMessage())
 		isKeyword = true
 	}
 	if isKeyword {
 		node := treeNodes.NewMessageNode()
 		node.SetReceiverSelectorPartsArguments(valueNode, keywords, arguments)
-		return node, nil
+		return node
 	} else {
-		return valueNode, nil
+		return valueNode
 	}
 }
 
-func (p *Parser) parseBinaryMessage() (treeNodes.ValueNodeInterface, error) {
-	node, err := p.parseUnaryMessage()
-	if err != nil {
-		return nil, err
-	}
+func (p *Parser) parseBinaryMessage() treeNodes.ValueNodeInterface {
+	node := p.parseUnaryMessage()
 	for p.isBinaryAfterPatch() {
-		node, err = p.parseBinaryMessageWith(node)
-		if err != nil {
-			return nil, err
-		}
+		node = p.parseBinaryMessageWith(node)
 	}
-	return node, nil
+	return node
 }
 
 func (p *Parser) isBinaryAfterPatch() bool {
@@ -276,31 +229,23 @@ func (p *Parser) isBinaryAfterPatch() bool {
 	return p.currentToken.IsBinary()
 }
 
-func (p *Parser) parseBinaryMessageWith(nodeInterface treeNodes.ValueNodeInterface) (*treeNodes.MessageNode, error) {
+func (p *Parser) parseBinaryMessageWith(nodeInterface treeNodes.ValueNodeInterface) *treeNodes.MessageNode {
 	selector := p.currentToken.(*scanner.BinarySelectorToken)
 	p.step()
 	node := treeNodes.NewMessageNode()
-	selectorParts := []scanner.ValueTokenInterface{selector}
-	parsedUnary, err := p.parseUnaryMessage()
-	if err != nil {
-		return nil, err
-	}
-	//literal array with one selector
-	arguments := []treeNodes.ValueNodeInterface{parsedUnary}
+	selectorParts := []scanner.ValueTokenInterface{selector} //literal array with one selector
+	arguments := []treeNodes.ValueNodeInterface{p.parseUnaryMessage()}
 	node.SetReceiverSelectorPartsArguments(nodeInterface, selectorParts, arguments)
-	return node, nil
+	return node
 }
 
-func (p *Parser) parseUnaryMessage() (treeNodes.ValueNodeInterface, error) {
-	node, err := p.parsePrimitiveObject()
-	if err != nil {
-		return nil, err
-	}
+func (p *Parser) parseUnaryMessage() treeNodes.ValueNodeInterface {
+	node := p.parsePrimitiveObject()
 	for p.currentToken.IsIdentifier() {
 		//TODO: patchLiteralMessage
 		node = p.parseUnaryMessageWith(node)
 	}
-	return node, nil
+	return node
 }
 
 func (p *Parser) parseUnaryMessageWith(nodeInterface treeNodes.ValueNodeInterface) *treeNodes.MessageNode {
@@ -313,12 +258,12 @@ func (p *Parser) parseUnaryMessageWith(nodeInterface treeNodes.ValueNodeInterfac
 	return node
 }
 
-func (p *Parser) parsePrimitiveObject() (treeNodes.ValueNodeInterface, error) {
+func (p *Parser) parsePrimitiveObject() treeNodes.ValueNodeInterface {
 	if p.currentToken.IsIdentifier() {
-		return p.parsePrimitiveIdentifier(), nil
+		return p.parsePrimitiveIdentifier()
 	}
 	if p.currentToken.IsLiteralToken() && !(p.currentToken.(scanner.LiteralTokenInterface).IsMultiKeyword()) {
-		return p.parsePrimitiveLiteral(), nil
+		return p.parsePrimitiveLiteral()
 	}
 	if p.currentToken.IsLiteralArrayToken() {
 		//TODO: ByteArray
@@ -333,30 +278,26 @@ func (p *Parser) parsePrimitiveObject() (treeNodes.ValueNodeInterface, error) {
 		}
 	}
 	//in case of emergency LUL
-	return nil, errors.New("what is our token?")
+	panic("what is our token?")
 }
 
-func (p *Parser) parseBlock() (*treeNodes.BlockNode, error) {
+func (p *Parser) parseBlock() *treeNodes.BlockNode {
 	position := p.currentToken.GetStart()
 	p.step()
 	node := treeNodes.NewBlockNode()
 	p.parseBlockArgsInto(node)
 	node.SetLeft(position)
-	parsedStatements, err := p.parseStatements(false)
-	if err != nil {
-		return nil, err
-	}
-	node.SetBody(parsedStatements)
+	node.SetBody(p.parseStatements(false))
 	if !(p.currentToken.IsSpecial() && p.currentToken.(scanner.ValueTokenInterface).ValueOfToken() == "]") {
-		return nil, errors.New("Close bracket expected smth like ]")
+		panic("Close bracket expected smth like ]")
 	}
 	node.SetRight(p.currentToken.GetStart())
 	p.step()
 
-	return node, nil
+	return node
 }
 
-func (p *Parser) parseBlockArgsInto(node *treeNodes.BlockNode) (*treeNodes.BlockNode, error) {
+func (p *Parser) parseBlockArgsInto(node *treeNodes.BlockNode) *treeNodes.BlockNode {
 	var args []*treeNodes.VariableNode
 	var colons []int64
 	verticalBar := false
@@ -364,11 +305,7 @@ func (p *Parser) parseBlockArgsInto(node *treeNodes.BlockNode) (*treeNodes.Block
 		colons = append(colons, p.currentToken.GetStart())
 		p.step()
 		verticalBar = true
-		parsedVariable, err := p.parseVariableNode()
-		if err != nil {
-			return nil, err
-		}
-		args = append(args, parsedVariable)
+		args = append(args, p.parseVariableNode())
 	}
 	if verticalBar {
 		if p.currentToken.IsBinary() {
@@ -376,59 +313,52 @@ func (p *Parser) parseBlockArgsInto(node *treeNodes.BlockNode) (*treeNodes.Block
 			if p.currentToken.(scanner.ValueTokenInterface).ValueOfToken() == "|" {
 				p.step()
 			} else {
-				return nil, errors.New("bar inside block node is expected")
+				panic("bar inside block node is expected")
 			}
 		} else {
 			if !(p.currentToken.IsSpecial() && p.currentToken.(scanner.ValueTokenInterface).ValueOfToken() == "]") {
-				return nil, errors.New("bar inside block node is expected")
+				panic("bar inside block node is expected")
 			}
 		}
 	}
 	node.SetArguments(args)
 	node.SetColons(colons)
-	return node, nil
+	return node
 }
 
-func (p *Parser) parseParenthesizedExpression() (treeNodes.ValueNodeInterface, error) {
+func (p *Parser) parseParenthesizedExpression() treeNodes.ValueNodeInterface {
 	leftParen := p.currentToken.GetStart()
 	p.step()
-	node, err := p.parseAssignment()
-	if err != nil {
-		return nil, err
-	}
+	node := p.parseAssignment()
 	if p.currentToken.IsSpecial() && p.currentToken.(scanner.ValueTokenInterface).ValueOfToken() == ")" {
 		interval := treeNodes.Interval{}
 		interval.SetStart(p.currentToken.GetStart())
 		interval.SetStop(leftParen)
 		node.AddParenthesis(interval)
 		p.step()
-		return node, nil
+		return node
 	} else {
-		return nil, errors.New("close parenthesis expected. something like ) ")
+		panic("close parenthesis expected. something like ) ")
 	}
 }
 
-func (p *Parser) parseLiteralArray() (treeNodes.LiteralNodeInterface, error) {
+func (p *Parser) parseLiteralArray() treeNodes.LiteralNodeInterface {
 	var contents []treeNodes.LiteralNodeInterface
 	start := p.currentToken.GetStart()
 	p.step()
 	for !(p.atEnd() || (p.currentToken.IsSpecial() && p.currentToken.(scanner.ValueTokenInterface).ValueOfToken() == ")")) {
-		parsedLiteralArray, err := p.parseLiteralArrayObject()
-		if err != nil {
-			return nil, err
-		}
-		contents = append(contents, parsedLiteralArray)
+		contents = append(contents, p.parseLiteralArrayObject())
 	}
 	if !(p.currentToken.IsSpecial() && p.currentToken.(scanner.ValueTokenInterface).ValueOfToken() == ")") {
-		return nil, errors.New("hmm parse error btw. we expect ) here")
+		panic("hmm parse error btw. we expect ) here")
 	}
 	stop := p.currentToken.(scanner.ValueTokenInterface).GetStop()
 	p.step()
 	node := treeNodes.CreateLiteralArrayNode(start, stop, contents)
-	return node, nil
+	return node
 }
 
-func (p *Parser) parseLiteralArrayObject() (treeNodes.LiteralNodeInterface, error) {
+func (p *Parser) parseLiteralArrayObject() treeNodes.LiteralNodeInterface {
 	if p.currentToken.IsSpecial() {
 		if p.currentToken.(scanner.ValueTokenInterface).ValueOfToken() == "(" {
 			return p.parseLiteralArray()
@@ -441,14 +371,14 @@ func (p *Parser) parseLiteralArrayObject() (treeNodes.LiteralNodeInterface, erro
 	if p.currentToken.IsLiteralArrayToken() {
 		if p.currentToken.IsForByteArray() {
 			//TODO: ByteArray
-			return nil, errors.New("Not implemented")
+			return nil
 		} else {
 			return p.parseLiteralArray()
 		}
 	}
 	//TODO: Optimized token
 	//TODO: patchLiteralArrayToken
-	return p.parsePrimitiveLiteral(), nil
+	return p.parsePrimitiveLiteral()
 }
 
 func (p *Parser) parsePrimitiveIdentifier() *treeNodes.VariableNode {
@@ -467,24 +397,18 @@ func (p *Parser) parsePrimitiveLiteral() treeNodes.LiteralNodeInterface {
 	return node
 }
 
-func (p *Parser) step() error {
+func (p *Parser) step() {
 	if p.peekToken != nil {
 		p.currentToken = p.peekToken
 		p.peekToken = nil
 	} else {
-		currentToken, err := p.scanner.Next()
-		if err != nil {
-			return err
-		}
-		p.currentToken = currentToken
+		p.currentToken = p.scanner.Next()
 	}
-	return nil
 }
 
 func (p *Parser) nextToken() scanner.TokenInterface {
 	if p.peekToken == nil {
-		peekToken, _ := p.scanner.Next()
-		p.peekToken = peekToken
+		p.peekToken = p.scanner.Next()
 	}
 	return p.peekToken
 }
diff --git a/parser/smalltalkParser_test.go b/parser/smalltalkParser_test.go
index 684f0ec..1fe761c 100644
--- a/parser/smalltalkParser_test.go
+++ b/parser/smalltalkParser_test.go
@@ -10,178 +10,178 @@ import (
 
 func TestNumberParser(t *testing.T) {
 	inputString := `5.1`
-	literalNode, _ := InitializeParserFor(inputString)
-	testutils.ASSERT_STREQ(t, literalNode.(*treeNodes.LiteralValueNode).GetValue(), "5.1")
+	literalNode := InitializeParserFor(inputString).(*treeNodes.LiteralValueNode)
+	testutils.ASSERT_STREQ(t, literalNode.GetValue(), "5.1")
 }
 
 func TestStringParser(t *testing.T) {
 	inputString := `'test'`
-	identifierNode, _ := InitializeParserFor(inputString)
-	testutils.ASSERT_STREQ(t, identifierNode.(*treeNodes.LiteralValueNode).GetValue(), "test")
+	identifierNode := InitializeParserFor(inputString).(*treeNodes.LiteralValueNode)
+	testutils.ASSERT_STREQ(t, identifierNode.GetValue(), "test")
 }
 
 func TestBoolParser(t *testing.T) {
 	inputString := `false`
-	identifierNode, _ := InitializeParserFor(inputString)
-	testutils.ASSERT_STREQ(t, identifierNode.(*treeNodes.LiteralValueNode).GetValue(), "false")
+	identifierNode := InitializeParserFor(inputString).(*treeNodes.LiteralValueNode)
+	testutils.ASSERT_STREQ(t, identifierNode.GetValue(), "false")
 }
 
 func TestAssignmentNumberParser(t *testing.T) {
 	inputString := `a := 5`
-	assignmentNode, _ := InitializeParserFor(inputString)
-	testutils.ASSERT_STREQ(t, assignmentNode.(*treeNodes.AssignmentNode).GetVariable().Token.ValueOfToken(), "a")
-	testutils.ASSERT_TRUE(t, assignmentNode.(*treeNodes.AssignmentNode).GetValue().IsLiteralNode())
-	testutils.ASSERT_STREQ(t, assignmentNode.(*treeNodes.AssignmentNode).GetValue().(*treeNodes.LiteralValueNode).GetValue(), "5")
+	assignmentNode := InitializeParserFor(inputString).(*treeNodes.AssignmentNode)
+	testutils.ASSERT_STREQ(t, assignmentNode.GetVariable().Token.ValueOfToken(), "a")
+	testutils.ASSERT_TRUE(t, assignmentNode.GetValue().IsLiteralNode())
+	testutils.ASSERT_STREQ(t, assignmentNode.GetValue().(*treeNodes.LiteralValueNode).GetValue(), "5")
 }
 
 func TestAssignmentStringParser(t *testing.T) {
 	inputString := `a := 'b'`
-	assignmentNode, _ := InitializeParserFor(inputString)
-	testutils.ASSERT_STREQ(t, assignmentNode.(*treeNodes.AssignmentNode).GetVariable().Token.ValueOfToken(), "a")
-	testutils.ASSERT_TRUE(t, assignmentNode.(*treeNodes.AssignmentNode).GetValue().IsLiteralNode())
-	testutils.ASSERT_STREQ(t, assignmentNode.(*treeNodes.AssignmentNode).GetValue().(*treeNodes.LiteralValueNode).GetValue(), "b")
+	assignmentNode := InitializeParserFor(inputString).(*treeNodes.AssignmentNode)
+	testutils.ASSERT_STREQ(t, assignmentNode.GetVariable().Token.ValueOfToken(), "a")
+	testutils.ASSERT_TRUE(t, assignmentNode.GetValue().IsLiteralNode())
+	testutils.ASSERT_STREQ(t, assignmentNode.GetValue().(*treeNodes.LiteralValueNode).GetValue(), "b")
 }
 
 func TestAssignmentBoolParser(t *testing.T) {
 	inputString := `a := true`
-	assignmentNode, _ := InitializeParserFor(inputString)
-	testutils.ASSERT_STREQ(t, assignmentNode.(*treeNodes.AssignmentNode).GetVariable().Token.ValueOfToken(), "a")
-	testutils.ASSERT_TRUE(t, assignmentNode.(*treeNodes.AssignmentNode).GetValue().IsLiteralNode())
-	testutils.ASSERT_STREQ(t, assignmentNode.(*treeNodes.AssignmentNode).GetValue().(*treeNodes.LiteralValueNode).GetValue(), "true")
+	assignmentNode := InitializeParserFor(inputString).(*treeNodes.AssignmentNode)
+	testutils.ASSERT_STREQ(t, assignmentNode.GetVariable().Token.ValueOfToken(), "a")
+	testutils.ASSERT_TRUE(t, assignmentNode.GetValue().IsLiteralNode())
+	testutils.ASSERT_STREQ(t, assignmentNode.GetValue().(*treeNodes.LiteralValueNode).GetValue(), "true")
 }
 
 func TestAssignmentLiteralArrayParser(t *testing.T) {
 	inputString := `a := #(1 2)`
-	assignmentNode, _ := InitializeParserFor(inputString)
-	testutils.ASSERT_STREQ(t, assignmentNode.(*treeNodes.AssignmentNode).GetVariable().Token.ValueOfToken(), "a")
-	testutils.ASSERT_TRUE(t, assignmentNode.(*treeNodes.AssignmentNode).GetValue().IsLiteralArray())
-	testutils.ASSERT_STREQ(t, assignmentNode.(*treeNodes.AssignmentNode).GetValue().(*treeNodes.LiteralArrayNode).GetValue(), "1 2")
+	assignmentNode := InitializeParserFor(inputString).(*treeNodes.AssignmentNode)
+	testutils.ASSERT_STREQ(t, assignmentNode.GetVariable().Token.ValueOfToken(), "a")
+	testutils.ASSERT_TRUE(t, assignmentNode.GetValue().IsLiteralArray())
+	testutils.ASSERT_STREQ(t, assignmentNode.GetValue().(*treeNodes.LiteralArrayNode).GetValue(), "1 2")
 }
 
 func TestBinaryMessageParser(t *testing.T) {
 	inputString := `a + b`
-	messageNode, _ := InitializeParserFor(inputString)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.VariableNode).GetName(), "a")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetSelectorParts()) == 1)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetSelectorParts()[0].(*scanner.BinarySelectorToken).ValueOfToken(), "+")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetArguments()) == 1)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.VariableNode).GetName(), "b")
+	messageNode := InitializeParserFor(inputString).(*treeNodes.MessageNode)
+	testutils.ASSERT_STREQ(t, messageNode.GetReceiver().(*treeNodes.VariableNode).GetName(), "a")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetSelectorParts()) == 1)
+	testutils.ASSERT_STREQ(t, messageNode.GetSelectorParts()[0].(*scanner.BinarySelectorToken).ValueOfToken(), "+")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetArguments()) == 1)
+	testutils.ASSERT_STREQ(t, messageNode.GetArguments()[0].(*treeNodes.VariableNode).GetName(), "b")
 }
 
 func TestNumberWithMinusParser(t *testing.T) {
 	inputString := `2*3-4`
-	messageNode, _ := InitializeParserFor(inputString)
+	messageNode := InitializeParserFor(inputString).(*treeNodes.MessageNode)
 	testutils.ASSERT_TRUE(t, messageNode.IsMessage())
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetReceiver().(*treeNodes.LiteralValueNode).GetValue(), "2")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetSelectorParts()) == 1)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetSelectorParts()[0].(*scanner.BinarySelectorToken).ValueOfToken(), "*")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetArguments()) == 1)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.LiteralValueNode).GetValue(), "3")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetSelectorParts()) == 1)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetSelectorParts()[0].(*scanner.BinarySelectorToken).ValueOfToken(), "-")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetArguments()) == 1)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.LiteralValueNode).GetValue(), "4.00")
+	testutils.ASSERT_STREQ(t, messageNode.GetReceiver().(*treeNodes.MessageNode).GetReceiver().(*treeNodes.LiteralValueNode).GetValue(), "2")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetReceiver().(*treeNodes.MessageNode).GetSelectorParts()) == 1)
+	testutils.ASSERT_STREQ(t, messageNode.GetReceiver().(*treeNodes.MessageNode).GetSelectorParts()[0].(*scanner.BinarySelectorToken).ValueOfToken(), "*")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetReceiver().(*treeNodes.MessageNode).GetArguments()) == 1)
+	testutils.ASSERT_STREQ(t, messageNode.GetReceiver().(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.LiteralValueNode).GetValue(), "3")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetSelectorParts()) == 1)
+	testutils.ASSERT_STREQ(t, messageNode.GetSelectorParts()[0].(*scanner.BinarySelectorToken).ValueOfToken(), "-")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetArguments()) == 1)
+	testutils.ASSERT_STREQ(t, messageNode.GetArguments()[0].(*treeNodes.LiteralValueNode).GetValue(), "4.00")
 }
 
 func TestFewBinaryMessageParser(t *testing.T) {
 	inputString := `a - b + c`
-	messageNode, _ := InitializeParserFor(inputString)
+	messageNode := InitializeParserFor(inputString).(*treeNodes.MessageNode)
 	testutils.ASSERT_TRUE(t, messageNode.IsMessage())
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetReceiver().(*treeNodes.VariableNode).GetName(), "a")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetSelectorParts()) == 1)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetSelectorParts()[0].(*scanner.BinarySelectorToken).ValueOfToken(), "-")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetArguments()) == 1)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.VariableNode).GetName(), "b")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetSelectorParts()) == 1)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetSelectorParts()[0].(*scanner.BinarySelectorToken).ValueOfToken(), "+")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetArguments()) == 1)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.VariableNode).GetName(), "c")
+	testutils.ASSERT_STREQ(t, messageNode.GetReceiver().(*treeNodes.MessageNode).GetReceiver().(*treeNodes.VariableNode).GetName(), "a")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetReceiver().(*treeNodes.MessageNode).GetSelectorParts()) == 1)
+	testutils.ASSERT_STREQ(t, messageNode.GetReceiver().(*treeNodes.MessageNode).GetSelectorParts()[0].(*scanner.BinarySelectorToken).ValueOfToken(), "-")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetReceiver().(*treeNodes.MessageNode).GetArguments()) == 1)
+	testutils.ASSERT_STREQ(t, messageNode.GetReceiver().(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.VariableNode).GetName(), "b")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetSelectorParts()) == 1)
+	testutils.ASSERT_STREQ(t, messageNode.GetSelectorParts()[0].(*scanner.BinarySelectorToken).ValueOfToken(), "+")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetArguments()) == 1)
+	testutils.ASSERT_STREQ(t, messageNode.GetArguments()[0].(*treeNodes.VariableNode).GetName(), "c")
 }
 
 func TestGroupMessageParser(t *testing.T) {
 	inputString := `a - (b + c)`
-	messageNode, _ := InitializeParserFor(inputString)
+	messageNode := InitializeParserFor(inputString).(*treeNodes.MessageNode)
 	testutils.ASSERT_TRUE(t, messageNode.IsMessage())
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.VariableNode).GetName(), "a")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetSelectorParts()) == 1)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetSelectorParts()[0].(*scanner.BinarySelectorToken).ValueOfToken(), "-")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetArguments()) == 1)
-	testutils.ASSERT_TRUE(t, messageNode.(*treeNodes.MessageNode).GetArguments()[0].IsMessage())
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.MessageNode).GetReceiver().(*treeNodes.VariableNode).GetName(), "b")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.MessageNode).GetSelectorParts()) == 1)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.MessageNode).GetSelectorParts()[0].(*scanner.BinarySelectorToken).ValueOfToken(), "+")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.MessageNode).GetArguments()) == 1)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.VariableNode).GetName(), "c")
+	testutils.ASSERT_STREQ(t, messageNode.GetReceiver().(*treeNodes.VariableNode).GetName(), "a")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetSelectorParts()) == 1)
+	testutils.ASSERT_STREQ(t, messageNode.GetSelectorParts()[0].(*scanner.BinarySelectorToken).ValueOfToken(), "-")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetArguments()) == 1)
+	testutils.ASSERT_TRUE(t, messageNode.GetArguments()[0].IsMessage())
+	testutils.ASSERT_STREQ(t, messageNode.GetArguments()[0].(*treeNodes.MessageNode).GetReceiver().(*treeNodes.VariableNode).GetName(), "b")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetArguments()[0].(*treeNodes.MessageNode).GetSelectorParts()) == 1)
+	testutils.ASSERT_STREQ(t, messageNode.GetArguments()[0].(*treeNodes.MessageNode).GetSelectorParts()[0].(*scanner.BinarySelectorToken).ValueOfToken(), "+")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetArguments()[0].(*treeNodes.MessageNode).GetArguments()) == 1)
+	testutils.ASSERT_STREQ(t, messageNode.GetArguments()[0].(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.VariableNode).GetName(), "c")
 
 }
 
 func TestUnaryMessageParser(t *testing.T) {
 	inputString := `-1 abs`
-	messageNode, _ := InitializeParserFor(inputString)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.LiteralValueNode).GetValue(), "-1")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetSelectorParts()) == 1)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetSelectorParts()[0].(*scanner.IdentifierToken).ValueOfToken(), "abs")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetArguments()) == 0)
+	messageNode := InitializeParserFor(inputString).(*treeNodes.MessageNode)
+	testutils.ASSERT_STREQ(t, messageNode.GetReceiver().(*treeNodes.LiteralValueNode).GetValue(), "-1")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetSelectorParts()) == 1)
+	testutils.ASSERT_STREQ(t, messageNode.GetSelectorParts()[0].(*scanner.IdentifierToken).ValueOfToken(), "abs")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetArguments()) == 0)
 }
 
 func TestIfStatementParser(t *testing.T) {
 	inputString := `a > 10 ifTrue:[25] ifFalse:[2]`
-	messageNode, _ := InitializeParserFor(inputString)
-	testutils.ASSERT_TRUE(t, messageNode.(*treeNodes.MessageNode).GetReceiver().IsMessage())
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetReceiver().(*treeNodes.VariableNode).GetName(), "a")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetSelectorParts()) == 1)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetSelectorParts()[0].(*scanner.BinarySelectorToken).ValueOfToken(), ">")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetArguments()) == 1)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.LiteralValueNode).GetValue(), "10")
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetSelector(), "ifTrue:ifFalse:")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetSelectorParts()) == 2)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetSelectorParts()[0].ValueOfToken(), "ifTrue:")
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetSelectorParts()[1].ValueOfToken(), "ifFalse:")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetArguments()) == 2)
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.BlockNode).GetBody().GetStatements()) == 1)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.BlockNode).GetBody().GetStatements()[0].(*treeNodes.LiteralValueNode).GetValue(), "25")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetArguments()[1].(*treeNodes.BlockNode).GetBody().GetStatements()) == 1)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetArguments()[1].(*treeNodes.BlockNode).GetBody().GetStatements()[0].(*treeNodes.LiteralValueNode).GetValue(), "2")
+	messageNode := InitializeParserFor(inputString).(*treeNodes.MessageNode)
+	testutils.ASSERT_TRUE(t, messageNode.GetReceiver().IsMessage())
+	testutils.ASSERT_STREQ(t, messageNode.GetReceiver().(*treeNodes.MessageNode).GetReceiver().(*treeNodes.VariableNode).GetName(), "a")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetReceiver().(*treeNodes.MessageNode).GetSelectorParts()) == 1)
+	testutils.ASSERT_STREQ(t, messageNode.GetReceiver().(*treeNodes.MessageNode).GetSelectorParts()[0].(*scanner.BinarySelectorToken).ValueOfToken(), ">")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetReceiver().(*treeNodes.MessageNode).GetArguments()) == 1)
+	testutils.ASSERT_STREQ(t, messageNode.GetReceiver().(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.LiteralValueNode).GetValue(), "10")
+	testutils.ASSERT_STREQ(t, messageNode.GetSelector(), "ifTrue:ifFalse:")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetSelectorParts()) == 2)
+	testutils.ASSERT_STREQ(t, messageNode.GetSelectorParts()[0].ValueOfToken(), "ifTrue:")
+	testutils.ASSERT_STREQ(t, messageNode.GetSelectorParts()[1].ValueOfToken(), "ifFalse:")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetArguments()) == 2)
+	testutils.ASSERT_TRUE(t, len(messageNode.GetArguments()[0].(*treeNodes.BlockNode).GetBody().GetStatements()) == 1)
+	testutils.ASSERT_STREQ(t, messageNode.GetArguments()[0].(*treeNodes.BlockNode).GetBody().GetStatements()[0].(*treeNodes.LiteralValueNode).GetValue(), "25")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetArguments()[1].(*treeNodes.BlockNode).GetBody().GetStatements()) == 1)
+	testutils.ASSERT_STREQ(t, messageNode.GetArguments()[1].(*treeNodes.BlockNode).GetBody().GetStatements()[0].(*treeNodes.LiteralValueNode).GetValue(), "2")
 }
 
 func TestIfStatementWithExpressionParser(t *testing.T) {
 	inputString := `(pitch>0.9 ifTrue:[1] ifFalse:[0])*23`
-	messageNode, _ := InitializeParserFor(inputString)
-	testutils.ASSERT_TRUE(t, messageNode.(*treeNodes.MessageNode).GetReceiver().IsMessage())
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetReceiver().(*treeNodes.VariableNode).GetName(), "pitch")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetSelectorParts()) == 1)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetSelectorParts()[0].(*scanner.BinarySelectorToken).ValueOfToken(), ">")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetSelectorParts()) == 1)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.LiteralValueNode).GetValue(), "0.9")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetSelectorParts()) == 2)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetSelectorParts()[0].ValueOfToken(), "ifTrue:")
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetSelectorParts()[1].ValueOfToken(), "ifFalse:")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetArguments()) == 2)
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.BlockNode).GetBody().GetStatements()) == 1)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.BlockNode).GetBody().GetStatements()[0].(*treeNodes.LiteralValueNode).GetValue(), "1")
-	testutils.ASSERT_TRUE(t, len(messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetArguments()[1].(*treeNodes.BlockNode).GetBody().GetStatements()) == 1)
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetArguments()[1].(*treeNodes.BlockNode).GetBody().GetStatements()[0].(*treeNodes.LiteralValueNode).GetValue(), "0")
-	testutils.ASSERT_STREQ(t, messageNode.(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.LiteralValueNode).GetValue(), "23")
+	messageNode := InitializeParserFor(inputString).(*treeNodes.MessageNode)
+	testutils.ASSERT_TRUE(t, messageNode.GetReceiver().IsMessage())
+	testutils.ASSERT_STREQ(t, messageNode.GetReceiver().(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetReceiver().(*treeNodes.VariableNode).GetName(), "pitch")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetReceiver().(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetSelectorParts()) == 1)
+	testutils.ASSERT_STREQ(t, messageNode.GetReceiver().(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetSelectorParts()[0].(*scanner.BinarySelectorToken).ValueOfToken(), ">")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetReceiver().(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetSelectorParts()) == 1)
+	testutils.ASSERT_STREQ(t, messageNode.GetReceiver().(*treeNodes.MessageNode).GetReceiver().(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.LiteralValueNode).GetValue(), "0.9")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetReceiver().(*treeNodes.MessageNode).GetSelectorParts()) == 2)
+	testutils.ASSERT_STREQ(t, messageNode.GetReceiver().(*treeNodes.MessageNode).GetSelectorParts()[0].ValueOfToken(), "ifTrue:")
+	testutils.ASSERT_STREQ(t, messageNode.GetReceiver().(*treeNodes.MessageNode).GetSelectorParts()[1].ValueOfToken(), "ifFalse:")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetReceiver().(*treeNodes.MessageNode).GetArguments()) == 2)
+	testutils.ASSERT_TRUE(t, len(messageNode.GetReceiver().(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.BlockNode).GetBody().GetStatements()) == 1)
+	testutils.ASSERT_STREQ(t, messageNode.GetReceiver().(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.BlockNode).GetBody().GetStatements()[0].(*treeNodes.LiteralValueNode).GetValue(), "1")
+	testutils.ASSERT_TRUE(t, len(messageNode.GetReceiver().(*treeNodes.MessageNode).GetArguments()[1].(*treeNodes.BlockNode).GetBody().GetStatements()) == 1)
+	testutils.ASSERT_STREQ(t, messageNode.GetReceiver().(*treeNodes.MessageNode).GetArguments()[1].(*treeNodes.BlockNode).GetBody().GetStatements()[0].(*treeNodes.LiteralValueNode).GetValue(), "0")
+	testutils.ASSERT_STREQ(t, messageNode.GetArguments()[0].(*treeNodes.LiteralValueNode).GetValue(), "23")
 }
 
 func TestSequenceParser(t *testing.T) {
 	inputString := `a := 2. a + 2`
-	sequenceNode, _ := InitializeParserFor(inputString)
-	testutils.ASSERT_TRUE(t, len(sequenceNode.(*treeNodes.SequenceNode).GetStatements()) == 2)
-	testutils.ASSERT_TRUE(t, sequenceNode.(*treeNodes.SequenceNode).GetStatements()[0].IsAssignment())
-	testutils.ASSERT_STREQ(t, sequenceNode.(*treeNodes.SequenceNode).GetStatements()[0].(*treeNodes.AssignmentNode).GetVariable().Token.ValueOfToken(), "a")
-	testutils.ASSERT_TRUE(t, sequenceNode.(*treeNodes.SequenceNode).GetStatements()[0].(*treeNodes.AssignmentNode).GetValue().IsLiteralNode())
-	testutils.ASSERT_STREQ(t, sequenceNode.(*treeNodes.SequenceNode).GetStatements()[0].(*treeNodes.AssignmentNode).GetValue().(*treeNodes.LiteralValueNode).GetValue(), "2")
-	testutils.ASSERT_TRUE(t, sequenceNode.(*treeNodes.SequenceNode).GetStatements()[1].IsMessage())
-	testutils.ASSERT_STREQ(t, sequenceNode.(*treeNodes.SequenceNode).GetStatements()[1].(*treeNodes.MessageNode).GetReceiver().(*treeNodes.VariableNode).GetName(), "a")
-	testutils.ASSERT_TRUE(t, len(sequenceNode.(*treeNodes.SequenceNode).GetStatements()[1].(*treeNodes.MessageNode).GetSelectorParts()) == 1)
-	testutils.ASSERT_STREQ(t, sequenceNode.(*treeNodes.SequenceNode).GetStatements()[1].(*treeNodes.MessageNode).GetSelectorParts()[0].(*scanner.BinarySelectorToken).ValueOfToken(), "+")
-	testutils.ASSERT_TRUE(t, len(sequenceNode.(*treeNodes.SequenceNode).GetStatements()[1].(*treeNodes.MessageNode).GetArguments()) == 1)
-	testutils.ASSERT_STREQ(t, sequenceNode.(*treeNodes.SequenceNode).GetStatements()[1].(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.LiteralValueNode).GetValue(), "2")
+	sequenceNode := InitializeParserFor(inputString).(*treeNodes.SequenceNode)
+	testutils.ASSERT_TRUE(t, len(sequenceNode.GetStatements()) == 2)
+	testutils.ASSERT_TRUE(t, sequenceNode.GetStatements()[0].IsAssignment())
+	testutils.ASSERT_STREQ(t, sequenceNode.GetStatements()[0].(*treeNodes.AssignmentNode).GetVariable().Token.ValueOfToken(), "a")
+	testutils.ASSERT_TRUE(t, sequenceNode.GetStatements()[0].(*treeNodes.AssignmentNode).GetValue().IsLiteralNode())
+	testutils.ASSERT_STREQ(t, sequenceNode.GetStatements()[0].(*treeNodes.AssignmentNode).GetValue().(*treeNodes.LiteralValueNode).GetValue(), "2")
+	testutils.ASSERT_TRUE(t, sequenceNode.GetStatements()[1].IsMessage())
+	testutils.ASSERT_STREQ(t, sequenceNode.GetStatements()[1].(*treeNodes.MessageNode).GetReceiver().(*treeNodes.VariableNode).GetName(), "a")
+	testutils.ASSERT_TRUE(t, len(sequenceNode.GetStatements()[1].(*treeNodes.MessageNode).GetSelectorParts()) == 1)
+	testutils.ASSERT_STREQ(t, sequenceNode.GetStatements()[1].(*treeNodes.MessageNode).GetSelectorParts()[0].(*scanner.BinarySelectorToken).ValueOfToken(), "+")
+	testutils.ASSERT_TRUE(t, len(sequenceNode.GetStatements()[1].(*treeNodes.MessageNode).GetArguments()) == 1)
+	testutils.ASSERT_STREQ(t, sequenceNode.GetStatements()[1].(*treeNodes.MessageNode).GetArguments()[0].(*treeNodes.LiteralValueNode).GetValue(), "2")
 }
 
 func TestIdentifierParser(t *testing.T) {
 	inputString := `radio_altitude`
-	variableNode, _ := InitializeParserFor(inputString)
-	testutils.ASSERT_STREQ(t, variableNode.(*treeNodes.VariableNode).GetName(), "radio_altitude")
+	variableNode := InitializeParserFor(inputString).(*treeNodes.VariableNode)
+	testutils.ASSERT_STREQ(t, variableNode.GetName(), "radio_altitude")
 }
diff --git a/scanner/smalltalkScanner.go b/scanner/smalltalkScanner.go
index 8d31c6c..bb4448c 100644
--- a/scanner/smalltalkScanner.go
+++ b/scanner/smalltalkScanner.go
@@ -1,13 +1,11 @@
 package scanner
 
 import (
-	"errors"
+	"github.com/SealNTibbers/GotalkInterpreter/talkio"
 	"math"
 	"strconv"
 	"strings"
 	"unicode"
-
-	"github.com/SealNTibbers/GotalkInterpreter/talkio"
 )
 
 const (
@@ -148,20 +146,16 @@ func (s *Scanner) classify(character rune) string {
 	return s.getClassificationTable()[character]
 }
 
-func (s *Scanner) Next() (TokenInterface, error) {
+func (s *Scanner) Next() TokenInterface {
 	s.buffer.Reset()
 	s.tokenStart = s.stream.GetPosition()
 	if s.characterType == EOF {
 		s.token = &EOFToken{&Token{s.tokenStart + 1}}
 	} else {
-		sT, err := s.scanToken()
-		if err != nil {
-			return nil, err
-		}
-		s.token = sT
+		s.token = s.scanToken()
 	}
 	s.stripSeparators()
-	return s.token, nil
+	return s.token
 }
 
 func (s *Scanner) previousStepPosition() int64 {
@@ -172,9 +166,9 @@ func (s *Scanner) previousStepPosition() int64 {
 	}
 }
 
-func (s *Scanner) scanToken() (TokenInterface, error) {
+func (s *Scanner) scanToken() TokenInterface {
 	if s.characterType == ALPHABET {
-		return s.scanIdentifierOrKeyword(), nil
+		return s.scanIdentifierOrKeyword()
 	}
 
 	if s.characterType == DIGIT || (s.currentCharacter == '-' && s.classify(s.stream.PeekRune()) == DIGIT) {
@@ -182,22 +176,22 @@ func (s *Scanner) scanToken() (TokenInterface, error) {
 	}
 
 	if s.characterType == BIN {
-		return s.scanBinaryInSelector(), nil
+		return s.scanBinaryInSelector()
 	}
 
 	if s.characterType == SPEC {
-		return s.scanSpecialCharacter(), nil
+		return s.scanSpecialCharacter()
 	}
 
 	if s.currentCharacter == '\'' {
-		return s.scanStringSymbol(), nil
+		return s.scanStringSymbol()
 	}
 
 	if s.currentCharacter == '#' {
-		return s.scanLiteral(), nil
+		return s.scanLiteral()
 	}
 
-	return &Token{}, nil
+	return &Token{}
 }
 
 func (s *Scanner) scanIdentifierOrKeyword() TokenInterface {
@@ -262,13 +256,11 @@ func (s *Scanner) scanName() {
 	}
 }
 
-func (s *Scanner) scanNumber() (*NumberLiteralToken, error) {
+func (s *Scanner) scanNumber() *NumberLiteralToken {
 	start := s.stream.GetPosition()
 
-	number, err := s.scanNumberVisualWorks()
-	if err != nil {
-		return nil, err
-	}
+	number := s.scanNumberVisualWorks()
+
 	currentPosition := s.stream.GetPosition()
 
 	var stop int64
@@ -279,67 +271,58 @@ func (s *Scanner) scanNumber() (*NumberLiteralToken, error) {
 	}
 	s.stream.SetPosition(start - 1)
 
-	_, err = s.stream.ReadRunes(stop - start + 1)
+	_, err := s.stream.ReadRunes(stop - start + 1)
 	if err != nil {
-		return nil, errors.New("can't read an amount of runes to scan number")
+		panic("can't read an amount of runes to scan number")
 	}
 	s.stream.SetPosition(currentPosition)
 
-	return &NumberLiteralToken{NewLiteralToken(start, stop, string(number), NUMBER)}, nil
+	return &NumberLiteralToken{NewLiteralToken(start, stop, string(number), NUMBER)}
 }
 
-func (s *Scanner) scanNumberVisualWorks() (string, error) {
+func (s *Scanner) scanNumberVisualWorks() string {
 	s.stream.Skip(-1)
-	number, err := s.readSmalltalkSyntaxFromStream()
-	if err != nil {
-		return "", err
-	}
+	number := s.readSmalltalkSyntaxFromStream()
 	s.step()
-	return number, nil
+	return number
 }
 
-func (s *Scanner) readSmalltalkSyntaxFromStream() (string, error) {
+func (s *Scanner) readSmalltalkSyntaxFromStream() string {
 	if s.stream.AtEnd() || unicode.IsLetter(s.stream.PeekRune()) {
-		return "0", nil
+		return "0"
 	}
 	neg := s.stream.PeekRuneFor('-')
-	value, err := s.readIntegerWithRadix(10)
-	if err != nil {
-		return "", err
-	}
-	floatValue, err := s.readSmalltalkFloat(value)
-	if err != nil {
-		return "", err
-	}
+	value := s.readIntegerWithRadix(10)
+	floatValue := s.readSmalltalkFloat(value)
 	if neg {
 		floatValue *= -1
 	}
-	return strconv.FormatFloat(floatValue, 'f', -1, 64), nil
+	return strconv.FormatFloat(floatValue, 'f', -1, 64)
 }
 
-func (s *Scanner) readIntegerWithRadix(radix int) (int, error) {
+func (s *Scanner) readIntegerWithRadix(radix int) int {
 	value := 0
 	for {
 		if s.stream.AtEnd() {
-			return value, nil
+			return value
 		}
 
 		character, _, err := s.stream.ReadRune()
 		if err != nil {
-			return 0, errors.New("readIntegerWithRadix doesn't work as expected. FeelsBadMan")
+			panic("readIntegerWithRadix doesn't work as expected. FeelsBadMan")
 		}
 		digit := CharToNum(character)
 		if digit < 0 || digit >= radix {
 			s.stream.Skip(-1)
-			return value, nil
+			return value
 		} else {
 			value = value*radix + digit
 		}
 	}
-	return value, nil
+	return value
 }
 
-func (s *Scanner) readSmalltalkFloat(integerPart int) (float64, error) {
+func (s *Scanner) readSmalltalkFloat(integerPart int) float64 {
 	var num, den float64
 	var atEnd bool
 	var possibleCoercionClass rune
@@ -358,7 +341,7 @@ func (s *Scanner) readSmalltalkFloat(integerPart int) (float64, error) {
 				}
 				digit, _, err := s.stream.ReadRune()
 				if err != nil {
-					return 0.0, err
+					panic(err)
 				}
 				if !(unicode.IsDigit(digit)) {
 					break
@@ -392,10 +375,7 @@ func (s *Scanner) readSmalltalkFloat(integerPart int) (float64, error) {
 			}
 			digit, err := s.stream.PeekRuneError()
 			if err == nil && (digit != 0) && unicode.IsDigit(digit) {
-				exp, err = s.readIntegerWithRadix(10)
-				if err != nil {
-					return 0, err
-				}
+				exp = s.readIntegerWithRadix(10)
 				if neg {
 					exp = -1 * exp
 				}
@@ -407,9 +387,9 @@ func (s *Scanner) readSmalltalkFloat(integerPart int) (float64, error) {
 
 	value := float64(integerPart) + (num / den)
 	if exp == 0 {
-		return value, nil
+		return value
 	} else {
-		return value * math.Pow(10, float64(exp)), nil
+		return value * math.Pow(10, float64(exp))
 	}
 }
 
@@ -487,6 +467,7 @@ func (s *Scanner) scanLiteral() TokenInterface {
 	if s.currentCharacter == '(' || s.currentCharacter == '[' {
 		return s.scanLiteralArrayToken()
 	}
+	panic("Man you have a big problem!!!")
 	return nil
 }
 
diff --git a/scanner/smalltalkScanner_test.go b/scanner/smalltalkScanner_test.go
index 9afaefa..1cc85d7 100644
--- a/scanner/smalltalkScanner_test.go
+++ b/scanner/smalltalkScanner_test.go
@@ -12,11 +12,11 @@ func TestScanNumber(t *testing.T) {
 	vwReader := talkio.NewReader(inputString)
 	vwScanner := New(*vwReader)
 	var token TokenInterface
-	token, _ = vwScanner.Next()
+	token = vwScanner.Next()
 	testutils.ASSERT_STREQ(t, NUMBER, token.TypeOfToken())
 	testutils.ASSERT_STREQ(t, token.(ValueTokenInterface).ValueOfToken(), "0.56")
 
-	eofToken, _ := vwScanner.Next()
+	eofToken := vwScanner.Next()
 	testutils.ASSERT_STREQ(t, eofToken.TypeOfToken(), "EOFToken")
 }
 
@@ -25,11 +25,11 @@ func TestScanIdentifier(t *testing.T) {
 	vwReader := talkio.NewReader(inputString)
 	vwScanner := New(*vwReader)
 	var token TokenInterface
-	token, _ = vwScanner.Next()
+	token = vwScanner.Next()
 	testutils.ASSERT_STREQ(t, IDENT, token.TypeOfToken())
 	testutils.ASSERT_STREQ(t, token.(ValueTokenInterface).ValueOfToken(), "radio_altitude")
 
-	eofToken, _ := vwScanner.Next()
+	eofToken := vwScanner.Next()
 	testutils.ASSERT_STREQ(t, eofToken.TypeOfToken(), "EOFToken")
 }
 
@@ -38,11 +38,11 @@ func TestScanFloatNumberWithD(t *testing.T) {
 	vwReader := talkio.NewReader(inputString)
 	vwScanner := New(*vwReader)
 	var token TokenInterface
-	token, _ = vwScanner.Next()
+	token = vwScanner.Next()
 	testutils.ASSERT_STREQ(t, NUMBER, token.TypeOfToken())
 	testutils.ASSERT_STREQ(t, token.(ValueTokenInterface).ValueOfToken(), "1.02")
 
-	eofToken, _ := vwScanner.Next()
+	eofToken := vwScanner.Next()
 	testutils.ASSERT_STREQ(t, "EOFToken", eofToken.TypeOfToken())
 }
 
@@ -51,11 +51,11 @@ func TestScanFloatNumberWithExp(t *testing.T) {
 	vwReader := talkio.NewReader(inputString)
 	vwScanner := New(*vwReader)
 	var token TokenInterface
-	token, _ = vwScanner.Next()
+	token = vwScanner.Next()
 	testutils.ASSERT_STREQ(t, NUMBER, token.TypeOfToken())
 	testutils.ASSERT_STREQ(t, token.(ValueTokenInterface).ValueOfToken(), "10000")
 
-	eofToken, _ := vwScanner.Next()
+	eofToken := vwScanner.Next()
 	testutils.ASSERT_STREQ(t, "EOFToken", eofToken.TypeOfToken())
 }
 
@@ -64,11 +64,11 @@ func TestScanFloatNumberWithNegativeExp(t *testing.T) {
 	vwReader := talkio.NewReader(inputString)
 	vwScanner := New(*vwReader)
 	var token TokenInterface
-	token, _ = vwScanner.Next()
+	token = vwScanner.Next()
 	testutils.ASSERT_STREQ(t, NUMBER, token.TypeOfToken())
 	testutils.ASSERT_STREQ(t, token.(ValueTokenInterface).ValueOfToken(), "0.0001")
 
-	eofToken, _ := vwScanner.Next()
+	eofToken := vwScanner.Next()
 	testutils.ASSERT_STREQ(t, eofToken.TypeOfToken(), "EOFToken")
 }
 
@@ -92,11 +92,11 @@ func TestScanRealExpressions(t *testing.T) {
 	vwScanner := New(*vwReader)
 	var token TokenInterface
 	for _, eachTest := range tests {
-		token, _ = vwScanner.Next()
+		token = vwScanner.Next()
 		testutils.ASSERT_STREQ(t, token.TypeOfToken(), eachTest.expectedTokenType)
 		testutils.ASSERT_STREQ(t, token.(ValueTokenInterface).ValueOfToken(), eachTest.expectedValue)
 	}
-	eofToken, _ := vwScanner.Next()
+	eofToken := vwScanner.Next()
 	testutils.ASSERT_STREQ(t, eofToken.TypeOfToken(), "EOFToken")
 }
 
@@ -127,11 +127,11 @@ func TestScanIfStatementExpressionWithDifferentSubexpressions(t *testing.T) {
 	vwScanner := New(*vwReader)
 	var token TokenInterface
 	for _, eachTest := range tests {
-		token, _ = vwScanner.Next()
+		token = vwScanner.Next()
 		testutils.ASSERT_STREQ(t, token.TypeOfToken(), eachTest.expectedTokenType)
 		testutils.ASSERT_STREQ(t, token.(ValueTokenInterface).ValueOfToken(), eachTest.expectedValue)
 	}
-	eofToken, _ := vwScanner.Next()
+	eofToken := vwScanner.Next()
 	testutils.ASSERT_STREQ(t, eofToken.TypeOfToken(), "EOFToken")
 }
 
@@ -151,7 +151,7 @@ func TestScanAssignmentExpression(t *testing.T) {
 	foundAssignment := false
 	var index int
 	for i := 0; i < len(tests)+1; i++ {
-		token, _ = vwScanner.Next()
+		token = vwScanner.Next()
 		if foundAssignment {
 			index = i - 1
 		} else {
@@ -167,7 +167,7 @@ func TestScanAssignmentExpression(t *testing.T) {
 	}
 	testutils.ASSERT_TRUE(t, foundAssignment)
 
-	eofToken, _ := vwScanner.Next()
+	eofToken := vwScanner.Next()
 	testutils.ASSERT_STREQ(t, eofToken.TypeOfToken(), "EOFToken")
 }
 
@@ -186,11 +186,11 @@ func TestScanArray(t *testing.T) {
 	vwScanner := New(*vwReader)
 	var token TokenInterface
 	for _, eachTest := range tests {
-		token, _ = vwScanner.Next()
+		token = vwScanner.Next()
 		testutils.ASSERT_STREQ(t, token.TypeOfToken(), eachTest.expectedTokenType)
 		testutils.ASSERT_STREQ(t, token.(ValueTokenInterface).ValueOfToken(), eachTest.expectedValue)
 	}
-	eofToken, _ := vwScanner.Next()
+	eofToken := vwScanner.Next()
 	testutils.ASSERT_STREQ(t, eofToken.TypeOfToken(), "EOFToken")
 
 }
diff --git a/talkio/stringReader.go b/talkio/stringReader.go
index 9587063..9e6c18e 100644
--- a/talkio/stringReader.go
+++ b/talkio/stringReader.go
@@ -179,7 +179,7 @@ func (r *StringReader) WriteTo(w io.Writer) (n int64, err error) {
 	s := r.s[r.i:]
 	m, err := io.WriteString(w, s)
 	if m > len(s) {
-		return 0, errors.New("strings.StringReader.WriteTo: invalid WriteString count")
+		panic("strings.StringReader.WriteTo: invalid WriteString count")
 	}
 	r.i += int64(m)
 	n = int64(m)
diff --git a/treeNodes/nodesEvaluation.go b/treeNodes/nodesEvaluation.go
index bc69698..3505afe 100644
--- a/treeNodes/nodesEvaluation.go
+++ b/treeNodes/nodesEvaluation.go
@@ -1,7 +1,7 @@
 package treeNodes
 
 import (
-	"errors"
+	"fmt"
 	"strconv"
 
 	"github.com/SealNTibbers/GotalkInterpreter/scanner"
@@ -42,36 +42,33 @@ func (s *Scope) FindValueByName(name string) (SmalltalkObjectInterface, bool) {
 	return value, ok
 }
 
-func (s *Scope) GetVarValue(name string) (SmalltalkObjectInterface, error) {
+func (s *Scope) GetVarValue(name string) SmalltalkObjectInterface {
 	value, ok := s.variables[name]
 	if ok {
-		return value, nil
+		return value
 	} else {
 		if s.OuterScope != nil {
 			return s.OuterScope.GetVarValue(name)
 		} else {
-			return nil, errors.New("variable not found")
+			panic(`we do not have variable with "` + name + `" in this scope`)
 		}
 	}
 }
 
 func (message *MessageNode) Eval(scope *Scope) SmalltalkObjectInterface {
 	receiver := message.receiver.Eval(scope)
-	if receiver == nil {
-		return NewSmalltalkString("Internal error")
-	}
 	var argObjects []SmalltalkObjectInterface
 	for _, each := range message.arguments {
 		argument := each.Eval(scope)
 		if argument == nil {
 			each.Eval(scope)
-			return nil
+			panic("message argument should not be nil (void)")
 		}
 		argObjects = append(argObjects, argument)
 	}
 	result, err := receiver.Perform(message.GetSelector(), argObjects)
 	if err != nil {
-		return NewSmalltalkString(err.Error())
+		fmt.Println(err)
 	}
 	return result
 }
@@ -97,11 +94,8 @@ func (assignment *AssignmentNode) Eval(scope *Scope) SmalltalkObjectInterface {
 
 func (variable *VariableNode) Eval(scope *Scope) SmalltalkObjectInterface {
 	// return value for variable
-	smalltalkValue, err := scope.GetVarValue(variable.GetName())
-	if err != nil {
-		return NewSmalltalkString(err.Error())
-	}
-	if smalltalkValue != nil && smalltalkValue.TypeOf() == DEFERRED {
+	smalltalkValue := scope.GetVarValue(variable.GetName())
+	if smalltalkValue.TypeOf() == DEFERRED {
 		return smalltalkValue.Value()
 	} else {
 		return smalltalkValue
diff --git a/treeNodes/smalltalkObjects.go b/treeNodes/smalltalkObjects.go
index 8143511..c05053f 100644
--- a/treeNodes/smalltalkObjects.go
+++ b/treeNodes/smalltalkObjects.go
@@ -533,7 +533,7 @@ func (a *SmalltalkArray) GetValueAt(index int64) SmalltalkObjectInterface {
 	return a.array[index]
 }
 
-func (a *SmalltalkArray) GetValue() ([]interface{}, error) {
+func (a *SmalltalkArray) GetValue() []interface{} {
 	var interfaceSlice = make([]interface{}, len(a.array))
 	for i, each := range a.array {
 		switch each.TypeOf() {
@@ -544,16 +544,13 @@ func (a *SmalltalkArray) GetValue() ([]interface{}, error) {
 		case BOOLEAN_OBJ:
 			interfaceSlice[i] = each.(*SmalltalkBoolean).GetValue()
 		case ARRAY_OBJ:
-			innerArray, err := each.(*SmalltalkArray).GetValue()
-			if err != nil {
-				return nil, err
-			}
+			innerArray := each.(*SmalltalkArray).GetValue()
 			interfaceSlice[i] = innerArray
 		default:
-			return nil, errors.New(`we do not support this type "` + each.TypeOf() + `" in array`)
+			panic(`we do not support this type "` + each.TypeOf() + `" in array`)
 		}
 	}
-	return interfaceSlice, nil
+	return interfaceSlice
 }
 
 func (a *SmalltalkArray) Value() SmalltalkObjectInterface {