The mission of the MyKitaab podcast series is to help answer the question “I have written a book, how do I get it published in India?”
Here, host Amar Vyas talks to me about writing, blogging and Open Source software, especially Emacs!
You can access the podcast as follows:
Or listen to it here:
Prelude> 3+4 7 Prelude> (5*6)+7 37 Prelude> 2^12 4096
areaCircle x = 3.14 * x areaSquare x = x * x
areaCircle 3 9.42 areaSquare 4 16
Have experience writing programs for the list operations mentioned above in a functional programming language or in a language with support for the functional paradigm
| Syllabus | Haskell Example |
|---|---|
| Create a list | let xs = [1,2,3,4,5] |
| return head of list | head xs |
| return tail of list | tail xs |
| test for empty list | null xs |
| return length of list | length xs |
| construct an empty list | xs = [] |
| prepend an item to a list | element : xs |
| append an item to a list | xs ++ [element] |
Going beyond the specification, there are many more list examples here: https://wiki.haskell.org/How_to_work_on_lists
A string is simply a list of characters
“This” = [‘T’,’h’,’i’,’s’]
Haskell lists have a head and tail, they also have an init and a last (see below for examples of these). You can prepend an element to a list (add it to the front) using the : operator, and concatenate (join) two lists using the ++ operator.
Use the : operator for preference in Haskell: it’s much faster than ++
Here are some examples to illustrate the above
Prelude> let xs = [1,2,3,4,5]
Prelude> head xs
1
Prelude> tail xs
[2,3,4,5]
Prelude> init xs
[1,2,3,4]
Prelude> last xs
5
Prelude> tail xs ++ init xs
[2,3,4,5,1,2,3,4]
Prelude> head xs ++ last xs
<interactive>:15:1:
No instance for (Num [a0]) arising from a use of ¡®it¡¯
In a stmt of an interactive GHCi command: print it
Prelude> [head xs] ++ [last xs]
[1,5]
Prelude> xs!!2
3
Prelude> xs!!6
*** Exception: Prelude.(!!): index too large
Prelude> xs!!0
1
Prelude> 0:xs
[0,1,2,3,4,5]
Prelude> xs ++ 6
<interactive>:25:1:
No instance for (Num [a0]) arising from a use of ¡®it¡¯
In a stmt of an interactive GHCi command: print it
Prelude> xs ++ [6]
[1,2,3,4,5,6]
Remember that a string is a list of characters. Let name = <your name>
let ls = [1,2,3,4,5] last ls:init ls ++ tail ls ++ [head ls] ++ [ls!!3]
Prelude> [1..5] [1,2,3,4,5] Prelude> [1,3..10] [1,3,5,7,9] Prelude> [10,9..1] [10,9,8,7,6,5,4,3,2,1] Prelude> [-5,-3..5] [-5,-3,-1,1,3,5]
Now for some list comprehensions. The following examples show how to draw down from ranges in a list comprehension
Prelude> [x*2 | x <- [1..5]] [2,4,6,8,10] Prelude> [x*x | x <- [1..10]] [1,4,9,16,25,36,49,64,81,100]
You can add predicates to restrict the values of a list comprehension as follows
Prelude> [x | x <- [1..10], odd x] [1,3,5,7,9]
You can add more than one predicate. What are the even numbers between 1 and 50 that are divisible by 3?
Prelude> [x|x<-[1..50], x `mod` 3==0, even x] [6,12,18,24,30,36,42,48]
You can draw down from two variables as follows. Watch out for the order! Note that x**y means x to the power of y
Prelude> [x**y | x <- [1..5], y <- [2,3,4]] [1.0,1.0,1.0,4.0,8.0,16.0,9.0,27.0,81.0,16.0,64.0,256.0,25.0,125.0,625.0] Prelude> [x**y | y <- [2,3,4], x <- [1..5]] [1.0,4.0,9.0,16.0,25.0,1.0,8.0,27.0,64.0,125.0,1.0,16.0,81.0,256.0,625.0]
take 5 [1..] [1,2,3,4,5]
The above means take the first 5 elements from the infinite list that counts up from 1. Haskell only creates as much of the list as it needs.
Combining lazy evaluation with functions that produce infinite lists means you can do such things as the following
Prelude> take 10 (cycle [1,2]) [1,2,1,2,1,2,1,2,1,2] Prelude> take 5 (repeat "Brubeck") ["Brubeck","Brubeck","Brubeck","Brubeck","Brubeck"]
pythagTriples x = [(a, b, c) | a <-[1..x], b <- [1..x], c <- [1..x], c^2 == a^2 + b^2]
areaCircle x = 3.14 * x areaSquare x = x * x
Note that Haskell functions must start with lower case letters.
Remember, whilst you are learning you can type up functions in your favourite editor and then load them into the editor using :l path/to/file. Use :r to reload the functions when you’ve made changes to them.
Here’s how to write functions with two parameters:
areaRectangle l w = l*w perimeterRectangle l w = 2*l + 2*w
area3Rect = areaRectangle 3
You can now work out the areas of different rectangles as follows
*Main> area3Rect 4 12 *Main> area3Rect 5 15 *Main> area3Rect 6 18 *Main>
area3Rect is a partially applied function – a function where some of the parameters have been fixed.
Try creating a partially applied function based on perimeterRectangle.
This leads us nicely on to Higher Order Functions…
map is the name of a higher-order function that applies a given function to each element of a list, returning a list of results.
filter is the name of a higher-order function that processes a data structure, typically a list, in some order to produce a new data structure containing exactly those elements of the original data structure that match a given condition.
reduce or fold is the name of a higher-order function which reduces a list of values to a single value by repeatedly applying a combining function to the list values.
| Syllabus | Example |
|---|---|
| map | map (+3) [1,2,3,4,5] -> [4,5,6,7,8] |
| filter | filter (>3) [1,2,3,4,5] -> [4,5] |
| fold | foldl (+) 0 [1..10] -> 55 |
*Main> map (+3) [1,2,3,4,5] [4,5,6,7,8]
Here we map the odd function…
*Main> map odd [1..10] [True,False,True,False,True,False,True,False,True,False]
*Main> filter (>3) [1,2,3,4,5] [4,5]
Here we filter out the odd numbers in a list.
*Main> filter (odd) [1..20] [1,3,5,7,9,11,13,15,17,19]
A string in Haskell is treated as a list of letters. `elem` returns true if the letter is an element of the list so…
*Main> filter (`elem` ['A'..'Z']) "What Are The Capitals In This Sentence?" "WATCITS"
Prelude> foldl (+) 0 [1..10] 55 Prelude> foldr (+) 0 [1..10] 55 Prelude> foldl (-) 0 [1..10] -55 Prelude> foldr (-) 0 [1..10] -5
The first example is quite straighforward. Foldl takes the first item from the list (1) adds it to the accumulator (0) and stores the result in the accumulator (1)
It then takes the second item from the list (2) adds it to the accumulator and stores the result (3). Working through the list you get the result 55.
The second and third examples are similar.
The last example is particularly interesting, however. Why does it give the result -5? Try and work through the logic, and remember that if you subtract a -ve number its the same as adding
You can use fold in haskell like you use loops in imperative languages
simpleCount 1 = "One" simpleCount 2 = "Two" simpleCount x = "Many"
You can use pattern matching to set base cases in recursive functions. Here’s an example of a factorial function from later on. Note how factorial 0 is defined as being 1 using pattern matching.
factorial 0 = 1 factorial n = n * factorial (n-1)
canDrive x = if x <18 then "Too young to drive" else "Old enough to drive"
Here it is using guards:
canDrive' x
| x<18 = "Too young to drive" |
| otherwise = "Old enough to drive" |
The following function uses guards to work out the cost in pence of sending a large letter in the UK
letterCost weight
| weight <= 100 = 96
| weight <= 250 = 127
| weight <= 500 = 171
| otherwise = 2.46
Looking at the above letterCost function you might reasonably deduce that you could send an elephant via the UK postal service for £2.46. Unfortunately, the prices given are only for large letters which can weigh no more than 1kg.
fizz n | n `mod` 3 == 0 = "Fizz" | otherwise = show n
factors n = [x | x <- [1..n], n `mod` x == 0]
Now, remembering that a number n is prime if and only if it has two factors, [1,n], let’s define function to determine if a number is prime
prime n = factors n == [1,n]
*Main> factors 15 [1,3,5,15] *Main> factors 7 [1,7] *Main> prime 7 True *Main> prime 2 True
Oops, 2 is not a prime number. Use pattern matching to fix the prime function…
prime 2 = False prime n = factors n == [1,n]
Check that…
*Main> prime 7 True *Main> prime 2 False
Done!
factorial 0 = 1 factorial n = n * factorial (n-1)
As you can see, pattern matching makes it very easy to set the base case for a recursive function. Here’s another recursive function. This one reverses a list. I’ve called my function reverse’ to distinguish it from the existing Haskell reverse function,
reverse' [] = [] reverse' (x:xs) = reverse(xs)++[x]
There are two important things to note here:
First, pattern matching is used to ensure the case of an empty list is handled.
Second, note the use of the (x:xs) pattern to identify the head and the tail of the list. Haskell programmers use this pattern a lot.
*Main> (\x -> x*2) 3 6
Here’s another lambda function that multiplies two numbers
*Main> (\x y -> x*y) 3 4 12
The above example is an anonymous version of the areaRectangle function mentioned earlier.
Here’s how to use a lambda function to find the numbers that divide by 3
*Main> filter (\x -> x `mod` 3 == 0) [1..20] [3,6,9,12,15,18]
factors n = [x | x <- [1..n], n `mod` x == 0]
Here’s an example
*Main> factors 6 [1,2,3,6]
Remember that a number is perfect if it’s the sum of its factors, not including the number itself, so we add an extra predicate to eliminate that.
factors n = [x | x <- [1..n], n `mod` x == 0, x/=n]
Check this
*Main> factors 6 [1,2,3]
So a number is perfect if sum (factors x) == x. Lets run a list comprehension to find the perfect numbers <1000.
*Main> [x | x <- [1..1000], sum (factors x) == x] [6,28,496]
Or use a filter…
*Main> filter (\x -> sum(factors x) == x) [1..1000] [6,28,496]
Try running that on [1..10000] to see how long it takes Haskell to figure out the next perfect number!
public class StrAsc
{
public static void main (String args [])
{
String s = "A String";
System.out.println("The character at index 2 is " + s.charAt(2));
System.out.println("The ASCII equivalent is " + (int)s.charAt(2));
}
}
1) Write a method that accepts the length and width of a rectangle and returns the perimeter of the rectangle
double Perimeter(double length, double width)
{
return length*2 + width*2;
}
2) Write a method that accepts the base and height of a triangle and returns the area of the triangle
double areaTriangle(double base, double height)
{
return 0.5*base*height;
}
3) Write a method that accepts three integers as paramaters and returns the average of the integers.
double average(int a, int b, int c)
{
return((a+b+c)/3.0);
}
4) Write a method that accepts an integer array as a parameter and returns the average of the values of that array.
double average(int [] numbers)
{
double av = 0;
double total = 0;
for(int n: numbers)
{
total += n;
}
return total/numbers.length;
}
5) Write a method that accepts an integer array as a parameter and returns the minium value in that array
double min(int [] numbers)
{
int minVal = numbers[0];
for (int n : numbers)
{
if (n < minVal) minVal = n;
}
return minVal;
}
or
double min(int [] numbers)
{
Arrays.sort(numbers);
return numbers[0];
}
6) Write a method that returns the hypotenuse of a triangle when the other two sides are int a and int b. (Remember: hypotenuse squared equals a squared plus b squared)
double hypotenuse(double a, double b)
{
return Math.sqrt(a*a + b*b);
}
7) The scalar product of u=(u1,u2,u3) and v=(v1,v2,v3) is defined to be u1v1+u2v2+u3v3. Write a method that accepts two int arrays as parameters and returns an int representing the scalar product of those two arrays
double scalarProduct(int [] u, int [] v) throws Exception
{
if (u.length != v.length) throw new Exception();
double product = 0;
for(int i = 0; i<u.length; i++)
{
product += u[i]*v[i];
}
return product;
}
8) If A = (a1,a2, …an) and B = (b1,b2, …bn) then the vector sum of the two arrays A + B = (a1+b1, a2+b2, … , an+bn). Write a method that accepts two arrays as parameters and returns an array representing the vector sum of those two arrays.
double [] vectorSum(int [] u, int [] v) throws Exception
{
if (u.length != v.length) throw new Exception();
double [] sum = new double[u.length];
for(int i = 0; i<u.length; i++)
{
sum[i] = u[i] + v[i];
}
return sum;
}
9) The Euclidean distance between two points A = (a1,a2, …an) and B = (b1,b2, …bn) is defined as sqrt((a1-b1)2 + (a2-b2)2 +… + (an-bn)2). Write a method that accepts two int arrays representing A and B as parameters and returns a double representing the Euclidean distance between them.
double [] eDistance(int [] u, int [] v) throws Exception
{
if (u.length != v.length) throw new Exception();
double [] sum = new double[u.length];
double dist = 0;
for(int i = 0; i<u.length; i++)
{
dist += Math.pow((u[i]-v[i]),2);
}
return sum;
}
I wrote about inserting characters in Emacs in this post.
There I pointed out that it’s easy to insert characters such as è and ä by using the C-x 8 key combination. So, for example:
C-x 8 ' e prints é C-x 8 `e prints è C-x 8 ^ e prints ê C-x 8 " u prints ü C-x 8 / / prints ÷ C-x 8 C prints © copyright
What I didn’t realise at the time is there was an easier combination formed by simply entering the Unicode name of a character.
For example, to insert é, use the combination
C-x 8 [return] LATIN SMALL LETTER E ACUTE
Capital letters begin, unsurprisingly, with LATIN CAPITAL.
At first glance the above doesn’t look easier, even allowing for the fact that Emacs allows you to use a few shortcuts. With tab completion, I got the key sequence down to…
C-x 8 [return] lat [tab] sm [tab] e [space] a [tab]
… but that’s still not as compact as the original examples.
So why is that an easier combination?
Well, it’s easier in the sense that it’s easier to remember, and therefore it can be quicker to use for obscure characters than having to look up a character code.
Just as an experiment, I tried to put in a British pound sign without using the appropriate key on my UK keyboard.
I used C-x 8 [return] and typed po [tab], and there was pound sign (along with
POODLE, POULTRY LEG and POUTING CAT FACE).
If you’re interested what POUTING CAT FACE looks like (I certainly was) here’s a link: http://www.fileformat.info/info/unicode/char/1f63e/index.htm
The BBC likes to think it single handedly ignited the 80’s UK programming boom thanks to its BBC B micro. Well, maybe so. If you were the sort of kid who’s parents could afford one. Most of us learned our chops on cheaper machines like Spectrums, Vic 20s and even Dragon 32s. (Remember them?) – and were grateful for the opportunity.
Well, now the BBC is back to save the world (or at least that part of it that concerned with educating British children) with the Microbit. Another spectacular example of Auntie knows best.
Now don’t get me wrong. The Microbit is a lovely piece of kit. It’s cheap, it’s flexible, it comes with a well thought out website to help program it. Boxes of the things are being sent out, free of charge, to schools up and down the country.
The thing is, I never asked for them. Are Microbits the best way to teach kids programming? I’m a teacher and I don’t remember being asked for my opinion. The trouble with this sort of thing is that they’re always proposed and built by tech-heads; by people who are very good at IT. They get it, they enjoy it. They always found it easy.
… exactly the wrong sort of person to understand what the average 12 year old non techy finds interesting or difficult. I’m not saying that you can’t motivate kids to learn computing. That’s my day job. But you don’t do it this way. I’m sure that Microbits are going to be featuring in the pages of most local newspapers over the next few months. Expect to see lots of photographs of smiling school children talking about how they’re learning to program. You can’t argue with that. Except the lessons won’t stick, there’ll be no progress for the majority and in a year’s time the Microbits will be sitting in the bin next to the video conferencing kits, the control equipment and the ghosts of the Learning Grids.
No doubt a group of manufacturers are currently sitting round, patting each other on the back as they congratulate each other on doing their bit for education. Frankly, I’d rather the money had been spent giving me a bit more preparation and marking time.
There’s a teacher shortage in this country, there are too many people saying what needs to be done and precious few actually prepared to get their hands dusty at the chalkface. You want to help, get in the classroom and get teaching. Otherwise, shut up, and stop wasting my time.
for k in range(1,10):
print(k)
Countdown from 10 to 1
for k in range(10,0,-1):
print(k)
Print the days of the week
for day in ["Sunday","Monday","Tuesday","Wednesday","Thursday", "Friday","Saturday"]:
print(day)
Print the five times table
for k in range(1,11):
print("5 x {0} = {1}".format(k, 5*k))
food = ["Sausage", "eggs", "Bacon", "Beans"]
pupils = ["John", "Jill", "Emily", "Satpal"]
scores = [5,3,6,7,9,1,2]
days = ["Sunday","Monday","Tuesday","Wednesday","Thursday", "Friday","Saturday"]
for day in days:
print(day)
print(food[1])
print(pupils[2:])
print (days[2:4])
print(pupils[:2])
print(days[-2])
print(len(days))
print(max(scores))
print(min(scores))
if "John" in pupils:
print("Pupil is present")
else:
print ("Pupil absent")
pupils = pupils + ["Arthur"]
print(pupils)
Now write your own modules to do the following
public class Meth
{
final double PI = 3.1415;
Meth()
{
int r = 4;
System.out.println("The Area of a circle radius " + r + " is " + area(r));
System.out.println("The Circumference of a circle radius " + r + " is " + circumference(r));
}
double area(int r)
{
return PI*r*r;
}
double circumference(int r)
{
return 2*PI*r;
}
public static void main (String args [])
{
new Meth();
}
}
1) Print out the following shapes: \/ \/\/ \/\/\/ \/\/\/\/ \/\/\/\/\/
for (int i = 1; i<6; i++)
{
for(int j = 0; j<i; j++)
{
System.out.print("\\/");
}
System.out.print(" ");
}
2) Print out the following 54321,4321,321,21,1
for (int i = 5; i>0; i--)
{
for(int j =i; j>0; j--)
{
System.out.print(j);
}
System.out.print(" ");
}
3) Print out the following shapes */ */ */ */ *****/
for (int i = 1; i<6; i++)
{
System.out.print("\\");
for(int j = 0; j<i; j++)
{
System.out.print("*");
}
System.out.println("/");
}
4) Print out a 10 x 10 table square
for (int i = 1; i<11; i++)
{
for(int j = 1; j<11; j++)
{
System.out.print("\t"+ i*j + "\t |");
}
System.out.println();
}
5) Print out the following shapes \/ \// \\/// \\//// \\\/////
String seed = "";
for (int i = 1; i<6; i++)
{
seed = "\\" + seed + "/";
System.out.print(seed + " ");
}
6) Print out an 8 x 8 chessboard. Use * for black and – for white
boolean isBlack = true;
for (int i = 1; i<9; i++)
{
for(int j = 1; j<9; j++)
{
System.out.print(isBlack ? "*" : "-");
isBlack = !isBlack;
}
isBlack=!isBlack;
System.out.println();
}
7) Print out the following shapes:
* ** ** *** *** *** **** **** **** **** ***** ***** ***** ***** *****
String stars = "";
for (int i = 1; i<6; i++)
{
stars = stars + "*";
for(int j = 0; j<i; j++)
{
System.out.println(stars);
}
System.out.println();
}