If you missed the first article which covers how I managed to get my first script completed and working, including how I broke down the script to learn it in parts, You can check it out by clicking here.

Today we will be moving onto the second and third parts to reveal how the complete script looks, and the concepts I have managed to grasp. Because I am excited with the fact that i can write the whole script without checking previous versions, I will start by showing the full version of the script as I now prefer to write it, and then we will move on to the breakdown.

I initially planned to write an article for each part, but since I spent the last couple of days practicing, and I managed to comprehend the script much faster than I thought, I figured I might as well write about both parts so I can move on to practicing the second script: read_journal.py.

If anybody is following the series, please feel free to leave a comment and let me know if I should have wrote an article for each path, or if this combination was okay. I will surely take your feedback into consideration for future articles. I also want to welcome my first 🎉🙏🏽, I hope you find value as we walk this journey together.

Now, let’s take a look at how my script looks.

1. Full write_journal.py Script:

import os
from datetime import datetime

def write_entry():
    # Paths
    jfpath = os.path.join(os.path.dirname(__file__), "journal_files")
    os.makedirs(jfpath, exist_ok=True)

    # Datetime and File naming
    fmt_date = datetime.now().strftime("Date: %Y-%m-%d Time: %H:%M:%S")
    f_name = datetime.now().strftime("%Y-%m-%d_%H-%M-%S") + ".txt"
    f_path = os.path.join(jfpath, f_name)

    # entry and file creation
    entry = input("How was your day?:")
    with open(f_path, "w") as file:
        file.write(f"{[fmt_date]} {entry}")

    print(f"file saved at: {f_path}")

# call function
if __name__ == "__main__":
    write_entry()

Excited as I am that I understand the functions in this script enough to consistently write it without help, I must admit that I am not writing it clean without bugs, i.e missing a letter here or a comma there.

It bothered me at first, but apparently, even the decades long experienced coders still go through that experience. So it doesn’t bother me anymore, especially considering that I am able to understand the errors and correct them on my own.

We will cover some of the bugs as I go along the breakdown of this script. on the last article we already covered the paths section of the script.

Now we will get into the datetime and file naming part, as I reveal what I have learned below.

2. Datetime and File naming:

Datetime.now() is the function that captures the local current date and time at the exact moment when the function is called in the code. i.e it captures the year, month, day & Hour, minute, second.

strftime() is a method that specifies how a captured datetime should be represented as a string. In full the method’s name is “string format time”, which makes it self explaining for me to understand, so I think of it as taking the raw datetime and formatting it to be shown the way I want it to.

Together, I learned to use these to record a formatted time that will appear next to my entries, and another format of datetime which I use to name each new file with the date and time that the file was created.

After some experimenting on my own, I even managed to figure out how to make even more variations of how the date and time appears in my entries. Which is why I now added the words “Date:” and “Time:” to my {fmt_date} variable.

# Date time and File naming

# First i assign a formatted datetime to a variable called fmt_date for use inside my journal entries
fmt_date = datetime.now().strftime("Date: %Y-%m-%d Time: %H:%M:%S")

# Then i have to use the same function and method to create a file name
f_name = datetime.now().strftime("%Y=%m=%d_%H-%M-%S") + ".txt"

# I use os.path.join to define the file path inside f_path using the file name
f_path = os.path.join(jfpath, f_name)

We have to create two separate formats because inside a file you are free to use any characters as you write, but naming any file or folder is a different story.

Operating systems do not like file names with characters like colons (:) in them. I think it is because most of these characters are reserved for the os to use for instructions and other operations.

We also do it separately because we have to add the “.txt” at the end of the file name to let the computer know that it is a text file the next time we want to access it. One of my most reoccurring bugs is that I often forget to add the file extension at the end.

Another bug I often come across here is, at the top of my script when I am importing. I will often only write import datetime instead of from datetime import datetime, or I might misspell datetime when I write it the second time.

we covered os.path in the previous article so I wont go into it now.

