Planetpython on Janusworx

derb; Script to Create podcast RSS feeds

feedback@janusworx.com (Mario Jason Braganza) — Thu, 14 Sep 2023 17:38:03 +0530

I wrote a tiny script that creates an RSS feed for all the audio files it finds in a folder.
I call it derb.

My mother gets devotional songs and sermons on cds, which I rip to MP3 files and then dump on her phone for her.¹
She listens to them all the time, and now three of her friends want to do the same too.
I thought of just sticking them in my self hosted Jellyfin instance,² but then I realised, all of them have erratic, slow internet. So the idea of self hosting a podcast feed really appealed to me.

So I quickly used Feedgenerator in conjunction with Tinytag, to whip up a script that’d help me do just that. The code’s up on Github, if you want to go install and play with it yourselves.

Here’s a quick walk through derb.py.³

Setting up house
#

We set up a place to accept a path containing the files. The feed will ultimately be placed as a feed.xml in the same folder as well We then walk through the folder (after a really basic sanity check) and gather all the files into a list.
The base_url is where the feeds (along with the audio) will be served from.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


base_url = "https://ab.janusworx.com"

book_folder = input("Paste path to audiobook folder here: ")
book_out_path = base_url + (book_folder.split("/")[-1])
file_list = os.walk(book_folder)

# Do a basic check on the validity of the path we get, 
# before we build the audio file list.
try:
 all_files = (list(file_list)[0][2])
except IndexError as e:
 print(f"\n\n"
 f"---\n"
 f"ERROR!: {e}\n"
 f"Have you typed in the right path?\n"
 f"---\n")
 sys.exit("Quitting script!")
audio_files = []
for each_file in all_files:
 each_file = Path(each_file)
 if each_file.suffix in ['.mp3', '.m4a', '.m4b']:
 audio_files.append(str(each_file))
audio_files = sorted(audio_files)

Creating a feed
#

We now go about the business of setting up the feed proper.
To begin with, we grab the first file we can get our grubby paws on, and create a TinyTag object that’ll give us a lot of metadata. (If there isn’t any, we quit.)
Oh, and by the way, how do I know what data I’d need to create a feed? I just cribbed everything from the Feedgenerator’s excellent documentation. I also looked at the widely linked to, RSS reference page for clarification if I got confused.

We then, instantiate create a feedgenerator object along with the podcast extension.
Following which, we supply the feed a title, an id⁴, feed author details, a language, podcast category and description.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


# Setup a feed
## Grab feed metadata from the first audio file
feed_metadata_file = TinyTag.get(Path(book_folder, audio_files[0]))

## Grab title from metadata file.
## At the same time, break out if there isn’t any.
if not feed_metadata_file.album:
 sys.exit("\n---\nStopping feed creation.\n
		Setup audio file metadata with a tag editor")
feed_title = feed_metadata_file.album

## Creating feed instance
audio_book_feed = FeedGenerator()
audio_book_feed.load_extension("podcast")

## Setting up more stuff on the feed proper
audio_book_feed.id(base_url)
audio_book_feed.title(feed_title)
audio_book_feed.author({"name": "Jason Braganza", "email": "feedback@janusworx.com"})
audio_book_feed.link(href=f'{book_out_path}', rel='self')
audio_book_feed.language('en')
audio_book_feed.podcast.itunes_category('Private')
audio_book_feed.description(feed_title)

Adding episodes and writing out the file
#

After which it’s then a matter of looping through that audio file list we created and adding them as entries to the feed object we created.
Once again we grab the metadata from each file, using Tinytag, and then set each feed entry’s details (title, id and enclosure).
I’ve hardcoded the mime types, since I know I only have two basic type of audio files. If you don’t know what kind of audio, you might be serving, the mimetypes-magic package should help.
Finally we write it all out to a file.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


# Loop the file list and create entries in the feed

for each_file in audio_files:
 each_file_metadata = TinyTag.get(Path(book_folder, each_file))
 episode_file_path = Path(each_file)
 episode_suffix = episode_file_path.suffix
 episode_mime_type = 'audio/mpeg' if episode_suffix == '.mp3' else 'audio/x-m4a'
 episode_title = each_file_metadata.title
 episode_size = str(each_file_metadata.filesize)
 episode_link = f"{book_out_path}/{each_file}"
 
	audio_episode = audio_book_feed.add_entry()
 audio_episode.title(episode_title)
 audio_episode.id(episode_link)
 audio_episode.enclosure(episode_link, episode_size, episode_mime_type)

# Write the rss feed to the same folder as the source audio files
audio_book_feed.rss_file(f"{book_folder}/feed.xml")

Serving
#

Once done, I moved it all to my trusty Pi, which runs barebones Nginx with a single bare page, protected by basic auth.

I decided not to publish the feeds publicly.
Rather I’m going to just set it up in their podcast players, when I meet them, or pass it over to their kids over Signal.⁵
It’s already worked with three of them, so everyone’s happy and here’s me hoping, fingers crossed, it’ll be easy to support in the long run.

Update (2023-09-15): Guess I’m using it for myself too, now 😂

Feedback on this post? Mail me at feedback@janusworx.com

P.S. Subscribe to my mailing list!
Forward these posts and letters to your friends and get them to subscribe!
P.P.S. Feed my insatiable reading habit.

Yes, while it’s slowly moving to Youtube, that world still mostly depends on CDs and USB sticks. ↩︎
the audio files, not my mother’s friends. ↩︎
Large parts are elided. Please look at Github for the actual file. ↩︎
normally, the site it’ll be served from ↩︎
Why should I be the only one doing family tech support? ↩︎

TIL: The Difference Between a CLI Tool and a Freeze Tool

feedback@janusworx.com (Mario Jason Braganza) — Wed, 01 Mar 2023 11:35:47 +0530

I keep writing these tiny utilities for myself in Python and while I love writing in Python, I definitely don’t enjoy the little war dance I have to do everytime I want to run it on a new machine. Keeping track of virtual environments, and then installing packages in them, quickly gets tiresome. I want to just run the program once I’m done with it. Like a C program. Or Rust. Or Go.

I could go learn one of those languages. Sure. That’s an option.
And I see no problem doing it for other needs (like if I’m working with a group that uses said language) or for my career’s sake or just for being a polyglot.

But when I write for myself, I’d rather stick to Python.
Its mental model fits my brain. I find writing Python joyful.

So what’s a boy to do?
Since I was writing CLI applications, I went and looked for how to write Python CLIs and I found argparse and Typer and Click and I was confused. They didn’t seem to give me my executable. They had all sorts of other powerful features, but the one I wanted.
And I went looking some more. And the penny dropped.

What I wanted, wasn’t a way to build a CLI, (although that is what I was writing).
What I wanted, was a way to bundle my environment into an executable.
What I wanted, I learned, was a way to freeze my code.

More searching led to Nuitka, PyOxidizer, PyInstaller and their ilk.
I went with Nuitka, because that is what I found first and what I found was dead simple

python -m nuitka --static-libpython=no mastodon-to-moi.py

and boom!
I got myself an executable mastodon-to-moi.bin!
And then I got greedy and did a mastodon-to-moi.bin --help and figured, that’s where the cli/tui frameworks like Typer and Textualize, come in handy. To scaffold and help these interfaces.

But when I ran it on my laptop, which has nothing other than system Python, it hiccoughed. I tried Pyinstaller next, and that too, did not do the trick. It choked on a loop, that worked when I ran it as with Python normally. PyOxidizer scared me off.

This needs looking further looking into, but atleast I know what I need to do now

Afterthought: The one con I do see, is losing platform independence. My binaries will be Linux on Intel only.¹ I could just take my Python source anywhere, set up my environment and go. Well, I still have that option if I need it and in the meanwhile, having binaries affords me a lot of convenience.

until I learn to cross compile that is. ↩︎

Updated Poemfeed

feedback@janusworx.com (Mario Jason Braganza) — Fri, 27 May 2022 18:52:00 +0530

Update: fixed Github link

The little script I wrote in 2020, to get me my daily poetry fix, died a couple of months ago.
Life got in the way of me, figuring out what was wrong.

I finally got around to it today.
A little bit of peeking under the hood revealed that Cloudflare did not like me using the Python Requests library to check the Poetry Foundation page.
Or maybe it just did not like the useragent string that Requests gave it.
I was in no mood to go down that rabbit hole, so I just went looking for modern alternatives to Requests.
Found HTTPX.¹ and switched over to it.²
And then while I was at it, replaced PyRSS2Gen with FeedGenerator.

And tada! Poemfeed lives again!
Find the updated code, over on Github.

Writing code today, made me realise, how far I have come since I wrote that code.
I figured out the issue, I knew just how I wanted it to work, I went out, researched the code, and then wrote and iterated over the code and got it working in a matter of hours.
Kushal was right.
Writing lots of shitty code, over and over and over again is the best way to get fluent.
Here’s to more contributing and lots more of writing code!

P.S. Subscribe to my mailing list!
Forward these posts and letters to your friends and get them to subscribe!
P.P.S. Feed my insatiable reading habit.

which delightfully, has a Requests compatible API ↩︎
and to be sure, changed the userstring, so that my script presented itself as Firefox ↩︎

Starting up #CNC2021.

feedback@janusworx.com (Mario Jason Braganza) — Tue, 20 Apr 2021 19:06:06 +0530

Enough learning.
I now have to drill what I’ve learnt over the past few weeks and months by writing lots of code.

Been noodling around with what that might look like in my head. Here’s what I got.
After tentatively coding up stuff in a couple of domains and after a short chat with a friend, I realise I love writing code for the web.
I love reading.
I love to write on my blog.
I love that with just a few keypresses, my words can be read by anyone on the web, no gatekeeper required.
I would love to write code to enable this for more people.
I would love to play and tinker and push at the boundaries of this domain. This intersection of all this is web development.
Ergo, I want to become a web developer.

So while I have learnt and watched and written a bit of code and understand how programming works, what I need now, if I want this to be my second career, is fluency and a portfolio.

To that end,

I need to do all sorts of basic exercises in the languages I am learning (Python/HTML/CSS/JavaScript)
I need to find and contribute to open source projects, to get a feel of how it is to work with folks and to understand how this whole world functions
I need to write toy projects for myself.

Learning by my ownsome was a tremendously hard, extremely lonely task.
I don’t want to repeat that mistake again.
So, to start with the “doing”, I’ve signed up at Code Newbie for their #CNC2021 challenge.
Lasts 5 weeks, and I’m already a couple of days behind, but never mind that.
I also stretched a bit and signed up for the Code More challenge.

As to what’s involved, I have no clue, yet.
Will wait up for their emails and then do the work and write all about it here.

I Can’t Do This Yet … Updated

feedback@janusworx.com (Mario Jason Braganza) — Sat, 17 Apr 2021 14:33:15 +0530

Updated version of the post. I seem to have somehow, mangled the old one.
I’ll just blame it on the gremlins in the cloud.

I’ve been “soft” looking for a job, since the end of last year when I learnt the basics of Python.
(Want me to come work with you as a junior developer? Here’s my resume!)

And I’ve had rejection after rejection after rejection.
I apparently am good.
I have skills.
I could be an asset for companies.
But I am not “quite” what folks are looking for, not quite right for them.
I am not quite what it is, folks are looking for, to take chance on.
I am a square peg …

And while I understand this in my head, my heart does not get it at times.
And that’s when Seth, as usual comes to the rescue.
With a word, that I am increasingly using to mentally toughen myself and give me courage.

Yet …

From A Professional Stumbler …

Leo’s working hard to do something he’s never done before. He’s just turned one, and he doesn’t know how to walk (yet).

There are no really useful books or videos on how to walk. It’s something he has to figure out on his own. But instead of waiting on the couch until the day he’s ready to proudly strut across the room, he’s there, on the floor, every day, trying it out.

He’s already discovered a hundred ways that don’t work, and stumbled countless times.

But he persists.

I don’t know about you, but this is precisely the way I learned how to walk as well.

In fact, it’s the way I learned how to do just about everything important. By doing it.

From A Simple Missing Word …

“Yet”.

You can append it after any sentence related to your journey of achievement and contribution.

“I haven’t finished the project”
“I haven’t learned how to juggle”
“I haven’t made the sale”

YET.

And along the way, “Yet” turns “can’t” into “haven’t.”

Yet isn’t the result of brazen persistence. It’s what we earn with learning, insight and generosity.

From So Far / Not Yet …

What to do in the face of failure? What happens when you’ve done your best and it still doesn’t get the review, close the sale or win the race?

… The growth mindset, is to realize that while you did your best, it’s not your best forever, it’s just what you’ve done so far. And that while you haven’t created what you set out to create, the key word, the one you have to remind yourself of daily, is yet.

From You Have No Credibility (yet)

Your belief, even your proof, is insufficient for you to get the attention, the trust and the action you seek.
Attention is not yours to take whenever you need it. And trust is not something you can insist on.
The bad news is that you are not entitled to attention and trust. It is not allocated on the basis of some sort of clearly defined scale of worthiness.
The good news is that you can earn it. You can invest in the community, you can patiently lead and contribute and demonstrate that the attention you are asking be spent on you is worthwhile.

So yes, I might not be up to par, might not match up to what they look for, might not be skilled enough … yet.
I’ll get there, soon enough!

“You’re not that good”

And of course, Seth has to read my little blog and riff off my post :P
I kid. He doesn’t even know I exist. But talk about happy serendipity!
You’re not that good, spells my journey up above in beautiful detail.

The first is that when we begin, we’re not that good. This is a fact. The breakthrough for anyone on this journey is adding the word **“yet.” **

It doesn’t pay to pretend that we’ve figured it out before we have. It’s counterproductive to adopt a brittle attitude in the face of criticism. In fact, during this stage, “you’re not that good,” is precisely what we need to hear, because it might be followed with insight on how to get better.

The second is that once we start to build skills and offer something of value, some people are going to persist in believing that we’re not that good. Fine. They’ve told us something about themselves and what they want and need. This is a clue to offer our leadership and contribution to someone else, someone who gets what we’re doing and wants it. The smallest viable audience isn’t a compromise, it’s a path forward. Find the folks who are enrolled and open and eager. Serve them instead.
The danger is that when you hear rejection during this stage, you might come to believe that you’ve accomplished nothing, as opposed to realizing that you might simply be talking to the wrong people.

And the third comes full circle. Because it’s possible that in fact, we’re not that good yet, and there aren’t enough people who want what we’ve got. We’re simply not good enough for this part of the market. So we embrace that truth and begin at the beginning. We’re not good enough yet. We haven’t practiced enough, found enough empathy, understood the genre well enough and figured out how to contribute. Yet. At least for this audience.

And then we get better.

A Love Letter to Books

feedback@janusworx.com (Mario Jason Braganza) — Thu, 08 Apr 2021 18:38:32 +0530

Despite financial troubles there’s a sense in which my childhood was immensely privileged — a pauper in the material world, I was a sultan in the world of ideas.

— Erik Hoel

I started by wanting to share that quote and link on my microblog and then my thoughts turned into a blog post sized comment.
I decided to post it here too, then.

That quote describes my life to a T, even now.

I might be financially down in the dumps, but when it comes to books, my friends and kinfolk, have always somehow found a way to keep me happy and occupied.

The school librarian knew I used the library for what it actually was, a repository of magic and wisdom, and not what most folks used it for, a sick bay.
Which meant at least once a month, I would tell my teachers I was sick, go to the library and read books for an hour and after a year, the librarian would turn a blind eye to my presence too.
I was lost in Verne and Poe and Dickens.

The roadside vendor at the railway station, who I would buy books second hand from, would always keep the keep the newest ones for me.
If I couldn’t pay, he’d lend them to me on the condition, that I return it in day or two
This is where I got to read epic fiction. Tolkien’s worlds and McCullough’s Rome, all entranced me.

As a young hardware engineer making calls all over the city, I got to know the nooks and crannies of Bombay and more importantly I learnt where I could find the books that I wanted to read.
The Strand, and the roadside vendors at Fountain and Matunga and other nooks and cranies across the expanse of my tiny (in area) city became intimate friends.
Crazy animé, Golden age Marvel, “Banned” books, Old scifi and fantasy authors like Asimov and Niven/Pournelle and and newfangled ones like Gaiman and GRRM and the ones who would merge story telling and philosophy like PKD or Anthony DeMello and Carroll.

Friends, family, bosses, coworkers have all been indulgent too.
I own the Ultimate Sandman, and the Complete Calvin and Hobbes, and the Complete Asterix, and a Niven novel that Asimov signed, and lots of Gibran, and lots of Anthony DeMello, and lots and lots and lots of hardbacks thanks to their generosity.

In a life, that has been constantly buffeted by storms, books have been my solace.

I may not not have graduated college, but books have been my education.
Books have gotten me over breakups.
Books have taught me how to save money and make it grow.
Books have made me a better human by passing on the wisdom of the ancients to me.
Books made me healthier by teaching me how to lose weight sustainably.
Books gave me a leg up in life.
Books are helping me reinvent my work life as I change careers to programming.

Books give me a leg up in life.
With books I have been truly privileged and truly blessed!

Thoughts on Setting Up a Blog

feedback@janusworx.com (Mario Jason Braganza) — Fri, 26 Mar 2021 05:45:00 +0530

This post was first sent to my newsletter on March 19th, 2021.
[You really ought to subscribe][1] :)

