DEV Community: Abhishek Keshri

Pending Code Reviews Are Blockers for Your Team 🚧

Abhishek Keshri — Fri, 09 Aug 2024 09:00:07 +0000

I've worked and interacted with a lot of people working in engineering teams across various contexts, and one of the most common pain points I've encountered is the prolonged wait time for code reviews.

Long delays in code reviews can cause several issues:

Slower Delivery Pipeline 🐢

When reviews are delayed, the overall progress of the project is hindered, affecting delivery timelines.

Idle Time and Context Switching 🦥

Developers either move on to new tasks or, worse, sit idle waiting for reviews. When feedback finally arrives, they must context switch, which disrupts their flow and reduces productivity.

Here are steps you can take to improve this process:

Start Early 🐦

You don’t have to wait until your PR is fully refined to start getting feedback. It’s beneficial to seek input early—either right after the first draft or even during the ideation phase. This approach helps align the team early on and reduces the scope of later revisions.

Pair Programming / Mob Programming 🤝

Collaborating on a piece of work through pair or mob programming ensures that your team is aligned and solves the problem together. This approach often eliminates the need for a formal code review altogether.

Treat Pending Code Reviews as Blockers 🚧

Often, it’s not that we’re unwilling to do code reviews; rather, they get deprioritized amidst other daily tasks. Changing this mindset is crucial. Consider code reviews as blockers for your team and aim to address them as soon as possible. Personally, whenever I receive a notification about a code review, I ensure that I tackle it immediately after finishing my current task.

What strategies have helped your team improve code review processes? 💬

All the keyboard shortcuts I know! ⌨️🥂

Abhishek Keshri — Sun, 07 Jul 2024 11:56:33 +0000

Keybindings or keyboard shortcuts are essential to an efficient workflow.
They help you navigate faster, be more productive and reduce the time you spend on repetitive tasks.

My workflow is heavily keyboard driven and primmarily relies on a browser and a terminal within a tiling window manager, for these I use my own set of keybindings. Because I work on multiple machines and operating systems, I have to keep track of all the keybindings I use and make sure they are somewhat consistent across all the systems and tools.

I realized that this keybinding information was scattered across the internet and several configuration files, making it hard to find when needed. So, I embarked on a journey to document all the keyboard shortcuts I use daily!

The purpose of this post is to provide a central location / index for all the keybindings I use across different tools and operating systems.

Tools Covered

Here's all the tools I covered:

Aerospace

Aerospace is my go to tiling window manager for macOS, its similar to i3, find out more here

Alacritty

Alacritty is a cross-platform, GPU-accelerated terminal emulator. find out more

Arc Browser

Arc is a web browser built on Chrome, that provides some handy features. find out more
Its my primary browser on MacOS.

Keybindings

MacOS

I change very few of the default keybindings on MacOS at a system level.
I remap the Caps Lock key to Escape and Swap Fn and Ctrl keys.

Keybindings.

Neovim

Neovim is central to my workflow and my primary editor, where keyboard shortcuts significantly enhance productivity.

Qutebrowser

Qutebrowser is a keyboard-driven browser that can be used with minimal mouse interaction.
It's my primary browser on Linux and I use it on MacOS as well.

Raycast

Raycast is a macOS app launcher with tons of expandable plugins.

Keybindings

Shell

Efficient shell usage is crucial, I use zsh as my primary shell but knowing the basics of bash is also important.

Sway

Sway is my primary window manager on Linux, it is a wayland port of i3.

Tmux

Tmux helps manage terminal sessions efficiently, I rarely have a terminal open without tmux.
I manage all my tmux keybindings with tmux-tilit

Keybindings

Vimium

Vimiun is a Chrome extension that provides keyboard shortcuts for navigation and control in the spirit of Vim.

Zsh

Zsh is my primary shell, I use it with oh-my-zsh and powerlevel10k among other plugins.

Wrapping Up

Alright, that's all for now, I hope you find some of these keybindings helpful.
Feel free to tweak these keybindings to suit your needs better, I will be updating this list as I add more tools and keybindings to my workflow.

Remember, the key to efficiency is not just knowing these shortcuts, but incorporating them into your daily workflow.
Keep practicing, keep exploring, and you'll find your productivity soaring in no time. Happy coding!

How to be good at Open Source 🧑‍💻🌏