That was the datetime and file naming section, let’s dive into the last section of the script below.

3. Entry and File Creation:

This was the hardest part for me to fully understand, which is where I also make most of my mistakes, but I am satisfied with the fact that even if I make a mistake and get an error while running the code, I easily know what the mistake is and I can easily correct it.

input() is a function that will prompt the user for input from a device’s keyboard, which we then assign to a variable called “entry”. The function allows for a prompt to be written inside of the inputbrackets, similar to the print function, incase a developer may want to guide a user on what kind of input to insert i.e; “How was your day?”.

open() is a function that simply takes a file path and opens that file. We can further let the program know what will be doing with the file by using the argument “w” for writing into a file, there are other arguments such as “r” for read, “a” for append, and more I think. (I often do not remember if I should add a comma after the file path or not.)

with is a statement that is used together with the open() function, it ensures the file is properly opened, but most importantly that it is automatically closed as soon as the program moves out of the indent area.

I learned that this makes the file handling smoother, and this is how almost all of files will be opened and closed by coders to avoid file corruptions and errors.

write() in write.file is a method that takes string inputs and returns them into the file that was opened. This method behaves according to what argument was used while opening the file. (Here I often get confused as to whether file or write comes first, I always end up writing it the other way and correcting it after running the script.)

Another thing I do is, I will often use the journal folders path instead of the file path in this section.

But when I get confused I just do it the way I think is right and run the script instead of checking the completed script, I feel prouder of myself when I fix the code this way.

Here is the code with some notes.

# Entry and File creation

# I use input to take a simple text based entry with no special formatting since this only runs in my terminal
entry = input("How was your day? ")

# Using (with open) we open the file path as a file to write "w" into it
with open(f_path, "w") as file:
    # Then we write the formatted date and entry into it
    file.write(F"{[fmt_date]} {entry}")

# then we print to let ourselves know the script ran sucessfully
print(f"file saved successfully as: {F_path}")

Conclusion:

I am now confident enough with all that I have learned above to move onto the next script; “read_journal.py”. I have also been experimenting more with the format, I am able to add new lines to make the entry look cleaner, I will cover this in the future.

With only this basic script, I have learned that once you push past the frustration it actually gets very exciting and dopamine-y when you start to get clarity and understanding.

I am afraid that if it continues like this I might start coding for the rush rather than anything. Haha I am joking… Probably ;-).

If you found anything of value in this article, please consider following the blog and commenting, I would like to know what you think of my journey or any advices that you may have.

I will soon start working on the second script and an article for it as soon as I feel like I have learned it thoroughly.

Until then🫡.

On my very first article, which you can read at www.obakengcodes.com, I mentioned how I was driven to learning how to program by my deep frustration of not finding a notebook style app that was tailored to my specific desires.

Today we will take a more technical look at how my first script looked, and what I have learned from it so far. Lets dive into the beginning of my_journal_project:

1. The Full write_journal.py Script:

This is what the final product of my AI generated script looked like after some hours of debugging and mostly slow manual typing errors:

import os
from datetime import datetime

def write_entry():
    #1. get the current script directory(where write_journal.py is located)
    script_dir = os.path.dirname(os.path.abspath(__file__))

    #2. define the journal folder path inside the project directory
    journal_folder = os.path.join(script_dir, "journal_txts")

    #3. Ensure the journal folder exists(create if missing)
    if not os.path.exists(journal_folder):
        os.makedirs(journal_folder) #makes the folder if its not found
        print(f"file path: {journal_folder}")


    #4 Get the current date and time
    right_now = datetime.now()

    #5. format for display in the log
    formatted_date = right_now.strftime("%Y-%m-%d_%H:%M:%S")

    #6. create a safe filename based on the date and time(for uniqueness)
    file_name = right_now.strftime("%Y-%m-%d_%H-%M-%S") + ".txt"

    #7. combine folder path with the new filename
    file_path = os.path.join(journal_folder, file_name)

    #8. Prompt the user for their journal entry
    journal_entry = input("Tell me about your day:\n >")

    #9. wrap the entry with a timestamp for context
    log_entry = (f"[{formatted_date}] {journal_entry}\n")

    #10. write the entry to a new file inside journal_txts
    with open(file_path, "w") as file: # "w" = create new file
        file.write(log_entry)

    #11. confirm success to the user
    print(f"Entry saved successfully as '{file_name}'")