I blame Mahe for this post.

Hey, Jason!
Can you please write an article on how to build a website like yours, where I can post my blogs?

Check out her blogs, here and here.

This one is squarely aimed at all the young ones, who are convinced that they need to be writing.
(Maybe, it was me who convinced you, in the first place.)
You are young (or like me, forever young) and broke (also like me).
You need a place for your thoughts to call home.
You need a place to write, and grow and focus more on what you want to say about life and what you study or what you work at, or the portfolio/showcase of thoughts you will slowly build.

What you use to write, does not matter at this stage!

So, what now?

Intent (aka, what do you want out of your blog?)

I have learnt the hard way, that the only way I can write better posts, is by writing [*lots* of crappy ones][crap]. I started a static website in the early oughts, then had a blogger blog, then a tumblr blog, then a self hosted wordpress blog, and then a self hosted ghost blog and now this self hosted [nikola blog][nb]. I sweated over the spacing. I fretted over which blog engine was best and most performant. I wondered about which ones protected privacy best. I had flame wars over which language was the best one to create a blog in, what sites were the best hosts, what frameworks would work better and how static blogs were so much faster than dynamic blogs but dynamic blogs offered so much power and flexibility. (all while I did not know how to write a single line of code.) I designed my blogs the way I wanted them, I bought premium themes, I bought fancy text editors and then figured out how I would write and where I would share them. I was all set.

And then? … zip, nada, nothing.
The blogs just languished.

This current incarnation of the blog is the only one that I have stuck with and written lots on.
Every one of those previous attempts just withered on the vine.
And not for lack of good intentions.
I was always going to write that perfect post.
I was waiting for more data, so that the post would be complete.
I was researching for depth, because this subject was not just a post. It was a whole series.
I never got around to actually writing though.
It was lack of focus. Lack of intent.
Think about why you are starting the blog and what do you want on there?
And that will give you direction about what to write.
You might realise that you don’t want to write, and just play with technology.
That is fair too. At least you’re being intentional about it.

Begin Writing!

If you have never written before, my advice to you is

to do precisely 1 hour of research, into all the free, hosted blog engines that are out there. Off the top of my head, Write.as, Netlify, Tumblr, Wordpress, and Medium come to mind.
make dummy blogs and explore all their features over the next day or two (at most). Figure out what interface you are most comfortable with.
Begin Writing.

I cannot stress this enough.
You will never write perfect posts.
How do I know?
Because I tried so hard, for so many years.
And failed.

What you can do, is show up on the first day.
Publicly commit to writing everyday.¹
And write.
Everyday.
Good.
Bad.
Ugly.
Whatever.
Just put words on the page.

The only two things that’d probably matter are,

That you show up on the time you committed to
And if your blog needs a general direction in the long run, you kinda sorta write your posts in that general direction.

Even that is a pretty distant second though.
First, master showing up daily.
Build that discipline.

Tools of the trade

Caveat, don’t even *think* about reading this section, if you have not written close to a hundred posts on a regular schedule first. You need that muscle built strong. The rest as they say, is window dressing. Once you have written a couple of hundred posts, you get a pretty good handle on what it is that you are writing and what it is, that the blog needs to do to serve that purpose. I can tell you why I did, what I did with my blog. It might help you build yours? I don’t really know. But honestly, once you get on with writing, you will figure out most of this stuff or know someone who does, or understand that maintaining the status quo is good enough, until you can afford to pay for a hosted vendor, who does this all for you.

I used Wordpress for a long time and loved it.
Then I thought I wanted to control it all, and so I hosted Wordpress on my own site.
Then I actually understood, what a headache maintaining it all really is.
Then I looked for something simpler.
I backed the Ghost kickstarter and as soon as they released it, I began using it.
It served my needs really well, until they decided to go in a different direction and abandon what I loved most about it. Writing in markdown. (I had written enough, to realise that any blog engine that I would use, needed to support Markdown.)

And by then, like I said, I had written enough to know what I wanted out of a blog.
I was writing for myself, so I did not want comments.
That eliminating comments also got rid of moderating people and spam was just a bonus.
If I wanted, I could actually go spread my message seperately. (the fediverse, email newsletters, social media networks and all that jazz.) But that is an intentional step. Separate from my act of writing.
I mostly wrote words. So I needed something that would have pretty text.
And since it was mostly just text, I could get by with a bunch of Markdown files rendered into static html files.
I did not want to upgrade and patch and maintain a blog engine some place.
I wanted something I could either host on my own server or just on some site somewhere else.
This would be easier once again if it was just a bunch of files that needed to be placed somewhere.
I wanted the ability to write from anywhere.
And finally I wanted a measure of control over where all this was.

All these considerations led me to realise …
A static blog, with a pretty looking theme would address both my bunch of files requirement and my show words well requirement.
There were tons of fonts that I could use. So I chose one that was free to use and I could host myself.
Not just hosting fonts, right now I can afford to host the site myself, so I have a Linode that hosts this blog.
The static blog can just as easily be hosted on some free place like github.io if life takes a turn for the worse.
I was learning Python, so using a static site generator that supports markdown and was built in Python seemed logical. So I picked Nikola.
(Did not really matter in the long run. I have used Go based Hugo, and Ruby based Jekyll too and all of them work essentially the same way. Even the theme I use on the blog, Lanyon, is originally a Jekyll theme, and can be found in Hugo as well).
So I learnt how to install it on my desktop, and customise it to use the fonts I wanted in the weights I wanted.
Then I learnt how to automatically deploy it via ssh to my site. Most static site engines offer to automatically deploy to github.io or are available as hosted services on Netlify. Here’s Nikola on Github/Netlify.
And finally, I’ve always wanted everything to be under my name, ergo the domain which I saved up for and bought.
It’s not essential to your writing, but probably essential to your identity in the long run, so that might be something to consider too.

So there we are.
One more post done :)
If you have questions, mail me! (jason at this domain)

or to a schedule that you are comfortable with and publicly commit to. ↩︎

Consolidating Websites

feedback@janusworx.com (Mario Jason Braganza) — Fri, 15 Jan 2021 09:00:00 +0530

*Update: 15/01/2021. It’s done. I moved everything and it all seems to be working. If something is broken, let me know, on [the fediverse][cbj], or mailing me at jason at this domain. To my tech posse, no there is no forwarding of old links happening. The site is too small and I have no time. Nobody is going to miss this. And to that one little friend, who noticed that the site was dead and actually cried, I love you.*

Happy New Year and welcome to the first newsletter of the year :)

I’m starting the year with a bit of spring cleaning.
I decided to stop publishing to mjbraganza.com
Yes, the book review and the photo website is now gone.
I had started it to give my family and friends the option where they did not have to see me work rants and struggles.

A few years of doing this have taught me that they don’t mind it anyway. They don’t check it on their own anyway. The newsletter is where the magic happens for family & friends.

Which left me the unwanted, detested task of having to run two websites, maintain two sets of data and run two newsletter like things.
I also have goals (my health, my family, my professional life) that I need to focus on, which leave me very little time to do these (even though I enjoy it immensely).
So, I’ve decided to stop doing it.
Like Cal Newport says,

Do less
Do Better
Know why

janusworx.com is where home is, for the forseeable future.
If you are looking for the old stuff, I will be bringing it over here, slowly as time and energy allow.

And once again, I wish you and yours a very Happy New Year!

My Plan for the New Year

feedback@janusworx.com (Mario Jason Braganza) — Fri, 01 Jan 2021 12:15:12 +0530

My plan for the new year …

A final thought from Atomic Habits as we start the new year:

“Improvements are only temporary until they become part of who you are.

The goal is not to read a book, the goal is to become a reader.

The goal is not to run a marathon, the goal is to become a runner.

The goal is not to learn an instrument, the goal is to become a musician.

This year, focus on the identity you want to build.”

— James Clear

A Day of Updates

feedback@janusworx.com (Mario Jason Braganza) — Mon, 16 Nov 2020 18:08:36 +0530

Could not focus much on programming today.
So decided on doing things with Python programs.

Nikola Upgrade
#

I use Nikola to generate both my websites.
It is an extremely easy to use, no fuss static site generator, which is easy on my server’s resources.
Version 8.1.2 was released a few hours ago and I hopped on and installed it.
I follow a slightly unconventional upgrade path, because I was terrified of breaking my server in the early days, when I was still learning about how to go about installing things on servers.

I have Miniconda installed.
I use that to generate a conda environment, which I then installed Nikola into.
When a new release drops, I create a new conda environment, install the new release in there and run them against my source folders (after backing them up).
This lets me revert very quickly to the old data and the older version of Nikola, in case I do something boneheaded and screw things up.
If all works fine for a month, I delete the older conda environment along with the old Nikola release.
I have been doing this for quite a while now, and while it may be overkill, it gives me peace of mind.
As usual, Nikola upgraded with no issues at all.

Pleroma Bot
#

I always wanted to understand what bots do.
Now I realise they are athromorphic programs that (with the right permissions and the right credentials) look like actual users of a service, doing sets of activities they are programmed to do.
Like your banking app has set of solutions to common queries that it shows you, before it hands off to an actual human, if those solutions don’t fit your needs.
They feel like supercharged scripts to me.
So I decided to see if I could install one.
Since I am learning Python, I love reading the low volume Daily Python Tip Twitter account.
It has surprising, handy, funny, interesting tips and tricks about the Python language and the massive ecosystem around it.
But, I have weaned myself off Twitter for my own sanity.
I only use it sparingly once a day.
And going back to that noise and tumult no longer interests me.
I saw a bot that mirrored tech news accounts to Mastodon and wondered if a bot could get Daily Python Tip to me on my Pleroma timeline.
A quick search led me to Pleroma Bot.
A couple of struggling hours later, (creating a twitter developer account, creating a pleroma account for the bot, figuring out how to get bearer tokens for said accounts) and tada, I got the bot to come alive!
It checks the Twitter account once a day, and mirrors the tweets to the bot account.
You’re most welcome to follow it for a Python tip, daily.
The next thing to do, is to see if I can get a bot to post a tagged pleroma status to my twitter account.
But that is something for another day …
Update, 2020/11/17: figured out how to use the bot to mirror multiple accounts. It now mirrors, Daily Python Tip, RegexTip, and CompSciFact.

Git the Branch

feedback@janusworx.com (Mario Jason Braganza) — Fri, 13 Nov 2020 18:55:00 +0530

I started playing with a way to control Git via Python.
Kushal had asked me to write a program, that would show me the local git branches.
So here it is!
I call it Git the Branch. (painfully, punny, I know :))

And now I realise why he asked me to do this.
The program itself is trivial.
Here’s the code on my code repo, Gitlab, and Github.
It just consists of me using GitPython to access the current folder via a GitPython Repo object.
And then querying it for its branches.

The important work was done yesterday, when I pored over the documentation and figured out how GitPython actually works.
And I realised that is what Kushal wanted me to do.
Read something and figure out how I could adapt it to my situation.

The other thing I realised, was licensing.
I want my programs to be used, played with and adapted.
So it makes sense for me, to make it as easy to use as possible.
This is why I have decided, that until circumstances dictate otherwise, I shall use the MIT License.
This led me to check if I could then actually license my software as such, if the software that I depend on (in this case GitPython) have different licenses.
My arbitrary and random research suggests that I can do so.
If I learn otherwise, I shall think about what to do next.
If you have anything to suggest, please let me know, by mailing me at jason at this domain.

One other (painful) thing, that I realised is that I cannot focus at all when I am writing code.
This post has come out in a blur of focussed writing.
My academic studies are also something that I can focus for hours on.
Apparently that focus does not translate to programming.
I need to build up this skill for this domain seperately.
Hopefully, this will come with showing up daily.

This was fun to do.
Here’s to writing my way to fluency.

P.S. Subscribe to my mailing list!
P.P.S. Feed my insatiable reading habit.

P.P.P.S. Update, 7pm the same day, The answer to focus, lies in this serendipitous Seth post

A third might be, just for an hour, to turn it off.
All of it.
To sit alone and create the new thing, the thing worth seeking out, the thing that will cause a positive change.

I love it when the universe speaks to me :)

Poem Feed

feedback@janusworx.com (Mario Jason Braganza) — Fri, 13 Nov 2020 17:00:00 +0530

Update, 2020/11/13: This has been working beautifully! I love the poems as they show up in my feed.

This is a tiny little niche thing, I built all for my ownsome.
It all started, when I got hooked on reading the daily poem, on the Poetry Foundation page.

Learning Python as I am, I wondered if there was a way to have it come to my RSS reader.
And so Poemfeed is a tiny little utility that does just that for me.

It looks up Poetry Foundation’s, Poem of the Day for a new poem.
If there is one, it follows the link to the complete poem, and then gets the link to that page and writes that into an simple RSS entry in an xml file.

I then wrote a simple cron job that executes the python script twice a day, and if an xml file is generated, it moves it to a place that my RSS reader can access.
Et voilà, a brand new poem everyday! (or as often as they publish :))

The code’s here, on my repo, on Gitlab and on Github, if you want to have a look see.

Starting Work on Git-the-Branch

feedback@janusworx.com (Mario Jason Braganza) — Thu, 12 Nov 2020 15:16:12 +0530

The Itch
#

Aiming to write a tool using this which will show all the git branches in the current directory and the last commit date on those branches (and only the local branches :))

What I did today
#

I had to carry my phone in to the service centre, so I did not quite have as much focussed time as yesterday, with all the coordinating and carrying, but I learned a few new things

Kushal hinted that I could use GitPython to do what I want.
So I spent a little while reading there.
And then decided to test it out.

