The document describes the development of the KiND programming language. It discusses how KiND aims to be a beginner-friendly language through features like replacing errors with praise and having a graphical user interface. It also covers the motivation for developing KiND, the initial lazy paradigm used for the language architecture, and how this was replaced with a new-order paradigm to allow for things like multi-line functions and multiple valid outputs from rules. Key goals of KiND include making programming more accessible and positive for children.

1. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Developing KiND Programming Language
Shaishav Saraswat - 1105210040
Naman Jain - 1105210024
Raunaque Kr. Srivastava - 1105210032
Alok Kr. Singh - 1105210004
Institute of Engineering and Technology, Lucknow - 226021
May 7, 2014
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

2. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
What is a programming language?
Beginning Programming
Why KiND !?
Preface
Simpli

3. ed De

4. nition
"A programming language is a means to tell the computer what to do."
We have seen programming languages of various types including
High-Level Languages, Low-Level Languages, Machine Languages etc...
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

5. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
What is a programming language?
Beginning Programming
Why KiND !?
Beginning Programming
For a beginner in the programming world it is immensely dicult to
compete with one who is well versed with computing and it's
method, with a whole lot of syntaxes to gobble up in his mind.
Today kids learn languages like Logo and BASIC which according to
Dr. Eric Grimson (Professor at MIT) is the the worst

6. rst
language.
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

7. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
What is a programming language?
Beginning Programming
Why KiND !?
Beginning Programming
For a beginner in the programming world it is immensely dicult to
compete with one who is well versed with computing and it's
method, with a whole lot of syntaxes to gobble up in his mind.
Today kids learn languages like Logo and BASIC which according to
Dr. Eric Grimson (Professor at MIT) is the the worst

8. rst
language.
So, we thought of making an alternative

9. rst programming
language. We call it KiND.
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

10. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
What is a programming language?
Beginning Programming
Why KiND !?
Why KiND !?
The term originates from a spoken language called Swahili and it
means child.
Also it kind of served three purposes by just one shot.
1 It emphasize our focus on kids.
2 Easy to learn and gentle to read.
3 Kind to the programmer.
Kindness to the programmer is emphasized by a concept called
Praising the programmer.
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

11. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Motivation
Praises in place of Error
Chocolate model
Crowd Sourcing
What to expect further?
Motivation
The demons of programming universe
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

12. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Motivation
Praises in place of Error
Chocolate model
Crowd Sourcing
What to expect further?
Motivation
The demons of programming universe
We had two Swords to kill these Demons
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

13. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Motivation
Praises in place of Error
Chocolate model
Crowd Sourcing
What to expect further?
Motivation
The demons of programming universe
We had two Swords to kill these Demons
1.a fully error free language , or
2.A better cosmetic treatment of errors
we took the easier path and decided to go the cosmetic way
lets see
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

14. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Motivation
Praises in place of Error
Chocolate model
Crowd Sourcing
What to expect further?
Attitude
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

15. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Motivation
Praises in place of Error
Chocolate model
Crowd Sourcing
What to expect further?
Attitude
Positive Attitude
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

16. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Motivation
Praises in place of Error
Chocolate model
Crowd Sourcing
What to expect further?
Attitude
Positive Attitude
Stop Criticism... Start Praising!!!
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

17. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Motivation
Praises in place of Error
Chocolate model
Crowd Sourcing
What to expect further?
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

18. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Motivation
Praises in place of Error
Chocolate model
Crowd Sourcing
What to expect further?
Praiser
a Praiser rather than a Error Finder
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

19. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Motivation
Praises in place of Error
Chocolate model
Crowd Sourcing
What to expect further?
Dynamic Personalisation
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

20. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Motivation
Praises in place of Error
Chocolate model
Crowd Sourcing
What to expect further?
Dynamic Personalisation
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

21. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Motivation
Praises in place of Error
Chocolate model
Crowd Sourcing
What to expect further?
The Yummy Model
The missing Chocolate model!
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

22. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Motivation
Praises in place of Error
Chocolate model
Crowd Sourcing
What to expect further?
Crowd Sourced Praise Messeges
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

23. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Motivation
Praises in place of Error
Chocolate model
Crowd Sourcing
What to expect further?
Automatic grading tool
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

24. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Motivation
Praises in place of Error
Chocolate model
Crowd Sourcing
What to expect further?
Can it be Used elsewhere?
This error handling model can be easily used any where as this can easily
be extended to work for any other language
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

25. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Motivation
Praises in place of Error
Chocolate model
Crowd Sourcing
What to expect further?
What to expect in Future?
SpellChecker
Pro

26. le Based Praise or Scold
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

27. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Why Graphical Environment ?
Basic Motivations
User Interface
Why Graphical Environment ?
This language is basically dedicated
to the children.Children love
Graphical Interface over Character
Interface
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

28. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Why Graphical Environment ?
Basic Motivations
User Interface
Basic Motivations for this interface
This is a screenshot of python
idle.Here the drawback is single
pane display.Both input and results
are displayed on separate window.
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

29. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Why Graphical Environment ?
Basic Motivations
User Interface
Basic Motivations for this interface
Python idle does
not show line
number.This is an
extra feature
added here.
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

30. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Why Graphical Environment ?
Basic Motivations
User Interface
Basic Motivations for this interface
Also various colours are used for displaying various inputs.Kids love colors.
orange ! numbers
blue ! string
green ! single quote
dark green ! comment
and many more colors to attract kids
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

31. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Why Graphical Environment ?
Basic Motivations
User Interface
Working
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

32. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Conventional Vs. KiND
Architecture of KiND language
Conventional Vs. KiND
Conventional languages use a common syntax for executing a task which
is a name of a function followed by it's parameters which may or may not
be natural.
A statement in C language
printf(min(a,b));
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

33. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Conventional Vs. KiND
Architecture of KiND language
Conventional Vs. KiND
Conventional languages use a common syntax for executing a task which
is a name of a function followed by it's parameters which may or may not
be natural.
A statement in C language
printf(min(a,b));
Let's look a more natural approach to doing the same thing :
Same statement in KiND
Print the minimum of a and b.
We call each black of code as paragraph which would consist of
sentences made of words. Thus, sentences are nothing but expressions.
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

34. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Conventional Vs. KiND
Architecture of KiND language
Header De

35. nitions
Firstly, let's see the structure of Header

36. le declarations.
De

37. ning Add keyword in ENGLISH:
define Add :
[ output #1 + #2
Add 1 to 2
Add 1 and 2 ]
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

38. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Conventional Vs. KiND
Architecture of KiND language
Header De

39. nitions
Firstly, let's see the structure of Header

40. le declarations.
De

41. ning Add keyword in ENGLISH:
define Add :
[ output #1 + #2
Add 1 to 2
Add 1 and 2 ]
De

42. ning Add keyword in NORWEGIAN :
define Legg :
[ output #1 + #2
Legg 2 og 3
Legg 2 til 3 ]
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

43. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Conventional Vs. KiND
Architecture of KiND language
The Lazy Paradigm
Let's see how to match sentences to these rules. We will use a stack
structure as shown :
Add 2 to 3
Output Rule
] 1 + ] 2
num table
[2; 3]
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

44. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Conventional Vs. KiND
Architecture of KiND language
Problems with Lazy Paradigm
Following problems were encountered with Lazy Paradigm
We cannot create multiple line functions
Output rules must return numbers
Multiple-rule matching was not compensated properly
Direction-Oriented matching was not possible
Thus, after so much eorts we ended up with a calculator.
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

45. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Conventional Vs. KiND
Architecture of KiND language
Multiple-Rule Matching
Most languages use following construct to express formal parameters :
func1(var1, var2, var3), func2(var4, var5)
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

46. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Conventional Vs. KiND
Architecture of KiND language
Multiple-Rule Matching
Most languages use following construct to express formal parameters :
func1(var1, var2, var3), func2(var4, var5)
Whereas, KiND may use following construct :
Word1 var1 func1 var2 var3 var4 word2 func2 var5.
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

47. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Conventional Vs. KiND
Architecture of KiND language
Multiple-Rule Matching
Most languages use following construct to express formal parameters :
func1(var1, var2, var3), func2(var4, var5)
Whereas, KiND may use following construct :
Word1 var1 func1 var2 var3 var4 word2 func2 var5.
|________________________| |____________________|
|___________________| |_________________________|
|_____________________________| |_______________|
All above choices are legal and cannot be handled by Lazy paradigm.
This concept is called Parameter Sharing.
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

48. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Conventional Vs. KiND
Architecture of KiND language
New-Order Paradigm
It began with a radical redesign of our processing architecture. Let's have
a look:
We are now able to create multiple line functions and we will process
them as new paragraph instances using recursive sequences.
Each output rule for a set of syntax rules must contain it's
corresponding return type. ex. null for Store
Each valid rule will now create a replica of the original sentence and
we will process each one of them giving more than one legal outputs.
For each matching rule we now have a direction which tells the
direction in which it is to be processed.
We will not process sentences in place, instead, we will

49. rstly

50. nd all legal ways of processing a sentence (i.e. a set of rules)
and then process them.
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

51. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Conventional Vs. KiND
Architecture of KiND language
Header De

52. nitions
New Math and I/O repositories had to be developed to inculcate all these
new features. So Header

53. les were developed newly in their entirety.
De

54. ning Add keyword
define Add :
[ null output Store the addition of #1 and #2 in it.
Add 1n to 2n
Add 1n and 2n
Add 1n with 2n ]
[ null output Store the addition of #1 and var in var.
Add 1n to var]
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

55. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Conventional Vs. KiND
Architecture of KiND language
Structures in KiND Architecture
We now treat each of our input as a paragraph and a paragraph has 3
properties :
orig para : It is basically a list of sentences
current para : Which is just a funny name for answer
symbol table : Contains variables and constants and their scopes
and values.
Each sentence has the following properties :
orig sentence : It contains the original sentence as a string.
rule order : List describing the way we learnt how the sentence has
to be processed.
current sentence : It is an intermediate variable which contains the
sentence as it is evaluated according to rule matchings.
processed : It is a boolean which tells whether we have processed
the entire sentence or not.
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

56. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Conventional Vs. KiND
Architecture of KiND language
Structures in KiND Architecture
Each rule order has 4 properties :
keyword : It is the keyword found in the sentence in one of the
repositories.
rule : It is the rule that matches in that keyword.
repository : It is the repository in which the keyword of this
sentence was found.
direction : This speci

57. es in which direction the matching part of
sentence was to be processed.
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

58. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Conventional Vs. KiND
Architecture of KiND language
Primary Procedures
All of these were de

59. ned as classes and the best way to process is via
recursive calls to the following functions :
1 processPara(para class list) : returns a para class list.
2 processSentences(sentence class list) : returns a
sentence class list.
3 executeSentence(para class list) : returns para class list.
processPara would use processSentence to

60. nd out how to process each
of its sentence. After that it calls executeSentence to execute it which
would again call processPara after substituting the inputs in the matched
rule and the process continues until we process everything.
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

61. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Unique Features
Limitations!!
Future Endeavors
Conclusion
Unique Features
1 Gentle-Learning Curve :- Since the syntax is based on natural
language it is easy for beginners to learn our language.
2 Self Documenting :- Syntax is natural to read thus self
documenting
3 Multi-Language Support - From the very beginning we designed
the architecture of the language in such a way so that we can
support any natural language that can be written and it's not just
english, as we showed before.
4 Parameter Sharing - Language seamlessly supports more than one
legal matching sequences for any input sentence
5 Personalized Programming - Addressing each user by his name
and keeping tab of his language pro

62. ciency.
6 Extensibility :- Users can add functions at there own whims and
fancy's and this has been made possible by Python at the back end.
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

63. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Unique Features
Limitations!!
Future Endeavors
Conclusion
Limitations
1 Slow : Python is a slow language as it is not type critical.since our
interpreter has beeen written on python thus it in turn makes it slow.
2 Dicult for Complex Projects : Our language consists of proper
grammatical expressions. Designing soft-wares requires a huge
amount of code and writing statement like i+ = 2 in our language
would make it very dicult to code such large projects.
3 Hectic : Even simple expressions within algorithms would become
huge in our language making algorithm design work hectic.
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

64. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Unique Features
Limitations!!
Future Endeavors
Conclusion
Future Endeavors
1 Loops and Conditionals : We need to implement structures that
support Loops and Conditional expressions to extend capabilities of
the language.
Target date - July, 2k14
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

65. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Unique Features
Limitations!!
Future Endeavors
Conclusion
Future Endeavors
1 Loops and Conditionals : We need to implement structures that
support Loops and Conditional expressions to extend capabilities of
the language.
Target date - July, 2k14
2 Data Structures : We need to create a mechanism to create
powerful data structures which would bring a sense of completeness
to the language.
Target date - November, 2k14
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

66. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Unique Features
Limitations!!
Future Endeavors
Conclusion
Future Endeavors
1 Loops and Conditionals : We need to implement structures that
support Loops and Conditional expressions to extend capabilities of
the language.
Target date - July, 2k14
2 Data Structures : We need to create a mechanism to create
powerful data structures which would bring a sense of completeness
to the language.
Target date - November, 2k14
3 Optimization : Our target from the very beginning was to get
things done and not to get them done quickly. We will now move
onto optimizing the dynamics of new order paradigm.
Target date - January, 2k15
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

67. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Unique Features
Limitations!!
Future Endeavors
Conclusion
Future Endeavors
1 Loops and Conditionals : We need to implement structures that
support Loops and Conditional expressions to extend capabilities of
the language.
Target date - July, 2k14
2 Data Structures : We need to create a mechanism to create
powerful data structures which would bring a sense of completeness
to the language.
Target date - November, 2k14
3 Optimization : Our target from the very beginning was to get
things done and not to get them done quickly. We will now move
onto optimizing the dynamics of new order paradigm.
Target date - January, 2k15
4 Community Release :- We will then make the source code public
on our dedicated website . This would encourage people to
contribute to the project by developing libraries in various other
languages and expanding it's scope world-over.
Target date - February, 2k15
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

68. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Unique Features
Limitations!!
Future Endeavors
Conclusion
Future Endeavors
1 Supporting Contributors :- Currently we support extensibility via
text

69. les which is a bit primitive. So, we propose to bifurcate our
IDE into two segments :
a KiND DC : Downstream Console : Users who want to use existing
features of the language as it is.
b KiND UC : Upstream Console : Users who want to contribute to the
project directly i.e. extend its features. Users would be able to add
newer language support and even add newer python library functions.
All of these de

70. nitions would be coalesced in a .kuc

71. le which can be
easily shared among community members.
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

72. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Unique Features
Limitations!!
Future Endeavors
Conclusion
User Interface
What's next !
Voice Recognition
We use natural language for mathematical processor so We will
implement speech to text conversation
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

73. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Unique Features
Limitations!!
Future Endeavors
Conclusion
User Interface
What's next !
Auto-Complete
Auto-Complete feature help save lot of typing eort anf labour
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

74. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Unique Features
Limitations!!
Future Endeavors
Conclusion
User Interface
What's next !
Project Hierarchy
We will be adding a new pane to show project structure of the directory
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

75. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Unique Features
Limitations!!
Future Endeavors
Conclusion
User Interface
What's next !
Other Features
We will be adding spell checker feature
We will add tabbed pane view so that a number of

76. les can be
handled simultaneously
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

77. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Unique Features
Limitations!!
Future Endeavors
Conclusion
Conclusion
1 We began by analyzing problems faced by programming beginners
and tried to create a more natural programming language.
2 We ended up making a Self-Documenting language - KiND and
it's Python based Interpreter which supports multiple natural
language declarations.
3 Our focus on the very beginning was to drift away from a steep
learning curve and supports almost in

78. nite extensibility.
4 KiND is supported by a personalized IDE which is powered by a
praise model.
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language

79. Introduction
Praiser Model and Errors
User Interface
Designing KiND Language
Analyzing KiND
Unique Features
Limitations!!
Future Endeavors
Conclusion
/ Thank You .
L99!!!!!!99K
Shaishav, Naman, Raunaque, Alok Developing KiND Programming Language