Abhishek Keshri — Sun, 24 Mar 2024 02:51:47 +0000

What's the coolest thing about open source software? 💭

If you need a new feature, you can just go ahead and add it yourself!

I recently did this with lazygit, a terminal-based git client I use every day.
I wanted to add co-authors to commits, which is handy for pair programming at Incubyte

My pull request for this feature got merged recently, and now I'm thrilled to use it with the latest release!

Here are some tips I learned along the way:

Add Value

Make sure your contribution adds value to the project. Don't just contribute because it's trendy.

Ask for Help

Don't expect to get everything right on the first try. Ask the project maintainers for feedback and guidance.

Be Patient

Remember, many open source projects are labors of love. Be patient if things take time or responses are slow.

Accept Rejection

Sometimes your ideas might not fit with the project's goals. Be polite and be prepared to fork the project if necessary (and maybe even become a maintainer yourself!).

Most importantly, be a good open sourcerer, and may the code be with you! 🖖

#OpenSource #Community #SoftwareDevelopment

Master Git Interactive Rebase 🧑‍💻🎓

Abhishek Keshri — Sat, 27 Jan 2024 13:30:21 +0000

A clean commit history can significantly enhance the speed and efficiency of code reviews. However, achieving it isn't always a walk in the park.

Fortunately, we have powerful tools like Git Interactive Rebase to streamline the process.

📚 I've put together a comprehensive guide to help you master Git's interactive rebase, making your commit history cleaner and more efficient.

Check out the guide and level up your version control game!

We'll learn squashing, reordering, and editing commits, making your commit history tell a story.

Tailored for both beginners and seasoned developers, this guide delivers actionable insights and best practices to help you master Git's interactive rebase feature.

Let me know your thoughts and happy coding! 💻

Ultimate Windows Dev Environment for 2024! 🪟🧑‍💻

Abhishek Keshri — Tue, 02 Jan 2024 15:59:52 +0000

I was never a big fan of the command line experience on windows, but recently things have improved and I tried creating a command line based dev setup.

Sharing it here.

If you use windows I definitely recommend going through it.

youtube.com

Here's the repo link if you want to set it up directly.

2KAbhishek / win2k

Ultimate Dev Setup for Windows 🪟🪄

win2k

Ultimate Dev Setup for Windows 🪟🪄

win2k in action

win2k is a set of handcrafted configs for setting up a complete dev environment on Windows.

It makes developing on Windows much more pleasant for CLI lovers.

✨ Features

Can set up a complete dev environment within minutes
Full featured CLI dev environment on Windows (natively, without WSL!)
Shiny and extensible prompt with oh-my-posh and posh2k
Powerful personalized editing with nvim2k
Tiling window management with komorebi and whkd
Modern and intuitive keybindings for Windows inspired by tmux-tilit
Statusbar support with yasb
More!!

Setup

🚀 Installation

Enable remote script execution (Only needed one time)

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

Install scoop

Invoke-RestMethod -Uri https://get.scoop.sh | Invoke-Expression

Install git (7zip and aria2 to help with scoop installations) if you haven't already

scoop install aria2 7zip git

Clone win2k

git clone --recurse-submodules https://github.com

…

View on GitHub

Nerdy.nvim : Find Nerd Glyphs Easily 🤓🔭

Abhishek Keshri — Sun, 24 Sep 2023 03:36:25 +0000

Do you like Nerd fonts? but don't like going over to their site just to fetch a glyph for your pretty terminal?

Well, me too!

Introducing nerdy.nvim, a super handy plugin that lets you easily search, preview and insert all nerd font glyphs straight from neovim!

✨ Features

Fuzzy search nerd glyphs
Preview glyphs before inserting
Super lightweight
Can auto generate new icons from source

Setup

⚡ Requirements

You have installed the latest version of neovim

These two plugins are optional but highly recommended for a smoother user experience.

dressing.nvim — for prettier select UI
telescope — for fuzzy searching in list

🚀 Installation



-- Lazy
{
    '2kabhishek/nerdy.nvim',
    dependencies = {
        'stevearc/dressing.nvim',
        'nvim-telescope/telescope.nvim',
    },
    cmd = 'Nerdy',
},

-- Packer
use '2kabhishek/nerdy.nvim'

💻 Usage

nerdy.nvim adds a new command Nerdy.

You can add your custom bindings for the command, the recommended keybinding is <leader>f,.

