Programming on Janusworx

I Should Write Down and Summarize What I Did

feedback@janusworx.com (Mario Jason Braganza) — Mon, 23 Jan 2023 10:37:17 +0530

I did a lot of research the other day about what I’d need to build a contact form for my website.
I bookmarked lots of pages.

And today, I come and look at this mountain of videos and sites and pages and woneder what exactly it is, that I am supposed to tackle.
Nothing makes sense.
I know I ruled out Sendy as an option. Or did I?
Do I need Javascript? How much? Can I get snippets to copy paste? Do I need to go learn Javascript?
What is spam protection? Do I need spam protection? How do I do it?
I’ll have to go look at it all again now.¹

Note To Self:

As you wind down your day, summarize what it is that you were working on in the eve.. (in however shitty a manner. does not matter.) Which also means, you need to keep some time in hand to do that. Or stop working a bit earlier
As you being your day, look over your calendar first², agenda next³, and as you begin each task review your summary from wheneve you worked on it last⁴.

I do this when I work all the time for clients.
Wonder why I never do it for my learning.
Time to treat myself as my most important client, and not assume that I will remember the important bits.
Time to make it easy for myself to pick up the threads again.

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.

Or god forbid, research it all over again. ↩︎
Which I normally do ↩︎
Which I also normally do ↩︎
Which I never do ↩︎

Learning DSA, Day 001: Recursion Basics

feedback@janusworx.com (Mario Jason Braganza) — Mon, 08 Aug 2022 15:02:13 +0530

Using Abdul Bari’s, Mastering Data Structures & Algorithms using C and C++ to grok the basics.
Now that I grok programming, understanding DSA should help me write and think better.

And writing rough notes or thoughts to myself here, keeps me accountable and on track.¹

Today’s topic?

The Basics of Recursion
#

Types of Recursion
1. Tail Recursion
2. Head Recursion
3. Tree Recursion
4. Indirect Recursion
5. Nested Recursion

Tail Recursion
#

When a recursive call, is the last statement in a recursive function, that’s tail recursion

func(n)
{
	if (n>0)
	{
		blah … ;
		blah … ;
		blah … ;
		func(n-1);
	}
}

All the operations in the examples above happen at call time. Not when the function returns

Tail Recursion vs Loops
#

Tail recursion function can be written as a loop and vice versa
Time taken by both, O(n)
But the space taken by a loop is O(1) while a tail recursive function is O(n). The loop takes less space. Some compilers also do this under the hood (convert a tail recursive function into a loop)

Head Recursion
#

func(n)
{
	if (n>0)
	{
		func(n-1);
		blah … ;
		blah … ;
		blah … ;
	}
}

In the example above, the recursion happens before anything else takes place.
the recursion call is the first statement
the rest of the function is processed, in the return process. (i.e. once the recursion call is done executing)

Head Recursion vs Loops
#

Head recursion function and a loop that gives a corresponding output are not quiet convertible from one to the other. Some work required.

Tree Recursion
#

func(n)
{
	if (n>0)
	{
		blah … ;
		func(n-1);
		blah … ;
		func(n-1);
		blah … ;
	}
}

If a function calls itself multiple times, then we have ourselves a tree recursion
Time complexity? pretty complex. A simple thing like the one above would be O(2ⁿ), while the space complexity is O(n)

Indirect Recursion
#

void A (int n)
{
	if (something-something)
		{
			blah … ;
			B(n-1);
		}
}
void B (int n)
{
	if (something-something)
		{
			blah … ;
			a(n-1);
		}
}

Two (or more) functions calling each other in a circular fashion. A -> B -> C -> A

Nested Recursion
#

void fun(int n)
{
	if (blah-something)
	{
		blah
		fun(fun(n-1))
	}	
}

A recursive function passes a recursive call to itself as a parameter to the function.

The code’s all C++ pseudo code. Written only so I can get what I was trying to learn. ↩︎

Tomorrow is Another Date

feedback@janusworx.com (Mario Jason Braganza) — Sun, 31 Jul 2022 15:17:11 +0530