if __name__ == "__main__":
    write_entry()

2. What I Am Still Learning:

After getting the script to actually work, I moved on to typing the two remaining ones. After the week long process of typing and debugging the codes so they could finally work well together. I realized that I really didn’t know how any of the code worked well enough for me to actually code it on my own.

I at first attempted to write the whole def write_entry() function from memory without looking. but after botching the paths section, I just couldn’t get a single line of code out of my memory to write the rest of the script. That is when I got humbled further and had to settle on practicing only parts of this one basic script before I could move any farther.

The logical option seemed to be to start at the top and start working my way down, so as I went over the script, I decided that breaking it down into these three parts would work best for me according to what I understood the script to be doing at the various paths;

1. Paths and directory creation

2. datetime and file naming

3. entry input and file creation

I am only just starting to get a good enough grasp of the first path to actually be able to reliably write it on my own and even make longer and compact(shorter versions) of that part of the code, and understand how they relate to each other.

Once the Ai I am working with noted the progress I was making in grasping os.path… it started mentioning pathlib, which it said makes path scripts cleaner and allows for more functionalities, but I made a conscious decision to keep focusing on os.path for now and only explore pathlib when i get a confident grip on os.path.

Now that we have established what I am learning and what is still to be learned, let’s take a more focused look on how I have been practicing the paths part of the write_entry() function.

3. How The Learning Looks:

After breaking the code down to three parts, the paths part included everything the script was doing from note #1 to #3. I went back to both deepseek and chat gpt, I find that getting two different perspectives helps me understand better and asked for a breakdown of each line of code to actually understand what os.path was actually doing in each case because writing from a place of understanding beats writing from memory by a long shot.

This is what a break up of the paths section of the script ended up looking like:

def write_entry():
    # Paths
    # 1. os.path.abspath gets the "directions"/path to the current script; write_journal.py
    current_file_path = os.path.abspath(__file__)

    # 2. os.path.dirname gets the path of the folder where write_journal.py is saved
    scr_dir = os.path.dirname(current_file_path)

    # 3. os.path.join defines a new folder path "journal_txts" and joins it inside of scr_dir
    journal_folder = os.path.join(scr_dir, "journal_txts")
    # the folder is not yet created, this line points to where it is expected to be found

    # 4. os.path.exists checks the address given to see if the folder is there
    # 5. And if not, os.makedirs creates the folder at that address before moving on
    if not os.path.exists(journal_folder):
        os.makedirs(journal_folder)
        print("journal folder created successfully.")

How it looks without the notes:

def write_entry():
    import os

    # paths
    current_file_path = os.path.abspath(__file__)
    scr_dir = os.path.dirname(current_file_path)
    journal_folder = os.path.join(scr_dir, "journal_txts")

    if not os.path.exists(journal_folder):
        os.makedirs(journal_folder)
        print("journal folder created successfully")

Anybody with more experience in python than me(beginner) can tell this is the longer way of doing this simple task, but practicing this breakdown a couple of times helped me understand what each line of code was doing. And only when I was confidently reproducing this process multiple times on my own, that is when my mind started experimenting with shortcuts and picking up where I could squeeze more work into one line.

As you will see, compacting is not really about skipping any process. It is more nesting each task into the same line, so understanding each line first is vital.

After a few failed experiments and asking why some of my compacted lines weren’t working, I got to the point where I could do all of the above work in as few lines as possible.

like this;

def write_entry():
    import os

    # Paths
    jfpath = os.path.join(os.dirname(__file__), "journal_txts")
    os.makedirs(jfpaths, exist_ok=True)

