You may answer ”I can rate myself 9/10 in Python” when asked, but would that really be an honest opinion of yourself when you haven’t even stress tested Python and its design? Fret not, for I am here to show off … ahem ahem ... to guide you through what “Pythonic” actually means.

tl;dr

Python is highly flexible and allows some weird syntax that you normally would not expect from other languages like Java or C++. For example, as I mentioned in my previous blog Why Does Python Allow “print = 123”, that Python allows reassignment of built-ins and most stuff except for a few selected things like keywords which contribute to its lexical parsing inside the interpreter.

Things can get so weird with Python that any sane person would imagine that these shenanigans would throw an error but they do not. You would be right to rip your hair off and ask “WHY??”. It all boils down to the Zen of Python saying “Explicit is better than implicit” and its design philosophy which says “Everything is an object”— more details on this in the blog I shared above.

Dynamic Reassignment

Since I talked about this above, I believe you might be curious. So let’s explore this first:

def greet():
    print("Hi")

say_hello = greet  # <-- your focus goes here
say_hello()  # output: Hi

You just assigned a function to a variable. Not that great huh? Now look at this and tell me if it’s not that great.

print('foo') # output: foo

def my_logger(*args, sep=' ', end='\n'):
    with open('./logs', 'wa') as f:
        output = sep.join(str(arg) for arg in args)
        f.write(output + end)
        
print = my_logger

print('foo') # logs the output to a file instead of printing

Who says you can’t use print() in production level code. But hey it is actually better if you use logging built-in library.

Do not panic if you did this. Just use the del keyword to undo the effect:

del print # will return the print funciton to its original state

Another usecase I wanted to share is that it can be used to create customized REPL by directly modifying the __builtins__ package.

__builtins__.open = lambda *args, **kwargs: print("File access blocked!")
open("test.txt")  # File access blocked!

❓Where it can be useful?

• You can use it in unit testing when you need to change the behaviour of something, or when you want to test the sad flows.
• When you are trying to simulate dependency injection
• You can use it to wrap a function and make it work like a middleware
• You can use it to load and reassign event handlers dynamically
• You can partially execute a function by giving it some arguments and leaving out the other arguments before assigning it to a variable.
• Building custom REPL or sandbox environments were certain functions are off-limits like os.system()which can run any command in the terminal.
• And of course, monkey patching

📌 To be honest, there are countless things you can do with it. The list of use-cases I share at the end of each topic is not everything.

Lambdas Inside List

lambda are anonymous function which do not need a proper definition (using def) and just need a function body to work. But these anonymous functions are itself common in most languages, but how we can use them flexibly in Python is.

funcs = [lambda x=i: x for i in range(3)]
print([f() for f in funcs])  # [0, 1, 2] 

What you did up there is fill a list with lambda functions when you ran the list comprehension style for loop. And then inside the print() function, you looped over that list of functions and called each one.

The above was a simple example but it can get as complex as you want it to be:

def create_handlers(configs):
    handlers = []
    for conf in configs:
        handlers.append(lambda event, conf=conf: f"Handler for {conf} received event {event}")
    return handlers

configs = [
  'event handler 1', 
  'event handler 1', 
  'event handler 1'
  ]
handlers = create_handlers(configs)

# Simulate triggering events
for i, handler in enumerate(handlers):
    print(handler(f"event_{i}"))

The above is an example of dynamic event handlers, where create_handlers() function takes in the names of the event handlers and uses them within a function (which is this case is a lambda function). The create_handler() function then returns a list filled with lambdas.

Note that each lambda has 2 parameters event and conf but only 1 is set as default inside each. The other parameter is to be given to it within the for loop.

❓Where it can be useful?

• Creating button callbacks in GUIs (e.g., Tkinter or PyQt)
• Generating API endpoint functions dynamically (You technically can, but would you?)
• Scheduling jobs with parameterized behaviour
• Binding commands to CLI options (Use subprocess package instead of os.system(). Try both and see why)

Extended Iterable Unpacking

You may be familiar with unpacking of iterables, which is done like this:

a, b, c = [1, 2, 3] 

print(a) # 1
print(b) # 2
print(c) # 3

So what kind of unholy magic can we do with it, you ask?

Imagine that you have an array … erm I mean … list of too many elements. And the catch here is that you only need first few or the last few elements. The rest of the list is useless for you. I don’t know how you managed to get in this mess which screams “bad code” but there is a way out of it.

first, second, third, *rest_of_the_crap, second_last, last = [i for i in range(100)]

The *rest_of_the_crap variable contains all elements except for first, second, third, second last and last element.

That is all there is too it.

❓Where it can be useful?

• You can parse command line arguments and essentially separate the arguments from the main command
• You can parse structured data that comes in lists like for example CSV rows.
• You can use it in token trimming for Natural Language Processing (NLP)
• You can de-structure logs or traces after splitting it into a list

Swapping Without Temp

This one is also very simple but I wanted to include it anyways since not many languages are able to do it.

You can basically swap values in 2 different variables with each other without creating a temp variable.

Normally you would do this:

a = 1
b = 2

print(a) # 1
print(b) # 2

temp = b

b = a
a = temp

print(a) # 2
print(b) # 1

But by using Python given features you can shorten your code like this:

a = 1
b = 2

print(a) # 1
print(b) # 2

a, b = b, a

print(a) # 2
print(b) # 1

Pretty neat huh?

❓Where it can be useful?

• Umm … anywhere you need to swap two values? It is so simple that it can be used in many places. I will leave that for your imagination.

Chained Comparisons

Assume you have the following scenario:

my_var = 4

if ( 'some conditions go here' ):
  # you are supposed to do something here

What you want to check in the if block is that whether the my_var is greater than 2 and less than 6 or not. So you would try something like this:

my_var = 4

if ( my_var > 2 and my_var < 6):
  # you are supposed to do something here

This would definitely work as intended, but there is a neat way too:

my_var = 4

if ( 6 > my_var > 2):
  # you are supposed to do something here

It will work as intended. Why don’t you stop taking my word for everything and try something for yourself?

❓Where it can be useful?

• Well it is a short hand way to the lengthy stuff. Plus it is more clean.

Using "else” with Things Other Than “if"

else is definitely meant for after the if keyword. But not in Python. Turns out there are many other places where you can use it.

You can use it after the for loop (what???):

for i in range(3):
    if i == 99:
        break
else:
    print("Did not break!")  # This will print

Same can be done with while loop.

Now some of you geniuses woud say something like this: “Hey we learnt in Python 101 class that you can also use else in try block.”

While you distinguished geniuses are correct, but that else after the try block is different.

Here is a quick comparison:

• try ... else is about exceptions: the else is skipped if any exception is raised in the try.
• loop ... else is about flow interruption via break: the else is skipped only if break is used.

Now name that class “Python 102” after adding this into the syllabus.

❓Where it can be useful?

• Cleaning up after you have made too many temporary variables within a loop
• With it you would not need to update a flag like found=False
• Lock a user account after too many retries

Walrus Operator

This was popularized a while back with the release of Python 3.8, but not commonly known.

Walrus operator is a new operator (usable in Python 3.8+) which dynamically assigns value to a variable, while that value is being used somewhere. Yes I know it is kind of confusing:

if (n := len("hello")) > 3:
    print(n)  # 5

Here you are essentially assigning the value of len('hello') to n, while also using this value is comparison against the literal 3.

Here is a nerdy face emoji with buck teeth I made using walrus operator

:=(B)

❓Where it can be useful?

• Emojis ofc
• Saves you from computing something twice, when you can just access the variable later.

Meta Classes

Just like classes are used to define how the object is going to behave. similarly Meta classes are used to define how the Classes are going to behave.

Meta classes are defined within a class. You can say that it is like a class within a class.

class MyMeta(type):
    def __new__(cls, name, bases, dct):
        dct['magic'] = lambda self: "✨"
        return super().__new__(cls, name, bases, dct)

class MyClass(metaclass=MyMeta):
    pass

print(MyClass().magic())  # ✨

Track the sparkle emoji, and see that the magic() function is actually defined in the meta class.

The reason why I am discussing this here, is because other languages do not commonly use meta classes to modify the class behaviour. They have other mechanisms in place for that.

Also a worthy note here would be that existence of Meta Classes signify that Python Classes themselves are Objects on a lower level. Mind blown right?

❓Where it can be useful?

• You can use it in attribute enforcement. Which basically means that you can enforce certain rules on your class. Like for example, all constants should be named with uppercased name.
• You can create a centralized class registry for managing child classes like plugins.
• Obviously helps in metaprogramming-heavy apps
• You can even build your own declarative ORM. I might show you that but in another blog another time.

Using __getattr__ / __getattribute__ to Fake Everything

__getattribute__ intercepts all attribute access in a class. In other words, if you want to access any attribute inside a class, you would do MyClass().my_attribute but that would unintentionally call __getattribute__ function to get access to your desired attribute.

Here is an example where we overwrote the __getattribute__ function to print something before doing whatever it does:

class A:
    
    my_var = 123

    def __getattribute__(self, name):
        print(f"Looking for attribute: {name}")
        return super().__getattribute__(name)

📌 Be very careful — don’t call self.__getattribute__(name), you’ll get a recursion error!

Note thatmy_var is a class level attribute here, but you can experiment with object level attribute as well.

Now you can try accessing the my_var in two ways:

print( A.my_var ) # this will NOT trigger the custom __getattribute__

Output:
>> 123

OR

print( A().my_var ) # this will trigger the custom __getattribute__

Output:
>> Looking for attribute: __getattribute__
>> Looking for attribute: my_var
>> 123

The difference in outputs is because our custom implementation of __getattributes__ is an instance level method.

So the conclusion you get from this is that, __getattribute__ only runs when the Object is initialized.

But anyways, on a similar note, you can also use __getattr__ which is slighlty different than __getattribute__ . It only intercepts missing attributes only.

class A:
    def __getattr__(self, name):
        print(f"{name} not found — using fallback")
        return "something else?"

❓Where it can be useful?

• Fallback for alias and attributes
• Lazy loading to defer components until needed
• Audit and access control of every lookups inside a class

Dynamic Class Creation

Classes are defined using the class keyword. That is how you create a class. But there is another way to create a class and it is super cool.

MyDynamicClass = type("MyDynamicClass", (), {"x": 42})
print(MyDynamicClass().x)  # 42

In the above example I create a class named MyDynamicClass with an attribute called x having the value 42. And I did all of this using the type() built-in function.

So what’s the deal with this type() function? wasn’t this supposed to be used for checking the datatype of something? Turns out it is dual purpose.

This is how Python itself creates classes under the hood. type() is actually the “metaclass” for all classes.

❓Where it can be useful?

• Useful for metaprogramming
• Creating classes on the fly (e.g. ORM models, serializers)
• Core to metaclass mechanics and tools like Django, SQLAlchemy, etc.

Overloading Operators For DSL-Like Code

Firstly, DSL stands for Domain Specific Language, which is nothing but a mini-language tailored to a specific problem domain.

Operator overloading is like redefining what an operator does. 2+2=4 right? what if you could declare that + sign will from now on yodel instead of adding the two numbers? That is how powerful the operator overloading is.

class Num:
    def __init__(self, value): self.value = value
    def __add__(self, other): return Num(self.value + other.value)
    def __repr__(self): return f"Num({self.value})"

print(Num(5) + Num(3))  # Num(8)

print(Num(5) - Num(3))  # TypeError: unsupported operand type(s) for -: 'Num' and 'Num'

The __add__ method represents the + operator. Similarly there are other specific methods for each operator in a class instance.

In the above example we defined the how the + operator works if two Num() objects are added, so we got an expected response. But when we tried to subtract both, it gave us an error saying that we haven’t yet implemented how the - operator would work for two instances of Num() objects.

❓Where it can be useful?

• Packages like tensorflow, pandas and SQL alchemy use this all the time
• You could also create a new DSL out of existing rules like this
• Simulate Math and Symbolic computations
• Implementing finite state machines

Self-Defining Functions

Now we are talking about functions that do one thing when called and another when called again.

def f():
    print("First time")
    global f
    f = lambda: print("Now I do something else")

f()  # First time
f()  # Now I do something else

Note that I used a global keyword to reference the function definition that is recognized globally.

❓Where it can be useful?

• Single time initializations. First call will connect to the database and all other calls will persist the connection state
• It helps in performance optimizations. No need to define extensive checks and conditionals just to make the function behave differently the next time you call it
• You even use it in plugin callback/bootstrapping. Prepare the dynamic code on first function call and then use the stored code on each preceding calls.

Final Word

You may not use the knowledge I shared with you on a daily basis. But knowing it is definitely putting on a place higher than just every other Python programmer. This could prove to be your value proposition when you make or break a deal. Catch my drift? So the next time someone asks, how flexible are you, you say I’m as flexible as a python, and then proceed to destroy their notion of how Python should work.

As for how did I discover these flexible uses of Python, well, I just played with the code and looked around to see what was possible. And that is all you need to become a great programmer … curiosity is the the key to transition from “someone” to “distinguished”. Keep learning more and don’t stop.

The usecases I shared with you were just what I could think of at the moment. If you have any other ideas for any new usecases I did not cover, please comment below.

I’m open for connection, if you want to chat. You can reach me out through my Linkedin.

And don’t forget to show off and flex whenever you can in front of the recruiters. They asked you to own the stage, and that is what you should do.

Thank you for reading till the end 🥳

If you found this article helpful and learned something new, be sure to leave a 👏 or let me know your thoughts 📣on it. I’d love to read your feedbacks and will reply at my earliest.

You have tried and may remembered some part of SOLID principles. Maybe you completely forgot and just could not find any intuitive way to memorize this crucial concept. That is exactly why I am writing this article. This is how I did it and now I am sharing the intuition with you.

I’m not aiming to explain this concept. My main goal is to make this concept so intuitive and human-friendly that it becomes easier to remember and recall during your interviews.

TL;DR

Yes, there are thousands of articles like this one which talk about the solid principles out there. To be honest, I didn’t find (most of) them particularly useful maybe since they were trying to teach me the concepts, when I didn’t even know OOP quite well at that time. Or maybe the definitions and examples seemed confusing to me.

In any case, it is going to be a troublesome concept for those who are just starting out in this career path.

The key is to boil the concepts down to a very dumb simplified version. And no, I am not talking about the one-liner definitions you often see whenever you read about SOLID. Those can be misleading and abstract, since they want to cover a wide range of meanings. Still I found out that they can dumbed down to a very brain-friendly definitions.

📌 This is my take for how to understand this concept. You are free to accept or reject this notion.

But for you to better understand SOLID, you must first understand the OOP terminologies. But the thing is everyone on the internet will teach you OOP using a programming language of their own choice. That would make you language focused and before you know it, you will be understanding OOP as well as how the programming language works. What if you coujld learn about it in a context free way, where you would just learn about the OOP concepts and leave the programming language out of the window? Thankfully I have a sponsor which is me, myself and I have just the article for you if you are willing to learn.

Learn OOP Concepts Without any Language Context(Starter Pack)

Sorry about the shameless self promotion. Anyways, time to get down to business.

Don’t mind the starfish, it is just for show. Just like you, who will be showing off to the recruiters how good is your understanding of SOLID.

1- Single Responsibility Principle

This one is fairly simple and probably the only one you remember out of the other, more vague principles. It simply means that a single class has only one responsibility. If you want it to perform something out of its assigned responsibility, then you better make another class for it.

Of course I would also be showing you how it would look like in code. Here is a violation of Single Responsibility Principle:

class User {
  saveToDatabase() { /* Database logic */ }
  sendEmail() { /* Email logic */ }
}

Here is the same code but with three different classes for three different responsibilities:

class User {
  // Only user-related data and methods
}

class SomeDatabaseORMClass {
  saveToDatabase(user) { /* Database logic */ }
}

class Emails {
  sendEmail(user) { /* Email logic */ }
}

In the solution, we successfully divided the single User class into three different classes each with a single responsibility. User class only handles user related stuff. SomeDatabaseORMClass handles connecting with the database and storing stuff on the database. And finally Emails class only handles connecting to the email server and sending or receiving emails.

So for the first lesson, we conclude this with:

Only one responsibility per class

2- Open/Closed Principle

Open closed principle is just like replying with a “yes and no”, for a question.

Need an example?

Jack: Hey, Jill! what do you think? Is our way of fetching a pail of water from up the hill, efficient and optimized?

Jill: Yes and no Jack.

Jill: No because, obviously it hurts my legs to run with a bucket full of water.

Jill: Yes because it is the most efficient way we can afford right now. We don’t own a donkey or a wheelbarrow remember?

Now back to the donkey at hand. Open/Closed principle, just like a “yes and no” reply, says something similar.

The Class is “Open” if we want to extend it’s functionality. But it is “Closed” if we want to modify any code/behaviour of its methods.

📌 Notice that the word extend here, means inheritance in OOP.

Let’s look at some code now:

class Shape {
  area() {
    throw new GeneralError('Method not implemented.');
  }
}

class Circle extends Shape {
  area() {
    return Math.PI * this.radius * this.radius;
  }
}

class Square extends Shape {
  area() {
    return this.side * this.side;
  }
}

This is a very generic example you will find in many places. It features three classes Shape , Circle and Square. Note that all three classes have a method called area(), and both Circle and Square classes inherit from the Shape class.

If you tried calling area() within the Shape class, you will receive an error, because the method wants to be overridden (as in method over-riding).

Even though the Shape class is made in such a way, that it just wants to make you change that throw new Error() statement. But no no no no no, we don’t do that in Open/Closed Principle. Instead if you want to change it’s behaviour of throwing an error at you, you first inherit that class into another class, override that method, and then call it.