Org mode is ~~slowly spreading its tentacles~~ increasingly becoming something, I cannot live without, to manage my day.
And I’m getting pretty consistent with it too!

Like you see above, I use dates as my headlines, below which I list the various tasks for the day.¹
And that’s where I run into my current itch to scratch.

I don’t want to keep typing out the date daily.
The computer can do that for me.
But how? Of the millions of ways possible, what do I want to do?
My first thought was to figure out some way to insert a date into Emacs.
And then I thought, why only emacs? I want it systemwide, across all my programs.
So I checked if Espanso, my friendly text expansion program, would do that for me.
Turns out, Espanso does!
I could just type :dtx wherever I wanted and Espanso would happily insert the date in there. And so I did that for a few days.
Problem solved? Well, that’s when the itch got stronger.

See my evening tasks above?
I use Cal Newport’s idea of a shutdown ritual, to empty my mind and plan the next day, every evening.
Which, for the past couple of weeks meant using my little expansion snippet to put in today’s date for the next day’s headline, as I began planning it. And I’d just manually change the date part to the next day’s date.²

Until today.

I typed in :dtx and I got 2022-07-31.
And then the lazy bum inside me groaned. What? I need to the change the month too?
The computer can do that for me!

So I went back to Espanso to see if it did support date expansions for tomorrow.
Turns out it does!
Only for some reason, it just wouldn’t play ball with the way I want my dates expressed, (YYYY-MM-DD). It would throw weird yaml errors.
And then I recalled Emacs just called the shell to do it.
So I went looking to see, if Espanso could call the operating system shell³ to do expansions ala Emacs.
Turns out, it can!

Finally, I looked up how the date command worked with past and future dates, and jigged up a small expansion snippet and put that into Espanso’s match/base.yaml

 - trigger: ":dttx"
 replace: "{{output}}"
 vars:
 - name: output
 type: shell
 params:
 cmd: "date --date='tomorrow' +'%Y-%m-%d'"

Et voilà!
No more backspacing and struggling with Espanso undos and date calculations.
:dttx turns into tomorrow’s date:2022-08-01!
And the monkey brain is happy again :)

Subtasks not shown. ↩︎
like yesterday evening, I typed in :dtx to get 2022-07-30 for e.g. and then changed the 30 to a 31. ↩︎
in my case, bash ↩︎

Emacsclient Does Not Recognise Compose Key Sequences

feedback@janusworx.com (Mario Jason Braganza) — Sun, 31 Jul 2022 08:00:00 +0530

Originally published 2021/10/27. Updated to include the .xssessionsrc point

I run pretty often into this issue, so this is a checklist for me.
Issue being, that I cannot use Compose key sequences to type out the characters I need.

Case in point being, the apostrophe ’ and the quote marks “” , ‘’ that I use, all the live long day.

Make sure that emacs is running as a service. It runs in your user, so check status with systemctl --user status emacs.service
- Do the normal computer user thing. Restart the service.systemctl --user restart emacs.service.¹

Make sure the system is UTF-8 everywhere. (en_IN.UTF-8 does not work for me. Make sure it’s en_US.UTF-8)

One place that Emacs looks is the .xsessionrc file in the home folder.

These are the contents of mine. My Emacs refuses to let the compose key sequences work, unless it’s present

LC_NUMERIC=en_US.UTF-8
LC_MONETARY=en_US.UTF-8
LC_PAPER=en_US.UTF-8
LC_NAME=en_US.UTF-8
LC_ADDRESS=en_US.UTF-8
LC_TELEPHONE=en_US.UTF-8
LC_MEASUREMENT=en_US.UTF-8
LC_IDENTIFICATION=en_US.UTF-8
LC_TIME=en_US.UTF-8
PAPERSIZE=a4
LANGUAGE=en_US
LANG=en_US.UTF-8

if [ $DISPLAY != ":0" ]
then
	export XAUTHORITY=${HOME}/.Xauthority
fi

This should do the trick 99% of the time.

Have done it close to 4–5 times now. It works! ↩︎

Pycharm Does Not Recognise Compose Key Sequences

feedback@janusworx.com (Mario Jason Braganza) — Tue, 09 Nov 2021 15:56:04 +0530