And then immediately went yak shaving, because I wanted to solve the problem of how to quickly type iterate in Visual Studio Code.
I learnt lots of Python using Reuven Lerner’s courses and I used a lot of Jupyter Notebooks then.
And I love them.
The trick now, is to figure out how to use them in Visual Studio Code.
To my delight, the Python extension in VS Code has support for notebooks. And all works well for the most part.
The only thing that tripped me up was that when I tried importing a module in the notebook after activating my virtual environment, the Jupyter server hiccoughed and threw up some error about not finding the module (which I knew was definitely installed) and then something about it not being in the PYTHONPATH (which I had no clue of which places, it was looking in.)
A little snooping and I realised that the extension loads the server with a default kernel in someplace. And I need to tell it about my environment. Once I told it to use the kernel from my venv, all was fine.
VS Code went and installed a ton of things and found what was already there and everything was hunky dory.
A from git import Repo worked just fine.

I felt good about this piece of dawdling, because I know this is something I am going to do every day and better I spend some time figuring it out, right at the start.

I learnt that I could use the ! mark as a prefix in Jupyter to run shell commands! A !ls will show me the contents of my folder :)

I skimmed the GitPython documentation.
I kind of got what I want.
This will require lots more work, which I shall have to put in.
But even a cursory glance, showed me that GitPython was an exhaustive wrapper, that would let you do practically anything you would want to do with Git.

More tomorrow …

A Good First Day

feedback@janusworx.com (Mario Jason Braganza) — Wed, 11 Nov 2020 19:05:10 +0530

Was a really good day to ease back into Python today.
I got my VS Code up and running.
I got a personal [Gitea instance][crjw] up, to host my code, from where I will syndicate it to Github and Gitlab.
And finally I got a projects page up, to slowly fill up with projects.

I also managed to improve an old program I wrote for myself, but I’ll write about that in the next post.
All in all, a day well spent. A journey well begun.

Getting Back on the Horse

feedback@janusworx.com (Mario Jason Braganza) — Wed, 11 Nov 2020 09:49:28 +0530

Ok, one more time.
I know there have been lots of one more times before, but I am going to keep at this until I get proficient enough at this to land a job :)
And while I may not be brainy enough, the one thing I can do is be persistent enough to show up.

This time, I will focus on building tiny projects.
I realise my life is too chaotic for #100DaysofCode.
But I can do this, one tiny thing at a time.

Wish me luck!

A Hundred Days of Code, Day 026 - Refactoring

feedback@janusworx.com (Mario Jason Braganza) — Mon, 03 Aug 2020 13:00:03 +0530

Worked only an hour today.
Trying to change the little lookup program, I made the other day, into something a little better.

Not quite a good day.
Calling it quits early.

A Hundred Days of Code, Day 025 - Comprehension Exercises

feedback@janusworx.com (Mario Jason Braganza) — Mon, 03 Aug 2020 12:57:20 +0530

Working on Comprehension exercises today.

Reflections and Experience
#

I really need feedback, when it comes to programming. I cannot face a blank page. I always seem to start with printing something out to screen and then my brain kind of kicks into gear. Everything after that is just type, print, is this what I expected, if not then fix, type, print …
Exercise 3.1 and I think, I am finally getting good handle on comprehensions.
- from something that would take me at least 10 lines of code to just expressing it concisely in 1!
I can read Python messages and take a gander at what I need to do next.
- I see a '_io.TextIOWrapper' object and know I can iterate over it.
- I see AttributeError: '_io.TextIOWrapper' object has no attribute 'strip' and realise that it cannot be stripped into parts. I need another way to skin that cat.
And then I took it too far (just like this sentence), and nested a comprehension in another one, in where, I had to learn how to put in a conditional in the form of a ternary operator, in Exercise 3.2 (the commented for loop is much simpler!), but that was very good practice. Really stretched me!
I caught myself getting distracted a lot. I needed to set a 30 min timer and I spent about 15, looking for where the timer app in my Mint Desktop was, instead of just setting the darned timer on the phone.
Took an hour to figure out the comprehension for 3.2 and about 20 minutes to do it for Exercise 3.3. Practice helps!
Watching the solutions, and I realise, I got them right in principle, but that I need to be more aware of what happens to an object in memory, so that I can simplify code. I was able to remove one level of comprehension, which I used just to get the end of a string.

A Hundred Days of Code, Day 023, Day 24 - Tiny Utility to do comparative DNS Lookups

feedback@janusworx.com (Mario Jason Braganza) — Sat, 01 Aug 2020 15:33:22 +0530

Problem - Compare domain lookups, against DoH Servers
#

Take a list of domains (one per line) from a text file as input, find the IP address for the domain using the standard system level DNS, and then check against DoH answers from both cloudflare and google. and say if all answers match properly or not.

Notes
#

What do I need to do? (checklist)

Get a list of popular websites, (probably Alexa)
figure out a way to read them in
loop through each line, and look up its ip
- with the local dns (use the sockets module)
- with Google’s DoH json endpoint (use the requests module)
- with Cloudflare’s DoH json endpoint (ditto like Google)
Compare all the values.
Print if they match or not.

Experience
#

I should commit my work often. This took me two days, because I lost all of yesterday’s progress in a computer hiccough.
The program runs well. It intentionally limits itself to only the first result in the Google and Cloudflare lookups.
I should learn to focus more on what is at hand and not overthink the program.
I should be learning to build primitive little, handy dandy tools, not giant cathedrals.
I spent two hours fiddling with a way to create another program that would process files for me. (and abandoned it)
I need to read the documentation across sites very carefully.
- They are written with experienced programmers in mind, and not beginners like me.
- For e.g. When I was trying to look up domain names with Cloudflare, I blindly copied the example and then wondered why it was not giving me the appropriate replies. I then realised I was missing a seperate parameter, &ct=application/dns-json which was quite clearly listed above, but not in the example below. (which in truth was listed, but as part of the command at the command line and I, like a dumbass, just copied the requisite code to adapt to my Python program. Lesson: Cargo cult with extreme caution)
Which leads back to the fact, that I should stick to what is assigned, because just doing that much at this stage is taking me a long time. Improvements and features can wait until I am much more fluent.
I realise I am trusting autocomplete too much, and I should at least look at what I am completing. I spent 40 minutes, wondering why my comparisons were not working, when in fact, I was using the wrong variables.
Lost loads of time with typos.
Be more intentional. More slow.

Code.
#

Put your sitenames into a file called dumpsites.txt Run check-ip.py

Gitlab / Github

A Hundred Days of Code, Day 022 - Getting into the Groove

feedback@janusworx.com (Mario Jason Braganza) — Thu, 30 Jul 2020 12:03:45 +0530

Did the same time as yesterday.
Only about an hour.
Was much more prodcutive though.

Getting the hang of how to sit and program and work through things I do not know.
Gaining a bit of experience with the workflow now.
I have the basics in hand. I know what I want to look up.
So check problem, work a bit, look up, try, fail, repeat, gain incremental success, work some more.
Love the feedback loop too.
With other stuff I try, I have to wait days, weeks, months.
Here, it’s immediate.

Beginning to love the work, as I get more familiar with it.
Tomorrow is another day :)

A Hundred Days of Code, Day 021 - Swing and a miss

feedback@janusworx.com (Mario Jason Braganza) — Wed, 29 Jul 2020 18:06:35 +0530

Only did about an hour of distracted work and exercises today.
I’ll still count it though.

Tomorrow is another day :)

A Hundred Days of Code, Day 020 - Setting up an Editor for Python Development

feedback@janusworx.com (Mario Jason Braganza) — Tue, 28 Jul 2020 17:29:08 +0530

Had given myself a day, to see if I could get a good Python development environment using Elpy and Emacs.
It does work.
Just not well enough for me.
At the end of the day today, I was happy I learnt so much about Emacs.
But that is not my focus right now. Python is.
Emacs knowledge can come slowly and organically.

So I have kept Emacs as my regular editor for nearly everything text.
And switched to the community edition of Pycharm for all my Python projects.

I am also grateful to all of you, who gave me problems to practice on.
These will help me grow.

A Hundred Days of Code, Day 019 - Future Exercise Addendum

feedback@janusworx.com (Mario Jason Braganza) — Mon, 27 Jul 2020 16:23:14 +0530

Ok, think I have the problem of writing code, licked.
Will start with one problem from all the Lerner Courses, that I still have to do.
And another problem, I ask my friends to give me.

This should prove for a promising start.
If you, dear reader, have problems in Python that you’d like me, a budding Python programmer to solve, please mail them to me at jason at this domain.
It’ll add to my pool of problems and give me plenty to practice.

A Hundred Days of Code, Day 019 - Python Iterators and Generators, Done!

feedback@janusworx.com (Mario Jason Braganza) — Mon, 27 Jul 2020 11:55:48 +0530

Starting up with the last of the Lerner courses, I got.
Iterators and Generators.
Hopefully I get done with this and use the same intensity with actually writing code.
What shape will that take and how will I write about it? I have no clue
For now, notes follow.

Notes
#

** Part 1, Iterators **

If we run the iter function on something and it comes back with an iterator object, then it’s iterable; I can iterate on it.
Behind scenes in a for loop, Python does something similar. It asks if the object that has to be looped over is iterable with iter. And then keeps doing next with it to get the next result/item, until it comes across a StopIteration which lets it know, that the values are exhausted and it can stop looping.
The for loop is a very thin shell, that asks the appropriate questions of the iterator. But it is always the iterator that determines, what exactly is returned.
iterable vs iterator
- iterable means that it can be put into a “for” loop in Python
  - things like strings, lists, dictionaries, sets, files and objects (that I will soon create) that implement that iterator protocol.
  - it responds positively to the iter function’s question, Are you iterable? It returns an iterator object instead of raising errors (TypeErrors in this case)
- an iterator is the object returned by the iterable, the thing on which the next function is run.
  - it could be the original object (the iterable) itself.
  - it could also be a seperate object returned by the iterable.
  - when the iterator object is exhausted, it returns StopIteration
  - these are what give us the values.
How do I make my objects iterable?
- By implementing the iterator protocol
  - the object must respond to iter, by returning an iterator object
  - it should respond to the next function with values
  - it should raise a StopIteration error, when it’s done.
Best to create a helper class, pass the data to it and return that as the iterator instance.
- helps with state, since I can then use the same object and iterate over it multiple times independantly.

** Part 2, Generators **

Creating a whole class just to implement an iterator, might be overkill
Generators are a solution, that might come in handy.
They are like functions; functions that implement the iterator protocol.
instead of using return, we use yield.
- this lets us return multiple items.
I can use them to chunk large items, buffer uncertain stuff, and wrap complex stuff.
Rule of thumb,
- if I already have a class, just added functionality to it using an iterator class.
- but if I need something standalone, just use a generator function

** Part 3, Coroutines **

Little helper functions.
- With such a function, I assign the yield statment to a variable.
- This makes the function sit and wait for me to send it something.
- Once it receives data, it ingests it, processes it and poops out, yields an answer :)
- x = yield x
- Instead of sending data back to a coroutine with send, I could send it an exception using throw.
- I use close to close the generator and break out (trap GeneratorExit)
- I can just say yield from some_generator if I am calling another generator from my generator.

** Part 4, Generator Comprehensions **

Create one just using () genvar = (x*x for x in range(-5,5)) will make genvar a generator object.
The general idea, I am getting, behind the idea of generators and iterators is that we use them on really large objects, so that we don’t run out of memory.
- for e.g. joining a list of 3 elements is easy-peasy. A list of 3 billion elements less so, and ergo, generators and iterators.
- the ultimate idea being, just like an oil pipeline. We ought not to store it in tanks (lists, dictionaries etc.) We ought to strive as much as possible that it flows from upstream, right through to our taps in a single unbroken stream. Just pass the oil along, using various t-junctions and pipes and motors and stuff. Keep it flowing. Minimise storage.
- it also spreads wait times across well, time. So I never have to wait for something to gather up and collect and then display. the generator comes back instantly and when it has to get a values, I just have to wait for that one value.

** Part 5, itertools **

itertools is a collection of generators/iterators, that’ll let me add the iterator protocol to existing classes and functions. Looking through these feels like looking at specialty carpentry tools, like this biscuit joiner.
lets me take advantage of other smarter folks’ work and optimisations
- itertools.chain crawls elements across iterables
- itertools.count counts upwards from a number given, in steps if we want.
- itertools.cycle cycles through a range of options
- itertools.repeat repeats a value for the number of times, we tell it
- itertools.filterfalse takes a iterable and a function, applies the function to the iterable and if the function returns false, only then is the element from the iterable, passed through. (the inverse in which only true elements are returned is a built-in in Python, aptly called filter)
- itertools.takewhile and itertools.dropwhile are opposites of each other
  - takewhile takes a function and a sequence, applies the function to the sequence (starts a while loop) and then immediately stops if it hits false
  - dropwhile inverts that. it starts a while loop when it hits it’s first false and then keeps going from there.
- itertools.compress takes two iterables of equal length, (or if they are unequal, it’ll stop when it reaches the end of the shorter one) and then if the element second iterable rings true, it returns the element in the first one.
- itertools.accumulate adds the first element to the second element, then adds that the third element and so on. (if i want to use some other function of add, I can do that too)
- itertools.tee lets me create multiple instances of a generator, each with it’s own state (memory intensive.)
- permutations and combinations
  - itertools.product takes an element from one iterable, runs it across all the elements of the second (or third and fourth) and returns a cartesian product, an x,y (or x,y,z) coordinate tuple.
  - itertools.permutations does permutations across two iterables. returns tuples.
  - itertools.combinations does combinations.
  - itertools.combinations_with_replacements does combinations allowing each element to repeat. (a combination might not allow (10, 10, 10) for example; this helps with that)
- more-itertools is an external package that gives me more complex itertools. (pip install more-itertools) need to look at them later.

Learning / Feedback/ Experiences from doing exercises
#

Reuven tells stories “Deep in the recesses of Python …”
Reuven’s talking Python interpreter, “Hey Object, are you iterable?”
I am slowly anticipating the problems in Reuven’s code as he keeps iterating on them.
- ‘Will this work?’, asks Reuven.
  ‘NO!’, I yell back at the screen. ‘This function does not do anything, will return None and cause an error!’
  I am learning! This is fun! :)
Been going, “Ooooh! So that’s how they do it!” lots of times in this class.
Ok, have now dropped from a 30,000 foot view of Python to a 10,000 foot view. Will hit ground level, starting tomorrow, when I start doing exercises.

Read all about my Python Iterators & Generators journey here

A Hundred Days of Code, Day 018 - Python Comprehensions, Done!

feedback@janusworx.com (Mario Jason Braganza) — Sun, 26 Jul 2020 19:00:00 +0530

Continuing my comprehensions journey.
Hopefully it makes more sense this time around

Notes
#

** Set Comprehensions **

If I want a set of uniques from a group, I could use a set.
- Or like Reuven likes to joke, a set is a dictionary with no values; an immoral dictionary 😂
Create it with a somesetcomp = set('somecondition' for a something in somethingbig) or in a simpler manner, somesetcomp = {'somecondition' for something in somethingbig}
- Protip, better to start with a list comprehension, be done with figuring out stuff and then just switch the brackets at the end. Fewer issues that way.

** Dictionary Comprehensions **

Create it like so somedictcomp = {somekey:somevalue for something in somethingbig}
It creates only one dictionary, not a set
It has to have a key and a value variable, seperated by a colon. If it is just a single variable, I’ll end up with a set comprehension.

** Nested Comprehensions **

Running a comprehension on the elements of a parent comphrehension is a nested comprehension.
- For e.g. if I had a list of lists and I needed to pull out each element from each list I would
  - create a comprehension that would get each list from my giant list of lists
  - and then run a comprehension on those lists to get each element out.
  - big_list = [[10, 20], [30, 40], [50, 60], [70, 80]]
  - elemental_list = [each_element for each_list in big_list for each_element in each_list]
Pretty handy when needed. I can go as many levels deep as needed.

** Why Comprehensions? **