But if you were to change the area() method inside the Shape class, you might only do something like changing the error type it throws, like right now it is throwing a GeneralError() and you might change it throw a VerySpecificErrorType().

Note that this Open/Closed principle, encourages using abstract classes like Shape and method overriding.

So for Open/Closed Principle we conclude with:

The existing code works, so don’t mess with it. If you really want to, then extend it and override it.

This principle encourages you to use abstract classes by inheriting it into your concrete classes.

3- Liskov’s Substitution Principle

Seriously, out of all the names … this name does not explain anything about what this principle is about other than it somehow references some kind of substitution. Liskov’s name here does not mean anything unless her parents named her scientifically and taught her all about computers and waited years afters years, until she published about the substitution principle … End of my rant.

Imagine this: while working with OOP, you are eventually going to run into inheritance. And you know that one base class can be inherited by many other classes. I’m going to call these other classes as “sub-classes”.

Now since these sub classes are inheriting from the base class, they should all share whatever functionality was in the base class right? Let’s see some code and then I will ask you some more questions, ready?

//This is my base class
class Bird {
  fly() { print('Flying') }
}

You see here I have a class name Bird which has a single method called fly(). Now imagine that I create a subclass which inherits from this Bird class, and I call the fly() method on the subclass rather than the Bird something like this:

//This is my base class
class Bird {
  fly() { print('Flying') }
}

//This is a subclass
class Penguin extends Bird {
  //this is empty
}

Penguin().fly()

What do you think should happen when I call the fly() method on the Penguin class? Just like everyone would expect, it should print “Flying” right?

This should also be same for any other subclass that inherits from the Bird class. But what if the Penguin class overrides the fly() method? What would be the point of writing the fly() logic in the Bird class anyways? This simply breaks the original logic of the fly() method.

And this is exactly what Mrs. Liskov is trying to tell us. She simply wants to stop us from changing any predefined behaviour from the base class. That is her way of saying that:

Child classes should behave just like their parents, just because they inherited it.

📌 By “behave”, I mean methods in a class by the way.

You should be able to call base class methods through any of its subclasses without observing any change in behaviour.

But wait, didn’t this just violate the Open/Close Principle? Technically no, because in Open/Close Principle we:

1. created an abstract class
2. which we inherited into a concrete class
3. and override the methods of the abstract class

In that scenario, the abstract class was meant to be overridden. Meanwhile, here the parent classes are concrete classes.

And this my friends, is the substitution she was talking about. Basically the subclasses are substituting the base class and are still able to run the same methods that the base class had.

This principle encourages you to preserve the functionality of your base classes whenever you perform polymorphism or simply inheritance.

4- Interface Segregation Principle

There are lots of vocabulary you need to understand here. Interface refers to the class which is a part of OOP system. It is a class, the only duty of which is to provide a blueprint for another class. The interface, unlike abstract class does not implement any logic, it just contains the names of the methods the other fully implemented class should have.

Here is some code, so you will understand better:

// it only contains the names of the methods
interface Worker {
  work()
  eat()
}

// the class implemented the logic within those methods
class Robot implements Worker {
  work() { print('Working') }
  eat() { throw new Error('Robots don’t eat!') }
}

📌 Usually programming languages have a special keyword to define an interface. Just like you see above, interface is defined with the interface keyword, while class is implemented with a class keyword.

But nonetheless, interface is being inherited just like any other base class would be.

Before you ask, interface and abstract classes are two different things. Here is a quick comparison:

Ok enough with the side lesson, lets resume the discussion on the Interface Segregation Principle.

So you saw my interface and class example in code above. You know how interfaces work and what purpose do they serve. It is time we look into the other vocabulary that was presented to us: Segregation — which only means “separation into parts”.

In our Worker and Robot example, the Worker interface has two method names i.e. work() and eat(). Now we know that these two methods are completely unrelated to each other.

If we were to have another method called drink() then we might say that it relates to eat() method because both them symbolize consumption of some sort of food.

Similarly if we had a method called liftWeights() then we might say that it relates to the work() method.

But for simplicity, lets keep ourselves from adding more methods into the picture.

Since both of those methods, eat() and work() are unrelated, it only makes sense to keep them both in separate interfaces like this:

interface Workable {
  work();
}

interface Eatable {
  eat();
}

class Human implements Workable, Eatable {
  work() { console.log('Working'); }
  eat() { console.log('Eating'); }
}

class Robot implements Workable {
  work() { console.log('Working'); }
}

Just like inheritance you can often extend more than one interface just like I have shown in the Human class.

What you did here is you separated a single monolithic interface into several parts with respect to their “category”. Of course you, the developer, decides according to which aspect you wish to divide them.

So we conclude this with:

Keep your interfaces chunky, not chonky.

Interfaces should be divided into smaller chunks. Where you group the methods only based on the work they do.

This principle simply encourages atomicity in your interfaces, which then reflect the same atomicity in your classes. So this is highly compatible with the single responsibility principle.

5- Dependency Inversion Principle

As we inherit the base classes into the sub classes, we see that the sub classes are now dependent on the base classes.

Or maybe you wanted to try composition in your classes, and you ended up with something like this:

class MySQLDatabase {
  connect() {
    print("Connecting to MySQL...");
    // MySQL-specific connection code
  }
}

class UserService {
  constructor() {
    this.db = new MySQLDatabase();
  }
  
  getUser() {
    this.db.connect();
    print("Fetching user data...");
  }
}

// initialize the user service class
const userService = new UserService();
// call the database connection method directly within getUser()
userService.getUser();

The MySQLDatabase class is responsible for connecting to the database.

UserService is a class which is responsible for the user-related operations.

Notice that in the constructor of UserService class, we are using the class variable db to store the connection to MySQL by directly calling the class by its name.

Then in getUser() method, we are using that same db variable and using it to fetch user-related information from the database.

The problem here is simple, If you decide to change the MySQLDatabase class to something else in the future, you would also need to make changes to UserService class.

If you haven’t guessed it yet, right now the UserService class is directly dependent on the MySQLDatabase class.

📌 Notice that I used the word “directly” here which is the opposite of the word this principle tells us to follow … i.e. “inversely” or “inversion”, therefore we call it dependency inversion.

Instead of having the UserService class rely on MySQLDatabase class, we can introduce some level of abstraction here, like this:

// same as before
class MySQLDatabase {
  connect() {
    print("Connecting to MySQL...");
    // MySQL-specific connection code
  }
}

class UserService {
  constructor(database) {
    this.db = database;  // Database is injected, not hardcoded
  }
  
  // this is also the same as before
  getUser() {
    this.db.connect();
    print("Fetching user data...");
  }
}


const db = new MySQLDatabase(); // You pass this db variable into the constructor as a dependency
const userService = new UserService(db);
userService.getUser(); // works the same

Notice the changes inside the constructor of UserService class. We are not directly assigning the db variable. Now we have successfully abstracted how the UserService class interacts with the database.

The UserService class does not know what will be passed into the constructor, but it knows at least that whatever is passed into the db variable, will probably have a method called connect().

This might not look much fancy to you but its true potential can easily be seen below:

// same as before
class MySQLDatabase {
  connect() {
    print("Connecting to MySQL...");
    // MySQL-specific connection code
  }
}

class PostgreSQLDatabase {
  connect() {
    print("Connecting to PostgreSQL...");
    // PostgreSQL-specific connection code
  }
}

class MongoDatabase {
  connect() {
    print("Connecting to Mongo...");
    // Mongo-specific connection code
  }
}

class UserService {
  constructor(database) {
    this.db = database;  // Database is injected, not hardcoded
  }
  
  // this is also the same as before
  getUser() {
    this.db.connect();
    print("Fetching user data...");
  }
}

const db = new MongoDatabase(); // use which ever database class you want
const userService = new UserService(db);
userService.getUser(); // works the same

I simply added PostgreSQLDatabase class and the MongoDatabase class into the picture.

Now you can easily use any of the database you like and pass it into the UserService class. This class would not mind anything as long as there is a connect() method inside the db variable.

So we conclude this with:

Don’t glue classes together directly . Use a plug so you can swap parts easily.

You will see this pattern being followed in several frameworks like Laravel and Nest.js.

With That … Here Are A Few Pointers

As in my personal experience, I can tell you this that SOLID principles are not always the right answer. There have been instances where I had to violate maybe two or three principles altogether. In the end, it is all about getting the job done in the most cost-friendly and optimized way.

But tech interviews tend to make it a really big deal. The reason for that is simple, If you know how to structure your code then you are less likely to fall into pits where it is very difficult to recover from. You might end up stacking a lot of technical debt before you know it.

Once you get the hang of it, you will know yourself when to forfeit the tradition and follow your path.

Thank you for reading till the end 🥳

If you found this article helpful and learned something new, be sure to leave a 👏 or let me know your thoughts 📣on it. I’d love to read your feedbacks and will reply at my earliest.

Also, if you want me to write something you’d be interested in, please do let me know. Here is my Linkedin.

In any case, you will not go empty handed today, since not only I will tell you the concept of how to host your own blog site without any support from backend, but I will also show you two example: one using React.js and another using Vanilla JS for those who like simplicity.

My Motive

As you know I am a blogger who likes to share my stories as a software engineer and help any individuals with any questions, those who might be looking for some straightforward and insightful answers.

After I made my portfolio site, I made a section in there where I am listing all of my blogs. Each of those blogs are linked to medium.com articles, so when people click on any blog in my portfolio site they get redirected here to read the article. Naturally I started looking for alternatives to host my own blog.

As a software engineer I could always make one from scratch with full control over every aspect of the blogging solution, but I could also use the same time working on something more interesting which I can write and share about.

Now just to be clear, I am not opposed to the idea of spending on hosting providers. In fact, I would not think twice before spending money on something which can return the investment at some point in the future.

Anyways, the first alternative that came to my mind was Wordpress but it required me to own and host a webserver, which consequently meant me spending $$$. None of my blogs here on medium are “members-only” because it is my hobby and spending on a hobby which I don’t earn anything from seemed like a no-no to me. I could use Google ads to generate revenue but that would only clutter things up and drive people away right? … right?

In other words, I do not like when I see Ads popping up in the corners. So I would naturally assume that my readers do not like it either.

While I do know why you might have clicked on this article, I want to make it clear that the title up there is in fact, a bit misleading.

I said that I will not use backend, but I am using one hosted by someone else, although it is completely free to use. To cut to the chase, I am using Github as a hosting service for my blogs and I created a frontend in React.js (you could use any other frontend framework you like) deployed on Vercel, to show the content taken from Github with my custom CSS styles.

Of course you will have the complete liberty of choosing how your blog presents itself to your visitors.

Before anything else

There are a couple of things I want to make clear before you continue reading.

A typical blogging application consists of a backend which stores and provides each blog content individually. Typically there is a listing page in the frontend, where all of the blogs are listed and when the user clicks on any one of the links, they are redirected to a page where all of the content of that blog (including images, gifs, embeddable elements etc) will be shown.

And when the admin changes some words on any one of the articles, that change would get reflected on the user’s side almost immediately.

This is the flow I was targeting to use in my own blogging solution.

And before you ask … Yes, it does require some extra work but it is still somewhat easy to manage (as far as I think), and also yes, there are some limitations which we will discuss later in this article. But enough jibber-jabber, let’s see how I did it.

Use Github to host your blog content

This is fairly simple, as you only need to make a repository and upload some files to it. In my case I uploaded some markdown files.

Each of those markdown files will act as a single blog article, and the content inside it will be written in the markdown syntax. Just to show an example, here is a sample markdown file and its content:

# My Blog Title

Some intro explaining what this article is about like I always do 
when I write one.

![title_image](link/to/title_image.jpg)

Some more content which explains the topic in detail.

## Sub heading 1

sub heading content 1

> some famous quote from someone important

## Sub heading 2

sub heading content 2

| item 1 | item 2 |
|--------|--------|
|comparision 0-1|comparision 1-1|
|comparision 0-2|comparision 1-2|

# Footer

footer content

As you can see the markdown contains most of what will be present in a typical markdown file. That is it, till here. The real shenanigans is in the frontend, and it is prime time we start discussing that.

Create a frontend

For a frontend, you can think of two kinds of pages to show to the visitor:

• The listing page where all of your blogs are listed. Let us call it Index.jsx
• The blog page itself which shows the blog content with any images, tables and embeddable elements. Let us call it Blog.jsx

📌 I used React.js in my case but you can use anything else you like (even Vanilla JavaScript can work). But I will be explaining in terms of React.js to keep things consistent.

The Blog.jsx page will be created as a component which will look like this:

import React, { useState, useEffect } from "react";

function Blog(props) {
  const { blogContentLink } = props;
  const [htmlContent, setHtmlContent] = useState(""); // State to store the HTML content
  
  useEffect(() => {
    const fetchMarkdown = async () => {
      // TODO: write some logic here to fetch and convert markdown content to json
    };
    if (blogContentLink) {
      fetchMarkdown();
    }
  }, [blogContentLink]);
  return (
    <div>
      <div
        dangerouslySetInnerHTML={{ __html: htmlContent }} // Render the HTML content
      />
    </div>
  );
}
export default Blog;

Notice that I have a TODO comment in there. This is where we will be writing our markdown to HTML conversion logic.

Don’t worry about the dangerouslySetInnerHTML attribute. This is usually not recommended when you have a server, but in our case, we do not have a server.

Also notice that I am sending blogContentLink as a prop to this component.

This blogContentLink is the Github Raw URL which will respond with a 200 HTTP code and the markdown content of a file. Of course the markdown content needs to be converted into HTML to be able to get rendered in the DOM.

📌 In case you do not know, Raw Github URLs are special URLs which serve raw contents of a file. These URLs start like this:

https://raw.githubusercontent.com

But remember that our content was written in markdown right? Therefore, we need a way to convert the markdown into HTML. Luckily there happens to be a popular quote among JavaScript Developers:

“There is a JavaScript Library for that too“

— told by various JS Devs around the globe

Which brings us to our next step …

Convert Markdown into HTML

For this I am using showdown.js which is a bidirectional converter between markdown and HTML.

This library is very simple to use. Below is an example with vanilla JS:

const markdownRawUrl = "https://raw.githubusercontent.com/Blankscreen-exe/host-a-blog-without-a-backend/refs/heads/main/README.md";

fetch(markdownRawUrl)
.then( data => {
  let md_content = data.text();
  let converter = new showdown.Converter(); // initializing showdown.js object
  let html_content = converter.makeHtml(md_content); // convert markdown into HTML
})
.error( 
  error => console.error('Error fetching the Markdown file:', error) 
);

The example above is in Vanilla JavaScript just to show you how it works. We will be using the same code in our React.js component.

Of course there are alternatives to showdown.js which may or may not work better than this one. I felt happy using showdown.js. You should also pick the alternative which makes you happy.

Now we have the pieces of the puzzle, so how do they all fit together?

Combining everything we have learned so far

You will have your blogs (written in markdown) in your repository arranged like this:

blogs/
|- my_blog_title_1.md
|- my_blog_title_2.md
|- my_blog_title_3.md
|- my_blog_title_4.md

data/
|- blogList.json

components/
|- Blog.jsx
|- Index.jsx

App.jsx

... other react components

You will then create a .json file to hold the listing details of each blog. Let us call this file blogList.json. This file will be stored anywhere in the project where it can be accessed by the Index.jsx component. The sample blogList.json looks like this:

// inside data.json

[
  {
    "blogFileName": "my_blog_title_1.md",
    "blogTitle" : "My Blog Title 1"
  },
  {
    "blogFileName": "my_blog_title_2.md",
    "blogTitle" : "My Blog Title 2"
  },
  {
    "blogFileName": "my_blog_title_3.md",
    "blogTitle" : "My Blog Title 3"
  },
  {
    "blogFileName": "my_blog_title_4.md",
    "blogTitle" : "My Blog Title 4"
  }
]

Now you just need to loop over this JSON array and and show it in the listing page which we decided that we will call Index.jsx. Of course each listing item will provide the Blog.jsx component with a URL prop blogContentLink which would be a Raw Github URL pointing to any one of the markdown file.

Make sure that the blogFileName value matches the file name stored inside blogs/ folder.

For reference, your listing page should look something like this:

With this we are finally ready to finish the Blog.jsx file we left back there. Here is the update code:

import React, { useState, useEffect } from "react";
import showdown from "showdown";

function Blog(props) {
  const { url } = props;
  const [htmlContent, setHtmlContent] = useState(""); // State to store the HTML content
  
  const converter = new showdown.Converter({tables: true}); // Initialize the showdown converter
  useEffect(() => {
    const fetchMarkdown = async () => {
      try {
        const response = await fetch(url); // Fetch markdown content from the URL
        if (!response.ok) {
          throw new Error(`Error fetching markdown: ${response.statusText}`);
        }
        const markdown = await response.text();
        const html = converter.makeHtml(markdown); // Convert markdown to HTML
        setHtmlContent(html);
      } catch (error) {
        console.error("Error fetching or converting markdown:", error);
      }
    };
    if (url) {
      fetchMarkdown();
    }
  }, [url, converter]);
  return (
    <div>
      <div
        dangerouslySetInnerHTML={{ __html: htmlContent }} // Render the HTML content
      />
    </div>
  );
}
export default Blog;

That’s about it actually. Now your Blog.jsx component is able to render markdown formatted text. And now you can update the markdown file in the repository, and those changes will be reflected on your blog site.

With my custom CSS styles, my version of the blog page looks like this:

As I said, I prepared two types of demo for this blog. One is made with React.js and other one is made using Vanilla JavaScript.

In my source code, the vanilla JS version is in the root directory of the repository. Whereas the React.js implementation is located inside the react-sample-project folder:

GitHub - Blankscreen-exe/host-a-blog-without-a-backend: converting markdown from github raw content into renderable HTML

You can visit the live Vanilla JS demo Here:

Host A Blog Without Backend

The demo above will enable you to feed in any Github Raw URL of a markdown file and see its HTML being rendered inside a <div> element.

While the React.js Live Demo is not available, you can still run the project yourself if you like. I have included the instructions how to run the app in the README.md.

Limitations

As far as limitations are concerned using this method to host your own blog website, we can see that most of the limitations are bound to not having an actual backend system.

If your requirements for your blogging platform includes any features other than hosting and serving your blog content, then you are well off using Wordpress or other alternatives.

Github is only allowing you to serve your blog content and update it whenever you want without making any changes to your client side application. You need to understand that this is the extent of what you are going to get from Github.

For example, you will NOT be able to do the following:

• Integrate user analytics
• User profiling
• Keeping a track of likes and comments on your blogs
• You get the point, right?

That is what I feel, is the only major limitation which I should discuss before seeing you off.

However, if you think that there is another limitation which I did not discuss, then please, by all means, comment below and let me know.

Final Word

Now you know how you can host your own blog application without the need for any backend. You also know what limitations you would face when using something like this.

Of course it would not be much of a pain to set something like this up for a hobby blog.

Thank you for reading till the end 🥳

If you found this article helpful and learned something new, be sure to leave a 👏 or let me know your thoughts 📣on it. I’d love to read your feedbacks and will reply at my earliest.

Not many people know this, but this is a good piece of knowledge to have if you want to show off your understanding in Python Programming Language.

If you ever try to run print=123, the interpreter would just run it without causing a fuss, although it would seem that it should raise a warning at least if not an exception. The next time you run your print function like you usually do, the interpreter will tell you that an Integer Literal (since we assigned an integer to print) is not a callable i.e. a function.

What is more fun is that you can do this to almost anything in Python, not just the print() function.

📌 There is much to learn about Python’s design philosophy in this article and I have worked for it to be a fun read for the experienced as well as newbies. I hope you will learn about a lot in here and also upgrade your arsenal to impress recruiters too cuz why not?

If you are a language architecture nerd, you might have guessed, to answer this question we need to dive into the design philosophy.

But before all that, let’s unpack what we will discuss in this article:

• Everything is an object — a Python’s data model philosophy
• Namespace management and scoping
• Dynamic typing and flexibility
• Trusting the programmers — We are all consenting adults here

Apart from the above topics, I will also tell you about:

• The tradeoffs
• And how to revert back if you accidentally do run “print=123"

Everything is an object

Most sources and instructors do not go much into this or straight away skip it, although this concept is crucial if you want to engineer applications with Python, not just build it.

Anyways, let’s study a passage from the Python Reference Guide — Data Models:

Objects are Python’s abstraction for data. All data in a Python program is represented by objects or by relations between objects. (In a sense, and in conformance to Von Neumann’s model of a “stored program computer”, code is also represented by objects.)

This clearly states that everything you see in your Python code is an object. Even the literals including integers, string, lists and of course functions and variables.

But wait a minute, if you are coming from languages like JAVA and C, you can usually picture functions being methods of an object and variables being attributes of an object. But how are literals like integers, float and string fit into the picture?

These literals fit into Python’s “everything is an object” paradigm because they are instances of built-in classes. In Python, even simple literals such as 42 or "hello" are objects with attributes and methods.

Remember, you can call .capitalize() on a string? But now you must be thinking that you cannot call any methods on an integer. If you tried doing this, you will get an error:

>>> 123.bit_length()

SyntaxError: invalid decimal literal

This is because the interpreter is assuming that after the decimal point . there would be more numbers to make a floating point number but it finds letters instead. This is something the interpreter is designed to do.

To properly do this, you need the parentheses(), which is the same thing as what we did before, but this explicitly tells the interpreter what we are trying to do:

>>> (123).bit_length()

7

>>> int(123).bit_length() # It also works with the int() function too

7

Is Reassignment Also Valid For Literals?

This explanation about the “Everything is an Object” philosophy, will raise yet another question if you are genuinely curious:

If literals are objects too, then can we reassign literals?

Well if you have tried it, it would have given you an error saying something like this:

>>> "some string" = 123

  File "<stdin>", line 1
    "some string" = 123
    ^^^^^^^^^^^^^
SyntaxError: cannot assign to literal here. Maybe you meant '==' instead of '='?

It clearly says that the interpreter is designed to restrict the reassignment of literals. So what is this hypocrisy?

To answer this you need to understand the difference between data and their labels.

Literals, such as 123, 'hello', or 3.14, are direct representations of data and are not labels (variable names). When you use a literal in your code, Python directly interprets it as a value, not as a name to which a value is assigned. For example:

some_variable = 123  # 'some_variable' is a name bound to the integer object 123

You can reassign some_variable, but not 123 itself because 123 is not a name. This behavior is crucial to Python because it allows it to use the data behind literals to perform calculations and logical operations.

In this regard, functions, whether built-in or not, are labels which point to an object.

Python, by design restricts some data types by making them immutable (emphasis on “some”). But will we be able to reassign those data types if the immutability restriction was lifted? Still the answer is NO. Because don’t forget that these literals are interpreted as data not labels.

📌 I understand that this little hypocrisy might be a little confusing to understand. How can an “object” be a “data” and unlike objects, they cannot be reassigned?

Therefore I am offering a little more clarity on this in the few paragraphs below. You need to blow the minds of the recruiter with this don’t you?

What Exactly Are Literals in Python?

Literals in Python (e.g., 123, 'hello', 3.14) are syntactic constructs in the source code that directly represent objects. When Python encounters a literal in your code, it creates or references the corresponding object in memory during the program's execution.

Do Literals Exist As Objects Before Execution?

No, literals do not exist as objects before the program starts. Instead:

• Python’s parser reads the source code.
• It identifies literals (like 123 or 'hello') and their corresponding types.
• During execution, Python creates or reuses existing objects for these literals as needed.

For example:

x = 123  # Python creates an integer object 123 and binds it to 'x'

y = 123  # Python reuses the same integer object 123 (for small integers)

Python doesn’t initialize “all possible literals” before a program starts — it processes them dynamically during runtime.

How Literals Represent Data, Not Classes

When you write a literal like 123 in your code, Python implicitly:

• Associates it with a specific type (class):

123 --> int

'hello' --> str

3.14 --> float

• Creates an instance of that type (class) to represent the literal.

For example:

x = 123  # An instance of 'int' is created

y = "hello"  # An instance of 'str' is created

z = 456 # An BRAND NEW instance of 'int' is created

At runtime, literals represent instances of specific classes, not the classes themselves. They no longer behave like labels for those classes.

If you still cannot understand words, let the code do the talking:

class MockInteger:
    def __init__(self, value):
        self.value = value
    
    def __repr__(self):
        return f"{self.value}"  # Represents the data directly
    
    def __add__(self, other):
        if isinstance(other, MockInteger):
            return MockInteger(self.value + other.value)
        return MockInteger(self.value + other)

# Creating literal-like objects
num1 = MockInteger(123)
num2 = MockInteger(456)

print(num1)  # Output: 123
print(num1 + num2)  # Output: 579
print(num1 + 100)  # Output: 223

In the above code I have implemented a mock version of the Int() class, which represents the integer data directly and does not point to the class itself. This is done by manipulating the __repr__() method which stands for “Represent”.

The Role of Immutability

For immutable types (like int or str), Python ensures that the literal represents a fixed object in memory. Even if literals were mutable, Python's syntax design would still prevent reassigning them because literals represent data directly, not variable names.

Example:

>>> 123 = "hello"  

SyntaxError: Python does not allow literals to act as variable names

How Python Manages Literals Behind the Scenes

• For Small Integers: Python pre-caches small integer literals (e.g., -5 to 256) to optimize memory usage and performance:

a = 123 

b = 123 

print(a is b)  # True: Both refer to the same pre-cached object

• For Strings: String literals may be interned (reused) for optimization:

x = "hello" 

y = "hello" 

print(x is y)  # True: Both may or may not point to the same object

• For Larger or Complex Objects: Python creates new objects as needed.

Since we are talking about it, lets try and break what I said about the string literals that they may or may not point to the same object:

# string saying hello
x = "hello"

# Creates a string from bytes. 
# It still represents the string "hello"
y = b"hello".decode("utf-8")

print(x == y)  # True: Values match

print(x is y)  # False: Different objects

📌 There are more ways to break this but I have already deviated from the main topic too much in order to give you more clarity. I am up for further discussions if you like though 😄

But What Is This “Stored Program Computer” They Speak Of?

In case you are wondering, Von Neumann’s model of a “stored program computer” refers to a type of computer architecture where both instructions (code) and data are stored in the same memory.

This just means that both the code, and the data for the code, are stored somewhere in the hard-drive, and you can run it anytime by reading from the source. As you might have guessed, this is common in most programming languages we use today, so there is nothing fancy in there.

Unsurprisingly, Python’s implementation and runtime model are influenced by the stored program concept because:

• Both program code and data are treated as objects.
• This enables advanced features like meta-programming, introspection, and dynamic execution.

Alright! we get the “everything is an object” part. What now? How does this relate to the elephant in the room?

If you can assign values to variables, and variables are objects, then by logic you can use the assignment operator = with objects as well.

Here is some practical evidence for the “everything is an object” philosophy:

print(type(123))         # <class 'int'>
print(type("hello"))     # <class 'str'>
print(type(print))       # <class 'builtin_function_or_method'>

You can see that all of these come from a class one way or another.

Let me just put the pixels together for the big picture first, and you will get a clearer idea.

Namespace Management And Scoping

Namespacing refers to the system by which names (identifiers like variables, functions, classes, etc.) are organized and managed in different scopes to avoid conflicts. A namespace is essentially a container (or mapping) that holds a collection of name-to-object bindings.

Before we discuss namespacing in Python, let's talk about how the Python’s runtime memory holds information for your code. Then we will move back to discussing the namespaces.

In the same Python Reference Guide — Data Models the second paragraph says this:

Every object has an identity, a type and a value. An object’s identity never changes once it has been created; you may think of it as the object’s address in memory. The is operator compares the identity of two objects; the id() function returns an integer representing its identity.

We can understand two things from this:

1. Python reference guide is written in plain English and it is not that difficult to understand (for those who run away from reading)
2. Objects (or everything you see in your Python code) are stored at a specific location/address in memory.

I may be implicitly encouraging you to look into the Python reference guide.

With this in mind, let's try a little experiment:

>>> id(print) # The original print function
2975807137456

>>> print = 123

>>> id(print) # The modified print keyword
140732125882616

The id() function returns two distinct identities for the original and the modified version of the print function. This means that this new “print” value is being stored at a different location separate from the original built-in print function.

📌 For clarity, lets call the original print function the “global definition of print function” and the print after we assign 123 to it as “local definition of print”

This also means that the global definition of print function is still there, waiting to be called. But the problem arises when you try to call it, and it fetches the local version of print function instead.

This is known as shadowing in Python, and you can learn more about this behavior from Python Docs, Section: Core Language. And this characteristic is consistent with the Zen of Python’s second line:

Explicit is better than implicit

Let's get back to namespaces.

You may think of namespacing as a Python dictionary or, if you like, a hash table. For every value in the dictionary, there is a key through which you can access it.

And like a dictionary, there cannot be two keys with the same name. This explains why and how the original print function was shadowed by the new print value.

To understand why this happens, the LEGB rule can provide a more clearer explanation. And no, this is not about the rainbow.

The LEGB Rule: Resolution Order of Namespaces

When Python encounters a name, it looks for it in the following order:

1. Local: Names in the current local scope.
2. Enclosing: Names in the enclosing (nonlocal) scopes of nested functions.
3. Global: Names in the global scope of the current module.
4. Built-in: Names in the built-in namespace.

Since the global definition of print is the last location it will look into, therefore it will always end up with the local definition of print.

Since you are not reassigning print directly in a Python script, it will reside in the global namespace consequently shadowing the built-in namespace.

Dynamic Typing And Flexibility

Unlike languages like C and JAVA, Python supports dynamic typing. This means that a variable can be of any datatype at any given point in a program execution lifecycle.

A single variable can hold an integer at one point and a string at another point and a list at another point. Python allows this on-the-fly reassignment of variables and functions. Yes you heard it. Functions are no exception.

Now if we assume that if Python’s design was to restrict reassignment for specific names (like built-ins), that would break this uniformity and reduce the language’s flexibility.

But if you have been experimenting all along, you will find out that the for keyword does not support reassignment.

>>> for = 123
  File "<stdin>", line 1
    for = 123
        ^
SyntaxError: invalid syntax

This, as we discussed before, is the interpreter trying to do its job, which in this case is to find an “iterable” after the for keyword. Which consequently, it does not find and therefore raises an exception.

So will this work if we somehow bypass the exception? The answer is NO … because these reserved keywords like if, ⁣in, for etc are NOT objects. They are a part of the syntax, and they themselves hold no value.

Reasons why keyword are not objects:

• Keywords are reserved by the Python language to define its grammar and rules. They represent syntactic constructs, not runtime entities
• These keywords are not bound by any objects and can be used freely
• These keywords serve a predefined, specific role in the language

Although you cannot directly treat keywords like objects, you can still check or list them using the keyword module:

import keyword

# Check if a string is a keyword
print(keyword.iskeyword("for"))  # True
print(keyword.iskeyword("print"))  # False

# List all Python keywords
print(keyword.kwlist)

Trusting the programmers

I have already answered the technicalities behind the “Why”. But let’s talk about the “Why” as in, why did the Python creators leave this flaw open?

If you are from the Python community, you would be familiar with this quote (or something similar to this):

We are all consenting adults here…

This quote is not part of the official Python documentation but originates from the Python Community, particularly in discussions on forums, mailing lists, and Python Enhancement Proposals (PEPs). It embodies the principle that Python developers are responsible for their actions and are trusted to use features wisely.

The phrase is often used in discussions about:

1. Private Attributes: Python uses a convention (prefixing an attribute with _ or __) rather than access modifiers like private or protected in other languages. This allows access but signals that it’s intended for internal use.

class Example:
    def __init__(self):
        self._private = "Not really private"

obj = Example()
print(obj._private)  # Allowed, but discouraged

1. Dynamic Typing: Python does not enforce strict type checking, trusting developers to ensure correct usage of variables and objects.
2. Duck Typing: Python emphasizes behavior over strict type definitions, allowing developers to decide how to use objects.

Just to save you some time, if you wish to find this quote out in the wild … you can check out this mail in the Python mailing list.

Turns out, this is not a bug, it is a feature 😺

Trade Offs

There is one obvious trade off here. If you do indeed “accidentally” do something like print=123, it is going to cause errors if you plan to use print in the rest of the script. But it was your own responsibility in the first place so you cannot complain now can you? … can you?

Me being me, I can think of some awesome uses for this:

• We can use it in code obfuscation. Loosely typed languages already gives an edge to obfuscation but with this ability, Python can take it to yet another level
• Customize your script by rewriting your own interpretations of the built-in functions. I was always a fan of customizations, so I love this behavior
• Mix this ability with dynamic code execution and you will unlock even more potential in code obfuscation, customizations and whatever your imagination can take you to
• I am a software engineer and sometimes I have to test other people’s code to see if it works or to debug it and fix it. Using this ability I can make unit testing a lot more easier with temporary reassignments of built-in keywords and functions
• Since we are talking about breaking the code (even though temporarily), we could also use this in cyber security and ethical hacking. I don’t know much about this field but I sure do know how can I break my own code to get some info from the database if I was hacking into it (I might write about it in another article)

I honestly don’t know what else is there, but highly believe there are more possibilities with this bug … err, I mean feature. Do me a favor, let me know what else can you think of in the comments 👇.

Obviously I would avoid doing something like this in production level code, because that code should be something anyone can read and understand. With print=123 I would only be making a code spaghetti which no one asked for.

You thought I would talk about trade-offs here, but it was all about me being a mad scientist Muahahaha!

How Do We Turn It Back?

Yes, indeed it is a grave matter at hand. We have disturbed the undisturbed. We have caused chaos among the most serene of gardens. How do we repent and for our sins and undo the imbalance we committed?

No sweat really. Just do this:

del print

This will delete the local definition of print() and will no longer shadow the built-in definition.

Final Word

You have the knowledge, you have the skills. To become a master of the things you do on a daily basis, you just need to be curious. This curiosity is what guided me to explore this behavior in the Python language.

Who knows what other flaws … I mean undocumented features Python has. You can do it just like I did and maybe write about it too. Just remember to ping me to read it. You can reach me out through my Linkedin.

And don’t forget to show off and flex whenever you can in front of the recruiters. They asked you to own the stage, and that is what you should do.

Thank you for reading till the end 🥳

If you found this article helpful and learned something new, be sure to leave a 👏 or let me know your thoughts 📣on it. I’d love to read your feedbacks and will reply at my earliest.

I will be sharing stories about what I did (or at least wished that I should have done) when I first got hired as a junior developer. There were some things that I was right about and some which I didn’t think of much but proved to be very beneficial in the long run.

These are the compilation of my best practices at the very start of my career.

tl;dr