Did I not just write about this, the other day with Emacs?
I did, but Pycharm seems to have the same affliction. Pycharm, just like Emacs, stubbornly refuses to accept my Compose key combinations. Which means … you guessed it, no ‘,”,“ or ’ punctuation and all the other affordances, Compose gives me.
Considering that I need both, Pycharm as well as Emacs in my life, it behooved me, that I go solve this too.

And … drumroll … the answer turned out to be the same as Emacs.
Set the locale to be en_US.utf8 systemwide.

Which confused me a bit for a second.
I had done it for Emacs. So why was Pycharm behaving oddly?
And then, another second later, I realised, that this was a different machine.
This was my laptop, which I now use as my daily driver and the locale was set to India, as per my original preferences.

A quick, sudo localectl set-locale LANG=en_US.utf8 and a reboot later, both Pycharm and Emacs were humming along to the Compose key dance :)

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.

To my Teachers, With Gratitude

feedback@janusworx.com (Mario Jason Braganza) — Wed, 27 Oct 2021 16:00:00 +0530

Shoutouts of Gratitude to the teachers who I learnt programming from over the past couple of years …

Kushal Das, for bringing me in, teaching me the ropes and assuring me there was a place for me here

Reuven Lerner, who unravelled Python for me and made me realise that languages were small, and the reason I was struggling was not Python, but because I wanted to understand all of computer science in too short a time frame.¹

David Malan and Brian Yu for the grounding that is CS50.

Dr. Chuck (Charles Severance) for opening my eyes to the wonder that is web programming.
And databases, and Postgresql.
And Django.
And so much more!
You taught me how the pieces fit.

Julia Evans for showing me that being good at sharing knowledge, is not magic, just a lot of hard work and dedication.
And for teaching me oh so much, with your magical zines.

Mark Lutz for his exhaustive, thorough books on Python.

Damian Conway for making regexes make sense.²

Barbara Oakley, for teaching an old dog how to learn.

Cal Newport and Scott Young for helping me put it into practice (deliberately 😂)

Brad Traversy, while he may not have melted my mind, he is the embodiment of everything i learnt from the teachers above. Patient, humble, transparent, persistent, all round hero.

And last, but certainly not least, my young friend and mentee, Priyanka Saggu, for teaching me dogged persistence and for being an unabashed cheerleader on my journey.

All of this to say, good teachers are hard to find, and are worth their weight in gold. For every teacher on the list above, I failed with at least 5 more.

If you ever feel dumb, despite doing your best, like I constantly did, maybe it’s just the fact that the teacher and you are not compatible. The way they teach, might not be the way you understand

Which is why, if you are privileged enough to do so (or are willing to put in the time and the effort), there is no shame in looking for a ‘better’ teacher. No worries in doing the work of finding that someone who can make stuff go ‘click’ in your mind; who can make the world make better sense to you

My experience has been that such folk are hard to find, and when you do luck across gems (like the people above) make sure they know it.
Be grateful that life has brought you to them.
And make sure you learn all you can, to the best of your ability.

Reuven’s courses are worth it, for the groan worthy puns alone. ↩︎
Something that I’ve wanted to do since the 90s ↩︎

On the Difference Between Coding, Programming, Engineering, and Computer Science

feedback@janusworx.com (Mario Jason Braganza) — Tue, 03 Aug 2021 08:41:05 +0530

My homepage lists my new career shift as

“This is me, attempting to reinvent myself as a journeyman programmer. (aiming at craftsmanship)”

I’ve never warmed to the term coder. For some reason, it never meshed with the way I thought about my new career and the work I wanted to do. And I couldn’t quite articulate just how I thought they were different.

Today as I began reading The Secret Life of Programshtml though, I found author Jonathan E. Steinhart’s already done the hard work giving me a lovely explicit definition that I cannot better, even if I tried endlessly.
Here’s his take …

A number of different terms are used to describe working with software. These terms have no exact definitions, although they have acquired some rough meanings.