A comprehension is needed or rather the better tool for the job, when I have one sequence and I want to turn it into another sequence. Creating new things from old things
If I am interested in the side effects, the actions, umm, like printing to the screen for example, that is when I’d use for loops.
It gets increasingly obvious, the more I use it.

Read all about my Python Comprehensions journey here

A Hundred Days of Code, Day 017 - Python, Advanced Objects, Done!

feedback@janusworx.com (Mario Jason Braganza) — Sat, 25 Jul 2020 18:10:46 +0530

And we are done with objects!
This course finally gave me what I was looking for all these months.
The ability to think of and reason about Python, so that I can then think of and reason about, how to build my own programs.

Notes
#

Abstract base classes
- Sounds all high and mighty, but does something pretty logical and simple
- Helps me test if my object is of a generic (of sorts) type. I don’t want to test if 5 is an integer or a float or any of the other various county types in Python. I just want to see if it’s a number, of some sort. The abstract base class numbers helps me do that.
- There are such classes for strings and files, I hear.
- Will go into learning more about them in detail later, as I actually write more Python. But at least I know what they are now.

** Part 3, Context Managers**

Again, Context Managers, sound like something really complex, but they are just a matter of writing and doing things in a certain manner.

It’s something like a Tiny Habit stack loop, I learnt in the Atomic Habits book, as I was building up new habits.
- When I do this,
- then I will do this immediately after.
- and when I am done, I will do that.
Context Managers have a similar paradigm.
- With this object (as this variable, optionally)
  - I will run the __enter__ method
  - then after, I will do stuff
  - and when I am done, I will run the __exit__ method
- I can add the context manager protocol to my objects too, by impletementing the __enter__ and __exit__ methods in my classes
- They are used in a particular context, where you want to turn something on and then turn something off, before and after that context, thus Context Manager.
  - I can set something up in my __enter__ method and then tear it down in my __exit__ method.
  - This could be, for example, a network connection, a file, a redefinition of some sort, etc.
  - The __enter__ method must return self if all has to work well.
  - The __exit__ block, takes four arguments, one for self, one for an error class, one for the object, and one for the address in memory, the traceback. I can use them to catch errors in the main body of my with block, and then decide what the appropriate way to deal with them is.
  - A good example is using redirecting the print function’s output to a file, using a context manager. (The print function can write to a file, when I specify it as an output device like so print ("Hello there", file=f)
  - While I might be able to catch errors in the body of the context manager, I cannot if something happens during __enter__. just something to be aware of.
Contextlib is a library of context managers, Python already provides us.
- import contextlib
- contextlib.redirect_stdout/err will redirect stuff from the default output (the screen) to whereever else you want it to.

** Part 4, Properties and Descriptors **

A property is an attribute, that acts like getters/setters in other languages. It uses methods to set other attributes in the class (within the bounds we set). For e.g. a .temp property that will let you set temperatures, but only in the range you specify. not below 18C and not above 25C.
set by putting @property atop a getter function (let’s say temp) and then defining the setter properties in an identically named temp function again but decorated with @function_name.setter; in our case @temp.setter
the whole actual way to do it is like a contortionist twisting into a pretzel shape. Getting fluent with this will take time and practice.
it basically (to my mind) is like me giving someone something, and that someone goes and magician like, does something marvellous with that something, instead of just storing it in their pocket. it looks like assigning data to an attribute, but behind the scenes there are methods, just waiting to weave spells on said data.
When I take a property out of a class and abstact it, so that it can be used by many classes, it’s called a descriptor. (kinda like abstracting functions out of program files and into modules)
To kinda formally state, a descriptor is a class whose instances are supposed to be class attributes in other classes.
- To fit the descriptor protocol, a descriptor class needs to implement…
  - a __get__(self, host_instance, host_class) method with a corresponding __set__(self, host_instance, new_value_to_set) method
- These are class specific. As in, the descriptor is shared amongst all the instances it is used in.
- To get instance specific descriptors, you set the value that you are changing to be assigned as a dictionary using the host instance as the key and the value, as the value. (More contorting!) and then return the value of the [host_instance] value.
- Definitely tons of practice needed with this.
- Not used much, in day to day work, but used heavily behind the scenes by Python itself for its object system. The methods, Python classes have, are plain old functions, with descriptors (in conjunction with weak referenced elements) applied to them.
- The more I dive into all of this, the more Python feels less magical and more like the work of thousands of hard working atomic elements. And I think, I like this better. That everything complex, is actually lots of simple pieces, working together in concert.

** Part 5, Advanced Topics **

The only thing I can write here, is that Reuven goes deep into hijacking how Python creates classes and then using them for our own customised ends. How to create my own custom __new__ method, my own custom __init__ method, my own custom type of object, create my own class with a metaclass…
Never going to use this, unless I am writing the next Django or something, and even then I doubt, these would be needed 😂
But this was so much fun to learn!

Read all about my Python Objects journey here

A Hundred Days of Code, Day 016 - Python, Advanced Objects.

feedback@janusworx.com (Mario Jason Braganza) — Fri, 24 Jul 2020 20:34:43 +0530

Started up with Python Objects today.
This seems like a long, hard one.
Here’s hoping I learn lots.
Knowing Reuven, I know I will.

Notes
#

Part 1, Advanced Methods.

This section focuses on the dunder methods in Python.

By default objects are not equal to other objects even they they are from the same class, with the same attributes and methods.
- We could implement our own equals method though.
- The point being, we need to be intentional and methodical, when we design and implement our classses
Static methods are plain old functions that I write in my class for use by both the class and the instance. Could be used to clean up input or similar such utility functions. I create them by putting a @staticmethod decorator atop my method.
Class methods are those that are meant for use by only the class. I can call them from my instances, but they act on the class. I create them by using the @classmethod atop my method. For clarity, the first variable is now written as cls instead of self.

Part 2, Inheritance.

MRO, Method Resolution Order. I can do an classname.__mro__ to see how Python goes about looking for methods upwards, specially if I’m inheriting from multiple objects. Running help on an object also lists the MRO of its methods.
Best to explicity inherit from all parent classes, when inheriting from multiple classes.
We can use the classname.__bases__ to check for the classes parents.
A mixin is a class, we can inherit from (probably in addition to and before our parent class), that just adds functionality to our class. Does nothing sematically / organizationally to our objects or classes.
- The mixin must come first.
Adding an __ before an attribute, signifies that it is not to be touched. A little security by obscurity too. Nothing’s stopping me from actually going and changing things up. It’s just a notifier to people with common sense that such stuff ought not to be tampered with.
- The main reason though is to prevent conflict between attribute names.

Learning / Feedback/ Experiences from doing exercises
#

This course feels like the O’Reilly cookbooks in video form.
The first section takes all the operators, I take for granted in Python and then shows me how to implement them with my own classes
- how do I get len to work on my object? or how do I implement the == operator in my classes? etc. etc.
Starting with the last one and this one, have given up on exercises and just taking notes for now. As soon as I finish the run, I will be then going on an exercise binge with these pending exercises as well as Reuven’s Python Workout.
- The execption being, if I run into a topic that is really confusing, then I will attempt the exercises to drill the idea immediately into my head.
Obligatory Reuven plug, since I started up a new course :)
- Reuven is an awesome teacher.
- He takes the time, to explain stuff in painstaking detail, leaving nothing as an “exercise to the reader”.
- All of these courses, so far have been worth every single penny I spent on them.

Read all about my Python Objects journey here

A Hundred Days of Code, Day 015 - Python, Advanced Functions, Done!

feedback@janusworx.com (Mario Jason Braganza) — Fri, 24 Jul 2020 11:32:03 +0530

Delving deeper into Python functions and learning more about them, using Reuven Lerner’s Advanced Python Functions Course

Notes
#

The co_* series of attributes inside the __code__ attribute inside most functions gives a wealth of information about a function.
- For example, looking up the argcount attribute for some function hello, with hello.__code__.co_argcount will give us the number of arguments hello takes.
- And doing a hello.__code__.co_varnames will give us a tuple of all the local variables in a function
- hello.__code__.co_code contains the compiled bytecode for the function.
  - Importing the disassembler import dis and running it on the bytecode, dis.dis(hello) will show us what’s in there.
- hello.__code__.co_flags keeps a track of whether the function has * arguments or not via a binary switch. (It holds many parameters, one of which is the on/off switch for *args)
  - if said switch is set, the function checks for such arguments at runtime and turns them into a tuple to process.
  - they are set for *args via the hello.__code__co_argcount switch (0/1) and for keyword arguments with the hello.__code__.co_kwonlyargcount switch.
the __defaults__ attribute keeps all the functions default variable values. If I don’t supply a value to some parameter, the function will look in here, to see if a default value exists. hello.__defaults__ could hold a last name default, for example, if I want my hello function to work even if no last name was supplied, and it actually expected a full name.
- do not use mutable defaults. an empty list or dictionary for example.
- set the default to None first in such case and then create the list when the function runs at runtime.
The last thing I learnt about were nested functions.
- I can nest them two/three/as many levels deep as I wish. Practically, most folks do two or three.
- When an inner function takes the variables of its enclosure and does something with it and returns stuff…? those kinds of functions are called closures.

Learning / Feedback/ Experiences from doing exercises
#

The course so far is Reuven making simple functions and then breaking them down and explaining functionality in painstaking detail.
Reuven is an awesome teacher! I would gush about him every post, but then it would get too much 😂. So once per course is good
I kept looking at the disassembled code and wondering, what language it was. I still don’t know. My ‘educated’ guess is that it is a level of standard pseudo-assembly code for some phantom standardised processor. Once I had that mental model in mind though, all of it started making a lot more sense. This brought memories of Z80 assembly, I learnt in the mid 90s
This was fun to do! Onwards to Advanced Objects!

Read all about my Python Functions journey here

A Hundred Days of Code, Day 013, Day 14 - Python, Advanced Data Structures, Done!

feedback@janusworx.com (Mario Jason Braganza) — Wed, 22 Jul 2020 17:48:09 +0530

Notes and experiences for yesterday and today.
I ‘wasted’ a lot of time, again, struggling with exercises yesterday and ended up being too zombied to even write the summary post.
Have been much smarter about it today.
Stopped after about 30 mins and copied and tried to understand the solution.

Notes
#

List of Dictionaries

Just more convenient than a list of lists, not particularly faster
Make it more flexible.

Dictionary of dictionaries

Think beforehand of what your keys are going to be.
Looking in them, faster than lists
The tradeoff is more memory usage

Dictionary of Lists

Works when you need disparate elements to work with later. Those can be stored as dictionary values, in a list form.

Part 3

Decimals

To have something sane between integers and crazy floats.
I import the Decimal class and then create objects, like so

from decimal import Decimal
a = Decimal('0.1')
b = Decimal('0.2')

I create them from strings not floats, just like I would int strings.
It has various methods I can call on the Decimal object.
- Stuff like getcontext with has a method to set the precision of units after the decimal point.
Helpful if you need precision at a certain level.

Named Tuples

A very handy way of calling values in a tuple by sensible names, just like dictionaries
Very handy instead of heavyweight dictionaries.
Create them like so

from collections import namedtuple 
Person = namedtuple('Person', ['first', 'last', 'age']) 
me = Person('Jason', 'Braganza', 42) 

Doing a me.first will get me Jason, just like a dictionary.
I can still refer to the tuples with the numeric indices.
I can do a ._replace to replace values, if I want to. me._replace(first ='Mario'). It just returns a new object with the same name, which I can choose to catch in a new variable.
Better for readability.
Basic uses. The moment I want to twiddle with it too much, I know I should just make my own classes

defaultdict

A variation/improvement on the normal dictionary.
We want a dictionary, with default values.
When I check for the presence of a key, if it does not exist it’ll get created with a default value.
We give it a function or a class, that will run, be called everytime a key does not exist.
So I could pass it basic primitives, like a list with no entries and it will return an empty list for a value everytime, there is not one. Or saying int, in which case it will create a key with 0 for a value
Create them like so

from collections import defaultdict 
d = defaultdict(int) 

So now when I do d['a'], it well check for key a. If it does not exist, it will create it, and give it a value of 0 by running the int function with no arguments.
I can use any function or callable, as long as it has no arguments.

OrderedDict

No need to use it anymore
But handy in case I am looking at old code.
Regular dictionaries order stuff chronolgically as of Python 3.7.
Which is what ordered dictionaries used to do.

Counter

from collections import Counter
if I pass an Counter dictionary an iterable, it will create a dictionary with the occurrence of each element.
if I go c = Counter[10, 10, 20, 50, 60, 60, 80, 80, 80, 90'], then I get a dictionary like Counter({10: 2, 20: 1, 50: 1, 60: 2, 80: 3, 90: 1})
I can also do a most common method to get the most frequently used elements. c.most_common()

Enums

from enum import Enum
Create ’em like

class ColorEnum(Enum)
Red = 1
Blue = 2
Green = 3

Matches symbolic labels / names to numeric values.
If a = ColorEnum.Red and b=ColorEnum.Red then they would both be equal.

Learning / Feedback/ Experiences from doing exercises
#

Reuven keeps harping on the fact, that I need to think things through.
- Is this how you want to build things?
- What are the ramifications?
- What if you want to change up things or if things are expected to grow exponentially in the future?
- Think! Be itentional. Design accordingly.
Caught myself frequently initalising a total in a loop and then wondering why I would not get the actual total :)
Now my approach, kinda matches what Reuven does. Which means, I am beginning to write some sane code :)
Finished with this course. And on to the next one. Planning, building in margin and working at it a little bit everyday helping a lot!

Read all about my Python advanced data structures journey here.

A Hundred Days of Code, Day 012 - Python, Advanced Data Structures continued

feedback@janusworx.com (Mario Jason Braganza) — Mon, 20 Jul 2020 16:21:04 +0530

Ok! Had a nice refreshing break, yesterday being Sunday.
Back to work today!
If today’s notes, feel a little light, that’s because I was struggling with exercises.

Notes
#

Part 2

A lightweight solution to classes, if I am just combining all sorts of data structures is the built-in collections. Some of them could be
- List of Lists
- List of Tuples
- List of Dictionaries
- Dictionary of Dictionaries
- Dictionary of Lists
Mostly use them to solve tricky issues. If I find myself using lots of functions, just to deal with these structures, I am better off using classes.
- These structures also lend themselves to being converted into classes.
- Sometimes it’s just a matter of adding a few methods, et voilà, I have a class!

Lists of lists