Soft skills is to programmer as algorithm is to a program. Just like a good algorithm makes a good program, good soft skills makes a good programmer. What happens if a programmer doesn’t have any soft skills? you ask … they are similar to a cog in a clockwork where the cog doesn’t change jobs or it’s position and just stays there for as long as necessary. The worst part is … the cog doesn’t decide the end of it’s externally imposed fate. I hope this analogy makes sense.

This article isn’t my rant about the importance of soft skills. People have done that before. What I’m doing here is showing you a practical approach to make those soft skills beneficial for you in early or further stages of your career.

Communication, time management, team work, negotiation, problem solving, critical thinking etc all are tools that can be used to maximize your potential, but it is rarely being talked about “how exactly?”. Let’s explore the possibilities.

Humans, as an individual, have improvised and survived throughout the centuries because of these so-called soft skills. But what is the meaning behind this seemingly abstract term. These are the skills that enable you to do human things like feeling empathy, communicating thoughts, taking the lead, solving problems etc.

Know this, that soft skills are not something that can be taught. As far as I have experienced. These skills are developed as you use them. Doesn’t make sense? It will in a few moments.

Ask yourself this: “How did I learn how to move my hands or legs?”

As time passed after you were born, you realized you had limbs. Great! you have limbs, now what? did you have as much control over them as you have now? Maybe you can drive a car, cook a meal or draw really well right now but were you able to direct your hands to perform those tasks after a few months of being born?

You made all sorts of silly gestures and flailed your arms uncontrollably, until you realized that you had gradually gained control of your arms and legs. That is what I mean by “These skills are developed as you use them”. Soft skills are natural.

Anyways, lets talk about the things you need to do.

1- Diary Keeping

I didn’t always write a personal diary, but I did like to make a record of “special things” in a day. When I got a job, everyday became a special day for me. A new morning with new possibilities. The sun shining, the flowers smiling …. no not exactly like a Lala-land but it was exciting nonetheless.

So anyways, I started keeping a diary. Where you ask? Well … I was using Ubuntu in my workplace and there is this notepad tool I really love called Cherry Tree. It has a nice feature to maintain all my notes in a tree-like structure in a single file with rich text formatting. I had setup my tree to look something like this:

Year: 2023
|- Month: Jan
  |- Day: 01 <-- this is a "date node"
  |- Day: 02
  |- Day: 03
  |- ...
  |- Day: 31
|- Month: Feb
  |- Day: 01
  |- Day: 02
  |- Day: 03
  |- ...
  |- Day: 29

Inside each date node I had a separate note in which I would write about the events related to that day. I would not write everything like a micro-managing maniac, just some important events, if any.

For example;

1. If I had a meeting with HR regarding my outstanding documents which needs to be submitted into the company’s records, I would make a note of that.
2. If everyone in the dev room (room for developers) had a quick round of CSGO, I would make a note of that.
3. If I encountered a bug that messed with me for 4 hours, I would make a note of that as well.

The first example had something to do with reminders, such that I would easily be able to recall in which day I was reminded or submitted the documents. The second one was just for fun. The third one however, will be able to remind me (in detail) how I solved a specific bug in a specific use case. And that is important.

It is important because at the early stages of my career I faced lots of problems, and I needed to remember exactly how I solved those problems because you can encounter a single problem multiple times when you are junior or are tasked with training juniors. It’s a one-to-many relation.

But once you encounter one problem too many times, it becomes your second nature. In other words, you become one step closer to being a senior … developer, that is.

As for the first use case I discussed earlier, I think I still have some explaining to do. I really hope not, but if your first ever workplace turns out to be toxic and HR is trying to pull your leg one way or another, you will need to keeps your wits about you. That is where keeping notes about reminders and office-related event comes in handy.

Not that my first workplace was toxic, but I kept notes about stuff because I personally wanted to optimize my routine. Like manage how much time I spend on working and slacking off. But if you have a micro-managing boss you can rest assured that you neither need a diary nor to optimize your routine (as something ‘extra’) in the office. Those things will become a part of your work. No kidding, but let’s hope you get hired in a great working place.

In each date-node, I would categorize things like this:

📌 I wrote the above sample in markdown to make it simpler to understand. Cherrytree stores the rich text formatted content in XML.

By looking at the above sample, you can guess that I didn’t have any problems remembering what happened when and what did I do and when… you get the point.

Just don’t show it to anyone. If your boss hears word of this, they might get ideas about micromanaging. This is for you and ONLY you. You have been warned 😬

If you want, you can even put in start time and end time in each TODO item to know how much time each task took. Feel free to make this format more sophisticated or simplify it down to suit your needs.

2- Building Rapport

Now I know that, some of you may be an introvert and cannot keep up with lengthened durations of socialization. But even if you are an introvert, a little communication with your co-workers never hurts. Heck, even I am an introvert, but I have respect among my peers because I have clearly communicated my values and authorities to them. It was tough, but it paid off not only in establishing my position as a good person but also for upgrading my skills and career.

Think of it this way: you got hired to do a certain job and communication is a major part of a software engineer’s job. Without it, how are you going to get your requirements or ask if some instructions are unclear? Moreover, there will be meetings and it will be really great for you if you could put in some of your own inputs to the topics being discussed. You need to be able to talk to others without freaking them out.

But how does one communicate? Are there certain rules at play? Well yes, but not only in the office scenario, but also everywhere else.

For example, you go out and see a dirty guy with un-ironed clothes who probably hasn’t taken a bath for a long time now and a well dressed guy who maybe does not wear a perfume, but is clean and looks well maintained. Who seems more approachable to you?

The things is, not only your words but also how you look and act matters and it is in fact the first ever communication you do with everyone else. Before they even greet you, they judge your body language. Is it inviting? is it friendly?

Don’t worry if your face doesn’t match their ‘beauty standards’. Don’t worry if you are less knowledgeable than others. These things don’t matter in business anyway. What matters is if you can bring value in the company you are working for. This includes making the environment more friendly and inviting.

If you don’t have many friends, now is your time to make some. Since introverts often need clear instructions (I needed them too 😁) on the ‘how’ and ‘what’ when socializing, this is for you guys:

Greet people properly and try to talk about similar interests you both might have. If you can not find any similarities, try talking about a book that you have been reading or talk about one of the recent Fireship’s Code Reports or anything is particular. Tell them you have found it interesting (which hopefully you genuinely do) and that you are looking forward to what comes next. This way you are essentially talking about your own interests while inviting the same interests from the other person. If they don’t seem interested in your yap, then now you can ask them about themselves, their hobbies, what they like and what they don’t.

Remember that people are more likely to tell you about themselves if you have told them about yourself first or if they are in an interview where you are interviewing them. Going straight up and asking people about themselves may go wrong if it is your first point of contact.

📌 Honestly I could add more to these instructions but that would make this article extra lengthy (which I don’t want). So instead I’m open to talk about how you can improve your communication skills on discord (username: blankscreen.exe). I usually help people from Reddit prepare for interviews and help them get a job.

As a junior dev you are obviously going to work under a senior. That senior should be your first friend because it is easy to get to know someone if you are in constant interaction with them.

Your goal is not to sell yourself here like you do in an interview. It is certainly not to look charming and eye-catching. You goal through communication should be to let yourself known among other employees and present yourself as approachable and a sensible person.

3- Asking Questions Never Gets Old

This leads me to another important topic and it goes without saying. You need to ask question and not be afraid to ask them. You are in a junior developer position because you don’t know certain things. Also keep in mind that at any point in your career, no one can judge you for asking questions, but you need to be respectful.

Your seniors might already have their hands full. It will reflect bad on you if you just ask questions without doing your own research first. It’s like finding the easy way out without putting any effort into your work. This, as any sane person may think, it not appreciated in a professional setting.

Personally, when an intern or a junior asks me a question about a problem, my first reverse-question to them is, “so what have you tried?”. That is because I want to see if they have actually put in some effort before calling me out of my work. I do not care if their efforts were fruitless. I will happily solve their problems with them if they are willing to do some work.

If the seniors tell you to wait before they come to you, you shouldn’t just wait idly doing nothing. Try and look for a solution on your own. You have Google, you have Stackoverflow and of course CrapGPT which might not always give you solid good directions but works if you are asking for basic syntax, or something trivial like “how to center a div”.

📌 I tried using CrapGPT for a month, but long story short, I wasn’t getting much value from it. So I resorted to going back to stackoverflow or official docs. Maybe I will write something on my experience with CrapGPT.

It would be much better if you first did your research about a problem from different sources and then if you still don’t find a proper solution, you should ask a senior for help.

This is something that can get you laid off if you don’t properly respect and value other’s time. Your seniors are not necessarily there just because they are good at their work or they are happy doing it. They have a livelihood to earn and if you cannot value that, then your recruiter will probably start to have doubts in the potential value you are bringing to the company.

As for me, 😁 I love doing my work, but I don’t appreciate it if someone disrupts my flow for no reason. I don’t mind mentoring as this is also a part of my job. But I would rather not spend time doing something that I am not supposed to do. No one wants to be caught sulking around doing something useless during working hours right?

I will now emphasize on the importance of asking the right questions. What you don’t want to ask are questions like these:

• How do I solve this error?
• How can I implement custom authentication?
• How does the request lifecycle work?

Notice how these questions fail to show what effort you have put in your work before jumping on someone’s head for an answer. Also notice, that these questions are basically prompting others to do your own work for you, which, in all honesty, you should be doing. By asking these types of questions, you are clearly showing that you don’t have enough ability to Google some simple stuff like custom authentication and request lifecycle in this example. Stack overflow is overflowing with answers to this and all directly related questions, yet somehow you managed to look past all that and chose the superfast and easy way to bug a senior dev.

Do not ask for things which you easily get an answer to if you google a little bit. Yet simple things can be complicated for juniors, and I understand that. Therefore, you need to be able to show your research and discuss the things that you have tried before you can ask for help.

This should not discourage from asking too many or dumb questions. Questions are always appreciated, as they show your willingness to learn. But you need to be mindful about asking the proper questions and back it up with evidence of your efforts.

4- Ask To Participate In Code Reviews

Asking to participate in code reviews and debugging existing problems is a great exercise if you want to get familiar to a project you are working on. In fact, you will most probably get debugging as your first ever task as junior dev. So in most cases, you wouldn’t even have to ask to participate.

If you are doing it yourself, then you will have ample opportunities to learn how the project is working under the hood and also observe how the project is structured by your seniors.

If you are observing a senior do it, then you will have an opportunity to learn how they do it. Which files do they start with? and how do they track a bug to its source? How are they handling a bug? All of these things are what you should be looking out for when observing a senior do their work. You don’t just need to observe, this is actually a good place to start questioning too!

During debugging and code reviewing, you will find yourself collecting an arsenal of questions, some of which may be impressive and some just plain stupid that even you can answer after some Googling. Save the tricky ones for your senior and the easy ones for yourself. This is also where diary keeping skill comes in handy.

5- Ask For Time When Doing Something New

We all believe that an opportunity can arise at any given moment and surprise us. This is also true if your supervisor suddenly appears out of nowhere and tasks you with building something out of a technology you have absolutely no clue about. This can happen with equal probability for seniors and juniors alike.

If you ever saw someone telling your senior dev to build something using a new technology, they will always estimate some time during which they will be learning about this new technology and convey the estimations to their higher-ups.

Truth be told, some companies readily give out “learning time” if they want one of their resources to work on something new, because they understand the importance of proper work in contrast with makeshift work.

On the other hand, as you might have guessed, some companies don’t allow for such time. This difference is simply due to the lack of resource management and planning capabilities in a company’s management department, but unfortunately, it happens all the same.

📌 Honestly speaking I could rant all day without breaking a sweat about these companies who don’t allow “learning time”. I can go into intricate details about what goes wrong and where. But it is not in the scope of this article.

So the take here is to politely ask for some time (from your normal working hours) to learn something new. This request of your should always accompany time-estimations, which are important because it shows that you have done your research about a technology and broke it down into organized hierarchy of milestones and that you have planned your learning journey properly. So now people won’t think that you are just blabbering a number, but you are backing it with proper evidence of how much effort you are going to be putting each day.

One good way to do this is … let me just tell you through an example:

Assume that your supervisor shows up to you and asks you to learn about MongoDB, because that is what you will be using in your next project. You will tell the supervisor that you will look into it.

Your next move should be to search for online resources that teach MongoDB. In this scenario, you will find that they have a Mongo University which covers everything you need to know about Queries, Compass and Mongo’s driver code etc.

You will review the time estimations for that course and add some extra time to it. You will tell your supervisor that it will take X hours to learn about this technology in order to be able to actually use it.

Now there are 2 things that can happen:

• You supervisor approves of it and you start learning.
• Or your supervisor suggests you some other alternative course/mini-project and you work on that … with time estimations.

6- Time Management And Deadline Estimations

I talked about adding some extra time up there. Let’s discuss how we actually estimate timelines and how will we manage our time according to our estimates and deadlines.

First about the estimations; when your supervisor relays some tasks to you, you will almost always be asked to estimate timelines for each umbrella activity and its sub tasks.

In case you don’t know Umbrella Activity is a combination of several tasks which are required for a certain feature to work. For example, adding a like button to posts is an umbrella activity. It will have sub tasks such as modifying database to record number of likes, changing frontend etc.

If the project you are working on is being created from scratch, you will have a chance to witness how the timelines are being set by your seniors. You might not need to manage a Gantt Chart or plan time estimates at all for overall projects because that is what the senior developers and project managers meet up for.

But the supervisor might still come to you with some tasks, that they plan to give you, and ask your opinion on how much time should a specific task take (if you were to do it, instead of someone experienced).

The thing is, they understand that you as a junior developer will take some extra time to understand stuff before doing it, as compared to senior developers who will plug this, slap that and call it a day. Therefore they would want to know how much time you want to take doing your stuff independently.

By this you can infer two things:

1. Time estimates are NOT objective, it is in fact subjective. It depends on the person doing it.
2. It is NOT a given that a certain task will always take a certain amount of time.

And this brings up a good question: how do we know how much time will we take when we do a certain task?

The answer to that is, you can never know the duration you are going to spend on something. Anything can go wrong at any moment. You never know.

So what do we say when we are being asked about time estimates?

Think of your time estimates like “How much time am I willing to spend on this task?” rather than “How much time will it take?”. That is how the seniors do it.

If you want to include in some time for research before you actually do it, tell them about it and the hours you are allocating for the research. At the end, after you have finalized your time estimates, add another 10% to 15% of the total time as a buffer. This buffer time will act as a 1UP if you are not able to meet any of your deadlines for any reason.

Now that you have given your time estimates successfully, lets talk about how to manage time so that you can meet your deadline which you yourself have set.

You might have heard about Pomodoro Technique or Time Boxing etc. While these are good techniques which can be used outside of software engineering, but they are quite a hassle to work with. These techniques promise you a healthier work pattern, but at the cost of your attention. Attention is something 99% of which you would rather spend on your actual work, than on managing your work.

You can try it yourself, use pomodoro technique, work 25 mins and rest 5 mins. Do this in a loop until your day ends. Or you can try time boxing and set strict time frames for each day’s tasks. You would soon find yourself managing your work pattern more than doing your actual work which you were hired for. And yes this might not look good on you from your supervisor’s perspective.

While these techniques are good on their own, I personally haven’t benefitted from them after trying them out. Let me know if there was a technique that worked for you down in the comments.

As for me, I used to take tasks assigned to me by the project manager, and planned on doing one or two of them in a single day. I was a bit slow but it was understandable and I was producing results independently so no one bothered me much. But deadlines were still strict, because that is something coming from the client themselves.

A good thing you can do is take your tasks seriously. Everyone expects you to get stuck finding a solution to something. They know you will take some extra time doing normal stuff. However deadlines should be taken seriously.

I remember myself trying to figure out something in and out of working hours. Some of you might have an ego about not working after office hours but at this stage, you should worry about your growth even if you have to work some extra. Of course there is a limit after which extra hours become bad for your health so take that into consideration as well.

7- Discuss Your Potential Growth

This is one of the things you can do to show that you are willing to bring value to the company as you seek out further growth opportunities. After all you can only contribute better to the company if you grow or climb up the corporate ladder.

You can discuss about your growth (either in your responsibilities or your role) with anyone, but I would recommend that you ONLY do it with your direct seniors or their leads. This is because any other person, especially if they are not well-known in their field or rank close to you, would consider it as a competition and that is when things get dirty.

But we are going to assume a workplace which is free of politics and think straight. I am not preaching about office politics here anyways.

Assume that you are a lead engineer in a huge project and are being paid in millions to oversee the project (hopefully this assumption is true in your future). Now there are two juniors who are working under you.

Junior A is shy but excels in his field. He knows what he is doing and will do absolutely anything you ask of him. He does often get stuck in things, as juniors always do, but with minimal support, he can get back on his feet.

Junior B, however is not shy, but not very social either. He would greet people nicely and thus, became a familiar face in the office. He is not as much proficient as Junior A, but he makes it clear that he is willing to learn anything and produce quality results.

One day, both of them come to you and pose their questions like this:

Junior A: “I have been doing mediocre work for a while now and I am looking for challenges. If you can, please allow me the opportunity to take on additional responsibilities.”

Junior B: “I have been thinking about upgrading myself in the right way so that I can contribute better. This has been on my mind for a while now. I’d like to know what can I do to better myself and what pathway is available for me.”

Now think really hard from a lead’s perspective! Which junior deserves a higher position in the corporate ladder and hopefully an increment in their salaries?

If you were thinking that this is a game where one person wins and other looses, then you are dead wrong. Psych! Both of them are deserving.

From a lead’s perspective, you can see that they both are willing to upscale themselves and genuinely rise to new heights in their own way. One wants to take on additional responsibilities and other wants to learn something useful. The biggest similarity is, they both are ASKING FOR IT from you, the lead engineer.