Coding, a fairly recent term popularized as part of “learning to code,” can be viewed as the somewhat mechanical work of translation. Let’s compare it to the job of medical coding. When you visit a doctor, getting a diagnosis is the easy part. The hard part is translating that diagnosis into one of the over 100,000 codes in the ICD standards, ICD-10 at the time of writing. A Certified Professional Coder who has learned these codes knows that, when a doctor comes up with a diagnosis of “struck by cow,” it should be assigned code W55.2XA. This is actually harder than many coding jobs in the programming space due to the sheer number of codes. But the process is similar to what a coder would do if directed to “make that text bold” on a web page; a coder knows which code to use to make that happen.

The ICD-10 standard is so complicated that few coders know it all. Instead, medical coders get certified in specialty areas such as “Diseases of the nervous system” or “Mental and behavioral disorders.” This is analogous to a coder being proficient in a language such as HTML or JavaScript.

But programming*—that is, being a programmer—means knowing more than a specialty area or two. The doctor in this scenario is analogous to a programmer. The doctor determines a diagnosis by evaluating the patient. This can be pretty complex. For example, if a patient has burns and is soaking wet, is it a “bizarre personal appearance” (R46.1) or a “burn due to water skis on fire, initial encounter” (V91.07XA)? Once the doctor has diagnosis, a treatment plan can be devised. The treatment plan must be effective; the doctor probably doesn’t want to see the same patient suffering from a bad case of “parental overprotection” (Z62.1).*

Just like the doctor, a programmer evaluates a problem and determines a solution. For example, maybe there’s a need for a website that allows people to rank ICD-10 codes in terms of silliness. A programmer would determine the best algorithms for storing and manipulating the data, the structure of the communication between the web client and server, the user interface, and so on. It’s not a simple “plug in the code” sort of thing.

Engineering is the next step up in complexity. In general, engineering is the art of taking knowledge and using it to accomplish something. You could consider the creation of the ICD standards to be engineering; it took the large field of medical diagnoses and reduced them to a set of codes that could be more easily tracked and analyzed than doctor’s notes. It’s a matter of opinion as to whether or not such a complex system represents good engineering. As an example of computer engineering, many years ago I worked on a project to build a low-cost medical monitor such as those that you see in hospitals. The charge I was given was to make a system that a doctor or nurse could figure out how to use in less than 5 minutes without any documentation. As you might imagine, this required much more than just knowledge of programming. And I beat the goal—my solution ended up taking about 30 seconds to learn to use.

Programming is often confused with computer science. While many computer scientists program, most programmers aren’t computer scientists. Computer science is the study of computing. Computer science discoveries are used by engineers and programmers.

Coding, programming, engineering, and computer science are independent but related disciplines that differ in the type and amount of knowledge required. Being a computer scientist, engineer, or coder doesn’t automatically make someone a good programmer. … Engineering and programming are similar to music or painting—they’re part skill and part art.

So I could also state my goal as

“This is me, attempting to reinvent myself as a programmer. (aiming at becoming an engineer)”

I think I’ll stick with my line though. I love the inclusion of the arts in there. Programmer and engineer are too dry without them :)
But this little screed helps me explain my intentions better to other people :)
And for that, a hat tip and lots of gratitude to you, Mr. Steinhart!

Jason Learns Django

feedback@janusworx.com (Mario Jason Braganza) — Thu, 22 Apr 2021 13:52:06 +0530

Meta post.
More than Django itself, I am beginning the phase of my journey, where now I write code and install programs and do all the things.
Am committing 2 hours to this daily, on weekdays along with a tiny what did I learn post.

I am beginning with Django itself, and if I have difficulties with any underlying concepts, I will quickly dive down and write code to understand those.
Learning along with Brad Traversy’s Python Django Dev To Deployment.
It’s a bit old, but I like the way he teaches.
And to make sure I am not cargo culting, I am doing this with Django 3 (the course has Django 2)

What did I do/learn today?

Set up a timetable of when I’ll go about doing things.
Bought the course.
Installed Django and got it to work.

And that’s about it.
Looking back at it, I wonder why this took me three long hours, but it is what it is.
I’d rather show up daily and make progress.

#CNC2021 Pre-Mission

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