check :help nerdy for more details.

NOTE: By default there are no configured keybindings.

Fetch new icons

Running the python scripts/generator.py command will automatically fetch new icons from source and update the icons.

Behind The Code

🌈 Inspiration

I love nerd font glyphs, and I use them anywhere I can! but I was wasting a lot of time going back and forth between nerd font site and neovim, also the copy feature was super buggy for me on the site, so I made nerdy!

💡 Challenges/Learnings

Making the generated icon table with vim.ui.select was a bit tricky.

🧰 Tooling

dots2k — Dev Environment
nvim2k — Personalized Editor

🔍 More Info

nerdicons.nvim — Nerdy was inspired by nerdicons, thanks to the original authors for the groundwork.
co-author.nvim — Another one of my plugin that easily lets you add co authors

GitHub Repo

2KAbhishek / nerdy.nvim

Find Nerd Glyphs Easily 🤓🔭

nerdy.nvim

Find Nerd Glyphs Easily 🤓🔭

nerdy.nvim in action

Do you like Nerd fonts? but don't like going over to their site to fetch a glyph for your pretty terminal? Well, me too!

Introducing nerdy.nvim, a super handy plugin that lets you search, preview and insert all nerd font glyphs straight from neovim!

✨ Features

Fuzzy search nerd glyphs, by name and unicode
Preview glyphs before inserting
Super lightweight
Can auto generate new icons from source

Setup

⚡ Requirements

You have installed the latest version of neovim

These two plugins are optional but highly recommended for a smoother user experience.

dressing.nvim — for prettier select UI
telescope — for fuzzy searching in list

🚀 Installation

-- Lazy
{
    '2kabhishek/nerdy.nvim',
    dependencies = {
        'stevearc/dressing.nvim',
        'nvim-telescope/telescope.nvim',
    },
    cmd = 'Nerdy',
},

-- Packer
use '2kabhishek/nerdy.nvim'

💻 Usage

…

View on GitHub

How to Think Like an Architect 🧠🏛️

Abhishek Keshri — Mon, 14 Aug 2023 05:08:00 +0000

Have you ever wondered what skills it takes to be a software architect?

While civil architects design awe-inspiring structures that stand the test of time, software architects craft intricate architectures that form the foundation of modern technology. Software architects mold the digital landscape as we know it.

Architects possess a unique mindset that enables them to design and develop robust software architectures. Their ability to think strategically, make informed decisions, and balance trade-offs is vital for creating successful systems.

In this article, we dive deep into key principles and strategies that will help you train your brain to think like an architect.

The First Law of Software Architecture: Everything is a Trade-off

The foundation of architectural thinking lies in understanding that everything in software architecture involves trade-offs.
Architectural decisions require careful consideration of competing factors, such as

Performance vs. Readability
Modularity vs. Reusability
Flexibility vs. Simplicity

A good architect recognizes and embraces these trade-offs, making balanced choices that align with a project's long-term goals.

Architectural Thinking Impacts Businesses, Teams and End Users

Architectural thinking impacts business facets such as values, internal team dynamics, and customer satisfaction.

Business Value

In an organization, business executives and management may be concerned more with scalability, time-to-market, and cost-effectiveness.
This is where architectural thinking becomes significant in delivering business value. Architects get to make technical choices with business goals in mind because they get to think more holistically.

Happier Teams

Architectural thinking fosters effective collaboration and empowers team members. By creating architectures that promote communication, clarity, and shared understanding, architects contribute to happier and more productive teams.

User Satisfaction

A well-designed architecture ensures system reliability, performance and usability. Thinking like an architect means you prioritize user experience, i.e., the needs of your end user.

Strategies for Identifying Architectural Characteristics

Identifying architectural characteristics is crucial for designing effective software systems.
Here are some strategies to find and define these characteristics:

Through Understanding the Business Domain:

Gain a deep understanding of the domain in which the software system will operate.
This understanding helps identify key concerns, requirements and constraints that influence the architecture.

Through User Stories and Requirements:

Architectural characteristics can often be found implicitly or explicitly in user stories and requirements documents.
Pay attention to both functional and non-functional requirements, as they provide insights into the desired qualities of the system.

Through Business Conversations:

Engage in conversations with stakeholders, business analysts, and domain experts to uncover architectural characteristics.
Discussions about system goals, performance expectations, and scalability requirements can reveal crucial insights for architectural decision-making.