8- Accountability

You are going to make mistakes, that is a given. If you are thinking that senior developers are smart people and don’t make mistakes, then you sir are definitely wrong. As long as anything is living on this planet or the next, they will definitely make mistakes.

With that said, you are going to be judged by your mistakes as well as your accomplishments. There are two types of people who are going to judge you: Those whose judgment matters in your next salary review, and those whose opinions are just for themselves to feel good about.

In that regard, your supervisor’s image of you is definitely going to matter. Now I am tired of making comparison scenarios when I tell you about two people and ask you to compare them. So I will just cut to the chase. Believe me if you like.

If you try to blame others it is not going to reflect good on you. Even if it genuinely is someone else’s fault, still don’t blame anyone. You don’t want your co-workers ganging up on you in an alleyway.

Instead, volunteer to solve the problem or help solve it (if you do not have any other tasks of your own).

If it is, in fact, your own fault, then be quick to respond to it. Ask them the details of the problem and start debugging it like a good boi.

People want to see if you are a “problem solver” and not a “problem deflector”.

9- Mindset

Programming requires creativity, and creativity is about using the tools you have, in order to achieve a goal. Your methods can be unconventional but they do solve a problem. Since this creativity relies on the tools you have at your disposal, your creativity will grow as you knowledge of your technologies grow.

This field of work is for those who are curious. There are many technologies in the wild, that NO ONE person can know about all of them. You might know about some, but not all.

Curiosity is a tool which enables you to develop hunger for knowledge. But it can be troublesome if not given a proper direction. Afterall, eating the wrong kind of stuff can be bad for your dietary goals.

I know, I know … me an my stupid analogies. But you get the point.

If you let your curiosity run in the wild, it will hop on topic after topic without doing anything meaningful. If you don’t put a leash on your curiosity, it will start running like a wild horse, will be difficult to control.

I said that you need a direction for your curiosity. This means you must have a plan or a roadmap about which topics you are going to learn and which topics you are going to skip.

If you are learning from youtube, then know this that the youtube’s algorithm will try to feed you topics that will of course pique your interest but will be useless for your learning goals. That algorithm is not trained to feed you what you need but instead it works for maximizing views and engagement. It’s a deception.

I am not saying that you will not learn anything useful that way, but it cannot be called guided learning. Guided learning is when you have a curriculum that you follow to the end to gain knowledge about a certain topic. That is being followed in all the educational institutions, and that is what makes a huge difference between self-taught developers and ones with a degree (assuming they both tried to make good use of their time).

For roadmaps I will always recommend roadmap.sh unless I find a better alternative. This should give you some proper direction.

Another thing about your mindset, is that you should be humble. I don’t care if you have the ability to make the next facebook or google. If that were the case, you would not be hired as a junior developer.

I am certainly not discouraging you and stopping you from making the next facebook. But I want you to get rid of your ego and over-confidence. I want you to be realistic.

If there is something you have not done before, but you think that you could just give the docs a little read and be able to do it, then no, it does not work that way. You will most probably get stuck in an error and use some of your time debugging it. Notice how I said “use” instead of “waste”, because that is still a part of learning.

What do you think makes a senior dev a senior developer? The answer is mistakes and lots of it. Why do you think that you automatically assume that senior developers will have an answer for the bugs YOU are seeing on YOUR screen? The answer is because they have seen those bugs many times now and have solved them over and over again. They ran into those bugs because they made mistakes.

This is also an important part of accountability as I previously discussed. You should not be ashamed of accepting your mistakes, but be eager to learn how to fix them. It is completely OK to say “I don’t know about this”, at all stages of your career. Because this is what opens up a path for learning and growing.

10- Burning Out Is Not A Good Idea

It is a marathon, not a sprint. Only the wise understand this and conserve their energy, enthusiasm and attention in order to spend them wisely. A lot of bad things will follow if you get burned out. You would not have enough sleep to properly function let alone code, you will not have the capacity engage your attention anywhere, you will feel like sh*t all the time. Honestly I could give you more reasons why not burn yourself out, but that would be another blog article on it’s own.

If you burn yourself out, you will definitely miss out on the wealth (as in your salary) and the wealth of knowledge you could have taken if you were not half dead inside. This adds yet another meaning to the proverb “Health is wealth”.

Staying healthy and hygienic is as much important as arriving on time for your job. Take baths daily. Stand up from your chair and walk around a little bit. Eat less junk. Don’t stare at your screen for hours, and look away around you. These tiny actions can make a lot of difference.

You can never compromise on your health, even if the job demands it.

11- Think Of Software Engineering As A Craft

No one seems to preach this, yet this is as important as it gets. during your career, you might think of dropping out because you are good at it, maybe you think you have imposter syndrome. These kinds of discouraging thoughts are common.

📌 SWE = SoftWare Engineering

What you need to understand is that Software Engineering is a craft. Like any other craft, it will get easier and easier as you get accustomed to it. How do you get accustomed to SWE? Practice of course!

📌 All of the rules that apply on any given craft, is applicable on SWE as well.

Practice is what makes you a master in any given craft. So why not make use of it to become a master of your own craft (which is smashing buttons on a keyboard all the time)

But now the question arises: practice what exactly?

A good portion of what you will do in your job is problem solving by building your own algorithms and then translating it into a programming language of your choice. The “building your own algorithms” part is where you need to focus on because that is core of your purpose as a developer.

There are many ways you could practice code. There is Leetcode, CodeChef, Hackerrank, Codeforces etc. Just pick one of these sites and start problem solving. Always start with the easy questions first, even if you are feeling confident, just to get the feel of the platform.

Another way to practice code is by building pet projects. This exercise may or may not enhance your algorithm building skill, but will definitely allow you to explore technologies which you will use in your job. Use this to upgrade yourself and your arsenal of knowledge.

12- Know Your Apps Inside Out

It is not like you will be jumping ships every two days or so. A project that you are working on will most likely go on for a few months to years. Plus if you have spent time working on a project, then most likely you will escalate to supervisor for that specific project.

It is a cycle where your senior is slowly training you on the project so they can move onto new ones, and you will do the same for your juniors when your time comes.

Therefore it is always a good idea to explore every corner of the application you are working on. Become familiar with the technologies that are being used in it.

Remember that I talked about using some of your free time to learn about new technologies(section 11)? You should focus on the technologies that you will encounter in your currently assigned project.

This is where you should start with, when learning new things.

13- Do Things That Make You Stand Out

Doing things that you are supposed to do on a daily basis will not get you anywhere if you want a name for yourself. But don’t get carried away! Doing something extra does not mean that you are abandoning your responsibilities or are not working to be able to perform those duties better.

You should only do something extra, when your supervisor allows you to or when you have finished all your tasks for the day.

Now let us talk about what this “extra” actually is. This could mean that you are simply taking interest in your senior’s work or doing some extravagant like participating in critical decisions. You could, for example, ask your senior or project manager to bring you in the next meeting for some ABC Software as a bystander. There is no reason for them to decline you, but if they do then respect their decision.

If you are having trouble thinking of what “extra” you can do in your free time, then here are some suggestions:

• Volunteer if something new pops up. For example, your SQA raised a bug and you had some free time. So you could ask your supervisor to assign you that bug.
• If you have subscribed to fireship or if you are an avid visitor of places like hackernews, dev.to, daily.dev, medium etc. You could try and share something over lunch that you found interesting.
• Ask for feedback on your work.
• If there is a bug, share your understanding what could be done to solve it or to improve it. You would be surprised by the variety of solutions each of your co-workers have in mind.
• Talk to people outside your department. Let them know you exist and that you are a good person to talk to.
• If something feels within your expertise or skillset, offer your help on those.

Notice that most of these things are what I already told about in previous sections. Turns out that I was secretly planning to make you stand out and out grow your role 😁.

14- Show Empathy While Writing Code

Some of you might have that sudden and unquenchable urge to write clean code. If this happens, then you would certainly strive to become the very epitome standards and radiant efficiency.

You guys should know that most of what the clean code preachers say are a scam. At the end of the day, your code either makes the client or other developers happy.

If it is making the client happy, then your code is performant. If it is making other developers happy then your code is clean enough to work with.

But this new found urge of your can also be your downfall. It can turn into a tyrant that no one wants in their team. Allow me to elaborate:

When you are being assigned to a new project then it is not just a project that you are going to work with. It will also be the hopes and dreams of a “genius” person who started it from scratch.

Now you generate your very first pull request and your senior does not have the slightest idea the torment he is going to face. When he opens it for reviewing he sees the following:

• Every line of code has a comment above it which explains the line of code does.
• Onslaught of incredible one-liner code.
• A new file is created for every helper function.
• Excessive tests are written for each micro functionality.

The senior sees this much and rejects the pull request out of his horror. who knows what other monstrosities were in there? Here is what was wrong:

The comments are good but should be rarely used since the code should be self explanatory. Several proper code enthusiasts forget that. Also, what if someone changes the keywords used in the line of code? Now the code might do something different and would not fit the description which you put up there. I am this case your comment would be explaining a scenario that does not exist anymore. It would be a lie. You could argue that the person changing the code could rewrite the comment or remove it. But would you yourself want to work to work on someone else’s code where you have to put in double the effort to perform a single task? Time is money which the client’s are always counting.

One-liner code are great for flaunting your superiority complex. But do they make the code less readable? Yes of course. Other people who are going to work on it will have to break it down which can frustrate them. Afterall, software engineering as a whole can be a really frustrating exercise. Don’t get me wrong though, there are certain scenarios where you must use a one-liner either for efficiency or for a functionality to work properly.

Modularity is good to include in your code where you categorize related classes or functions in different files. But then you could easily be a victim of “modularity hell” as I like to call it. You will soon find out that each class/function is distinct and you will end up giving each of those classes/functions a category of their own. You need to learn to compromise a bit when it comes to modularity.

100% test coverage, as far as I see it, is a myth. The main idea for test driven development is to write minimal tests and then write the code that passes those tests. So we usually only write tests only to check if the requirements are working fine, that is it. writing excessive test not only forces you to give more time writing tests than actually writing the code that matters the most to the client.

One more thing that juniors often do not take into consideration is the standards. They tend to introduce their own into the codebase. If you see a standard being followed for whatever stupid reason, just follow it. Someone more experienced than you put their time and efforts to create those standards in a single project, whether it is for importing models or inheriting custom classes. No matter how unconventional the standards may look, just follow them.

15- Restrict AI Chatbot Usage

Almost 99% of the juniors (I could be exaggerating this number) I see today, whether in the company I work for or others, frequently use AI in their workplace. Is this bad? Well, for the most part my answer is going to be yes.

The reason behind this is simple, think about teaching your kids to use a calculator for even the simplest of calculations. Now that they have a habit of doing this, so much so that it has become a major part of their lives, they will be whipping out a calculator for even the most trivial of sums.

When their calculator malfunctions, they in turn also give out wrong answers. When their calculator’s batteries die, they panic because now they are unable to calculate anything. Turns out they have been overly dependent on their calculators that they simply forgot to use their brains.

Another analogy I would like to give you is that of a FPS shooting game. If you are overly dependent and abuse the usage of AIM BOT cheat, you will never develop the skill for aiming yourself.

Like every other tool, these AI chatbots have their good usage and bad usage. Beginners and juniors alike generally use them in a bad way.

Yes it can increase productivity (I personally cannot vouch for that though), but that depends on how the chatbot is used. If you throw all the logic building towards the chatbot and use your brain for Ctrl+C and Ctrl+V, then you did not grow, you did not learn anything, but what you actually did was to burn the bridge which leads to “being an experienced developer”.

Generally speaking, these chatbots are more useful in the hands of senior developers than it is useful for juniors. Juniors are there to learn stuff, that is what they should focus on while contributing to projects.

Juniors nowadays need to understand that there were legendary programmers before these chatbots were even a concept. How did they become the legends? They didn’t sulk around generating code, that much I can tell you.

Yes you can use it for ideas like how should you structure your database and for syntax problems like which method to call from a pre-made class. I do it in my work so I encourage you to do so too. But what I fear the most is that the line between good usage and bad usage is very thin and often blurred when it comes to these chatbots.

Another of my fears, is that you never give a weapon to someone, not until you have trained them how to use it at least. The reason why I am using such a grave analogy here is because it can potentially ruin careers of people. Think of someone who have used these chatbots for an year now. If they go to a recruiter there is going to be an interview. Will they be able to answer those questions?

It all boils down to how the tool is used, and sadly most people often like to go for the easy and convenient way.

Not to mention that the practice of using a chatbot with sensitive data can be subjected to violation of company’s or its client’s privacy.

You need to have a little confidence in yourself. You are better than the chat bot. Your seniors are way better than you. You have lots of other options. Be dependent on your wits rather than on a chat bot.

Final Word

These were some of the things I did while I was a junior or at least think that I should have done.

While some of the ideas I gave you are good on their own, your situation might vary. So feel free to use your creativity to make the most out of your career.

The list of advice I have here, is obviously not complete, but it is a good compilation of my personal journey as a software engineer. If you have any ideas of your own or deferring thoughts on any of my ideas that you would want the junior developers who are reading this to know, then please do comment below. It might do some good.

Above all else, soft skills matters more than writing code.

Lastly, some of the great points in this article are due to some very generous people from Reddit r\AskProgramming. I would like to give them my heartfelt gratitude. It is because of these people that programming aspirants have someone to rely on.

Thank you for reading till the end 🥳

You now know the recipe for success. Go out there and win the world.

If you found this article helpful and learned something new, be sure to leave a 👏 or let me know your thoughts 📣on it. I’d love to listen to your feedback.

📌 I wrote this one since some people have been asking for it. Hope you will like it.

So if you have been reading my previous articles then you would probably know that I work as a Software Engineer where my responsibilities include working on projects from scratch, collaborating on ongoing projects, debugging, containerizing and deploying stuff on cloud and who knows what sort of shenanigans I’m up to.

So now that you have a picture of what I do on a daily basis, you can relate yourself to me as we go on exploring these TMUX plugins.

If you want a refresher on TMUX, I have explained how to approach learning it in a human-friendly way, as it can be a daunting task:

How I Learned TMUX & Became A Workflow Ninja

Enough jibber-jabber, let’s get down to business … here is what you should expect from this article:

1- First, I will explain how to install and use any plugin.

2- Then I will open up a pandora’s box of TMUX plugins and go through each one.

3- I will also be telling you how to make your own TMUX plugins.

How To Install TMUX Plugins

There are mainly 2 ways you could do this:

• Manually 👉 Download the plugin code yourself (git clone it) and place it in the appropriate directory. You’ll then need to configure your tmux configuration file .tmux.conf to reference the plugin.
• Using THE plugin manager 👉A plugin manager automates the installation and management of tmux plugins. Tmux Plugin Manager (TPM) is a popular choice that simplifies the process considerably. You can install and update plugins directly from your tmux configuration file .tmux.conf.

I’m not going to explain any of the above methods, since you can already find a resource online which tells you how to do it. Let’s move onto the more exciting and fun part.

📌 But in case you encounter a problem while setting up Tmux Plugin Manager, the best I can do is reply to your queries in the comments.

List Of Plugins

📌 The order of these plugins are not meant to be ranked. They are randomly ordered.

All the plugins shown below can be seen officially listed here.

There are 3 categories in which I personally divide the plugins:

1. The essentials, which I use on a daily basis
2. The flex-material, which … well … is used to flex ofc
3. And some miscellaneous stuff, which might be useful in very specific contexts, but using them really depends on if you’d like to or not.

The first category is what I’m listing below.

🟢 aw-watcher-tmux

I used this simply because I like to keep a log of my activities. aw-watcher-tmux can not only be installed as a TMUX plugin, but can also work as a global application which runs as a service. Not only that it can also work on Mac, Windows, and of course Linux.

*takes in a deep breath* I use Arch by the way 😎 …

… this is something I’d like to say at this point in order flex on you as a developer, but it’s a lie though. I use Ubuntu. Maybe I’ll write something about getting used to Arch Linux someday too. Let me know if you would be interested.

Getting back to the topic …

In case of TMUX it keeps track of the sessions and activities inside those sessions. In case you are thinking about tracking the activity of a certain user, then no, it cannot categorize activities with respect to each user on a machine. And it shouldn’t, because that is a violation of privacy.

It is supposed to be used for productivity, not as a spyware. Therefore every data stays local.

Also it comes with a pretty UI in the browser so that is a plus. But don’t let your boss know about it, because they might start micro-managing you.

Here is the official website in case you are wondering.

🟢 tmux-autoreload

This is basically a “file watcher” designed for tmux.conf file, just like git watches files for changes.

It watches our configuration file and automatically reloads it, applying the latest settings right away. This saves me the trouble of reloading configuration manually every time I update it.

🟢 tmux-cowboy

It is designed to help you terminate unresponsive processes running within your terminal sessions. This is a quick and easy way to “kill” those CPU hogging programs that have become stuck or frozen.

Its main feature is its ability to kill processes, which it does by sending a fastest SIGKILL signal in the wild west to the target programs. The good thing is that it saves me the trouble of switching to another pane/windows to kill them myself.

But here’s a catch: It is not for noobs who just started learning how to use Linux based systems. You must be able to understand the risks that come with this plugin or else you will break something you shouldn’t have. It can also lead to data loss or unexpected behavior if the process hasn’t been properly shut down.

I would only recommend using this ONLY IF your process is completely unresponsive, other termination methods have failed, and when you know what you are doing.

🟢 tmux-git-autofetch