Here’s putting in some thought into what I’ll do this #CNC2021.

Their first mail asked me to reflect on …

Determine what has worked.
#

Figured out the basics of data structures and algorithms
Figured out how to write in Python
Figured out how write my own code.
Took a lot of work and persistence. Took a lot of grit.
Realised that I’m not “slow.” I just have a hard life and could only put in fewer hours compared to the folks who zoomed past me.

Determine what has NOT worked.
#

Just what I said above but in a slightly negative manner. This takes a lot of grit. I need to figure out how to stop bare knuckling it and do it sustainably.
I’m dog slow currently.
I need to look up everything and I get distracted when I do that.
I keep comparing myself to others and get overwhelmed

What are your long-term goals?
#

Get a job by accomplishing, in the next 6-12 months, what I listed in my introductory post.
- 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.

What are your short-term goals?
#

By the end of this challenge, I want to get into the rhythm of writing code across all the three goals I listed up above
I just need to see steady forward progress

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.

Putting Emacs Backup Files in a Separate Location

feedback@janusworx.com (Mario Jason Braganza) — Tue, 17 Nov 2020 16:27:56 +0530

Whenever Emacs saves a file, it makes a backup of the original.
So if I had a file.txt and I make changes and save it, Emacs firsts backs up the original to file.txt~.
While I love this functionality, and it has saved me from a pickle more than once, I don’t love the way my folders get polluted with ~ files all over the place.
My blog’s drafts folder had hundreds of these.

Mercifully, Emacs offers a way to stow all these files in one central folder of your choosing.
All I did was add this little snippet to my init.el

;; Set the folder for backup files to a subfolder in the 
;;.emacs.d folder of the user. 

(setq backup-directory-alist 
 '(("." . "~/.emacs.d/file-backups")))

Emacs now stops littering all over the place and saves the backups it creates, to a `file-backups` folder in my `.emacs.d` folder. You can choose a location, you like better :)

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!

Emacs, Final Day!

feedback@janusworx.com (Mario Jason Braganza) — Tue, 07 Jul 2020 18:12:46 +0530

Unlike #100DaysOfCode, I am not quite giving up on Emacs.
Rather that it has turned out to be a habit that has fit in, quite well, and I don’t need this accountability any more.

I use it for most of my prose (not code, yet.)
This post, is in fact, written in Emacs :)

I have not gained any modicum of knowledge by any means.
But I have enough muscle memory and immersion, to make sure I will continue using Emacs for most writing I do.

Finding Jason Blevins’ Markdown Mode was what did it for me.
I did not realise, I wrote as much Markdown as I did :)

I can move about, write, save, edit, and preview Markdown and prose.
This is enough to turn it into a daily driver for me.

The next steps now are to get more fluent in Emacs and then slowly explore all the other things I can do with it … Writing code, corralling files, and using it as an organiser!

Emacs, Day 05

feedback@janusworx.com (Mario Jason Braganza) — Thu, 02 Jul 2020 17:36:50 +0530

Practiced moving around with the Emacs keys for 30 mins

Emacs, Day 04

feedback@janusworx.com (Mario Jason Braganza) — Wed, 01 Jul 2020 15:40:18 +0530

Learnt all about movement and search today.

Emacs, Day 03

feedback@janusworx.com (Mario Jason Braganza) — Tue, 30 Jun 2020 19:12:05 +0530

Too tired, so just worked my way through the Anki deck for a bit today.

Emacs, Day 02

feedback@janusworx.com (Mario Jason Braganza) — Mon, 29 Jun 2020 18:10:47 +0530

Had an extremely busy day with studies today, so could not spend time learning much Emacs.
Decided to do a little bit of plucking the low hanging fruit and customising Emacs a bit to my liking.

I created an init.el file in the emacs.d folder in my home directory, to add all my custom stuff into.

Adding Package Managers
#

Yesterday, I had learnt, that I could install additional functionality by downloading extra Emacs packages from the GNU repo at ELPA.
But since the FSF requires the authors to fork over their copyrights to them, (and most authors being justifiably, unwilling), most packages are found at third party package sites, like MELPA and the now discontinued Marmalade.

