MORE ON CODING PAGES

CODING PAGES

Well, it's been a couple of days, and now I have a few basic rules.

First, here's what I found.

1. Programming is fun (let's get that out of the way).
2. Programming is complex, even small tasks.
3. There's a tendency to analyze too much.
4. There's a need to be correct - make it work.
5. The urge to look something up should be avoided.
6. Fear of running incomplete code - to see what breaks.

PROGRAMMING IS FUN

There's something exciting, after having spent a lot of time to learn a programming language, to write something and see it work. Even writing stuff in Excel VBA can be very interesting.

Programmers tend to take the long way home, just because you can. Like motorcyclists, if you really love riding, then you'll take the long bumpy route.

So, in the case of Excel, given a column of numbers to add, it's easy to use the built-in Excel SUM() function, but then, once in a while, to remove the monotony and have a little fun, why not dive into the VBA developer's area and write your own sum function?

OK, not everyone does it, but for some people, learning a programming language, if it is fun can help in their jobs. I can quickly think of engineers, data scientists, and accountants. The numbers people.

For coding pages, a good limbering exercise is to use the Python urllib.request library to count the number of anchors on a web page.

PROGRAMMING IS COMPLEX

But then so is writing. You had to learn the entire alphabet, and learn how words, sentences and paragraphs work before you could write anything sensible.

With programming, the language is the language of logic. It's not difficult, but mistakes are frustrating since they are silent and not so obvious.

However the key item in the coding pages is to exercise a specific skill until it becomes something automatic. You don't even think about it. You can literally program in your sleep. And if you really like the programming language, all the better since basically, syntactically, many of them are similar. Where they differ is in the platforms and toolsets they provide to make your job easy.

As an example, I use Python and the Flask framework. And for the display part, I use Twitter Bootstrap. And for data storage, I use SQLite - and occasionally MySQL. Right there, I had to learn a lot of different technologies to write a simple tool that does nothing. But the more I practise using these tools, doing simple work (for example post a form and save the results) the better I get at more complex tasks. Because I'm not hindered by the simple ones.

It's sort-of like typing. If you're a touch typist, then the work of typing is easier since you can now concentrate on the content, and not stare at the keyboard. You can stare at the screen instead. However, if you cannot touch type, your focus is on the keyboard and you often look up, to make sure that what you are typing matches what your fingers are hitting. I've noticed people who finger type banging away at the keyboard and nothing is happening on the screen.

Coding Pages reduce the complexity by making sure that the simple basics are well covered.

ANALYSIS PARALYSIS

There are multiple ways to put up a form in Python Flask. You can use the <label> tag for the label, and <input> tags for the text boxes. You can also use a <span> tag with a bootstrap class to format the label. You can also use an <input> tag with the "submit" type to put a button on the screen to submit the form, or you can use a Bootstrap <button> tag to put up a submit button and check when it's clicked. You can also choose to write some validation code in Javascript before the entire form is sent to the server, or add some restrictions on the controls so that requirements are met.

All this can make you just stop doing what you are doing to think of the method, because you want to pick the right one. Analysis paralysis. Like a food menu that has everything under the sun. Ten pages of chicken dishes, twenty of beef, and an encyclopaedia with all the various vegetable dishes available. You spend more time leafing through the menu and even after you've placed your order waste even more time wondering if you ordered the best dish. Similarly with programming, you select a method, code, code, code and then go back still wondering. While the main intention of the coding pages is simply to type and move forward.

I'm organizing my coding pages by date, multiple exercise. Some are not complete because when I'm tired, even after 20 minutes, I stop. Working or not. And I don't come back to fix it. It's forgotten. An exercise to be thrown away.

THE NEED TO BE CORRECT AND MAKE IT WORK

In real life, of course it has to work, and it has to work most (or all) of the time. But with the coding pages, if you get stuck, this is not the time for new things. Really, this isn't the time for new explorations. You've simply overcommitted on the exercise.

For the past few days all I've been practising is setting up (manually) a Python Blueprint app. This is an App that is split up into multiple modules. Not very difficult, in fact, there's no need to do this manually, you can create a template once and for all, and whenever you need this feature, simply copy the feature.

Same thing with forms and other things, and I will get there. But the main point of the exercise is to stimulate muscle memory. The enjoyment and the productivity is in the doing and if you constantly looking at reference material, you'll never get the work done. So it's good to be good at some things and knowing these things has extended benefits. You will code more enjoyably when you are looking for things and you'll get over the habit of constantly stopping to check if you are right.

This is why we don't write a lot of code before we run the application to test it. But for small applications, this is a habit to be broken. You should be able to code a full blueprint app, with forms and a database without running it once. Of course it will crash due to silly mistakes when you eventually run it, but at least you're on the move.

Typing lots, and assuming that you are on the right path is key to these pages. Very similar to Julia Cameron's morning pages where she tells you not to stop writing. I think she actually tells you not to lift the pen off the page, but I stop and wiggle my fingers to rest them.

Last point. Ultimately you may run the app and it simply has too many errors and continually crashes. My advice is to move on. Close that chapter, there are lessons learned in moving along.

THE URGE TO KEEP LOOKING THINGS UP

OK, this one's a 50-50 thing. The Python find() function works on strings to look up substrings in them. Like many functions, it's an object function, so it works on it's object. You may forget if it's a function or maybe part of a package (like the string import), So you may be stuck and look it up.

The find function takes as an argument the thing (substring) you are looking for. So something like:

x = "my home is in Nairobi".find('Nairobi')

That expression will return the position of the word "Nairobi" in the string "my home is in Nairobi"

It's the same as:

s = "my home is in Nairobi"

x = s.find('Nairobi')

But you can also do:

x = s.find("Nairobi", 10)

This tells the function to start looking at position 10, but, but give you the absolute position of the substring, not the relative position from where you started.

So you're looking at find, and you may be tempted to keep looking up what does it really do.

My advise is just to guess, and then when your program crashes - as it may - you can figure it out later and then won't be in a pickle. Just keep coding.

When I was using the urllib library to scan web pages, I had imported urllib - and I knew that the method I needed was urlopen() under urllib.request. I just didn't import urllib.request. I thought that importing urllib alone was enough, since I could then use the entire path urllib.request.urlopen() to get the web page.

The program crashed and I learned.

It's mostly small things like these where I keep stopping. Like what's the correct way to specify a blueprint? And how about the blueprint templates, where do I put those? And how do I know that they are actually working?

THE FEAR OF INCOMPLETE CODE

This may be the toughest one. Walk away when you are tired. Don't have to finish. When you're tired, you've actually done enough. As long as you don't get tired in the first fifteen minutes. I say that a good exercise is about 30 minutes, and possibly top out at an hour. Don't spend more than an hour, that's too much time simply for an exercise.

Like going to the gym. Go. Do an hour. Three or four times a week. Getting better daily, not a destination, but a journey.

The coding pages are a journey, even if you don't see the results immediately, they're there. It's like the Morning Pages. They've had subtle but continuous influence and even if I don't produce high class, top grade, quality manuscripts, the work is there. And it's at least there in body, something that I can look at and tell that it's growing.

So open your code editor. Think of something quickly - create a form with a few fields to store an encrypted message. Store the encrypted message and then retrieve it. That's not a lot of work, don't use military grade encryption. In fact, create a Caesar shift function, easily broken, even by a ten year old. The point is coding. The writing.

And even if it does not compile and work, but you've been at it for at least 20 minutes, it's time to move on.

SUMMARY

1. Think of something you know how to do in your programming language of choice. Something that takes input and gives some sort of output.
2. Create the folders, and empty files you need.
3. Write, write, write. Write everything and don't compile.
4. Compile
5. Take a few minutes to smile (if it works), or fix a couple of things.
6. Refactor, if you think you overshot the target (gave yourself too much work).
7. Close up, take a walk.

CODING PAGES

CODING PAGES

I must admit, this idea is not fully fleshed out. But in this morning's session of Morning Pages, I was thinking about the practise of writing. Writing is new, it's not something very ancient, even though it is ancient. If you go back far enough in your family's history, it won't take too many generations, in some cases just one or two, before you reach ancestors that could not write.

Having the skill, or simply ability, to write is something technical. It's not very natural. It's a skill from patient learning of how to hold a pen, and memorize the various symbols that make up the language in which you are writing. If it's Chinese, then I suspect that the learning period requires a lot more practice than the Arabic script of 26 letters.

And after you have learned the technical skill of holding the pen, making marks that are recognizable (not just legible) as letters you move on to the art of composing these together into words.

And all of this takes years to master. Once mastery is achieved, some people do go on practising. Taking the time to write daily, so that the hands become independent of the mind, and can write easily. They experiment with different pens, paper and other media. And ultimately learn to enjoy the simple act of writing.

WRITING IS NORMAL

Today, writing is normal. Those who cannot write are the exception. And we are steadily moving on to the next phase of this technological shift. From using pens and paper, we are using computers, tablets and phones. We are no longer mastering how to shape letters and how to hold a pen, rather how to tap on a key and make sure that the letter that appears is the correct one. 

We know the symbol, we just don't need to craft it manually. While some may argue that it's a different skill from writing using a pen, and of course, the media is different and the way we form the words is different, but I think it falls into the same type of experiential activity. Writing.

A DIFFERENT EXERCISE

The Morning Pages are an exercise I took out of two books, Writing Down the Bones by Natalie Goldberg was the first book I read, and she talks about sitting down for "free writing" - I think that's the term she used. And then much later, years even, I ran into Julia Cameron's book, The Artist's Way, where she codified this free form of writing by specifying when (first thing in the morning) how long (3 A4 size pages) and the media (a pen and paper). She was absolutely adamant about this while Natalie, if my memory serves me right, was not.

I enjoy writing code. As a person who spent quite a lot of time with drawings and sketches, I am familiar with long sessions in front of paper, scratching and making legible marks whether it's drafting something, sketching something, or writing something. When my career shifted to software development, I taught myself how to touch type. Initially so that I could concentrate on the work and not constantly have my face fixed on the keyboard. I thought that the touch typing skill was very important for someone in that software development career, though I know some people who manage to live in software development who stare at the keyboard all day.

Just as the hand got used to crafting letters, symbols, on a piece of paper, and so you could now concentrate on thinking about the word, in fact the entire sentence, and not worry about what the shapes of the letters look like, touch typing frees you from thinking of the keyboard, and only concentrate on the word. My fingers know where the keys are and repetitive practise has made the act of typing fairly easy.

WRITING PRACTISE

In my Morning Pages, I now am able to simply move along, not worry too much about content, and simply allow myself to enjoy the feel of the pen as I make the strokes. Indeed, it is an enjoyable experience now, but it wasn't always like this. My initial exercises were fraught with anxiety, I did not know what to do. I was thinking of an audience to my writing, even though Julia Cameron states that this stuff is not for even my re-reading. It's just practising letting go, writing free form. 

It took a really long time to get to the point where I pick up a pen, open my Morning Pages journal, and simply start putting down letters. Of course I'm thinking and of course I'm writing legible sentences, but for the most part, it's not nerve wracking and I don't have to struggle with the content.

TYPING VS HANDWRITING

I think that the same exercise, with different experience, different outcome, can be done on a computer keyboard. After all, it's just a piece of technology, just like a pen and paper. Remember my paragraph above regarding the nature of writing, that it's not natural, it is learned? We have learned to use pens and write and in the same fashion, we can learn to use a computer keyboard simply as a mechanism for putting down letters and writing.

Part of the difficulty in typing is that when you it the wrong key, your hand automatically hits the backspace key and removes the misspelled word. This doesn't happen when you handwrite. Deleting mistakes is very hard, and also, fewer mistakes are made since handwriting is very slow. It is slow and it is tiring. And so when typing, practise needs to continue, just like Morning Pages, till there is a comfortable pace at which the activity is done. And the mistakes are fewer. This does not mean repetitively writing out words, as is the case when someone is learning to type (the same as when a child or adult is learning to handwrite), but thinking on paper - in this case, thinking on the screen.

Because typing is faster than handwriting, care needs to be taken because when fatigue finally hits the hands (as it will), the frustration level in typing can be much more severe than with handwriting. When you write with a pen, and your hand gets tired, you have no option but to stop writing till your hand is ready again. Not only is the fatigue discomforting, it is painful and very uncomfortable. The same may not be the case on the computer keyboard. Your fingers may simply now hit the wrong keys over and over, so your backspacing and deleting activity takes a lot longer and the writing becomes more frustrating.

You should remember at that time to stop typing and take a break.

NOW ON TO CODING

Having said all of that, I still have not gotten to the point of explaining what CODING PAGES are. They are similar to Morning Pages in the sense that it's a practise of sorts. But it's also a way to encourage and push software developers past the boredom of the comfort zone.

Let me try and explain.

Computer programming is a combination of learning a computer programming language as well as a bunch of other tools (sort of like other different languages) in order to build software systems. You may have heard of front-end programmers. These are programmers who know how to design user interfaces using tools like Twitter Bootstrap. On the other side there are back-end programmers, who write software to do some sort of processing, not necessarily visible to the person using the software, but calculating and providing results. There are database programmers who learn how to fetch and provide data requested by the software system. And so on.

Coding, computer programming, involves writing these instructions to the computer, using some sort of notepad, or advanced development tool. You sit down, and you type.

It also involves a lot of stopping, to think, and to lookup something you forgot. For example, in the Python programming language, which is what I'm going to be using as an example for these coding pages, there's are date functions that allow you to lookup dates as well as calculate the difference (in days, or hours, or minutes or seconds) between them. I never remember what they are, so I spend time, every time I need to do this, looking it up.

I know what I want, just that my memory isn't good enough to hold all of that stuff in storage.

Sometimes it's a simple thing. For example, in the Twitter Bootstrap library, there's an extensive collection of classes that allow you to do quite beautiful screen layouts. And I always forget something or the other. For example, how do I stripe the table, or allow hovering, or make the entire cell clickable?

And so, even though I've done this stuff repeatedly, I go back too often that my productivity suffers and I'm not interested in starting new projects.

It's almost like forgetting what a few of the letters in the alphabet look like. Oops, I've forgotten what a lowercase "H" looks like, so I have to look it up. Not the same as spelling since that can be resolved quite quickly, but a real challenge looking up something which is not commonly found.

So in these CODING PAGES, I go into a simple exercise, to be done often. Daily. Taking up about 30 minutes of your time. I think an hour's too much, and fifteen minutes too little to get anything done, so 30 minutes seems about right. And the exercise is fairly simple. It's actually a typing exercise with a goal in mind. To exercise specific skills in some of the things programmers do. And to build something from end to end. This is so that some of the routine items become automatic, like this writing.

RULES

1. You can use any of the software development platforms that you are used to. However, a plain text enabled environment makes things easier.
2. You should be able to do three things:
1. Build a screen with a form - even one box.
2. Create a database with a simple table - to put data in the form.
3. Write some code to collect the data from the screen and put it into the database.
4. Write some code to take data from the database and put it on the screen.

Now, a couple of clarifications:

1. The database can be a simple file - say a CSV file.
2. The screen does not need any formatting, you can start with a simple HTML <input> tag at the start, or a <textarea> to type stuff into.
3. I'll be using Python, but you can use anything.

EXAMPLE 1

Here are three files.

• input.html - this file has the HTML input to type stuff into a box.
• display.html - this file has the HTML to display a table of what's in the file.
• data.csv - our database file. A file with sample information about people, names and emails.
• app.py - the Python program to take data from the input.

IMPORTANT

I'm using a framework called Python/Flask. There's a setup required but the important pieces for this exercise are:

1. Python installed on your laptop / desktop.
2. Flask installed (in Python)
3. Knowledge that the web server is part of Python/Flask - there's a small command to run the server

So, here's input.html

<html>

    <head>

        <title>Input Form</title>

    </head>

    <body>

        <form action="/putdata" method="POST">

            <p>First Name: <input type="text" name="firstname"></p>

            <p>Last Name: <input type="text" name="surname"></p>

            <p>Email: <input type="email" name="email" placeholder="email@domain.com"></p>

            <p><input type="submit" name="submit" value="Put Data"></p>

        </form>

    </body>

</html>

Now, that's not formatted at all, but the main thing is that I know what those pieces are and I don't have to look them up.

1. I know the general format of a HTML page and the main tags that form the header part <head> and the body part <body>
2. I know what the form tag <form> looks like and some of the parameters it takes - like where to send the form when the submit button is clicked.
3. I know how to put a text box inside the form.

I could write forms all day, and for the first few days, I'll just play with this. Forms by themselves, forms inside tables, forms horizontally (I think we use <span> tags and not <p> tags). And so on.

Now let's write the data file that we will be putting data in, and reading from.

This is data.csv

Tony, Mwai, tony@email.com

Jack, Johnson, jack@home.net

Mary, Mary, marymary@musicstuff.com

Evan, Watt, ew@gross.me

Judge, Jordan, jj@coolhouse.or.ke

That's done. Data can be in any format and later on, I'll switch to using a file database called SQLite that I absolutely adore.

Now, onto the file that's going to display all the data. For this, there's another technology that I'm going to use inside this template HTML file. Jinja2 - which I know. So it's best to keep within the scope of stuff that you know how to use. The Jinja2 templating language allows for variability inside a HTML file. This allows you to alter the data that's displayed based on the data, or other conditions. The Jinja2 programming language is not difficult to use. Together with Twitter Bootstrap they form a really useful framework for designing user interfaces.

Here's that file - display.html

<html>

    <head>

        <title>Data Display</title>

    </head>

    <body>

        <table>

            <tr>

                <th>First Name</th>

                <th>Surname</th>

                <th>Email</th>

            </tr>

            {% for row in data %}

            <tr>

                <td>{{ row.firstname }}</td>

                <td>{{ row.surname }}</td>

                <td>{{ row.email }}</td>

            </tr>

            {% endfor %}

        </table>

    </body>

</html>

That's it. That's what a HTML table looks like. The tags at each end <table>...</table> signify the scope of the table. The data between each <tr>...</tr> is a single row. And the data between the <td>...</td> tags is a single cell.

The Jinja2 programming part has some special tags also. It's inside the {% ... %} tags. That part needs some programming knowledge. There's another way to do this inside the code, but that will be a coding pages for another day.

Right now there's only one thing left. The actual application code. This is also not too complex, remember I'm trying to keep this exercise down to 30 minutes at the most, on a daily basis. So far we've written 38 lines of code, of which 4 lines are the data itself. And some of the code are single words (like <tr> to start a row).

Here's the program code in a file called app.py

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/input', methods=['GET','POST'])

def input():

    return render_template('input.html')

@app.route('/display')

def display():

    f = open('data.csv', 'r')

    data = [] # we'll keep the data in a list

    item = {} # each item is a dictionary.

    for line in f:

        line = line.strip().split() # this removes the newline

        item['firstname'] = line[0] # these remove any spaces end

        item['surname'] = line[1]

        item['email'] = line[2]

        data.append(item)

        item = {} # need to clear the dictionary.

    f.close()

    return render_template('display.html', data=data)

if __name__ == "__main__":

    app.run(debug=True)

And that's it. Another 20 lines of code.

Honestly, there was a tiny bit of debugging at the end, so writing this post took way longer than I anticipated. But writing the actual code was possibly much less than 30 minutes, including any debugging.

Here are screenshots of the HTML pages.

INPUT.HTML

DISPLAY.HTML

So that's the end of this coding session.

Of course, that's not a full application, the input.html part doesn't even work. If you type in it, nothing happens, but that's for later.

Motivation

MOTIVATION

I collect quotes. Words are powerful, they can and do drive you to action when you are stuck.

The general at the bottom of the hill wants his, or her, soldiers to charge up the hill. Not only are they outnumbered, but have a disadvantaged position.

This looks like a no-win situation.

We've seen the movies, the inspirational speech, the soldiers get fired up. There is purpose now. There is desire now. And there is an internal strength borne solely from words.

I may have a few inspirational books in my bookshelf, not too many. Most of them on leadership, some of them on creativity. I don't know if reading any of them has ever worked. I may have ended up exactly where I am by not reading any of those books at all.

---

INSPIRATION

But I think it's important to keep inspired. Inspiration fills an important part of existence, filling a gap to drive purpose.

If not solely for the purpose of finding the basic necessities of life, food and shelter, inspiration makes the activities meaningful.

To be inspired does not mean to be constantly in awe, on edge. But to have this sense that what you are doing is in sync with your being and feels great. Inspiration makes you feel satisfied. Full and complete. It makes you want to do and act, not to sit and sleep. And mostly does not wait for affirmation from others to tell you that what you are doing is right.

Sometimes, most of the time, quotes articulate the obvious in witty and intelligent ways. For example, Wayne Gretzky is quoted to have said, "You miss 90% of the shots you don't take." Quite obvious really. And why would it be motivational? That quote specifically has a challenge that has to do with the fear of failing. If you are afraid, then you don't act. When you don't act, well, it goes to say nothing happens.

So act.

The shoe company Nike has a good one too - "Just Do It."

WHAT I DO

I have a collection of quotes that I like, and I'm constantly building up my library. I have also written a small Python/Flask program to send me two of them daily. One at 6am early in the morning, and another at noon. I collected them and I know them all, but I still find it inspirational to be reminded of them.

A Word about Morning Pages

MORNING PAGES

The term and the practice was coined by Julia Cameron in her book The Artist's Way. It requires you to write three A4 (or letter-size) pages in the morning before you get your day going. Of course, she says it's OK to have a coffee, but the idea is that these three pages must be done in the morning before you do anything else, and that they must be done longhand.

---

WHY

Quite frankly, I don't think there's any reason that wouldn't sound like woo-woo. Many have tried to explain the intellectual, creative, experiential reasons, but at the end of the day, at least for me, it comes down to doing something enjoyable. The rewards are difficult to articulate but not complicated. For me, it comes down to holding a fountain pen, felt tip pen, gel pen, and sometimes a ballpoint pen, and letting words come out even if they don't form complete ideas. It's not about the content, but more the context, the place and the act. Like putting on a jacket, stepping out to my backyard, and walking up and down aimlessly. It's not specifically for exercise, but that I like the motion, to keep moving, one step at a time. And so I do enjoy just writing, or drawing lines, or drawing shapes and seeing what will happen.

If you don't like it, don't do it. It's quite that simple. And when we explore some of the things that Julia asks you to do, it will apply there also. There are some things that the book tries to codify which isn't meaningful for everyone, but has utility in trying to understand what the action, or direction, is trying to achieve.

I enjoy journaling, writing on a piece of paper, notebook, with a pen and paper. And so the Morning Pages come naturally to me. The fact that they are in the morning is because I'm fresher. And it's super quiet, especially since I'm up at 5:00 am. There's nobody about and I can sit and think quietly. Not so quietly since I love to listen to instrumental LoFi or classical guitar strumming.

---

LONGHAND

Tricky question. Julia insists that you have to do this longhand, but I don't agree. I do it longhand, but I think that there are valid cases for enjoying the morning pages typed.

Here's why.

Julia says that there's a closer connection to the words when you handwrite them. And this may be true for some, and it may be the case, sometimes, for myself. I have since come to understand that I think on paper. Which means that I like the act of writing down something that I'm thinking of, and then looking at the same thought, but now on paper. And when I write things down on paper, they are part of the thinking process, not the result of the thinking process.

Here's an example of something that I could write.

... should leave early, say 7am, get on the highway, but last time I was on it, got stuck, so perhaps 6:30am may be better, I really should be keeping track of this traffic thing if I want to get anywhere, is there any rush to getting there early? Work backwards, let's see if wasting a couple of hours on the road ...

You can see from that blathering, it's something that could have been going on in my mind, didn't need to be written down at all, but I have notebooks upon notebooks with stuff like that, and sometimes, rarely though, I go back and I can now understand better my thinking process.

SPEED

This is the first consideration when handwriting. When I handwrite, it's slow. It's very deliberate, that's a good word to hold on to - deliberate. The act of putting each word down is very conscientious. There's no going back with backspacing, so there's a greater sense of commitment, of permanence. And of moving forward. But it is slow.

But the brain is fast. By the time I've finished handwriting the sentence, my brain has had a couple more thoughts which I've already forgotten.

FATIGUE

Handwriting is a physical exercise, so your hand gets more tired than when typing - for the same amount of text. Granted, if you type a lot for a living, then your hand will eventually get tired even typing and you may get to the point where you are making tons of mistakes. But typing Morning Pages isn't (or should not be) one of them. Even typing slowly, you can hit the mark of 750 words (which seems to be the consensus is 3 handwritten pages) fairly easily and quickly.

ART

Typed pages are uniform, sterile almost. Handwritten pages are artistic. The same handwritten word doesn't look the same anywhere on the page. And if you can get lost in the "craft" of handwriting, the feel of the pen in the hand and how each stroke is being made, then writing gets close to art.

---

TECHNOLOGY / TOOLS

Let's not forget that like a computer, the pen is a piece of technology that was also invented at a point in time. It's quite an amazing little thing that you can carry around an instrument, together with a parchment (paper) that you can record what is going on, for review later.

This is essentially what a tablet, or laptop, can do as well.

Those who say that writing is "more natural" aren't being honest. Writing is as natural as typing. The alphabet that we use, the letters that we make with a pen are all symbols created and when we use a brush to draw something, we are also using technology.

A pen, a computer, a piece of paper, a wall, the back of a napkin, it's all good.

It's all a learned skill and each generation comes up with tools to do things better. There are some novelists who find it more creative now to write their novels on the tiny keyboard of a smartphone. Go figure.

And so the directive to handwrite (or longhand as Julia refers to it) should not be an absolute must. Perhaps in your own way, you find that hitting each key on a keyboard gives you the same connection with the letters and words, that someone holding a fountain or ballpoint pen would.

---

THREE PAGES LONG

Finally, a word about quantity. I have a problem with this blog, I can normally get started on a piece, because I have something to say, and then get bogged down in the details of articulating it and never finish. 

You'd be surprised at the number of drafts that I have started that have never been finished.

Julia says that 3 pages is about the right size. 3 A4, or letter size, pages. That's a lot of writing, that's a full article, every morning. Even though you're not really writing for publication, and content should not matter, it's difficult to write without thinking. You must think and so the inner voice must have some sort of content in mind.

Claims online that this should take 20 to 30 minutes seem exaggerated. Unless, of course, the handwriting is so big that you can whip off a page in 10 minutes. But writing a page of A4 is not so easy. I can manage close to 10 minutes on the paper size I use (possibly an A5 (10" x 7")) but that's in a real rush, and that's not enjoyable.

My own comfort zone is about 15 minutes per one page of roughly 10" x 7".

Someone online wrote that Julia's direction to write 3 pages equates to 750 words. Many people seem to think this is accurate, and so I counted some of my pages. I average about 320 words on a page (10" x 7") so 2.5 pages should do it for me. But there are some days I've gone to four, the most frequent though was 3. That's over 900 words.

Am I overdoing it? I don't think so. For the most part, I'm really not concentrating at all, I'm writing quite slowly, massaging each letter and word and feeling the stroke from the pen on the paper. I figured that trying to get to the end would spoil the enjoyment in the middle, so I really, really, really try very hard to simply concentrate on making the word that I'm writing count.

Count in terms of experiencing it. So when I write the word "actually" in longhand, each letter gets a musical expression, the a - the - c - the - t - the - u - the - a - the - double - l - and - the - y. By the time I finish writing the word "actually", I have had an "actually" experience.

It's slow.

It's purposeful.

It takes time.

And I don't watch the clock.

I think 2 pages is the right amount of time to get this right, and for it to mean something. Otherwise, it is possible to get to the end quite tired, and a little frustrated.