Technical Depth vs. Breadth

Striking a balance between technical depth and breadth is essential for architects.
Here's a breakdown of these two dimensions:

The 20-Minute Rule

To enhance technical breadth, commit at least 20 minutes each day to expand your knowledge.
Here are some resources that you can use to stay updated and explore new ideas:

Tips for Thinking Like an Architect

To enhance your architect's mindset, keep the following tips in mind:

Architecture is an iterative process, just like software development.
Collaborative decision-making and communication are crucial in effective architecture. Involving developers and business stakeholders provides a broader perspective and considers multiple viewpoints.
Be mindful of the context when making decisions Consider the specific project requirements, constraints and objectives to avoid falling into out-of-context traps.
Avoid over-evangelizing a particular solution or technology. Architectural decisions should be driven by a project's unique needs rather than personal preferences or biases.

By embracing the principles of architectural thinking, you can cultivate a mindset that enables you to approach software design and decision-making like an architect.
This perspective empowers you to create well-balanced, effective, and successful architectures.

Everything You Need To Know To Use ChatGPT More Efficiently 🤖🪄

Abhishek Keshri — Fri, 23 Jun 2023 11:15:34 +0000

Are you feeling lost in the new world of AI tools and Prompt Engineering?
Don't worry, we got you!
In this article, we'll demystify everything and equip you with the knowledge you need to get the most out of AI tools like ChatGPT.
So, let's get started!

What Is Prompt Engineering?

Prompt engineering is like being the conductor of an AI orchestra.
It's the art of crafting carefully tailored instructions, or prompts, that guide language models like GPT-3.5 (Used in ChatGPT) to produce the outputs we desire.
Think of it as giving your AI companion the perfect set of directions to create the results you're looking for.

In this article, we'll explore the fundamental principles of prompt engineering and how they can be applied in practice.

Principle 1: Write clear and specific instructions

The clarity and specificity of instructions greatly influence the output generated by the model.
Here are some guidelines to follow:

Use delimiters to clearly indicate distinct parts of the input. Delimiters can be anything like triple backticks ( ``` ) or semicolon (;). For example, when providing multiple inputs, you can separate them using delimiters to ensure the model processes them correctly.

Ask for a structured output format such as JSON or HTML. This helps in obtaining well-organized and easily parseable results.

Instruct the model to check whether certain conditions are satisfied. This allows you to incorporate logical checks in the output.

Utilize the power of "few-shot" prompting. Instead of asking the model to perform a task from scratch, provide an example or a partial solution and ask it to do something similar. This enables the model to generalize from the given example and produce the desired output.

By clearly specifying the desired output format and providing structured inputs, we increase the likelihood of obtaining the desired JSON response.

Principle 2: Give the model time to "think"

Language models like GPT-3.5 need time to process and generate outputs, especially for complex tasks.
To facilitate this, follow these guidelines:

Specify the steps required to complete a task. Number and list the steps clearly in your instructions. This helps the model understand the desired process and ensures a logical flow of information.

Ask for output in a specified format and provide an output template. By providing a template, you guide the model to generate output that adheres to the desired structure. For example, if you want the model to generate a formatted email, provide a template with placeholders for the recipient, subject and body.

Instruct the model to work out its own solution before rushing to a conclusion. Allowing the model to ponder and analyze the problem can lead to more thoughtful and accurate outputs.

By specifying the steps clearly and providing a template for the output, we enable the model to generate a well-structured guide.

Iterative Prompt Development

Prompt engineering is an iterative process.
It involves refining and improving prompts based on the model's outputs and analysis.
Here's a suggested approach for iterative prompt development:

Start with a clear and specific implementation of your idea, following the prompting principles mentioned earlier.
Analyze the generated outputs and identify any discrepancies or issues.
Refine your idea, and the prompt by further clarifying the instructions or addressing any ambiguities that may have led to undesired outputs.
Enhance prompts with a batch of examples.
Providing additional examples helps the model learn and generalize better, resulting in improved outputs.
Repeat the process until the desired results are achieved.
Iteration allows for continuous refinement and optimization of prompts.

Capabilities of Prompt Engineering

Prompt engineering empowers us to leverage the capabilities of language models effectively.
Here are a few key capabilities and their applications:

Summarizing: Language models can summarize larger pieces of text to their essential points.
This can be customized to focus on specific topics or aspects within the text.
For instance, you can prompt the model to summarize a news article while emphasizing the key events.
Inferring: Models can understand the content and make inferences.
This capability is valuable for tasks like sentiment analysis, topic extraction, grammar checks, and more.
For example, you can ask the model to determine the sentiment of a customer review or identify the primary topic in a given text.
Transforming: Language models can transform content from one form to another.
This includes tasks like format conversion (e.g., JSON to HTML), language translation, or even changing the mood or tone of the text.
For instance, you can prompt the model to translate an English sentence to French or convert a CSV file to JSON format.
Expanding: Models can generate large content from smaller inputs, allowing for the generation of articles, emails, lists, and more.
For example, you can provide the model with a few bullet points and ask it to expand them into a full-length article.

Get Prompting!

That's all folks, you now have all the fundamentals you need to go out there and craft your own prompts.
Use this knowledge to unleash the power of prompt engineering and watch your AI companion create wonders at your command.

This article is a condensed version of this course by Isa Fulford and Andrew Ng, you can take a look to explore more and try different examples.

This article was first published on Incubyte's blog, It can be found here

Video: Customising Your GitHub Profile!

Abhishek Keshri — Sun, 28 May 2023 00:52:37 +0000

In this video, I show you how to utilise Markdown and automated Github Actions to create an impressive Readme for your #github profile.

If you have any thoughts or feedback, do let me know in the comments section.

PR Labeler: Simplify Repo Maintenance with Automated Labels and More

Abhishek Keshri — Mon, 22 May 2023 21:03:39 +0000

What I built

Hey there! I've built a super handy GitHub Action that's all about making the lives of repo maintainers a breeze.

✨ Features

Add labels for the current and required number of reviews
Pop in a "Work in Progress" label for draft PRs
Keep an eye on a target branch (like staging) to make sure all the current PR commits are there

Category Submission:

Maintainer Must-Haves

App Link

You can find the action right here: GitHub Repository

Description

So, here's the deal: my GitHub Action is all about helping repo maintainers tackle their daily tasks with ease. It offers some nifty features, like automatically adding labels based on review counts, throwing in that "Work in Progress" label for those draft PRs, and even letting you track if all the PR commits exist on a specific target branch. It's all about making your life simpler!

Link to Source Code

Feel free to check out the source code over at: GitHub Repository

Permissive License

MIT

Background

Alright, so let me share a little story with you. I've had my fair share of struggles when it comes to finding PRs that desperately need some reviews. On top of that, I often found myself wondering if all the changes in my current PR actually made it to the staging/test branch. It was a real headache! That's why I built this action—to help me out (and hopefully you too!) by solving these pesky problems once and for all.

How I built it

I hopped on the GitHub Actions train and made great use of the Actions Toolkit provided by GitHub. Along the way, I learned some cool stuff about the updated API and YAML syntax. Now, if I could offer some feedback, I'd love to see better ways to debug and test GitHub Actions. And boy, a faster feedback loop would be a game-changer, trust me! Making those improvements would make the whole development experience a whole lot smoother.

That's it! Hope you find my GitHub Action as useful as I do. Happy maintaining!

Video: Personal Knowledge Management with Neovim

Abhishek Keshri — Sat, 13 May 2023 05:27:08 +0000

In this video I walk you through my note taking process with Neovim, I talk about how I organize, sync and search my notes and all the different tools and custom commands I use to achieve this.

If you have any feedback or comments do let me know.

Learnings From Clean Code

Abhishek Keshri — Mon, 27 Mar 2023 05:00:00 +0000

Learnings from Robert “Uncle Bob” Martin

Robert Martin, fondly known as “Uncle Bob” in software community, is a software engineer and more famously an author and one of the founding fathers of software movements like software craftsmanship, agile methodology, and test-driven development. Some of his most famous works include Clean Code, The Clean Coder, Clean Architecture, and Clean Agile. Martin is also a frequent instructor, with the ability to boil down difficult topics into a simple, understandable format, along with occasional cheeky humor.

One of the most striking qualities of Martin – in all of his writing and lectures, is that nowhere does he claims to have a full-proof solution or a doctrine that could solve all software development problems. He acknowledges that the teachings and lessons are ones he acquired from his 40+ years of experience and encourages the reader to validate the “time-testiness” and accuracy of those lessons. One of the qualities of a software craftsperson, according to Martin, is adapting to changing times and let go of irrelevant principles.

This article can be thought of as a list of learnings from the book Clean Code. By no means this is an exhaustive list, but rather a list of all lessons which had the most impact (personally) while reading.

1. The Meaning of Clean Code

Uncle Bob starts off the book by exploring the term itself.
Without stating a single clear-cut definition, he presents various definitions from prominent computer scientists.
Reading which, one can figure out common themes and characteristics that define 'Clean Code' being – readability, straightforward, maintainable, reads like prose, and doesn’t contain duplication.

Core learning: Clean code has more to do with writing understandable code which is both easily maintainable and changeable, versus clever (read complicated) logic which is harder to maintain.

2. Duplication is the Evil

Uncle Bob goes on a length about various characteristics of bad code.
Amongst them, code duplication holds a special spot, because majority of code problems have their origins linked to duplication.
It has inspired many coding patterns, techniques, and ideologies.

For example, database normalization techniques (1NF, 2NF, 3NF…) by Codd are ultimately about removing redundancy in database design.

In fact, paradigms like OOP, AOP, COP, and Structured Programming, are all different ways to deal with duplication.
Duplications can be of different types, the most obvious one being repetition of the same lines of code.
A more subtle form of duplication includes a chain of if/else statements that test the same conditions over and over.

In some cases, embracing duplication might be the way to go. An example would be hitting a deadline.
An example would be hitting a deadline.
If duplicating code helps in achieving a target, the pragmatic course of action would be to allow duplication and treat it as a technical debt (that needs to be addressed later).
The only risk with this approach is that the duplication is never removed, and it keeps getting accumulated.

Core learning: While writing a piece of software, be mindful of code duplication.

3. One and Only One

Similar phrases appear quite often in the book –

“Classes should have only one reason to change”

“A single source file should contain only one language”

“Functions should descend only one abstraction level”

“One assert statement per test”

Core learning: Doing more than one thing at a time, or trying to “juggle” multiple things will ultimately lead to poor code quality and make the code less flexible. By making sure that we keep things simple, it makes life easier for the entire team.

4. F.I.R.S.T Principle for Tests

Writing tests is often seen as something which takes a lot of time and doesn’t serve a real purpose.

“I wrote the code, I know it works… Don’t you trust me?”

However, that’s far from truth, writing tests unravels many aspects we would have not uncovered otherwise.
A good test suite could be a challenge to write, but the F.I.R.S.T. principle can help us out:

Fast – Tests should run fast. If they are slow, nobody would want to run them.
Independent – Each test should be independent of other tests, and they should be isolated enough to be run individually.
Repeatable – They should be environment-independent. Should run on dev, prod, QA, etc.
Self-Validating – The test should either pass or fail. Anything in between means more time would be wasted on reading log messages.
Timely – Unit tests should be written before writing the production code. Tests serve their purpose only when written in a timely manner.

Core learning: Having a good test suit is important.

5. Clean Code and Concurrency

Coding is hard enough without concurrency.
It has its unique challenges – complexity, overhead, non-repeatability of bugs, etc. and as such it requires a fundamental change in the design strategy.
That being said, some principles must be followed if we want to include concurrency in our system:

Single Responsibility Principle – Keep concurrent code separate from non-concurrent code
Encapsulation – Limit access to the shared data
Know the Library – Understand the concurrency library inside-out
Keep It Simple, Silly – Make sure that non-concurrent code runs and functions properly first
Platforms – Run your concurrent code on different platforms
Go back to the basics – Problems like Consumer-Producer, Dining Philosophers, and Reader-Writers are a good start for selecting an execution method for concurrent code

Core learning: Follow best practices.

Conclusion

This article is a condensed summary of the complete book, highlighting some of the more essential & impactful principles.
The underlying principles remain somewhat same throught the book – a combination of the following principle - Do Not Repeat (DRY), Keep it Simple Silly (KISS) and You Ain’t Gonna Need It (YAGNI).

This book has a lot more to offer including error handling, writing effective comments, meaningful comments, unit testing, etc.
We definitely recommend reading this by yourself for better insights!

Like what you read? then visit our site to learn more.

We are also looking for awesome people to work with, if you'd like to be a part of our team join us!