So I added this little snippet to my init.el to add the repos to my Emacs.

(setq package-archives
 '(("gnu" . "http://elpa.gnu.org/packages/")
	("melpa" . "http://melpa.milkbox.net/packages/"))) 

and then restarted my Emacs, for it to see the new repos.[^1]

And that led me to,

Markdown Mode
#

I realised that, the best way for me to learn Emacs, would be to write in Emacs.
And I write, most of what I write, in Markdown.
I had also learnt that Emacs has modes, which basically adapt Emacs and related shortcuts to the task at hand.
I went looking to see if there was something that would help me write Markdown more easily and found Jason Blevins’ excellent Markdown Mode for Emacs. ¹

Since I had MELPA configured, it took only a few seconds to get Markdown mode installed.
All I had to do was M-x package-install RET markdown-mode RET
(that is, mash the ALT-x keys, then type package-install, hit the return/enter key, then type markdown-mode followed by another return.)
More details on installation and usage at the Markdown Mode site.

A couple of minutes with it and I’m blown away.
I’ve heard of people switching to Emacs to use the excellent Org Mode, for taking notes and task organisation.
I am a convert to Emacs for Jason’s Markdown Mode.

And then to round up the day, I also installed the Ayu theme, because I love it and use it everywhere I possibly can :) ²

More tomorrow!

Excellent choice of name, Jason! High Five! ↩︎
Been a fan, ever since I saw it in a Corey Schafer video. ↩︎

Emacs, Day 01

feedback@janusworx.com (Mario Jason Braganza) — Sun, 28 Jun 2020 11:44:42 +0530

Slowly making my way through the Mastering Emacs book.

Things I did / learnt today …

Learnt that if I want to run Emacs all over the place (like I do), then the best thing to do is to have Emacs, running as a daemon in the background. So I did that via the handy systemd instructions, on this page.
And that Emacs has a kitchen sink’s worth of commands.
And that Emacs commands are like playing chords on the guitar or piano. You just hit a few of them in a sequence to get the desired sound (or action in this case)
C-g, the Control and the G keys get me out of a jam, if I am stuck.
Found Jess Hamrick’s really useful post, on moving about and buffers and frames and stuff.
Got myself a basic emacs Anki deck.
And I learnt how to move about.

All in all, a pretty good day.

Follow my Emacs journey here

Premature end to a Hundred Days of Code. Welcome to A Month of Emacs

feedback@janusworx.com (Mario Jason Braganza) — Sat, 27 Jun 2020 20:30:49 +0530

Life is really kicking my butt right now.
And the 12th studies are not making it any easier.
So am temporarily giving up on A Hundred Days of Code, again.

Hopefully, I will have the time to give Python, in a month.
In the meanwhile, with the limited time I do have, I’d like to learn me some Emacs.
Will write about it everyday.

Programming on Janusworx

I Should Write Down and Summarize What I Did

Learning DSA, Day 001: Recursion Basics

The Basics of Recursion #

Tail Recursion #

Tail Recursion vs Loops #

Head Recursion #

Head Recursion vs Loops #

Tree Recursion #

Indirect Recursion #

Nested Recursion #

Tomorrow is Another Date

Emacsclient Does Not Recognise Compose Key Sequences

Pycharm Does Not Recognise Compose Key Sequences

To my Teachers, With Gratitude

On the Difference Between Coding, Programming, Engineering, and Computer Science

Jason Learns Django

#CNC2021 Pre-Mission

Determine what has worked. #

Determine what has NOT worked. #

What are your long-term goals? #

What are your short-term goals? #

Starting up #CNC2021.

Putting Emacs Backup Files in a Separate Location

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

The Basics of Recursion
#

Tail Recursion
#

Tail Recursion vs Loops
#

Head Recursion
#

Head Recursion vs Loops
#

Tree Recursion
#

Indirect Recursion
#

Nested Recursion
#

Determine what has worked.
#

Determine what has NOT worked.
#

What are your long-term goals?
#

What are your short-term goals?
#

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
#

Adding Package Managers
#

Markdown Mode
#