jfpath = assigns the result of everything that happens on the right side to the the variable jfpath(journal folder path) on the left side.

os.path.join() joins os.path.dirname(__file__) the directory name where the script or (__file__) is saved, with the name of the folder we want to create inside of that directory “journal_txts” all on one line.

Then os.makedirs(jfpath, tells the computer to create the folder we want, but exist_ok=True) also tells it its okay/or to ignore the instruction if the file already exists. This is a neat little trick AI suggested after establishing that I fully understood if not os.path.exists():.

4. Conclusion:

Today I can break this paths concept down and write variations of this code without even opening my code editor or one of the chat bots. This makes me really proud of myself and now I look forward to learning more concepts as my_journal_project progresses further and grows in complexity to include sql database file handling, rich text editing, UI, and more…

If you would like to see how I moved on to practicing and improving on the second part of the code; datetime and file naming, consider bookmarking my website as I plan to publish that part soon. It turns out that I actually enjoy writing these blogs and documenting my journey, and I will be writing and posting much more frequently than I thought, I hope you learned something from reading up to this point.

print(“May your coding journey be fulfilling and fruitful. Until next post ;)”)

LOL, I remember how I would always substitute the character with myself, racing against time in front of a computer screen full of code, trying to remotely deactivate a world threatening device. Unfortunately though, due to socio-economic reasons, coding remained a fantasy out of reach for all of my childhood and half of my twenties. It became a forgotten dream that would almost never be revisited again.

Fast forward to today? Well, I am now old enough to buy myself a second hand pc, but… lets just say my first attempt at writing a functional script took the Hollywood right out of the fantasy, lucky enough though, I now have more reasons to learn how to code than just to look cool and be the guy that saves the world under the pressure of a countdown timer. Although, I wouldn’t mind that too :).

I will spare you the sob roller-coaster ride story that has been my life, and jump straight to this year; 2025. So what finally pushed me to setting up an environment and learning an actual programming language? and no, it was not to rekindle the childhood Hollywood driven passion of coding - it was something more immediate.

1. 2025 And What Pushed Me To Commit:

POV: It’s 2025, I have been working under a fixed-term contract with a minimum wage stipend for 3 years and 10 months, the struggle is real and I am fed up to the core of my soul with the empty promises of permanent employment with a full salary and benefits. But, I cannot just leave…

After nearly 4 years of temporary contracts and empty promises, I realized that no one was coming to rescue my career. If I wanted change, I had to build it myself.

Enter the “How to make money online?” phase, I spent months looking up and trying things I could do to make money online. Just a few that made it on my list; drop shipping, forex trading, YouTube Channel… and more. Most didn’t work for my budget, and others just frustrated me more than I could handle.

Around this same time, I was doing a lot of personal work, budgeting, and business ideas noting all on my phone using various journal type and note taking apps, most of which are just not made for the way I want to organize my thoughts, research, and ideas. This is when my frustration reached a tipping point and I wondered, wouldn’t it be nice if I could just design my own notebooks app? Something I could use for years to come and put an end to this daily frustration loop, while I try to improve my life.

I had no other option but to embark on this journey as a solo learner, I wasn’t leaving the job to enroll in some college, and I definitely wasn’t paying for a course… Even if I wanted to.

I had my reason to start, I knew I was doing this solo.

And so the journey began.

2. The First Steps:

A quick short-cut:

I surprisingly didn’t take long after that thought to actually start writing my first line of code, I skipped the hours and hours of confusing YouTube video sessions phase I hear so much about. Because I had already been using Ai chatbots like DeepSeek and chat gpt to learn a lot of other things much faster than I would otherwise, my first instinct was to open up both bots and start discussing what it would take to learn programming and what the best route for a complete beginner would be.

I had already witnessed the potential of AI in my own life, so there was no way I was choosing any path that wasn’t of the least resistance for me, considering that I also have a day job to do and thus cannot dedicate all my time to just learning how to code, this was the way for me.