As the name suggests, it auto fetches from remote git repository so that you don’t need to run git fetch everytime. I personally felt it very annoying when I commit some changes only to find out that the REF I’m pushing to has changed. So this plugin acts as a good reminder as well.

🟢 tmux-menus

Having trouble remembering all the key-binding which you yourself assigned? Say no more.

This plugin is the TUI solution for context menu inside the terminal. All you need to do in memorize one single key binding for tmux-menus. It presents the user with a popup context menu which handles all the hard-to-remember key-bindings in the backend and let’s you choose what you need to do. This is what it looks like:

The menu you are seeing above is just the main menu. There sub menus in there as well. I really recommend you try this one, because it makes life much much easier. Also, apart from regular key-bindings, there are a bunch of custom commands you can also use.

🟢 tmux-sidebar

This plugin provides you with a sidebar, which shows you your current working directory and, recursively, their inner contents and the contents of their subfolders.

This sidebar acts just like a pane, which cannot be interacted with, other than by using arrow keys to scroll through a mess of your directories.

On the far left is my sidebar. You can navigate to it just like you would in a normal pane i.e. prefix + <arrow_keys>.

🟢 tmux-sensible

As the name suggests, this plugin introduces a set of standardized settings to TMUX. The reason why I consider this standardization necessary is because, I mostly work on remote servers with several other people. That is where this standardization comes into play.

Using this plugin, everyone can stay on the same page and won’t be pinging others or reading the tmux.conf every 2 minutes.

In my case, I haven’t made too many changes to my tmux.conf which I got from tmux-sensible.

🟢 tmux-mighty-scroll