As simple to create as l = [[1,3,2],[4,5,6],[7,8,9]]
- If I do a l[0], I’ll get the first element, the list [1,3,2
- To get at the elements inside that list, I can go l[0][2] which will give me the number, 3.
- Behind the scenes, l.__getitem__(0).__getitem__(2)
We can either work with them with indices like up above, or iterate over them, with for loops or comprehensions
Better to use lists of tuples, if I am dealing with mixed types, specially those that are not apt to change, like records of some sort. Something like a list of details about movies.

Learning / Feedback/ Experiences from doing exercises
#

Learning to think atomically. Learning to break down each exercise into pieces and then learning to organise them in a manner, that I can solve it, step by step.
- What hints do Reuven’s results show?
- What should I compare first? What will be the aftermath? and so on.
Gave up an exercise after two hours of trying.
- After peeking at the solution I realised that it was not because of something I forgot or did not practice, but once again, because of something I did not know.
- in this case that there are set operators to use between two iterator objects.instead of crazily stepping through everything like I did below, I could’ve just created a union list run through them.
Just goes to show, there is lots for me to learn. And that there is a lot of tacit knowledge out there. And this I will only be able to figure out by writing lots of code!
Also (note to self), time your self and be ok with giving up and looking at the solution. I seem to keep thinking that I am wrong or am missing something. Never the fact, that it might be something that I do not know.
- I am now strictly going to give myself 30 minutes per exercise and then move on.
Lots of mistakes as usual.
- Wrong indentation, giving weird results.

Read all about my Python advanced data structures journey here

A Hundred Days of Code, Day 011 - Python, Advanced Data Structures

feedback@janusworx.com (Mario Jason Braganza) — Sat, 18 Jul 2020 19:14:17 +0530

Started with a new Reuven Lerner Course, on Advanced Data Structures..
Aiming to comfortably finish this in a week.
Notes and experiences, follow.
The course is three parts.

Part 1 - Deep dive into the common data structures
Part 2 - Combining Data Structures. Lists of lists, Dicts of lists, Tuples of Lists and so forth. How far can I go without classes? Or how can I enhance my classes with this approach?
Part 3 - Complex data structures, that come with the Python Standard Library. The Collections module, Weak references etc.

Notes
#

Part 1

The id of a variable shows me where the object in refers to, is located in memory.
If x=5 then the id(x) will point to where it’s object, here the number 5, is located in memory.
When I assign a variable to another, what I actually do is assign the new variable to the same objects address. That is all. When I do x = y, then y will point to 5 too, independent of x. If I set x to something else later, y is not going to follow x. Instead it steadfastly points to 5.
A simple way to say this is x is y, where I am not checking for equality, but rather testing the fact, that both of them point to the same location in memory, or not.
I can use sys.getsizeof() to find the size of an object in memory. (how much memory it uses), but it’s a tricky beast. For e.g. when it shows me the size of a list, it shows me the size of the list object. Not the size of the elements it contains. To get that, I need to go check the size of its elements one by one.
A singleton object (not many in Python) is an object that every time you create a new instance of, from the parent class, it always points back to the same instance. None is an example in Python.
Better to create a list using square brackets, rather than assigning them via a string. x = ['a','b','c','d'] works better than going x = list('abcd'). This obviously matters upon what you are doing and if that is possible to do or not.
I can tuple-unpack-split a string in various ways. If I go, a, b, *c = s.split[] it will get the first split item in a, the next one in b, and the rest will be a list in c. But if I want the first and last elements for example and don’t care about the stuff in the middle, I can also go, a, *b, c = s.split(). I need to play with this. Just realised I could’ve solved a lot of exercises I did in the past, more elegantly if I knew this then.
If I access an element in a sequence via its index, I will get the element back along with the elements type, but if I slice a sequence to get just one element back, I get a single element of the sequence’s type. Very nifty!
- For example if I access s[0] in the list ['jason', 'braganza'], then I will get a string jason back.
- But if I slice and get just the first element with a s[:1] (get upto, but not including 1), I get a single element list, ['jason'] back.
If I look up a key z in a dictionary d with a d[z] and it does not exist, then I get a KeyError. If I want to check keys without noise, I use the get method on a dictionary. If the key exists, the value is returned. If not None comes back.
- I can set keys similarly with the setdefault key if I want to set keys safely. If I just do d[z] = 100 and z already existed, its value would have gotten trampled and set to 1000. But if I do the samething with a d.setdefault(z, 100) then it sets it to 100 only if the key does not exist. If it does, it just returns the old existing value. No harm, no foul.
If I have two dictionaries and I want the contents of one in the other, then I use the update method. For e.g., I have dictionary a and dictionary b, so I do a.update(b) and everything from b flows into a.
- If there is overlap in the keys, then the values get trampled and overwritten.
I normally cannot add dictionaries, lists, or other sets to my sets (no unhashable types allowed), I can freeze a set with frozenset, which makes it hashable and then add it to my set.

Learning / Feedback/ Experiences from doing exercises
#

Reuven makes Python sound like a cute animated bear. ‘Python notices and says “Oh, you’re using 256. I’ve aleady got that. Don’t create a new object for that!”’ I wish my interpreter was as helpful 😂
This course is a lot less structured than the basic courses. It approaches you from the point of view, that you know stuff, you can read and write Python, you have a modicum of intelligence, so here’s a really juicy grab bag of interesting stuff about all the basics you learnt earlier.
- It’s best to always use f-strings, but if you need to eke performance, can you figure out, what kind of strings are the best? (spoiler, benchmark it)
- While Python lists are expandable, the C structures underyling it are fixed. How does Python let you have flexible, expandable lists then?
And so on and so forth. So far, this has been fascinating.

Read all about my Python advanced data structures journey here

A Hundred Days of Code, Day 010 - Python Functions, Basics Done!

feedback@janusworx.com (Mario Jason Braganza) — Fri, 17 Jul 2020 19:36:18 +0530

Today was hard!

Notes
#

‘*args’

way to get multiple arguments without having to assign placeholders for them
it scoops up all the arguments and gives it to the function in a tuple. I could then loop over it with for.
I just put * in front of one of my placholders et voilà, def example_func(*catch_everything)
I can define placeholders to catch specific arguments, but those need to be before my ‘*args’.
Edge Case: I could have my arguments in a list/tuple already. I can just add the structure with a * in front of it and Python will unpack it for me. If I have a list, catch_me_if_you_can=[1,2,4] then I can pass the elements individually, as arguments with a def example_func(*[catch_me_if_you_can])
Another kinda frequent edge case: ‘*args’ catches everything that is unassigned. so if i have something with a default value, it will get trampled by the data from my args. Best thing to do is to set the default after the ‘*args’ like so, example_func(a, *args, b=10)

Keyword Arguments

Normally in the form of name = value
Kinda like addressing lists vs dictionaries. Where instead of an index, I can now call an argument with a name.
So I can go def name(FirstName='', LastName='') and then put in stuff in whatever order I want to like name(LastName='Brontë', FirstName='Emily'. Pretty handy!
Try not to mix and match positional and keyword arguments. Python looks for positional arguments first, then keyword arguments. So if you have them, then the positional arguments have to come first!

‘**kwargs’

these scoop up keywords arguments into a dictionary. I can do everything with this, just like any other dictionary
I just put * in front of one of my placholders et voilà encore, def example_func(**catch_everything)

Combining Arguments

Arguments in decreasing order. Stick to the order as far as possible.
- mandatory parameters (no defaults)
- optional parameters (with defaults)
- *args
- **kwargs (with and without defaults)
Use them for different kinds of input

Variable scopes

Just because I have indentation, with an if or an else or a for, does not mean that I change a variable’s scope. Variables within those indented blocks could still be global, or the scope of the thing above
The slight exception is the variable within comprehensions. Variables inside them, have their own private scope
The scope changes, mainly, when we define functions. Generally …
- If I am in a function, I’m in a local scope
- If I am out of it, I’m in a global scope
- with some exceptions
So always think, am I in a function body … or not? (excepting comprehensions)
When Python looks for variable values it looks in the LEGB sequence. (left to right).
- Local (starts here if I’m in a function)
- Enclosing
- Global (starts here if I’m not in a function, rather in the main body of the program)
- Built-in
The globals function will have all the global variables for the program. It’s a dict with variable names as keys and the variable assignments as values
The locals function will have all the local variables for a function in the program, when it runs. It’s also a dict with variable names as keys and the variable assignments as values or I could also look at the function_name.code.co_varnames to peek at the local stuff
- Parameters to a function are also local variables.
- I should define my local variables, before I use them in a function, or I get an UnboundLocalError
- If I want to use and modify a global variable in a function, I should declare it at the beginning of my function. For example, if I have a global variable x, and I want to use it in a function, then I say global x in the beginning of the function.
- I can mutate elements of global variable, if they are mutable structures. As in, I cannot change list A to another set of entries, but I can append to list A, or delete items from list A. As long as you are not assigning to a variable, rather using object methods, you should be ok.
The built-ins scope, houses many things that are needed by Python, but are not reserved keywords. Stuff like list. I can use it to create lists, but it’s not reserved. I can redefine it if I want to (or more commonly redefine it by mistake)
- This feels like one of the few places, Python allows me to shoot myself in the foot.
- Do a dir(__builtins__) and review the names every now and then, and don’t use them in your code.

Kinda Advanced Stuff

While I said, they were verbs, functions can alse be nouns. I can just pass them as objects to other functions or elsewhere.
I can pass a function as an argument as in the case of sorted(someIterableofPositiveNegativeNumbers, key=abs) where I am passing the abs function as a keyword to the sorted function, which then uses abs to get the absolute values of the numbers first and then sorts them according to those values.
I can collect arguments for the inner functions I call with *args and **kwargs and then pass to them again with *args and **kwargs.
I can also take some data as an argument along with a function and apply that function to that data. Like I did above. The main function I create acts like some glue program. This process of applying function to data, is called mapping and the functions I create to do this are map functions. Python has a built in map function.
I can create functions, plop them into a dictionary and then call them as needed in my actual function, by accessing the dictionary keys and supplying arguements. This approach is called a dispatch table

Learning / Feedback/ Experiences from doing exercises
#

Getting used to the way, Python behaves. And beginning to love its consistency for the most part.
I write slow, step by step code. while it works, Reuven’s solutions are short and make me go, oh why did I not think of that? Maybe optimised thinking will come with time?
I have to use Python tutor a lot to get what is actually happening.
I’ve learnt to just dive in blind when begining to write programs. The more I think about stuff, the more I feel, like I can’t do this. So I just start. And build it line by line, error by error. And more often than not, it solves it self. Optimised solutions present themselves after I have the rough and ready solution done. “Aah! I could’ve written it this way”
And I am done with the introduction to functions! Hurrah! This course stretched me a bit, and showed me I still have a ways to go.

Read all about my Python functions journey here

A Hundred Days of Code, Day 009 - Python Functions, Basics

feedback@janusworx.com (Mario Jason Braganza) — Thu, 16 Jul 2020 16:12:47 +0530

Started up with learning about Python function basics, today. Notes follow. Using the Lerner pool of wisdom, as usual.

Why do we need functions?

DRY (Don’t Repeat Yourself), because we can take stuff that is repeatable, assign it a nickname and just call that nickname over and over, instead of tediously writing all that stuff over and over and over
If want to modify something, I can just call it (by the nickname) and then add my little spice to it. Like I have the recipe to an omlette written down somewhere, I can then just add a little note with secret ingredients at the bottom of that recipe to create a better or a different omlette.

Functions are objects.

We can think of them as verbs

Parentheses in Python (at the end of functions) basically mean, I want to execute, this here thing, on the left

I can run help on a function to get some information about it.
help(str.upper)

We don’t tack parentheses on the function, when I am lookif for its help, because I don’t want to run the darned thing.

Creating/Defining a function

We define a function using the def keyword. It’s followed by the name you want to call it by, followed by parantheses terminated by a colon
- def hello():
- This is actually a two step thing, even though I’ve always thought of it as one.
  - first, I create a function object.
  - then, I assign it a name.
- Functions in Python (unlike other languages), have the same name space as the rest of our Python program. I cannot have a function called x and also a variable called x

Returning results

Similar to math functions, even Python functions return values after running them
The default is None, unless you actually, explicity tell the function to return something
If you want to catch the results of what you are doing with the function, remember to return it.
A function can return whatever you want. statements, values, other functions etc.
Which is good and all, but remember to do this with intent. I ought to think about what I want to return and document it well
If I am returning multiple values of varying types, it comes back as a tuple. Not as different objects. I need to unpack them and assign them to multiple values explicity

Documenting Functions

The help function needs something to read and tell the user about what our functions do. Ergo …
Use docstrings (Documentation Strings) to do it.
- What are docstrings? If the first line in a function is a string, then that string is seen by the help system as a docstring and used for documentation.
- Use triple quotes around the string. I can have multiple lines in there
- The convention is to document what a function receives (the input), what it returns (the output) and what it modifies.

 def hello():
		"""This is it! The docstring! This will help me figure out what the hello function does!
		or more seriously
		expects: No arguments
		modifies: Nothing
		returns: A friendly greeting
		"""
		return 'Hello, hello :)

**Arguments**

Functions need stuff to work with.
We supply them using arguments.
Just a fancy name for the data we pass along to the function.
E.g. If a function returns a fancy format of our name, there must be some mechanism to pass our name across to the function. Arguments are how we do it. We don’t actually argue with the programe :P

A function can take any number of arguments. We just put them between the parentheses, seperated by commas

Positional Arguments
```
def hello(first, second):
 print(f'Hello, {first} and {last}')
```
- In the code above, I can call the function with hello('Tyche','Hestia') and it will assign Tyche to first and Hestia to second, because I typed them in that order.
- These are called positional arguments
- When I define a number of arguments, I need to pass all the arguments along. I can’t make space for two and pass only one or none.
- I can supply defaults, so that if the user does not supply all the arguments, the default is used in its place
- If some arguments cannot have defaults and are a must, they must come before the ones that are optional and can have defaults.
- How does Python know, how many to expect?
  - When Python defines the function, it records the definition and makes a note of what it needs to run the function properly
    - If I look at the guts of the hello function with a hello.__code__.co_argcount it’ll tell me, it has recorded two.
    - If I supply defaults, they are recorded in a seperate place called hello.__defaults__ and it supplies the requisite information, so the argcount always stays at the required number of arguments

A little dazed today, so calling it quits early.

Learning / Feedback/ Experiences from doing exercises
#

I keep looking for elegant, one statement like solution to problems and get frustrated. Reuven then shows up with a brutally efficient solution that has four if statements. I should remember to be more workmanlike, before I turn craftsman

Read all about my Python functions journey here

A Hundred Days of Code, Day 008 - Python Basics, Lists, Tuples, Dictionaries, Sets and Done!

feedback@janusworx.com (Mario Jason Braganza) — Wed, 15 Jul 2020 19:32:58 +0530

This was an amazing run! Learnt lots.
Done with the basics course.
Woohoo!

Notes
#

With lists
- Not pythonic to mix types
- can iterate, slice and dice, search, get lengths, transmute them (for e.g. reverse items in them) just like strings
- can have lists of lists!
- lists are mutable, unlike strings. can change items/elements of a list
  - If i create a list from another list, the new list items reference the old list items
  - if i want to copy elements from a list rather than reference them, I’ll go newlist = oldlist[:] which will copy the elements from the old list into the new one, rather than create references to the old ones
- Realise that there is a difference between changing the values of a variable and between changing elements of a list.
  - When I do x = 2 and y = x and then change x to be x = 3, remember that the value of y does not become 3. y continues to point to the original location in memory which holds 2. What I did was to break x’s connection to that value and assign to another value in another location
  - On the other hand, when I do x = ['jane', 'jill', 'mary'] and then create a copy with y = x and then change x[0]='edith', what I do in this case is change the actual element. The references to that object in momory stay unchanged. Which is why y[0], which holds references to the same object, will also reflect the change to edith.
  - Finally if I go, x = ['athena', 'diana', 'aphrodite'], now we’re back to the assignment. x will point to this new list while y points to the old one.
  - This distinction between changes in assignment vs changes to content is very important, when dealing with mutable/changeable data types like lists
- Append something to a list with .append - list.append(something, something else)
  - Heuristic, when a method on a mutable data type, changes data, in returns None
    - So I should just go mylist.append('blah') and stuff will be done
    - If go mylist = mylist.append('blah') (which I am very apt to do) the method will change the list, then return None and that None will get assigned to mylist, In effect, erasing the list and causing unnecessary heartache. So, be careful, very careful. Not careless, like Bond, James Bond.
- += or .extend takes an iterable on the right. picks each element. and then assigns them singly to the list on the left.
  - Append can take only one item.
    - If I want to add xyz as separate entries to mylist that has ['a','b','c'], append will just take it as a big lump and make ['a','b','c','xyz']
  - Instead I do a +=
    - mylist += 'xyz' or mylist.extend('xyz')will give me ['a','b','c','x','y','z'], which is what I wanted in the first place
  - it will only work if there are iterables on the right. (strings, lists, dictionaries etc.)
- the insert method will let you insert something at a location in the list.
  - Give it what you want, tell it where you want, and boom!
  - mylist.insert('d', 3) will put d after abc, giving me ['a','b','c','d','x','y','z']
- I can replace things in a list by giving it a location and telling it what to put in there.
  - I could do mylist[0]='artemis' and the list will change to ['artemis','b','c','d','x','y','z']
  - I could also give it a slice along with a list of what to put in there. Doing mylist[1:2]=['josephine','lisbeth'] will now give me ['artemis','josephine','lisbeth','d','x','y','z']
  - if you add additional elements, than what you replace, Python will insert them, growing the list.
- Removing things from a list?
  - the .pop method will pop off the last item in a list.
    - If i give it a location, it will remove the item at that index location. mylist.pop(3) will remove d from mylist giving me ['artemis','josephine','lisbeth','x','y','z']
  - When I know what I want to remove, I just use the remove method instead of pop.
    - mylist.remove('josephine') will remove poor Josephine leaving us with ['artemis','lisbeth','x','y','z']
    - If I’m not sure, I could check for the presence of an item before I remove it. Should prevent a program from barfing on me if that element isn’t there
      if 'q' in mylist: mylist.remove('q')
    - also the remove method only removes the first instance of something.
- Iterating and counting over lists?
  - the for loop!
    - I can use the enumerate function if I want numbered items out
  - I can iterate over a slice.
- The range function is very list like in its behaviour.
- I can sort lists.
  - same caveat as above. sort will change the list in place and return None. Don’t go assigning mylist = mylist.sort(). It won’t work
  - A .sort(reverse=True) will sort in reverse
  - sorting between mixed types in a list doesn’t work in Python 3 anymore. The types in a list, ought to be the same.
  - Sorting list of lists works by comparing indices
  - If I don’t want to change my original list, I can use the sorted function on the list.
    - It works on most iterables, not just lists, while the list method is restricted to lists
    - It returns a new sorted list, and keeps the original list intact.
    - I can do sorted('something', reverse=True) will return a reversed list.
I can str a list and list a string
I can split a string into a list, either by single characters or by a delimiter (a ; or a , or space)
- split without an argument will cut out all white space
I can join, strings and lists and stuff, but
- join works only on a string. it’s a string method
- and that string generally is the glue, that will string what we give it, together
- ' '.join(['Hail','Caesar']) will join the list using that blank space I gave it.
- it works backwards, so that I can feed it any sequence in the end. a list, a tuple, a dictionary … all fair game
- Remember, it won’t work on numbers. It’ll fail.
Tuples, are a kind of weird hybrid of strings and lists.
- Like a string, they are immutable
  Like a list, they can contain anything at all.
- crazyTuple = (1, 2, 4, 5)
- you create them by enclosing with () brackets. but that is just for you to know you are creating a tuple. I can just do crazyTuple = 1 2 3 4 5 and that creates a tuple just as well.
- I can do most everything with them just like strings and lists, slice, search, iterate blah blah
  - Typically used to create structures. like bookdetails = ('title', 'author', 'pubdate', 'price'). you know what to expect, once you see definition. Once we figure that [0] is the title, it normall will be the same for the other books too.
  - Behind the scenes in Python, function arguments are passed as tuples.
  - Note:* If elements in my tuple are mutable (like a list), I can change their elements, like appending or deleting items in the list. The tuple however is immutable. I cannot delete/modify the list item as a whole.
  - use extend if you want to append to a list in a tuple
  - Since a tuple is immutable, it doesn’t have a sort method. I can however sort by using the sorted function which will return a sorted list of the elements of the tuple, whill leaving the original tuple untouched.
Unpacking stuff
- If my variables on the left, match up to the number of items in the structure on the right, x, y, z = (10, 20, 30) then they get assigned to each. x is assigned 10, y,20 and z,30.
Dictionaries
- Hash tables, hash maps in other languages
- While in a list, I have values of my choice, the index is always numeric. so item 0 is a cookie, item 1 is cookie-dough and so on, with a dictionary, I get to define the indexes too! I can now say endresult is a cookie, ingredient is cookie-dough and on and on
- while if you want to append to a list, you use an append method, if you want to add keys (user defined indexes), you just assign it to a dictionary with its corresponding value. So I can just add cookie_recipe[sugar]=100 to my cookie recipe dictionary above. if the key is already in there, it just gets updated with the new value. if not, the key and the value get added to the dictionary.
- Keys are unique. Values can repeat. But keys can exist only once in a dictionary
- I can use most immutable data types as keys. strings, integers, tuples that don’t contain mutable data like lists etc.
- I can use in to look for keys in a dictionary. 'sugar' in cookie_recipe
- The get method will look for a key for you. If it exists it will return the key, or if there isn’t, it returns None. I could even customise the none with a message. If i do d.get('somekey', 'No such key'), it will print “No such key” if the key isn’t found.
- The setdefault method will set a key in the dictionary along with the value, if it does not already exist in the dictionary. If it exists already, it will return the existing value.
If I want to convert strings to numbers and want to do a sanity check (I would not want to convert text after all, Hello is not a number :P) then I can use the isdigit method on the string. It’s a string method to use on strings.
Sets, can be thought of as dictionaries without any values.
- Each value in a set can occur only once.
- create them by going myset = set() and then I can willy-nilly add values with myset.add(10) or myset.add(32). If I try adding same value twice, no dice. It is stored only once. Every value is unique
- I can use an iterable to add multiple items at once with the update method. I can pass a list for example, and it will add all the unique values to the list. myset.update([44, 777, 44, 56, 89, 777])
- I cannot have mutable / changeable data as elements of set. No lists, no dicts etc. Strings, Numbers are ok
- While sets look like lists, they are unordered with no indexing.
- I can iterate over them, though.
- To look for something in a set, use the in operator
- To remove the item use the remove method
- I can do set operations. s1 - s2 will show me items that are unique to s1. (it removes the common elements between the sets) or vice versa
- the symmetric_difference method will show me unique elements from both sets. stripping off the common elements. s1.symmetric_difference(s2)
- to find if a set is a subset of another I could use the <>= operators. Is s2 a subset of s1? s2 < s1
- I can combine sets (union) s1|s2
- Or I can find the common elements with intersection s1 & s2

Learning / Feedback/ Experiences from doing exercises
#

Reuven keeps going, Alright? And I keep nodding my head here :)
Still miss lots of stuff, writing code. Missing colons, no surrounding quotes, missing commas, so many commas … not converting strings to integers and then wondering how I get such large results from simple addition
But I’m done!
These were the basics, and I could run through them, but I did not realise I had so many gaps in my basics.
As I keep saying Reuven is amazing. He points out the pitfalls and keeps reminding me of important issues and shows various methods to solve things, keeps encouraging me and I could go on and on. Lerner fan for life!

Read all about my Python basics journey here.

A Hundred Days of Code, Day 007 - Python Basics, Variables, Basic Data Types, Strings and Loops

feedback@janusworx.com (Mario Jason Braganza) — Tue, 14 Jul 2020 18:26:08 +0530

Started with the Reuven Lerner, Intro Python:Fundamentals course today.
Made surprising headway, even though today was crazily demanding with work and personal stuff.

Notes
#

The difference between == and is
- If you want to see if two things are equal, use ==
  - like, is 2+2 == 4
- If you want to know if two objects are the same thing. if they are just pointers to the same memory location, use is. The heuristic is, if you are checking for singleton values, something that there is only one thing of; then in Python, we use is. Use sparingly . Make sure you check mostly to see if things are the same object or practically to see if something is None
  - mostly to check for the presence or absence of things.
  - like x = None and then I go check if x is None …
True / False heuristic in Python
- Nearly everything in Python is true
- except for False, None, 0 or anything empty (empty lists, dictionaries, etc.)
Learnt how working with strings in reverse works
- if I want the last element in a string, I could reference it by calculating it’s length and lopping one off (since indexes start at 0), like with the string s = 'Halt! Who goes there?' I could access the last element by s[len(s)-1] or the last but one, with a s[len(s)-2].
- This is made a lot more convenient by just dropping the len(s) stuff, just leaving the - numeral part - s[-1] or s[-2]
- This makes so much sense in my head now, if what I am doing is counting straight and then subtracting one. I should remember, things sometimes are simpler than they seem :)
  For some reason, I always imagined, Python could see the length of my string, so why couldn’t there be a reverse string way of doing things like s.rev[0] that would just count backwards 😂