I will get more technical on another article I plan to write as soon as I have published this one. so the short version of what I got out of this was;

1. You have to choose a language based on your industry of interest

2. Build your environment

3. It is best to start with a project as soon as possible rather than to bury yourself under theory that you might have forgotten by the time you actually have to write your first project

4. I also got a lot of project planning help in terms of how to structure a project and break it into manageable phases.

Choosing a language:

All I wanted was a language that would get me to the completion of my journal/notebook project as fast as possible, I didn’t need to build rocket systems, data analytics tools, or the next amazon website.

After doing some research on the various languages and looking at videos of what I now know to be their syntax, I decided that python would be the quickest for me to understand and actually see results in, otherwise I was afraid that I might give up along the way and run out of patience if I had chosen one of the difficult languages.

All I needed to know was that python would work for the program I was trying to build and I was sold, I figured if I could learn to think like a developer and understand how to use one language, I could transfer those skills, discipline, and patience to a more advanced or “valuable” language.

Building an environment and writing my first script:

With the help of AI, I was able to understand that all I needed as an environment to start working with python was two things; 1. Python itself which I got from python.org, and 2. A code editor, I ended up choosing vs code because it was free and had all the features I needed to start coding. I figured anything else I would add into the environment as I came upon the need along my coding journey.

First coding experience:

After the famous print(“Hello World”) script ran successfully, it was time to move on to the journal project.

When I said I was taking short cuts earlier, I really meant it. Within 30 minutes of installing my environment I was already writing the first script for my journal project. I was leveraging the power of AI, and all I would do is have the AI generated code on one part of the screen while I was manually typing it into vs code, line by line. I basically got handed three scripts; write_journal.py, read_journal.py, and main.py.

Another issue less mentioned in the beginner coder industry, is the painful process of being forced to learn to type the right way with both hands and proper finger placement. And because i didn’t want to struggle with this for months, I decided that I would only code using the right method so I can keep my eyes focused on the editor. It took me +4hrs to type and properly debug the basic 30 line script (because yes, chatbots are far from perfect, and my fingers were just not up to the task yet.).

My forearms and fingers were sore, my brain was hot from trying to solve all those bugs, and all i had to show for it was a script that took string input, and saved it to a .txt file, using the current datetime as title for the document. And yet, I was proud, I slept like I had laid the foundations for the next billion dollar program, I bet Mr. Zuckerberg couldn’t have felt any prouder than this when he made progress while founding his social media site.

I did the rest of the basic version of the .txt file writing and handling program, I thought I would be building a OneNote style notebook app within months with the help of AI. But it turns out when you tell it you are a beginner, it will really take you through the basics before showing you anything complex.

2. What’s Next?:

Because now I know what is really not possible, I have calm down with my projections and expectations. I find myself studying the same basic 3 script with +- 30 lines per script program to fully grasp what I am telling the computer to do. I enjoy challenging myself to rewrite parts of the script to help myself fully grasp the concepts of creating functions and how the existing ones work. I also get a rush when I spot a few lines of code that can be compacted into one line and to see it actually work.

My journey is not starting off perfectly, but I do love the progress I am seeing and I know I will improve on my journey and how it is structured as the time goes on.

I have decided that I need a way to document all the progress I am making, and what better way than a blog? i plan to create a few sections of the blog to focus on various topics. But the one I look forward to most is one that will focus on the technical knowledge as I learn it, because I believe that the best way to learn is by teaching. This blog will also help me get the typing exercise that my fingers need so I can reserve my mental energy for understanding syntax and logic while I learn.

There is so much ahead to look forward to. I am also learning about collaboration sites like Hashnode, github, and more where I will also get to learn from people with years of experience and possibly rethink and restructure my learning journey.

As of yet, I am still doing research on potential career or business paths to consider so I can shape my journey along such paths.

Follow along as I turn these 30-line scripts into a full journal app. Next up, I’ll be diving into the actual code and sharing what I am learning about Python functions and file handling.