Usually when you want to scroll up or down in a pane/window, you would first enter copy mode by typing: prefix + [. This plugin simply helps you do that and saves you from going into the copy mode manually.

To be honest, you can scroll quite well without this plugin in a tmux session. But if you tried scrolling with the default settings you would notice that scrolling only works similar to up/down arrow keys in a normal shell session outside of tmux, i.e. you will see previously entered commands (in chronological order) which will be shown against your prompt.

Remember that tmux-mighty-scroll will not work unless you enter command mode and type these magic words: set -g mouse on , or better yet, set this command in your .tmux.conf.

As a bonus, it also let’s you navigate to panes using your mouse. Just hover your mouse over a pane and left-click it.

🟢 tmux-continuum

The features tmux-continuum boasts about are:

• Continuous saving of tmux environment
• Automatic tmux start when computer/server is turned on
• Automatic restore when tmux is started

It basically persists sessions across system restarts. The good thing is that it is automagical. Even the “continuous saving” part, which saves at every 15 minutes interval.

It becomes a pretty big deal if your server went down because of some idiot (hopefully not you) and you need all your sessions back.

🟢 tmux-fzf

This plugin lets you manage tmux environment. What do I mean by that? well, you can perform operations with panes, windows or sessions like for example resize panes, create new or murder old sessions and all those things you would normally do with tmux key-bindings. Think of this as a single key combination which lets you perform all kinds of operations within tmux.

Here is what the tmux-fzf menu looks like:

What’s more you can even manipulate/setup existing key-bindings. But wait, there’s more. See that clipboard option in that menu? You guessed it! you can reuse previously copied stuff pretty easily.

If you hadn’t already guessed, there’s a catch. This plugin comes with dependencies. fzf being one of those dependencies which is basically a fuzzy-finder (search tool which uses fuzzy matches to find stuff).

Also that clipboard will not work unless you install CopyQ.

📌 There are lots of other tmux plugins which use fzf. fzf itself is a nice tool. Make sure you check it out.

Apart from these dependency issues, it is a good plugin to work with. especially if you are not a fan of memorizing key-bindings.

🟢 tmux-resurrect

As soon my work shift is over, I turn off my PC and walk out. When I get back in and power up my PC, I see that my precious tmux sessions are gone … poof.

That is the main issue this plugin solves. It will persist your sessions even if you shut down or restart your PC. This is especially helpful when your server crashes and you need to restart it.

🟢 tmux-named-snapshot

This plugin works as an extension of tmux-resurrect. It gives you the ability to save and restore sessions in your system. This is just like saving in a game, but if you are thinking that you can break something and load a previously saved session, to “undo” the chaos that ensued … then no. What’s done is done. There is no retribution for you.

Also you can name the snapshot before you save it which is nice.

🟢 tmux-mem-cpu-load

This is useful when you are cutting it very close to the CPU/RAM usage of your server and you need to know how much memory or CPU power is being consumed.

The value of memory shown by this plugin is dynamic and changes automatically.

To use it you will have to change configuration in your .tmux.conf and add the following line:

set -g status-right '#[fg=green]#($TMUX_PLUGIN_MANAGER_PATH/tmux-mem-cpu-load/tmux-mem-cpu-load --colors --powerline-right --interval 2)#[default]'

Or alternatively you can use prefix + : to enter command mode and type in the same thing. They both will have the same effect.

🟢 tmux-prefix-highlight

This one only highlights when you press TMUX prefix key. The highlight is shown in the status bar below a TMUX session. It is obvious why this would be a good plugin to have.

🟢 tome

Tome is a playbook which stores multiple shell commands. It also allows you the ability to access those playbooks and execute those commands without copy/pasting them. Sounds convenient and it actually is.

But some of you might think, “Hey we can already use aliases for that right?” … right?

You are correct but in my case I didn’t want to store the command of importing/exporting MySQL backup databases inside .bash_aliases or when I have to run commands from a README file. I think of tome as a more organized approach to storing and executing commands.

When you access tome using prefix + shift + p, it creates a new playbook if one does not already exist. The editor it will open is Vim which allows me the opportunity for shameless self-promotion … I already did a blog on learning VIM …

How I Learned TMUX & Became A Workflow Ninja

But you don’t have to go through all that. I’m a good guy. So I will tell you what you need to do.

When a new tome playbook is created it will open a blank file in VIM which does not have a name yet, because the file is not yet saved anywhere. You can type i to enter edit-mode and when you are done, type esc to exit edit-mode.

To save, you can use shift + :+ w + <file_name>. <file_name> is the name you want to save your playbook as.

To exit you can use shift + :+ q.

The main idea is to have a terminal editor (Vim/NeoVim) and use whatever commands written in there in any sequence you like. Here’s the official demo:

🟢 tmux-logging

As the name suggests, it logs the activities which go inside a TMUX session. This is useful because there are times where I need to retrospect on my actions in a server.

And if you are thinking that I do this because I accidentally wreak havoc on a server … then yes that is exactly why this plugin is necessary.

The thing is that I can easily see my previously run commands using the history command. In case you don’t know, this commands outputs a list of commands previously run in chronological order (last one being the latest command in history). But that does not give me the exact behavior of the server at that time. I don’t have any way to know if a command worked or not when I was previously working on my server.

This plugin not only stores the commands but also stores their respective outputs in a *.log file inside $HOME directory.

What’s more, it is also able to take a screenshot (textual) of your currently open terminal session. This means that everything that you can see in your terminal now gets stored in a *.log file.

It uses the prefix + shift + p to start/stop recording terminal actions and prefix + alt + p to take a screenshot of the current session. This is how the status bar at the bottom changes when you start/stop recording.

🟢 Extrakto

It is sort of a clipboard manager which can work on Windows, Mac and Linux. But there is a tmux plugin for it as well. Extrakto is also popular with Vim and NeoVim.

This plugin allows you to select text from your terminal session. It provides a search bar which fuzzy matches the text in your search query with everything else that is in your session. It uses fzf for fuzzy matching.

The plugin can be accessed by prefix + tab combination and looks like this:

As you can see, it allows several operations while the plugin popup is shown. Pretty convenient if you ask me and also good for flexing.

Honorable Mentions

These are just some plugins which although I haven’t used, but I think are cool to have.

🟢 muxile

This plugin lets you control tmux sessions from your mobile phone. Quite handy when you are on the go and someone from your team calls you because your server crashed (or something along those lines).

It requires the person sitting on the PC/Server to start and share a TMUX session to the person using the phone. This sharing is done via a QR code, which you can scan to get access to the session. After that, you can pretty much do anything.

Here’s a video preview of how it works.

To be honest, I haven’t used this one too much, but no doubt it is a handy tool for emergencies.

🟢 treemux

A sidebar with the modern Nvim-Tree file explorer for the current path, with bi-directional interaction in focus. Honestly it is way better than tmux-sidebar but has a dependency on LUA language and of course … NeoVim.

What blew my mind on this one is that you could use your mouse to resize the sidebar and access files on it the same way. If you don’t have issues with some extra dependency, then choose this one over tmux-sidebar.

📌 To be honest, I haven’t used this one … yet. That is because I haven’t used NeoVim … yet. Did I turn soft? Absolutely not. I’ll not only learn how to use NeoVim, but I will also write a blog post on it too. Let me know if you would be interested.

How To Create TMUX Plugin

TMUX Plugin Manager has a guide for making your own plugins. To make one, you will need understanding of Shell Scripting and Git. That’s it!

Use the links I gave you to master both, and you are all ret-2-go.

Final Word

Obviously I did not mention all of the plugins. And I may or may not have mentioned your favorite ones. This does not in any way mean those other plugins are useless or just not worth your time. All of them are wonderful and cover a specific usecase.

It is just that I only mentioned the ones that I frequently use in my workplace, and also that I haven’t used or had the need to use all of them. But just as an appreciation, let me know in the comments below if I didn’t mention a plugin which could have made my day more productive or have helped me in any other way.

As a sidenote, I’d like to motivate the junior devs out there. While researching about these plugins, I stumbled upon tmux-browser. While I was imersed inside the source code of this plugin I saw a typo. As much as a grammar Nazi I am, I couldn’t over look that. So I fixed that typo and submitted a Pull Request. The guy (whose repo it was) was very nice and accepted the Pull Request with a thanks.

Here is what I fixed:

I just hunted down a free PR 😆. Turns out you don’t have to be knowledgeable to contribute. You just need to be ready to help and review other’s work and they will appreciate that.

Thank you for reading till the end 🥳

Now with this knowledge you are able to supercharge your workstation. TMUX is a great tool and these plugins not only make it easier to use it but also adds valuable features to it that gives your regular terminal many dimensions.

If you found this article helpful and learned something new, be sure to leave a 👏 or let me know your thoughts 📣on it. I’d love to listen to your feedback.

Since you took the time to click this article, I would assume that you too, want to prove that your terminal skills are par excellence.

This is a breakdown of how I learned TMUX without getting tangled into the plethora of features it offers, and how I mastered it bit by bit.

If you have read my previous article where I explain How I Learned VIM Flexed In Front Of Other Developers, you would already know what to expect from this one.

I will walk you through what to learn first and what should come after, step by step. We will uncover the power that TMUX offers gradually as we slowly, but surely, become a terminal ninja.

TL;DR

Many a time I have had the need to open up more than one terminal session in my server machine which is located in the cloud. I usually connect to my server using SSH connection and that allows me to connect to my server while staying within my current terminal on my machine.

I could however open up another SSH connection on another terminal, but that would not be feasible where the server’s price plan is concerned. Those who have had the pleasure of working with a server, would sympathize with me.

Another problem I faced was the internet connectivity. If the connection strength fluctuated, the SSH connection would drop dead, and my processes will get affected, leaving me no choice but to wait for a stronger signal and try again next time.

When I heard TMUX can solve these problems and provide more value in my day-to-day tasks as a software developer, I said, “Let’s jump right into it!” without having a second thought. But I soon found out the overwhelming amount of features it has and the shortcuts which come with those features.

Simply memorizing the shortcuts is not my style, since I am a busy guy with a day job. Memorizing is a waste of time without any productive long term gains, and time is something I don’t normally have the privilege of spending like this. Instead, I like to merge the learning part into my daily chores.

What I am NOT doing here …

• I’m not going to cover all the shortcuts or shenanigans TMUX has to offer. I will deliberately skip some stuff. But you can rest assured that we will cover those things which will enable us developers to do what we do but better.
• I’m not going to explain the basics like what is TMUX and the theory and history behind it. This is not the place where you will that kind of blog-expanding material.

So without further jib jab, let’s start with this regime.

A Few Words About Practicing TMUX

Disclaimer: If you can already use TMUX then skip this section without delay. If not or if you are curious, then please, by all means, read on.

I understand that not all of you will have a Linux system like I have. TMUX does not run on Windows OS, nor does any online code execution platform e.g. Github Codespace, Replit or Gitpod supports TMUX. So you might wonder if there is an alternative or not.

There are several:

👉 Alternative 1:

Use TryHackMe TMUX Lab to practice what you learn here. They give you a virtual machine in your browser with GUI support, so that you will feel right at home. Since it is a lab it comes with a tutorial too.

The Catch: But there is a time limit of how long you are able to use it.

👉 Alternative 2:

Use Virtual Box to set up a Linux OS and install TMUX inside it. You will have to learn how to set it up on your own. You won’t be relying on anyone, and you will still get a GUI interface.

The Catch: It uses system resources, so if you don’t have much RAM or storage, you may still use it but with heavy lags.

👉 Alternative 3:

If you are on Windows OS, you can install WSL which stands for Windows Subsystem for Linux. It will let you use Linux commands via Windows Command Line. Neat huh?

The Catch: It can prove to be difficult to set up if you are a beginner. Things might go over your head even if you had a step-by-step guide.

👉 Alternative 4:

This is my favorite, as it does not rely on a third party and consumes my systems resources more efficiently than VirtualBox.

Since we only need a terminal where we can practice without a GUI part, we will set up a Linux environment inside a Docker container and access it.

Use the following commands to set it up:

# download and run an Nginx OS
docker run -t -d  -p 80:80 nginx:latest /bin/bash

# list out all the containers and find your container-id
docker ls

# start a bash terminal inside the container (replace the <container-id>)
docker exec -it <container-id> /bin/bash

You’ll know you have succeeded when you see something like root@12345678:/ #.

The Catch: You need your PC to be able to support hardware virtualization and run Docker. Even if your system does not support it, you can start this docker container in Github Codespaces and then use TMUX there.

If any of you have any other bright ideas … I’m all ears! Tell me in the comments. 👇

Day 1: Shoot & Scoot

If you know me any better, I always start with a shoot and scoot scenario which is concise, focused and practically doable. In this scenario, I think of some very minute tasks that I want to do with a tool. In this case, it is TMUX.

Since my daily chores involves opening and closing SSH sessions across different server, a very simple procedure of starting and closing of a TMUX session would do just fine.

So here are the steps I followed in my shoot & scoot approach (The simple approach):

• Open session
• Do something useful like running a deployment shell script in the server (it’s ok if you don’t get this part. Sometimes I don’t get it either).
• Close the session

But doing this for a single session would be very similar to what I have been doing up till now without using TMUX at all. Also, I would not be leveraging any of the benefits of TMUX if I followed this approach. Therefore, I was tempted to make things a little difficult by being able to start and close multiple sessions instead of just one.

You may want to do it just like I did in The spiced up version or if you do not feel comfortable in the terminal, just stick to the The simple approach.

Changing things in my previous approach a bit (The spiced up version) it should go in a somewhat similar fashion to this:

• Start a TMUX session (session A)
• Start another TMUX session (session B)
• Do something useful in session A.
• Switch over to session B.
• Do something useful in session B.
• Close the TMUX session A.
• Close the TMUX session B.

In this way, I am able to open and close multiple sessions (being more productive) while still keeping the whole procedure to a minimum.

Here are the commands I practiced in Day 1:

So what is session-id you ask? well, at the bottom-left corner, after you start a TMUX session, you will see something like this:

The [0] represents the session number among a list of sessions. Here, it is zero, which means the very first session. Both the zeroes you see above have different meaning, which you will learn about soon.

TMUX sessions have three states: Active, Dormant and Exited. These words are just my own invention, by the way.

• Active 👉 the session is currently opened, and you are able to use it.
• Dormant 👉 the session is running in the background, ready to be reused.
• Exited 👉 the session is not running or have ceased to exist.

When you write tmux or tmux new in the terminal, you are essentially creating a new session and making it active.

Similarly, when you delete a session using tmux kill-ses, you are exiting either an active or a dormant session.

You can use tmux kill-ses from within or outside of a session. When used outside all sessions, it deletes the most recently created one, regardless of its state.

But when you detach from a session using tmux detach or using the keyboard shortcut CTRL+b ... d, you are changing the state of the TMUX session from active to dormant. Or in the case of attaching back to (resume) a session, the state goes from dormant to active.

I hope that makes sense. If not, read again. 😅

📌 Now there were cases where I have to go out of my way to look at those commands or shortcuts which I had not planned for in a certain day. For that reason, I used CTRL+b ... ? to view all shortcuts. It’s obviously very helpful.

Day 2: Mastering Panes

There are two ways you can manage multiple sessions at once. One way includes using Panes, and the other is by using Windows.

I chose to go with Panes as they are easier to manage. The reason for this, as I think, is that seeing multiples panes in your terminal screen gives you a sense of what is happening simultaneously. An example of multiple pane view is given below:

Any ways, you may decide to go with either as you prefer.

The commands I planned to practice in Day 2 are as follows:

📌 You will be using CTRL+b (prefix command) a lot. It is kind of a specific command only for TMUX. To use it, you will need to press both CTRL and b simultaneously, and release them before pressing any more buttons. This “release action” is shown as ... in the above and upcoming commands.

Now there are three categories of commands here, so let's go over them one by one.

To manage panes, you will obviously need a way to create new panes and delete them at will. That is where the General Pane Operations come in.

Creating a new pane comes with an option. The new pane you are trying to create will split up your terminal into sections. Now, you may choose if you want to split those sections vertically (by pressing %) or horizontally (by pressing ").

📌 Note that " on keyboard can only be accessed in combination with a SHIFT key. So, " is actually typed on a keyboard as SHIFT+' (shift and apostrophe keys). Same goes for % and any other symbol which is accessed with a SHIFT key.

The kill pane command only deletes the pane which is currently active, and you are automatically switched over to another dormant pane.

📌 Yes, panes have states too. But you are able to see all of them at once, unlike sessions.

While using panes for the first time, I had this urgent need to arrange them such that it is easier to visualize them. Therefore, I added layout commands to the list. CTRL+b ... SPACE allows me to switch between multiple pane arrangements.

CTRL+b ... ALT+<1..5> similarly switches between layout but lets you directly select which layout you want. There are a total of 5 options.

CTRL+b ... z allows me to toggle between full-screen state of a single pane. Think of it like a “full-screen” or “maximize window” button.

This was a bit extra but pretty useful.

Lastly, to navigate between panes you use arrow keys but only after using the CTRL+b combo.

📌 I deliberately skipped the CTRL+b ... ! command which allows me to convert a pane into a window. This was very similar to CTRL+b ... z combo I just showed you.

Day 3: Managing Windows

Panes are good, but having too many will soon start to clutter the terminal real-estate. That is where windows come in.

Window acts in a similar way to a Pane, but the major difference is that instead of dividing a terminal screen into sections, it takes all the available terminal space to display itself (like a full-screen pane).

If you are still confused, here is a comparative analysis of Windows and Panes to clear out any doubts:

Here are the commands I practiced in Day 3:

CTRL+b ... c is used to spawn a brand-new window. To close a window, you will use CTRL+b ... &.

📌 Notice the - symbol after the 3:bash. That - represents the previous window you were at before switching to the current window. If you press CTRL+b ... l you will jump to the window marked by -. But hey! spoiler alert … this command is to be discussed in Day 5.

Just like how you used arrow keys with CTRL+b combo, you can use p or n to navigate between windows. But after navigating through windows like this for a while, I thought if there is a better way to do it … Yup there is and you’ll love it.

CTRL+b ... w not only shows you how many windows are there but also displays information about each window like how many panes are active inside it.

That’s not even the best part. It is not actually a list, it’s a menu which you can navigate with all four arrow keys and select a window/pane you want to go to by pressing ENTER.

In this mode you can also use CTRL+b ... x while highlighting a pane or a session to delete it.

📌 Notice the - sign after some arrows ➡️? that shows an expanded tree. Use left/right arrow keys here to toggle this hierarchy tree.

Day 4: Advanced Session Commands

Using TMUX over and over, having multiple sessions at my disposal and all of them running something important, I had a need to identify those session with something other than the index they are assigned.

Since there are commands which allow me to manipulate sessions based on their names instead of their index numbers, I thought it would make my life even easier.

It should be noted that by this time I was already over-equipped to use TMUX and I was already leveraging it to my benefits.

The commands I practiced on Day 4 are as follows:

The a flag can be interchangeably used with attach. The session-name is the same as session-id.

Not going to explain much about it because it is self-explanatory. Also these commands were repetitive and I was able to easily remember them, therefore I decided to cover some more.

These quick peek commands displays a list of windows, panes or sessions.

This day would seem lazy if you are eager to learn more. But I planned it out to have a pause-and-reflect moment. We have covered so much ground, it is only natural that we stop and ponder on what we have learned and also make sure we haven’t forgotten anything along the way.

Day 5: Streamlined Shortcuts

I dedicated this day for make-life-easier shortcuts.

By this time I was already pulling stunts in front of my co-workers and what I had learned up till now was more than sufficient for my daily tasks.

At this point you have a choice: either continue learning more or stop and focus on something else entirely. Me being me, chose the former. If I was going to have an everlasting effect on my co-workers by pulling terminal stunts, I had to make sure I’m not falling behind on anything.

Yes, my reasoning is based on 80% showoff and 20% for work efficiency. Why else would I do it? 😅

Anyways, the commands I practiced this day were about session, pane and window management. Wait more shortcuts? Yes, I certainly wasn’t lying when I said I was overwhelmed by its features.

For panes I have the following:

Where CTRL+b ... q shows index of each pane. It would look something like this:

Meanwhile, CTRL+b ... q <pane-index> will let you jump to the pane index you specify. I mostly used both the variants of this command simultaneously. It is a good exercise.

I soon realized that I did not often use CTRL+b ... ! to convert a pane into a window. I already had the ability to toggle a pane to full-screen (Day 2). So you may decide to ignore this one.

CTRL+b ... { / } swaps the current pane with the adjacent pane. You will get it when you do it yourself.

Now for the session shortcuts, here they are:

CTRL+b ... s is very similar to CTRL+b ... w which we already practiced (Day 3).

I already knew the command to create a named session (Day 4), but I may need to rename an already created session to something else. Therefore I used CTRL+b ... $.

Moving onto the window shortcuts:

This was pretty useful compared to other shortcuts we discussed in this day.

CTRL+b ... f will prompt you to find a window by its name and when you hit enter you will see a menu of results. Then you may pick a window from there.

CTRL+b ... l works like a “back” button to visit the last window we were working on.

Day 6: Copy Mode

This is purely optional. You may decide to skip this entirely and move onto the next day.

I was already using a tool in Ubuntu called Diodon. It is a clipboard manager which let’s me keep a history of my clipboard and reuse anything that is in it. This requires a few clicks so I was already fine with it.

Please note that these commands may or may not work for you based on your shell configurations. To troubleshoot the issue (if you find any) you can find a solution here on Stackoverflow.

This trouble-shooting guide I just showed you may require you to edit the .tmux.conf file located in your $HOME directory. I will not be covering that here.

Day 7: Command Mode

This is the last and most useful (and advanced) usage you can get out of TMUX.

Command mode, as it sounds like, lets you pass commands which can manipulate how your version of TMUX works. Of course it can be used to customize your shortcuts and stuff. You can even get rid of the CTRL+b combo and use some other (feasible) combination of keys in its place.

I will only be covering some commands here of course, since covering them all will make this article even longer and we don’t want that … do we?

In case you are wondering, the flags used above represent the rectangular side of each pane which you want to resize. Pretty dumb huh? Let’s see something more useful.

These commands are used for changing the settings of the session or the window. You can add a -g flag to have your setting take effect on a global level. Here are some examples which you may like:

set commands:

• set prefix C-a: Changes the default prefix key to Ctrl+a (instead of Ctrl+b).
• set status-bg black: Sets the background color of the status bar to black.
• set mouse on: Enables mouse support for scrolling and selecting text.
• set history-limit 10000: Increases the scrollback buffer size to 10000 lines.

setw commands:

• setw mode-keys vi: Sets the copy mode key bindings to vi-style.
• setw pane-base-index 1: Numbers panes starting from 1 instead of 0.
• setw window-status-current-style fg=yellow: Highlights the current window's status line in yellow.
• setw automatic-rename on: Automatically renames windows based on the active process.

Good To know

• TMUX can be configured using using it’s config file which is usually present in $HOME directory. The file itself is named as .tmux.conf. Here you can do all sorts of customization like changing the CTRL+b combo to something else.
• To use the .tmux.conf file, you can use the command tmux source /path/to/.tmux.conf.

Final Word

This concluded my 7-day sprint of practicing TMUX. Of course, there are lots of other commands which I haven’t covered yet. And I didn’t plan on doing so in one go.

After a week of TMUX training, I can handle most daily tasks without keeping a cheat sheet hostage. The keyboard fluency feels like ninja-level and my workflows are now smooth. Still there are mountains of commands to conquer, but that’s another sprint!

Do you realize now what’s next? Customize your own TMUX config. That would not only show others that you know what you are doing, but also allow you to explore a bit more on how TMUX works.

TMUX is a nice tool to have in your developer’s utility belt. Learning to use it can be difficult. As with anything else, becoming a proficient user of it requires time.

Nonetheless, learning to show off makes you learn it in a more serious way, doesn’t it?

Thank you for reading till the end 🥳

Now you are ready to pull some serious stunts in front of other developers. Show them how you CTRL your terminal … 😏

If you found this article helpful and learned something new, be sure to leave a 👏 or let me know your thoughts 📣on it. I’d love to listen to your feedback.

You whip up an invoice which lists the tasks you are going to do for the client and the charges that are associated with each task. This shows that you are meticulous about detailing the scope of work and transparent about the corresponding costs. It also demonstrates your commitment to clarity and fairness in your business dealings.

Although there are many other factors which contribute to your professionalism when dealing with freelance clients, but this was a tool which I wanted to use instead of the robust complete invoicing solutions which overload you with features you don’t really care about.

I wanted a quick and easy solution to this, therefore I made this script, and I’m going to show you exactly how I did that.

The Landscape

I wanted to keep it simple … stupid simple. So instead of going for an OOP approach as I usually do, I went and made a function. But to make it somewhat customizable I added a settings.py which contains configurations on how you want to set your invoice up.

The invoice itself is an HTML file which is written in jinja2 syntax. The data that is rendered into this template comes from data.json.

Naturally I went for a primitive factory design pattern which uses render_template() as a factory which is inside invoice_gen.py.

Here is what each file is meant for:

• data.json 👉 contains data to be rendered into Jinja template.
• invoice_gen.py 👉 the script file, which serves as a factory to generating invoices.
• settings.py 👉 contains configuration for the HTML template.

📌 The naming convention I have used here is inspired from Django such as settings.py, get_context_data() etc

Just so you can understand better, I have illustrated how it works in the diagram below:

Technologies

We are using the following:

• Jinja
• WeasyPrint

The Data File

This is just a json file which contains all the information we want to render in our template. Mine looks something like this:

{
    "title": "Services Invoice",
    "invoiceNumber": 13,
    "issueDate": "11-12-2023",
    "dueDate": "18-12-2023",
    "status": "due",

...

    "server": {
        "logo": "path/to/logo.png",
        "companyName": "Hammad's Company",
        "firstName": "M. Hammad",
        "lastName": "Hassan",
        "address": {
            "city": "Karachi, Sindh",
            "country": "Pakistan"
        },
        "email": "hammad.hassan@localhost.com",
        "profileURL": {
            "url": "https://www.upwork.com/freelancers/~01f9b5bc6f481f0385",
            "displayText": "Hammad on Upwork"
        }
    },
    "itemList": [
        {
            "title": "Python Course",
            "description": "Python basics course to get you started",
            "isFixedPrice": false,
            "rate": 10,
            "hours": 15
        },
        {
            "title": "HTML/CSS/JS",
            "description": "Beginner's frontend course",
            "isFixedPrice": false,
            "rate": 6,
            "hours": 10
        }
    ],
    "moderatorCharges": 0.1,
    "percentIncreaseAfterDueDate": 0.05

...

}

The above JSON file is a shortened version of the real one I’m using.

📌 In case you have read the above data and have questions …

Yes, I do teach programming on an individual basis to all kinds of students. Those who don’t have a computer science background are more than welcome to have a chat.

The Main Script

The process of generating invoices from a set of data defined in data.json uses several resources in order to spit out an invoice you can send to your clients.

First, you will need to import your dependencies.

from jinja2 import Template
import json

Then we write the function which inserts some contexts into a Jinja HTML template and will later convert those templates to pdf.

def render_template(
    template_file:str, 
    context:dict, 
    styles:list, 
    output_filename:str
)->str:
    
    # get the template file and render it using context variables
    template = Template(template_file)
    rendered_html = template.render(context)

    # set names for output files
    html_file = f"{output_filename}.html"
    pdf_file = f"{output_filename}.pdf"

    # writing html content to a file
    with open(html_file, 'w') as file:
        file.write(rendered_html)

    # Convert HTML to PDF using WeasyPrint
    HTML(html_file).write_pdf(pdf_file, stylesheets=styles)

    # return the name od the file
    return pdf_file

And now within the same script file we will load the assets we need in order to render our template.

# Load context data
context_data = {}
with open("./data.json") as data:
    context_data = get_context_data(json.load(data))
    
# load Jinja template
template_html = ""
with open(TEMPLATE_HTML_PATH) as template:
    template_html = template.read()

# Render the template and generate the PDF
pdf_filename = render_template(template_html, context_data, TEMPLATE_CSS, OUTPUT_FILENAME)
print(f"PDF generated: {pdf_filename}")

We are loading context data from the get_context_data() function, which is located in settings.py. This function accepts only one parameter, that is a python dictionary. We get this dictionary from data.json.

📌 Keep this in mind as it will become relevant soon.

We also load a Jinja template (which is just an HTML file) and read its contents using the with keyword and open function. TEMPLATE_HTML_PATH comes from settings.py which is explained in the next section.

Lastly, we call our function render_template() to do its magic.

The Settings File

This file contains all the customizable parts of the script. So if you want to change the outcome of the above-mentioned script, you only need to make changes to this file.

Import your dependencies, which now include weasyprint.

from weasyprint import HTML, CSS
from datetime import datetime

This file only contains three variables and a function.

OUTPUT_FILENAME = f"output-{datetime.now().strftime('%d-%b-%Y')}"
TEMPLATE_HTML_PATH = "./invoice_template_002.html"

TEMPLATE_CSS = [
    CSS("./invoice_template_002.css"),
    CSS("https://cdn.jsdelivr.net/npm/bootstrap@4.6.2/dist/css/bootstrap.min.css" ),
    CSS("https://maxcdn.bootstrapcdn.com/font-awesome/4.3.0/css/font-awesome.min.css" )
]

The first two variables are self-explanatory, so I’m not going to waste time on those.

TEMPLATE_CSS however, is a list of CSS objects which are imported from weasyprint library.

In this list you can add as many CSS modules as you like and all of them will be applied to your HTML template.

The first element in this list is my own custom CSS, therefore it has a relative path. The other two are links from Bootstrap and Font Awesome CDNs.

def get_context_data(context_json:dict)->dict:
    """This function manipulates the context you import from data.json"""
    context_json['issueDate'] = datetime.strptime(context_json['issueDate'], '%d-%m-%Y').strftime('%d-%m-%Y')
    context_json['dueDate'] = datetime.strptime(context_json['dueDate'], '%d-%m-%Y').strftime('%d-%m-%Y')
    context_json['invoiceDate'] = datetime.strptime(context_json['issueDate'], '%d-%m-%Y').strftime('%B')
    return context_json

get_context_data() does exactly what it says. It fetches the context data, allows users to manipulate that data like applying formula and performing calculations and returns the data as a python dictionary.

I used this function because although data.json has a lot of information, I did not put in data which should be calculated. For example, you have different products you are selling in your invoice, but the total amount you are charging the customer should be calculated rather than hard coded.

But you don’t see me calculating any of that in the function above. That is because I chose to perform the calculations inside the Jinja template.

In either case, I am not hard coding numbers here and there.

I’m not going to include the template file here, as it is very long and will cover too much space. But you can check out my GitHub repo for complete code.

GitHub Repo

GitHub - Blankscreen-exe/invoice_generator: python invoice generator using Jinja2 and WeasyPrint

Sample Preview

📌 I found the original HTML template here, and modified it to fit my needs.

Thank you for reading till the end 🥳

Above is just one possibility of what you can do with the factory code I provided. As an example, you can also make certificates, style them with CSS and put the name of the recipient in data.json.

I hope you will have fun using it.

If you found this article helpful and learned something new, be sure to leave a 👏 or let me know 📣 your thoughts on it. I’d love to listen to your feedback.

This is something many young and professional experts of their fields have been asking me recently. This article is my compilation of all the answers I gave them to satisfy their questions, as well as their follow-up questions.

I’m writing this in hopes that someone may benefit from this and gain valuable insights about their future that they are planning for themselves.

Since this question is highly subjective, I’m going to answer this question for Three different individuals with the following characteristics:

• Young individuals who lack market exposure or experience.
• Skilled individuals with experience in IT field.
• Individuals with experience in fields other than IT.

Moreover, I will also be explaining what you can do to make yourself future-proof.

📌 You may want to skip to the section which best describes you, but you may also gain some deeper insights if you read the other sections as well.

Also, section 1 is a mandatory read.

TL;DR

One thing that is common for all my answers (which is also backed by facts):

“Learning AI” alone cannot make you future-proof. In fact, nothing you do has the potential to make you future-proof. No one knows the future, we can only attempt to predict it and prepare for it.

With that said, learning AI will not necessarily make you future-proof BUT there are skills which can help you adapt to the future whether it is AI, decentralization or even negotiations. Those skills are your soft skills, and they are much more valuable in the long run as compared to AI.

To be honest, AI isn’t a skill, it is currently being widely accepted as the knowledge or understanding of the potentials and limits of software applications which make use of AI.

1- What Does “Learning AI” Actually Mean?

This term is abstract and can be taken with mixed meanings. Some of the people I talked to, were not able to pin point what it meant so here I am explaining it.

📌 This section is important, and is referred in several places within this blog.

There are currently, two ways to interpret this:

1.1- Become Familiar With AI Services

One way is to learn how to use the AI services provided by different organizations and startups, just like you would use Microsoft Windows OS , which is provided by Microsoft or Google Search Engine, which is provided by Google.

These services are provided by some organizations that enables you to create or use AI technology in exchange for some fee. There are lots of examples out there which cover a variety of different niche applications of AI, such as video editing, photo editing, image generation, chatbots etc.

The problem today is that AI is advertised as an easy source of passive income if you learn how to use it. So, is it wrong to believe in it? Not as long as there’s a service provider handling all the strings for you, leaving you to only select some preferences or options for how you want to run their AI service.

This service provider may come in various shapes and sizes. For example, Midjourney provides you with image generating services. With it, you will be able to generate images, but they hold the reins to their technology, and in this scenario, you are just a user.

It is a given in software development that every software products you will see out there in the market will be made with user-friendliness in mind. All you need to do is to get familiar with the tool, and then you will be using it to create stuff or use that service.

1.2- Learn The Technologies Behind AI

This path is for those who wish to dedicate themselves to the knowledge of Computer Science and Software Engineering. For non-programmers, this may be a difficult path to pursue but note that it is not impossible.

If this wasn’t clear enough, you will have to start learning the techy stuff like programming and application development. Yes, it is a tough route and not for the those with less patience, but then you will be learning AI in a truer sense.

📌 I am planning to write about how should you approach learning computer science or other related/specialized subjects such as machine learning in a separate blog and add the link to it right here.

There are roadmaps all around the internet which tell you step by step what you need to learn in order to be able to develop applications with AI technology. But the one I find the most intuitive and beginner-friendly with several necessary details is this one:

AI Roadmap

Keep in mind that going in-depth and learning the technical aspects such as programming is not necessary for you to learn how to use AI (as I have already shared in the section 1.1).

Moreover, the roadmap I shared with you does not incorporate any software development expertise, which is often listed with the job description of a machine learning engineer.

The reason I called this route a “tough one” is because it requires more than what is shown in the roadmap I shared above. It requires you to be a Software Engineer first, and then you will dive into the technical aspects of Machine Learning and AI.

The reason for this is that companies typically hire people who have a combo of Machine Learning understanding and some prior software development experience. If you only have skills in the former domain, then it is unlikely (but not impossible) for you to get hired as a Machine Learning Engineer. This is due to the fact that Machine Learning Engineers are often tasked with creating optimized end-to-end solutions and not just Jupyter Notebooks of their experiments.

📌 But enough of that. I’ll be explaining about getting hired as a Machine Learning Engineer or even as an AI Specialist in a separate blog. Be sure to check that out if you are interested.

Now, lets answer some questions …

2- Young Individuals Who Lack Market Exposure Or Experience

Not having a CS background and not having the know-how of computer basics are two different things. The answer in this section is for those who fall under both the categories. But I’ll be assuming that these are the people who have yet to dive into the professional world and get market exposure.

You may or may not have an affinity for technologies, but just being able to operate regular computer devices doesn’t necessarily make you tech-savvy.

Most people use smartwatches, but they have no idea what’s going on in there or how it does what it does. And they should not bother themselves with such things, because those devices are made with user-friendliness in mind. That is to say, they have yet to taste what dealing with technology is really like.

So, will it make you future-proof? Well, the reason I asked you to go through section 1 first, was to give you a better understanding what the “Learning AI” part actually meant.

If you choose to go with the first path (section 1.1), you will end up using and getting accustomed to several AI tools. This will be like, for example, learning how to use Google Sheets and then jumping onto using MS Excel.

Perhaps your employer/supervisor/professor wants you to switch to a new tool because it has more features than the last one, or simply because you have decided to move onto something else on your own. In any case, keeping up with new tools and services (which are popping out like moles in a half-eaten farm nowadays) will make you present-proof rather than make you future-proof.

If you decided to go with the second option (section 1.2), and you have confidence that this is the path you want to spend the rest of your life on, then congratulations, you have got the first step covered.

But just like as was in the previous case of keeping up with new tools, here you will be keeping up with new technologies (assuming that you are now past the point of getting software development skills and studying machine learning).

If you were building or contributing to the technologies that other developers use, then you might have a good chance of keeping ahead of some technologies, but then it is the “near future” we are talking about, and not 2077 🦾. These technologies we speak of, gets updated with tons of new features almost every week. So yeah, that is also present-proof instead of future-proof.

3- Skilled Individuals With Experience In IT Field

Having good knowledge of technologies gives these people an edge over non skilled individuals or those individuals who do not concern themselves with the field of IT.

There are various options on how these people can upgrade themselves such that they can perform a career switch or to add a new technology to their list of skills.

As explained in section 1.1, the first path will be relatively easy for these individuals as they are more tech oriented and have a much more thorough observation habit of judging the behaviour of the service or the application they are using.

These services can obviously help them in enhancing their productivity and enable them to do more in less time.

But the second path (section 1.2), may prove to be more difficult for varous reasons. Some of the reasons are shown below:

• They might deviate from their initial career path.
• They might waste time depending on the complexity of the technology they are learning. Since they also have their day job.
• New tools, libraries, and algorithms are released frequently, requiring them to constantly learn and adapt to the technologies in parallel to the technologies they are already keeping up with.
• There is a lot to learn, so there is a good chance that without proper guidance, the individual may be overwhelmed with a plethora of technologies to learn in mid-career phase.

So … the answer?

Going with the first path (section 1.1) is easy for them as it saves more time on their end and even makes them productive. The second path (section 1.2) however, is a lot more riskier for the working individual.

If you have read section 2, you would already know that both of these paths to “Learning AI” will get you nowhere near being future-proof. But there are some things you gain from it as well.

What Benefits IT People Can Get If They “Learn AI”

You might unlock opportunities for yourself if you wish to switch careers. In this case, you will be loved by employers as you would have both Software Development expertise and knowledge of Machine Learning.

It would be relatively easier for you to get an ML Engineer job rather than a fresh candidate with no prior experience.

Still you should understand that Machine Learning or AI related jobs are as much as in demand as the Software Development jobs. Learning new AI technologies and use them to build projects only expands your skillsets and makes you a bit more knowledgeable about different technologies.

And as you might have guessed already, learning AI in mid-career is not really that necessary, because even without it you would already be fit for a variety of roles in the software development industry.

Yes, there is a rising concern about jobs being replaced or automated by AI technology, and I also plan on addressing that here.

Things which are likely to get automated will certainly get automated. That said, ChatGPT, Github Copilot and BARD can write code by learning from us humans. That is very concerning isn’t it?

Now look at this problem from an employer’s perspective. Instead of hiring an employee, they can use ChatGPT to write code, but it comes with a lot of drawbacks that employers are not happy about:

• ChatGPT, Github Copilot or BARD are not efficient in coding complete applications and performing change requests … yet. They may be in the future but not now.
• The resources they consume to write a few lines of code is massive. Plus if they choose to use more than one bot to write code for them it scales their costs.
• Setting these bot services up and serving them around the globe can only be done by multi-billion dollar companies (it costs a fortune) like Google or Microsoft. The employers can’t have it for free and with the same efficiency.
• Basically the employers would be hiring robots outsourced by top-tech companies which can raise their pricing schemes anytime and the employers won’t have a say in this.

Although there are a bunch more reasons as well, but you get the gist of it.

And look, if the employers believed that they can get cheap and efficient labor out of robots, they would have done so years ago. After all, the only thing that any business stands for, ultimately, is making a profit.

📌 Some companies do actually care about their customers and their experience. But they can’t care for them if they don’t have a revenue. So yeah it boils down to profits.

3- Skilled Individuals With Experience In Fields Other Than IT

These individuals cannot go for the path described in section 1.2 unless they wish for a job switch. Even in that case they would need solid conformation that they would get hired for a technical role if they learned how to use this technology or that and gained some computer science knowledge. This obviously does not seem plausable.

These individuals may be the experts of their fields such as accountants, project managers, HR, artists, writers etc and may even have used a few softwares before to their work. But they are not technical experts like their typical IT guy.

For them, the only feasible way to “Learn AI” is to learn to use the AI services (as I have mentioned before in section 1.1).

At this point you already know the answer if you have been reading everthing up till now, that learning this or that technology or skill cannot make you future proof.

I have seen people market their courses like “AI is the future and learning AI will make you future proof”. If you are on a senior role in your company, you would know that this is not true at all.

Yes, learning how to use new software which has more features than the last one is a choice that every business makes. Learning new things can give you an edge over other candidates.

And no, prompt engineering is not something you can learn, but rather it is something that you already know. You talk to a bot in English and it replies to you in English. The better you define your question the better the answer gets. That is all there is to it.

Plus it is not a skill that people will get hired for. CEOs know of this and they would probably burden someone they already hired, with prompt engineering or using some other AI service rather than hiring someone entirely new for the job.

You need to understand that, there is still a reason you have your day job. Higher order of critical thinking, decision making and emotional intelligence is not something AI can mimic. Not yet anyways.

For those new to the domain of IT, I have already written a blog which explains the hype of current rise in AI technology.

Don’t Believe The Hype: Understanding A.I. Trends 2023 (Non-Technical Guide)

📌 I have debunked the myth of prompt engineering in the blog above as well.

If Only The Future Were As Simple As Learning Some AI Algorithms And Calling It A Day!

Don’t get me wrong, AI skills are hot these days, but let’s not kid ourselves — they’re not a magic shield against the ever-shifting winds of the economy.

If you really care about being future-proof, then here is my personal opinion how to become just like that:

• The adaptability of a chameleon 👉 The world is changing faster than a Kardashian’s hairstyle, so you better be ready to switch gears at a given time. Gone are the days of one-track careers — be prepared to learn new skills, embrace new technologies, and maybe even pivot your entire career path if the need arises.
• The resilience of a cockroach 👉 Life throws curveballs, and the future economy will be no different (as far as we can see from the present). Get ready for economic downturns, job changes, and even the occasional robot uprising (probably not … maybe). The key is to be mentally tough, bounce back from setbacks, and keep moving forward. When you find the doors closed, look for ways to open them, instead of waiting tor them to be opened.
• The creativity of a mad scientist 👉 Forget about rote memorization and textbook knowledge (AI can do that better now)— the future belongs to those who can think outside the box, generate innovative ideas, and solve problems in unconventional ways. Let your inner Picasso loose and embrace your weirdness — it might just be your ticket to success.
• The empathy of a social worker 👉 As AI takes over the mundane tasks, human skills like communication, collaboration, and emotional intelligence will become even more valuable. Learn to work effectively with others, understand their needs, and build strong relationships — these are the skills that will make you truly irreplaceable.
• The audacity of a con artist (but without the conning, of course) 👉 Never underestimate the power of a good hustle. Be proactive, network your butt off, and shamelessly promote yourself. In a crowded marketplace, you need to stand out and make a name for yourself. Learn about what people around you need and help them. You might even erect a business with this approach.

Now, let’s address the elephant in the room — those AI enthusiasts who preach future-proofing through algorithms. While AI skills are undoubtedly valuable, they’re just one piece of the puzzle.

Remember, robots may be able to crunch data and write code, but they can’t replace the human touch, the spark of creativity, or the ability to connect with others on a deeper level.

Being future-proof is not about learning this or that, but rather cultivating yourself such that you can take on the uncertainties of life like your better self. Learning from your mistakes is no different.

Thank you for reading till the end 🥳

If you found this article helpful and learned something new, be sure to leave a 👏 or let me know 📣 your thoughts on it. I’d love to listen to your feedback.

If you don’t already know, I have recently posted about Grid Search being a valuable tool for hyperparameter tuning. But as every other tool, it has its drawbacks.

TL;DR

Random Search is a hyperparameter optimization technique in machine learning that randomly samples a defined number of hyperparameter combinations from specified distributions. By distributions, I mean sets or ranges of possible parameter values.

It efficiently explores a subset of the hyperparameter space, making it faster and more resource-efficient than exhaustive methods like grid search.

While it might not guarantee finding the absolute best hyperparameters, it effectively discovers good settings, especially in scenarios with large or complex parameter spaces or sets are considered.

Here I will introduce you to Random Search, tell you how it works and how it compares to grid search.

What is it?

Random or Randomized Search is a searching algorithm which is modified to work with different sets of hyperparameter values in a machine learning model.

Hyperparameters are settings that aren’t learned during the training process but affect the behavior and performance of a machine learning model.

Minor Throwback To Grid Search?

In my previously related article, where I explain about Using Grid Search For Hyper-Parameter Tuning, we were giving the algorithm a list of values to select from (generally called a grid of values), and it would try every possible combination of those values with our model to find out the optimum settings (hyperparameter).

How Does It Work?

Randomized Search, as the name suggests, picks a parameter value at random from a range or list of possible values for a specific hyperparameter.

A little disclaimer … I will be demonstrating this with RandomForestClassifier() which can be obtained from sklearn.ensemble. The data I’m going to be using with this model is none other than the iris dataset obtainable from sklearn.datasets as load_iris.

📌 Also, make sure you have split the dataset into training and testing sets before you begin. You will soon know why you need this.

from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

Step 1: Define The Parameter Space Or Distribution

To define a distribution, we only a python dictionary which contains the parameter name as the KEY and the range of possible values as the VALUE for those keys.

Pretty easy start, huh? Take your time reading the comments below:

# Define hyperparameter distributions
param_dist = {
    'n_estimators': [int(x) for x in np.linspace(start=200, stop=2000, num=10)],  # Number of trees
    'max_features': ['auto', 'sqrt'],  # Number of features to consider for best split
    'max_depth': [int(x) for x in np.linspace(10, 110, num=11)],  # Maximum depth of the trees
    'min_samples_split': [2, 5, 10],  # Minimum samples required to split a node
    'min_samples_leaf': [1, 2, 4],  # Minimum samples required at each leaf node
    'bootstrap': [True, False]  # Whether bootstrap samples are used when building trees
}

For the range of parameter values, you will need to use python lists. Since these are lists, we can also use list comprehensions to help us create a lengthy list, just like I have done with list for n_estimators.

📌 Please take note that I’m using numpy here in some lists. You are free to use whichever methods you like. But if you are going to follow along, you will need numpy installed.

Step 2: Prime The Random Search Object

We can get the RandomizedSearchCV object from the same module we got our train_test_split from.

from sklearn.model_selection import RandomizedSearchCV

Note that the name of the Class we are importing has a CV in the end. This means that it comes pre-packed with Cross-Validation, just like Grid Search. And that is why we needed train_test_split to slice our dataset into training and testing sets.

If you are not familiar with the cross-validation technique, you basically split your dataset into multiple subsets (folds), train the model on some of them, and evaluate it on others. This helps ensure that the model’s performance is robust and not just tailored to the training data.

# Create a Random Forest Classifier
rf_classifier = RandomForestClassifier()

# Create the RandomizedSearchCV object
random_search = RandomizedSearchCV(
    estimator=rf_classifier,
    param_distributions=param_dist,
    n_iter=100,  # Number of parameter settings that are sampled
    cv=5,  # Number of cross-validation folds
    verbose=2,
    scoring="accuracy",
    random_state=42,
    n_jobs=-1  # Use all available processors
)

There are a lot of things going in here, so let’s walk through this slowly.

RandomizedSearchCV takes an argument named estimator which is the model we want to use.

param_distributions is the dictionary we prepared earlier.

n_iter signifies the number of iterations to run. The higher the value, the better the results are, but it will also take more time as well. There is a trade-off here, so you should plan on using an optimum and acceptable value. Default is 10.

cv represents the number of folds we should perform for cross-validation. If nothing is provided, it will be set to a default value, which is 5.

Adding a verbose argument will show you the progress of the search being performed. It accepts an integer value from 1 to 3. It will give you more detailed logs of what is going on. Here is what each one does:

• 1 👉 the computation time for each fold and parameter candidate is displayed
• 2 👉 the score is also displayed
• 3 👉 the fold and candidate parameter indexes are also displayed together with the starting time of the computation

scoring is the metric which will be considered for determining the best results. If this is not provided, the default will be selected based on the estimator you have selected. In case of Random Forest Classifier, it is “accuracy”.

random_state is for random, uniform sampling from lists of possible values. It accepts a random integer.

n_jobs represents the number of jobs to run in parallel. Since this is an iteration based process, we can allow it to run some jobs in parallel to cut down on the processing time. -1 means use the maximum number of jobs that can be run on the current processor. Default is 1.

To keep it from getting more complex than it already is, I have skipped some arguments that RandomizedSearchCV can take. But know this:

• refit allows you to define your custom scoring function.
• pre_dispatch controls the number of jobs that get dispatched during parallel execution.
• return_train_score accepts a boolean which represent whether the training score will be calculated or not. This can cut down on the training time.

📌 You can learn more about these arguments in SKLearn’s Official Docs.

Step 3: Fit The Data & Extract The Results

The hard part is over. Now we will simply fit the model with the training dataset.

# Fit the RandomizedSearchCV instance
random_search.fit(X_train, y_train)

Let’s get the results …

# Retrieve the best parameters found by RandomizedSearchCV
best_params = random_search.best_params_
print("Best Parameters:", best_params)

# Evaluate the model with best parameters on the test set
best_estimator = random_search.best_estimator_
test_accuracy = best_estimator.score(X_test, y_test)
print("Test Accuracy with Best Parameters:", test_accuracy)

best_params_ is a dictionary which may look like this:

{
  'n_estimators': 2000, 
  'min_samples_split': 10, 
  'min_samples_leaf': 2, 
  'max_features': 'sqrt', 
  'max_depth': 10, 
  'bootstrap': True
}

Notice it is using the same name we used while defining param_dist.

📌 Unlike in Grid Search, where I showed you a heatmap with all the values of the grid, I won’t be plotting any charts here. This is simply because Random Search is not systematic like Grid Search, so plotting a bunch of RANDOM values will not essentially tell us anything useful.

Thank you for reading till the end 🥳

Now you are able to find the best parameters for your model more quickly and efficiently … in a more processor friendly manner than the Grid Search.

If you found this article helpful and learned something new, be sure to leave a 👏 or let me know 📣 your thoughts on it. I’d love to listen to your feedback.