Strings are immutable. They can’t be changed. I can just process a copy and generate new ones, though.
just realised that the f in f-strings stands for formatted strings, since when I write raw strings, I use an r for, duh, raw strings
Slicing involves carving out a small contiguous part out of a larger string. The thing to note is that when I say s[0:4] it means upto, but not including 4
- If I say s[0:100], slices are forgiving and give me upto the end of my small string, without throwing an error.
- Empty colons in slices imply endings. s[:10] means start from 0 and go up to 9. Or s[9:] means start at 9 and go upto the end. Ergo s[:] means from the beginning to the end.
- I can have step sizes to step over. The default, hidden size is 1. I can step, oh, say every three elements by append :3 to the end of my slice like so, s[0:20:3], basically [start🔚step size]
- I can also have negative step sizes which will give me the results in reverse. The most common one being -1, because the quickly reverses a string for me (commonly done). But it works with other step sizes too. A -2 will start counting backwards every other character from the end. A reverse slice begins with the end character and then beginning. So s[10:5:-1] to carve out a slice backwards.
Sequences are strings, tuples and lists. They all can be sliced and diced and iterated upon.
Heuristic, else in a for loop is to match stuff when I don’t encounter a break. the else part matches the for to form the for-else construct, even though the break is inside the for loop
while loops are for when you don’t know the end of what you are looking for. there is not finite end. No 0 - 10 happening. You are just searching for something in an amorphous swamp. The swamp is vast, there is no way to say from this end of the swamp to that end.You only give up when you find what you are looking for, or when you decide it’s time to give up (some preset condition).
- make sure there is a counter that breaks stuff or I might loop forever

Learning / Feedback/ Experiences from doing exercises
#

Realising why Python notebooks are used. Very, very, very, handy to quickly write prose and code at the same time. It fits my mental model of programming perfectly!
I keep thinking strings and characters are English and forget to quote them! The number of NameErrors I get, is not funny.
Thing that keeps biting me when I write or statments. I should remember to say if x='blah' or x='meh'. I keep writing if x='blah' or 'meh', which is wrong.
I keep using a lot of superfluous variables. I should be more intentful. Instead of just printing an expression, I tend to figure out the expression, assign to a variable and then print it. Good for building, probably bad for optimal use. But I won’t worry about it too much now. Just something to improve on in the long term.
Reuven is a painstakingly methodical teacher. If he’s so good in his videos, I am jealous of folks attending his live classes

Read all about my Python basics journey here

A Hundred Days of Code, Day 006 - Starting and Quitting Comprehensions

feedback@janusworx.com (Mario Jason Braganza) — Mon, 13 Jul 2020 18:21:31 +0530

I know I said, I’d start with the basics, Reuven, but please forgive me this once :)
Will do the rest, bottom up :)

Have started up with this, because I’m fascinated with how folks manage to build in so much functionality into short, easy to read statements.
To my mind, comprehensions are the pithy proverbs of the programming world.
So here goes …

Notes
#

This style of writing code, comes from functional programming
Functional Programming is another style of writing code
- It assumes that data is immutable. (Or at least it treats it as such) It does not change the originals I work with. (I assume this means that I always work on a copy or something)
- we work with sequences of data and create new ones based on the old ones (changing case of a sentence, comes to mind)
- There are a bunch of techniques/patterns/heuristics that’ll let me do that
- We can treat functions as data and pass them around as arguments to other functions.
- The functools module assists with writing such code
Why code in such a manner? Some benefits include them being easier to read, easier to debug, shorter, more understandable.
Distributed Computing / Multiprocessing across processors and cores/threads makes these techniques more relevant in this day and age
My personal need is to write easy to read code, like when I see a well crafted list comprehension
If I want to square a list of numbers, my current go to is to generate a new list, using a for loop. Comprehensions are a better way of doing this
For loops are far when I want to execute something on each item of something iterable, like a list or a dictionary. when i want to have a statement happen
If just want to transmute the elements of list into something else, change each element, like square them all above, then comprehensions are my friend
Here’s a list comprehension to square a list of numbers from the list numbers.
- [one_number * one_number for one_number in numbers]
- The square brackets make it a list comprehension. If I want dictionary comprehensions, I would abut them with curly braces {}. And if I use (), I’ll get a generator expression (which I know only the bare basics about)
- For loops and comprehensions might look similar, but they really are different
Note: whatever expression you use to generate output has to return something. like the square expression above . because what I want to do is catch all my results in a container. functions (like the print function) that return None as their result, cannot work here. They will display stuff, but store only None in our comprehension container :)
I can also write the comprehesion over multiple lines (works because they are bounded by the list brackets here or bounded by other brackets elswhere)

[one_number * one_number		 
 for one_number in numbers]

here with the breakdown of the lines, the first line becomes my output generator; the expression I want to use and the second line, the data I want to process. Much more readable this way

learning / feedback/ experiences from doing exercises
#

Exercises today required a bit of head scratching and a bit of research, but were relatively simple
I should keep in mind that the computer can go crazy too. I kept wondering why my code wouldn’t run and and kept banging my head for an hour. Even Rueven’s solution was what I did. Until I restarted my Jupyter note book and everything worked the way I expected.
Should have a time limit on how much struggling I do. From the last week, it looks like I am a real sucker for pain otherwise. Half an hour tops and then go look up the solution.

Have reached the second set of exercises and realised why Reuven told me to start with the basics. I failed with the second one in this set. I just know, there is a simple solution and I cannot seem to get it. This basically means … yes … that my foundations are creaky.
Note to self, walk before you can run. By Jove, you should’ve learnt that by now! :)
So this is me, waving goodbye sorrowfully to comprehensions.
Will start with the basic Python course tomorrow.
But I’ll be back soon enough, damn it!

Read all about my comprehensions journey here

A Hundred Days of Code, Day 005 - Magic Methods and Winding Up OOP

feedback@janusworx.com (Mario Jason Braganza) — Sun, 12 Jul 2020 19:23:05 +0530

Done with Reuven Lerner’s OOP basics

Notes
#

len does the right thing across multiple types of objects.
- it counts characters in a string, elements in a list, and key-value pairs in a dictionary. how does it know how to do that?
that is because len uses a magic method (methods that have a __ for a prefix and suffix)
- len uses the __len__ method which i can use in my own classes, to implement a len method for my classes
If I choose to do so, I need to realise what those underlying methods expect to return and return the same type in my classes. __len__ expects to return integers, so when I implement it in my classes, I ought not to return a string. Once again Reuven strongly suggests using common sense :)
same thing when i try to print something. it calls the magic method __str__ to do stuff. or if i try to do repr to check for raw representations, the __repr__ method is called.
Python is filled with these methods which I can use to allow my classes to have standard Python like functionality. like a print(doggie) should give me details about the cute pup object i just created, if I have taken the time and attention to implement the __str__ or __repr__ methods
most of these methods come with the base primitive class object which every class inherits from. so i get them for free. and then i can override them and customise them to what I want to show.
people try standard methods on new objects. implementing them is much better than creating my own and asking people to use ’em.
if both are equal or really similar, ok to just use only __repr__. later when I have experience and other needs, i can implement __str__ too

learning / feedback/ experiences from doing exercises
#

Despite warning myself above, I went ahead and made the mistake of returning a whole lovely string, instead of an integer, when I tried to implement the len method on my class XD
and then I forgot to add the f prefix to an f-string and wondered why it was not interpolating for nearly 30 mins
Reuven has a wry sense of humour. In one of my exercises I get to create classes of animals for a zoo, with various attributes such as colour and legs and so forth. Then he has me put them in cages. After making me put 2 sheep in a cage with a wolf, he wonders if the legs of the sheep ought to be reduced or not XD
The number of typos I am making is staggering. Missing colons, missing quotes, missing brackets. If this is Python, I shudder to think how I’d fare if I picked up a static language to learn XD
Wasted another half an hour because I spelt colours with capitals like Black and then later looked for black and was tearing my hair out, because I knew there were black animals and why in tarnation, would Python not show me them XD
Saw Reuven do nested comprehensions and now I want to do that too! it took him one well thought out line to do what I did in 2 multiline functions

Final Words
#

This was amazing!
I learnt so much about classes and the way they work.
Reuven has a very joyful pedagogy.
I love him go hahahaha like Santa Claus.
I love the fact that he makes mistakes.
I love that for every problem, he poses, he has various approaches.
His fluency shines through every lesson.
I got lucky with the Pycharm Humble Bundle.
But I loved this so much, that I am going to sign up for all the Lerner courses, I possibly can.
Beginning with the basics.
If OOP is any indicator, the journey is going to be lots of fun.

Read all about my OOP journey here

A Hundred Days of Code, Day 004 - Class Attributes and Inheritance

feedback@janusworx.com (Mario Jason Braganza) — Sat, 11 Jul 2020 17:47:49 +0530

Learnt about Class Attributes and Inheritance, today.

Notes
#

The way we write functions/methods and define classes might look similar,
class CrazyTalk(object): and def how_now_brown_cow():
The way they behave/execute, though is wildly different.
Classes run / spring to life as soon as the program launches.
Functions don’t, unless they are called.
Realised that objects are containers.
What you can do with the object depends on what is in it.
Does it hold a dictionary with various methods to modify it?
Does it just hold a bunch of text?
Reminds me of media formats as containers.
A mp4 file is not just an mp4 file.
The video resolution could vary from one file to another.
The type of audio encoding could be different.
It could carry multiple streams of audio or video or other metadata.
What you can do with the file or where you can play it, depends on what is inside it.
Same with classes and objects.
Any thing that we define inside a class, is an attribute. (methods, variables etc.) Reuven made a point of stressing this, so writing this down.
If I just define a variable and try to use it, I’ll get an UnboundLocalError. I need to use className.variable when I call it.
So I can just write a variable like so

class SomeClass():
	crazy_var = 'Muahahahaha'
	def __init__(self):
		print(SomeClass.crazy_var)

and then call it with SomeClass.crazy_var or when I do it after I define __init__ then I can just directly define it as SomeClass.crazy_var (which sounds more logical to me), like so

class SomeClass():
	def __init__(self):
		print(SomeClass.crazy_var)
SomeClass.crazy_var= 'Muahahahaha'

A class attribute is associated with the class itself, while object attributes are associated with the objects that are created from the class.
So with car.wheels, the wheels are associated with the car class, but when I use car to create a Ferrari object, and it has Ferrari.white_wall_rims the rims are an instance attribute that belong to the Ferrari object / instance and not the car class it was made of.
If I ask for an object’s attribute and it isn’t there, then Python goes looking upwards to check if the class has it. In the previous point, if I go Ferrari.wheels it’ll work, because Python will check the Ferrari object and if there are no wheels in there, it’ll go check cars.
Name your attributes carefully.
Don’t have the same names between class attributes and object attributes.
Use your head!
Don’t do that!
When we create a class, that is identical to another with one or two teeny exceptions, when they are so similar that I base the new one on the old one — those new classe are said to be inheriting from the old one. They have an is-a relationship.
For e.g. a doggie is-a floofy animal.
A teddy bear is-a floofy animal too.
Both of them inherit their floofiness from the floofy animal class.
I can write that as class Doggie(FloofyAnimal):
Note: Methods are attributes on a class. They are not attributes of the instance object.
Note: If you have an __init__ method in your inherited class, the instance will not look for __init__ variables/details in the parent class.
(it’s like this in Python, Java/C++ can get stuff from the parent / grandparent. this is so, because with Python, everything is a live object whereas with the other languages, the __init__ stuff are declarative rules with orders of precedence (a la CSS) and the class comes alive only after all the rules are parsed.)
If you do want to inherit something from the parents __init__, then you explictly get it by using super(). as in get it from the supervisor above, i guess? I’d add a line like this to my doggie class

class Doggie(FloofyAnimal):
	def __init__(self, name):
		super().__init__(name)

And then it will pull the name from the Floofy Animal class if it’s in there.

Use inheritance only when it makes sense. No need to go hog wild.

learning / feedback/ experiences from doing exercises
#

Slowly getting the hang of list comprehensions. I should practice them more.
Because they are very easy to read later.
Just that, I get very confused while writing them.
Doing the exercises is slowly getting easier
Reuven is very hands on, has tons of jokes, and makes tons of typos.
I’ve gone from eyes glazed, looking at the his code and struggling to understand to yelling at the screen when he mistypes something :)
Shows that I am learning :)
Python Tutor is very handy to see the the thousands of mistakes I make.
Even that interface does not quite make me understand, but it gets me 80% of the way there.
(like when a return statement of mine was nested in a loop instead of being out at the end of the for statement.)

Read all about my OOP journey here

A Hundred Days of Code, Day 003 - Methods

feedback@janusworx.com (Mario Jason Braganza) — Fri, 10 Jul 2020 19:44:34 +0530

Learnt about methods today.
Notes follow …

My understanding about methods? They are functions in classes that help me manipulate the data the objects contain when they are created.

I have been using something them subconsciously all along.
The __init__ method, that is called/run automatically every time an object is created.

Aha
A nice way to unpack the .notation i use

Let’s say I have a class SquareNumbers that has a function (method) — x2 — that will, you know, square a number.
And then I create an object f with a number and call the square method on it.

f = SquareNumbers(10)
f.x2()

What I am actually doing, when I call f.x2() can also be written as SquareNumbers.x2(f).
I am sending a message x2 to the f object, and it will respond with however/whatever it is programmed to.

When I define object variables in a class, I should refer to them with a self.variable when I define methods.
I figure because each object can have it’s own set of values for those variables and I want Python to find them properly.

Also learnt this is not the case in most other languages.
With some languages, you set and get values of variables of the object, using even more explicit methods, call getters (accessors) and setters (mutators).
These are just fancy names for explicit methods to assign and then read data from the variables of a class.
In our example above, I would probably have a set_x function defined to set the value of x like f.set_x(20) (along with a corresponding get_x to read it)

This could also be because other programs have different categories of data (private, public) in classes, while Python does not.
Just differences in language design philosophies, I guess.

I can create an class, that can use objects created by other other classes.
For example, I can create a book class and then have several book objects.
And then create a new bookshelf class, whose objects can take all my books and put them in a list/library of sorts
This kind of relationship is called a has-a relationship in programming parlance.
(like my bookshelf has-a book on it)
It’s also called composition. I am composing a new class from other classes.
I can do what I want with the list in the bookshelf.
I could take their prices (if i added them) and then sum them up.
I could take the titles and list them alphabetically, or by author.

Aha

So what is becoming clearer to me is that classes can take user needs, and express them naturally, while leaving the creation of these calculations and listings and sortings with the programming language primitives behind the scenes.
For my book shelf i could just go shelf.sort.title.alphabetical()
Or if I have a new need tomorrow, hmm, like finding the total prices of all my books, I could just add a sum method to my bookshelf and I could go shelf.sum().

It basically makes my code, more human. More easy to understand. More natural.

Another thing that just occured is that I could swap out the primitives beneath the classes. If I find a faster, better way to sum up prices, I could just use that. While the way I would sum the books would still remain shelf.sum()

Doing the exercises, I realise that I need to learn a lot more Python vocabulary.
I somehow managed to gather a number of variables into a list.
But when I attempted to do it again, it threw an error.
And that’s when I learnt I could extend a list.
Lots more practice needed!

The self thing bit me hard!
I spent at least a 45 minutes trying to find out why my method could not find a variable, despite me defining it correctly. I should’ve obviously referred to it with self.variable!

Time to call it a day.

Read all about my OOP journey here

A Hundred Days of Code, Day 002 - Basic Exercises

feedback@janusworx.com (Mario Jason Braganza) — Thu, 09 Jul 2020 19:15:05 +0530

Did a few exercises today.
They were simple.
Create a few classes, change them, modify them, use a list as an attribute and so on.

In a couple of ways, this was just what I needed.
One, I had an extremely busy day at work, and so I did not have the brain power to do anything complex, so I needed the bar really low any way.
And two, I’ve realised, that I have always tried to just read a book and then leap mountains. I don’t know why. I must be a sucker for pain. And then when stuff does not work, I sulk and get frustrated.
Easing into hard topics like this, makes it more enjoyable for me and I learn better.
This is a meta skill, I should remember to use.
Come to think of it, everything I have learnt recently, actually learnt, has been this way.
I learnt Dvorak and touch typing, slowly, key by single key.
I learnt to diet and lose weight, by tens of grammes in the beginning.

So, note to self.
Start small.
Do the work.
Show up daily.

Read all about my OOP journey here

A Hundred Days of Code, Day 001 - Beginning With Classes

feedback@janusworx.com (Mario Jason Braganza) — Wed, 08 Jul 2020 18:08:05 +0530

Notes I’ve taken from the videos I watched, today. This is my attempt at Feynman-ing (below), what I learnt so far.

Classes and Object Oriented Programming started to come together for me, when I saw Kushal using them.

To use my father’s carpentry analogy, I could in theory just hammer nails into wood to join them.
But to make a really strong joint, I could use other methods.
I could screw pieces of wood together, which is markedly better than just nailing them.
I could chisel wood and create a dovetail or mortise joint.

So it all comes down to understanding what I want to do and figuring out the best technique to get it done.

Like I mentioned in the toot, I could in theory just kludge together all my primitives and create something.
But, if I want to create something beautiful and something that I (and others) can understand, I need to use a different method.
Object Oriented Programming, is a popular one.

Objects and Types (In Python)
#

We have objects and types/classes.
We can think of them like we do about cells in our body.
Python for the most part is natively made of objects.
Nearly every primitive I have come across in Python is an object.
Strings are objects and work a certain way / Skin cells work a certain way.
Dictionaries work a certain weay / Optical cells in the eye, work in an very specific manner.
Integers are objects and have their own ways of doing things, as do white blood corpuscles.

Objects are a special type of something.

A class makes objects.
An int class makes integers. A string class makes strings. And so on and so forth.

With Python even classes (the constructors) are objects.
So, there must be some kind of God / Creator thing that makes these primitives / originator classes.
And there is.
It’s the type class.
It’s the base class, the bottom turtle, if you will.
The type class creates all these primitive classes, which we then use to create other objects for our use.
The type of the int (integer) class is type as is the type of the str (string) class.
They are all objects of type type.

Which basically, again to use a physical analogy means that type is the iron forge, which i then use to create factories, which i then use to fashion usable things.
The forge lets me create lug nuts and chassis’ and then I take all these, to create a car factory, which lets me make cars of different types and sizes, with varying amounts of power.
The forge lets me create some mixer, which i can then choose to setup different sorts of mixer factories. Some can make ice cream, some can make porridge.
type (the forge), creates the int class (the factory), which lets me create all sorts of integer numbers to play around with.
type (the forge), creates the dictionary class (the factory), which lets me store and sling data about in various ways.

Note: This might not be true of other programming languages (for e.g. int might be a base primitive.)

Attributes
#

Every class can have attributes (data, or methods to manipulate data).
Those attribute themselves could be classes, having their own attributes.

Now each of those takes memory.
Python doesn’t gobble up all our memory however, because some (most?) objects share memory.

Run dir on an object to get it’s attributes.
For example, I could do this on the str class to see what it has.

>>> dir(str)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

I spy with my little eye, that any string object lets itself be split or joined or lets its case be altered and much, much more!

I can go into any object I want (with few exceptions) and change its attributes!
For example, I type os.sep to get the path separator. (on a linux machine it’s / and on windows it’d be \ and if python ever ran on classic Mac os I guess it’d be :
I can just change os.sep to be ! or hahaha or whatever i want!
Or I could just add whatever attribute I want to any object!
In short, I can set and get attributes on any object I want!
Sounds pretty free-ing! Will have to see what this means in practice!

Aha
The inbuilt functions that I have learnt are not the norm.
Most code is written in classes and functions are available as methods of those classes.
Ruby natively works this way.
Python pragmatically, has created some functions as primitives.
(One possible reason could be, for example, rather than have a len method on every in built class, they musta thought it easier to create a primitive len function that worked on different classes and data types)
In real life (and across programming languages) I should mostly be looking at object.method(), for e.g. some_list.pop()
If I want to look at how to manipulate something, the general heuristic is to look at methods first. Does an object support manipulating itself through itself? After all, it knows itself best! :)

If I want to know what methods an object supports, I can of course call dir on it, but a better cleaner way is to call help on it. (help(list)). It shows, more clearly, the methods an object supports.

Why Classes
#

Do I need to create classes?
Of course not, I have been creating programs without them all these months.
A couple of reasons I’d create a class,

To stop kludginess. I don’t to expose a list of dictionaries, that contain more dictionaries that have lists as their values. better to abstract them away from the user (future me) and present simpler interfaces.
I love to write well crafted prose. Classes represent complete sentences in human language. Nouns and verbs amounting to a sentence that makes sense and is well crafted.

How do i create a class
#

Aha
Just realised that when I create a class, I am creating a new type of primitive for myself.
My own data type!
I can create my own numbering system if i want to!
Muahahahahahahaha
(comes back to reality)

class somethingsomething(object):
	pass

That is all I need. Just to say class, create a class with this here name! And *Abracadabra-Alakazoom*, Python goes ahead and creates a new class for us!

As I wrote above, this is a factory, to create new somethingsomething objects.
I can do that by just assigning it a name. Like Iron man summoning his suit out of thin air.

somethingblue = somethingsomething()

And boom! The object `somethingblue` materialises!

This is just a blank template, of course.
I cannot do much with this. (Right now, I don’t even know, what I can imbue this with, or use it for :P)
So I guess, the rest of the course will probably deal with how to make classes work and function the way I want them to.

I can add attributes to my classes just by declaring them.

somethingblue.color='sky'

somethingblue.liquid='ocean'

somethingblue.code=0x0000FF

And then i could `dir(somethingblue)` and it will give me them attributes, along with a list of everything it has inherited from the parent class (here the `type` class)

A neater way of looking at only what I defined, is to do vars(somethingblue)

Aha
Heuristic - While i can add attributes willy-nilly to any object I want to, it’s bad form.
The idea being that the factory (the class) should ideally provide a set of default attributes and values, so that not too much monkeying is required.
This process/template of assigning sane attributes is called a constructor.

The way we create a class is two fold (very Smalltalk-esque)

I create a class.
I add its attributes.

So when Python goes to create an object of the class, it does it like quite similarly

it creates as new object when i say object = class_whatever(), using the __new__ method
it then goes looking to see if there is an __init__ method in the class, and if it exists, then to use that to setup the default attributes
it uses the self (by convention) argument, to assign those attributes to the object. (I am applying shampoo to mine own self)
and then assigns it to the variable that’s supposed to catch the instance.
(I always somehow assumed it was the other way around. A variable in memory was assigned and then created like a building. This is more nature like. Stuff grows and then is assigned a name)
I can absolutely go do what I want, assign attributes however, but if I want to stay sane, I’d rather follow convention

And that’s about all I studied today.
Follow along the my Python OOP train here.

P.S. The Feynman Method.

A Hundred Days of Code, Day 000 - Begin Again

feedback@janusworx.com (Mario Jason Braganza) — Wed, 08 Jul 2020 11:01:33 +0530

How do I begin this post?

By simply beginning :) Again!

This probably is the fourth (or is it fifth) time, I’ll be attempting to learn how to program.
And probably the same number of attempts at #100DaysOfCode.
I did 47 days last time and 37 days before that.

I will try my utmost to go the distance this time.
Because even if I didn’t complete a full run, I still learnt tonnes from all my previous efforts.
I do have a beginner’s grasp of Python.
And I hope get even better, much better, this time.

What am I going to do?
Well, I want to do Miguel Grinberg’s Flask Course, but as I stumbled through it the last time, and when I read other folks’ code, I realised that I need to get much better at understanding Object Oriented Programming.

So that’ll be the focus now.
And Reuven Lerner’s OOP Course is what is going to help me.

So here I set sail again …
Now, bring me that horizon!

Hiatus!

feedback@janusworx.com (Mario Jason Braganza) — Thu, 18 Jun 2020 09:10:31 +0530

Lost a friend to the virus last night.
And a shit-ton of personal issues have cropped up at the same time.

Need to go handle and process all of this.
Will be back, when I am back.

A Hundred Days of Code, Day 047

feedback@janusworx.com (Mario Jason Braganza) — Wed, 17 Jun 2020 11:05:49 +0530

Follow my whole plodding, Flask journey here.
Crashed and burned even harder today.
Tried to retrace my steps and did all the exercises again.
I reached, once more, all the way upto the forms chapter and it just does not work. Now it won’t even display my login page.

Was it worth doing?
Oh yes.
I gained a much better understanding of how Flask works, of what is required where.
Will work once more at the login page tomorrow.

A Hundred Days of Code, Day 046

feedback@janusworx.com (Mario Jason Braganza) — Tue, 16 Jun 2020 10:12:01 +0530

Follow my whole plodding flask journey here..

Am still stuck at where I was yesterday.
But made a tiny bit of progress.

Yesterday, it would not even submit the form.
And now I got it to do that.
How? I had forgotten to close the form tag.

Now while I see that it is posting perfectly in the terminal, I cannot get it to reply with a message saying that I indeed have logged in.

Will start watching the videos again tomorrow, to see if I have missed something.
One thing that I am doing different from the course, is that I am using the new style f-strings, while the course uses a slightly older style.
Could it be, that some flask module might not like it?
Will work at it tomorrow and write down, what I figure out.

A Hundred Days of Code, Day 045

feedback@janusworx.com (Mario Jason Braganza) — Mon, 15 Jun 2020 10:27:48 +0530

Follow my whole plodding journey here.

Wrote a basic login form today.
Short story short, it shows up, but it does not respond like Miguel shows in the course. It justs sits there … staring back at me … like an obstinate goat.

Will go spelunking into what I could have done wrong, tomorrow.

Learnt about adding routes and creating views and making templates.
Thoroughly confused though.
While I am dumbly following instructions right now, what I don’t get, is what do I need to write first? It all seems very circular to me.
What comes first? The route, the form, the template, the chicken or the egg?

Hopefully, I will gain clarity as I progress.

A Hundred Days of Code, Day 044

feedback@janusworx.com (Mario Jason Braganza) — Sat, 13 Jun 2020 12:44:38 +0530

Continuing the Flask course.

Learnt about seperation of concerns today.
To me that means that I should try to keep related things together and disparate stuff apart.
Case in point, we¹ created a seperate file config.py to store the variables about the program in. And then to kind of secure it even more, instead of hardcoding the password in the file, it now looks for an environment variable, which I need to set before running the program.
Another example was when we created a seperate file to process input (for our logins) and then put all the login, password etc. fields in there. This feels good. Feels like I am learning best practices and good habits already.

The file I created to process login input, is called a form (as in fill in this form? guess so) and uses the WTForms package to do the heavy lifting.
And that was where I learnt my next bit. Not only is Flask, made of modular pieces, it also has an ecosystem of various other modules (called flask extensions) that give it extra functionality, oomph and power.²

And here’s where I called it a day.

Who we? Why, Miguel the instructor and me, of course XD ↩︎
WTForms is an example ↩︎

A Hundred Days of Code, Day 043

feedback@janusworx.com (Mario Jason Braganza) — Fri, 12 Jun 2020 13:11:40 +0530

Continuing with the Flask course.

Today I learnt about how to loop, using Jinja loop blocks.
The syntax is slowly becoming clear to me.
Everything python related in enclosed is {% … %} blocks, except for variables which use their own {{ … }} syntax.

What I am still confused on is the relationship between the various files, I am writing. There is html and then there are templates and there are python files themselves. Hopefully that will get clearer in the days to come.
My naïve understanding, right now, is

Some native python code is mainly for launching and running the app.
The html templates pull data from …
The flask python code I write (the routes file, as of now).

I also learnt how to extend templates. I created a base template that basically contains the header and the title, which will now be used by every new webpage I build. Right now, it’s just the home page.
I can see a footer or header or some such persistent element that needs to be on every page, that can be created once and then extended multiple times.

More, tomorrow …

P.S. Looking at that finished app, and knowing my extremely rudimentary Python skills, I feel like an apprentice mason, hammer and a chisel in hand, wondering, how in heck, am I going to carve David?

A Hundred Days of Code, Day 042

feedback@janusworx.com (Mario Jason Braganza) — Thu, 11 Jun 2020 16:36:21 +0530

Second day with the Flask course.

Beginning to realise that Flask is not a monolithic thing, but consists of a lot of moving parts.
Looking forward to learning what they are as I progress along.

Today I learnt how to set my Flask variable, and create an environment, so that I can run Flask consistently without problems.

Miguel also teaches a simple, yet effective way to combat yak shaving.
You know, where all you want is one simple thing, but then that depends on that other thing, which reminds you that you need that third thing and the next thing you know, you’re at the zoo, shaving a yak, all so you can wax your car.
Just don’t do that other thing.
Focus on what you are doing.
If there is something you need, use a dummy. Mock something up.
This is a very real, meta lesson, that I’ll carry with me for the rest of my days.

So I learnt how to return a web page.
And that got tiring really quickly.
Which is when Miguel introduced me to templates.
And I realise why they are needed.
I created a basic template and also learnt about conditionals in the templating language, Jinja and then I called a stop to the day.
More to follow tomorrow.

The Long Road I took to Learn Basic Python

feedback@janusworx.com (Mario Jason Braganza) — Wed, 29 Apr 2020 14:37:54 +0530

I have been wanting to switch careers to programming for a long time now.
Just that juggling a part time job, home work, and a broken back, always kept me from somehow giving it the time, that that I needed.

It has been two years now.

My lowest ebb, was September last year, when I caught a really nasty bug, was laid up in bed, for nearly a month and then checked myself into a hospital because I thought I was having a heart attack.¹

In the meanwhile, people have learnt stuff, gotten careers and rocketed up their charts while I sit here spinning my wheels.
Or at least I used to think, I was spinning my wheels, until this month.

In my head, I used to be like, why is this so hard for me?

I write this, to remind myself from getting discouraged.
To remind myself of the progress I made, even if it hasn’t been much yet.
To show my future self, that past Jason, was not a fat slob.
He worked his ass off. And he was resilient.
I write this, because I had a few hard days again, but this time I don’t want to slide into a pit of despair once more.

The first thing, I reminded myself, was that everybody’s journey is different.
With my physical problems, it has not been easy to focus.
I have to juggle a ton of things, as a husband, son, consultant, patient and student.
And while it may seem all dark and gloomy, I was surrounded by incredibly loving and helpful people, which has made my journey, a lot easier than it would have been without them. My wife, my mother, my friends … all pillars of support!
So the pace I am at, might be much slower than other people, but it reminded me of something my physio said to me when I was sure, I would never be able to run more than 2 minutes straight.

You might be slow.
You might be fat.
You might be in pain.
But you will be better much sooner than other folks I know.
Because you are doing it.
While the rest are still sitting on their asses, moaning.

The second thing I did, was to take stock of how far, I have actually come.
Yes, I am not as financially well off as I would like to be.
Yes, life has kicked me in the nuts, more times, than I would like to count.
But I dug myself out of poverty.
I am working myself to the best shape of my life.
I could barely walk two years ago, and now I am practically running.
I am steadily inching to being my weight in my early twenties (while being much fitter than I was then)

So the problem is not me.
It might take time.
But I can do this.

And as I am doing this second public round of a hundred days of code, I realise all I have to do is to have no shame about my speed (or my abilities), and be resiient and persistent.

And to remind me about just how far I have come, I write this down.
I started nearly three years ago. I wasted a year, spinning my wheels.
And then I found Kushal and DGPLUG. A more supportive mentor and a more welcoming community, I hadn’t experienced in my life. I am still learning from them. And they still teach me with unending patience. If you are ever on IRC, just come say hi on the #learnandteach channel on Freenode.
I started learning the basics from a kids book, because the big ones were confusing.
I tried learning python after that, but I failed.
I tried lots of books, and online sites, but I just could not get it.
I realised that just learn the syntax and go, does not do a thing in my brain.
Or the excellent Python for You and Me would have been just the ticket.
Then I realised that maybe learning more basics would help.
And that this was not something I could learn in a few weeks or months.
So I studied the raw basics of computer science, so I could understand, what was what.
And then I understood some.
I then took my time and read the biggest non fiction book I ever read in my life. The Lutz Python Book.
And I understood some more.
I went and watched a series of videos by some kid on youtube.
And I understood some more.
Just doing all this took the better part of a year and a half.

Now here I am.
On the cusp of a moment, when I think the dam might break.
Because things make sense faster now.
I can read what other people write and actually understand.
I can think for myself and write short programs.
I can understand what the other folks teach and get it.
From here on, it seems just like a matter of loads of practice.

I write this though, to remind myself, that if this moment is not to be, then I needn’t worry.
I can see how far I have come.
I will do this.
All I need to be is shameless in my learning, patient in my attitude, and resilient in my mind.

P.S. I realised all this was inspired by an old Aurelius quote,

“True good fortune is what you make for yourself. Good fortune: good character, good intentions and good actions.”

Spoiler. It wasn’t. Just an enlarged spleen acting up due to complications from the bug. Still serious. Just not a heart attack :) ↩︎

A Hundred Days of Code, Day 006

feedback@janusworx.com (Mario Jason Braganza) — Sun, 19 Apr 2020 13:03:52 +0530

Journal progam done!
Yay! Find the code over at Gitlab or Github.

The program is a lot more basic than I expected.
It does not let me keep multiple journals :)
But I’m happy with what I learnt.

How to put together a program
How to use modules
Found a little extension in VSCode, called VSCode autoDocstring, that makes typing in docstrings a breeze.
Oh, I learnt about docstrings, to help document what I am doing.
And brushed up on the basics, loops, conditionals, etc.

Here’s to more happy programming.

Planetpython on Janusworx

derb; Script to Create podcast RSS feeds

Setting up house #

Creating a feed #

Adding episodes and writing out the file #

Serving #

TIL: The Difference Between a CLI Tool and a Freeze Tool

Updated Poemfeed

Starting up #CNC2021.

I Can’t Do This Yet … Updated

“You’re not that good”

A Love Letter to Books

Thoughts on Setting Up a Blog

Intent (aka, what do you want out of your blog?)

Begin Writing!

Tools of the trade

Consolidating Websites

My Plan for the New Year

A Day of Updates

Nikola Upgrade #

Pleroma Bot #

Git the Branch

Poem Feed

Starting Work on Git-the-Branch

The Itch #

What I did today #

A Good First Day

Getting Back on the Horse

A Hundred Days of Code, Day 026 - Refactoring

A Hundred Days of Code, Day 025 - Comprehension Exercises

Reflections and Experience #

A Hundred Days of Code, Day 023, Day 24 - Tiny Utility to do comparative DNS Lookups

Problem - Compare domain lookups, against DoH Servers #

Notes #

Experience #

Code. #

A Hundred Days of Code, Day 022 - Getting into the Groove

A Hundred Days of Code, Day 021 - Swing and a miss

A Hundred Days of Code, Day 020 - Setting up an Editor for Python Development

A Hundred Days of Code, Day 019 - Future Exercise Addendum

A Hundred Days of Code, Day 019 - Python Iterators and Generators, Done!

Notes #

Learning / Feedback/ Experiences from doing exercises #

A Hundred Days of Code, Day 018 - Python Comprehensions, Done!

Notes #

A Hundred Days of Code, Day 017 - Python, Advanced Objects, Done!

Notes #

A Hundred Days of Code, Day 016 - Python, Advanced Objects.

Notes #

Learning / Feedback/ Experiences from doing exercises #

A Hundred Days of Code, Day 015 - Python, Advanced Functions, Done!

Notes #

Learning / Feedback/ Experiences from doing exercises #

A Hundred Days of Code, Day 013, Day 14 - Python, Advanced Data Structures, Done!

Notes #

Learning / Feedback/ Experiences from doing exercises #

A Hundred Days of Code, Day 012 - Python, Advanced Data Structures continued

Notes #

Learning / Feedback/ Experiences from doing exercises #

A Hundred Days of Code, Day 011 - Python, Advanced Data Structures

Notes #

Learning / Feedback/ Experiences from doing exercises #

A Hundred Days of Code, Day 010 - Python Functions, Basics Done!

Notes #

Learning / Feedback/ Experiences from doing exercises #

A Hundred Days of Code, Day 009 - Python Functions, Basics

Learning / Feedback/ Experiences from doing exercises #

A Hundred Days of Code, Day 008 - Python Basics, Lists, Tuples, Dictionaries, Sets and Done!

Notes #

Learning / Feedback/ Experiences from doing exercises #

A Hundred Days of Code, Day 007 - Python Basics, Variables, Basic Data Types, Strings and Loops

Notes #

Learning / Feedback/ Experiences from doing exercises #

A Hundred Days of Code, Day 006 - Starting and Quitting Comprehensions

Notes #

learning / feedback/ experiences from doing exercises #

A Hundred Days of Code, Day 005 - Magic Methods and Winding Up OOP

Notes #

learning / feedback/ experiences from doing exercises #

Final Words #

Setting up house
#

Creating a feed
#

Adding episodes and writing out the file
#

Serving
#

Nikola Upgrade
#

Pleroma Bot
#

The Itch
#

What I did today
#

Reflections and Experience
#

Problem - Compare domain lookups, against DoH Servers
#

Notes
#

Experience
#

Code.
#

Notes
#

Learning / Feedback/ Experiences from doing exercises
#

Notes
#

Notes
#

Notes
#

Learning / Feedback/ Experiences from doing exercises
#

Notes
#

Learning / Feedback/ Experiences from doing exercises
#

Notes
#

Learning / Feedback/ Experiences from doing exercises
#

Notes
#

Learning / Feedback/ Experiences from doing exercises
#

Notes
#

Learning / Feedback/ Experiences from doing exercises
#

Notes
#

Learning / Feedback/ Experiences from doing exercises
#

Learning / Feedback/ Experiences from doing exercises
#

Notes
#

Learning / Feedback/ Experiences from doing exercises
#

Notes
#

Learning / Feedback/ Experiences from doing exercises
#

Notes
#

learning / feedback/ experiences from doing exercises
#

Notes
#

learning / feedback/ experiences from doing exercises
#

Final Words
#

Notes
#

learning / feedback/ experiences from doing exercises
#

Objects and Types (In Python)
#

Attributes
#

Why Classes
#

How do i create a class
#