#programming tips

hey, so you know that annoying thing that happens when you're coding, and you need to run/test the same program 100 times in a row, so you end up typing "python3 testScriptWithASuperLongName.py" into the terminal about 80,000 times?

well, there's a better way! it's called aliasing :D

in your bash shell (or zsh, or whatever shell you use, but bash is the default on VSCode and most people on tumblr use VSCode, so I'm using bash as the default to explain this concept) you can set an alias, essentially a shortcut command, that runs longer commands.

(yes you can just use the up arrow key to re-run the same command, but sometimes you're typing other things into the terminal too and you don't feel like hitting the up arrow key four times in a row, and also this is just a cool and useful tip to get comfortable with aliasing so shhhh)

so, in your terminal shell, just type this:

alias run="python3 testScriptWithASuperLongName.py"

now, you can run that entire super long command, just by typing the word "run" into your terminal. Here's a screenshot of an example on my computer to make it make more sense:

in this example, i just created a simple python file that contains one line of code: print("it works!")

then, as you can see, by setting the alias to run, i can now run that file, runningatestscript.py, simply with the command 'run'.

the best part is, this alias is temporary - it only lasts as long as your shell session is open. so once you close the terminal, the run alias is cleared and you can set it again next time to any file or task you're currently working on, to save yourself a lot of typing, typos, and time.

so if you want to, you can get in the habit of always setting a run alias in the VSCode terminal for whichever file you're working with as soon as you get everything open. that way, when you need to run the same file 50 million times, you have a super easy way of doing it! you can even set it to a single letter if you want to go for maximum speed, but i prefer to use whole short words, because they're easy for me to remember.

note: if you do want to set an alias to work for all sessions, you can simply add it to your ./bashrc file. this is a common way to automate repeatable tasks, and simply to set easier-to-remember commands for terminal commands that are really complicated/confusing/hard to remember.

for example, i saved the alias checkboot="[ -d /sys/firmware/efi ] && echo 'UEFI mode' || 'BIOS mode'" into my zshrc file (zsh equivalent of bashrc file). this way, no matter how many times i rebooted my machine, i would always be able to quickly check which boot mode was running by simply typing 'checkboot'.

yesterday i was updating my boot mode from BIOS to UEFI on my very old machine that is technically compatible with UEFI, but not configured for it by default. So it was extremely helpful and saved me the time and headache of having to remember and type that long-ass command a thousand times in between many different reboots and new shells.

if you have any tasks like that, or terminal commands that you know would be useful to you, but you can never remember them when you need them, i highly recommend getting comfortable with aliasing! it can be super useful to simply set custom aliases for all the commands you don't want to remember, so that you can automate things away and not have to worry about so much linux syntax all the time when you're tring to focus on programming.

It is time! My tutorial has been live since this morning but i have finally crawled out of bed for coffee and am now functioning.

once again i am just so proud and excited to show this tutorial to you. it is based off of just one function i have built in my personal tarot bot named grimalkin. if this tutorial is any fun to you, let me know and i’ll write more on the other commands grimalkin-bot has!

Day 3: Study Tips

I’m gonna do more stem related study tips because that’s what I know best ^.^

Study where you are comfortable and have access to resources. I usually study in my room, the library, or outside my professor’s office. 

Use resources. Sitting there and just staring at the problem will not help you. You gotta do some research. Ask your professor, use the textbook, find some online resources (I recommend Khan Academy for math or computer science). Professors are there for a reason, learn their office hours and use them. I used to be afraid of annoying my professor, but it’s their job and 9/10 they wanna see you succeed. 

Repetition is your friend! The only way I’ve learned to do problems is to repeatedly do problems and examples. In textbooks there are often problems that have the answers in the back of the book. 

If you aren’t 100% sure on something while studying, you won’t remember it for the test. I know it may get boring doing the same type of problems over and over, but it’s the only way to make yourself comfortable with math problems.

A programming study tip: if your program isn’t working, take a walk. Just walk around your building or room then come back a look at it. Big chance was your eyes just weren’t picking up an error. 

As a programmer sloppy code, messy syntax, vague class names, and unclear variable definitions can be a pain in eyes and eventually hinder your thinking capabilities to complete your program on time. 🥵

So, it's very important to write a clean piece of code that is easy to read, understand and well-worth. 🧐

Have you ever stared at a section of code and felt lost, even though it seemed straightforward at first glance? Many developers have faced this challenge - where understanding, testing, or modifying code feels harder than it should. This difficulty is what we refer to as code complexity, a factor that directly affects software quality, maintainability, and performance.

In this blog, we’ll explore the concept of code complexity, its causes, learn how to measure it effectively, and examine practical ways to manage it. We’ll also discuss modern tools and practices that simplify complexity management. By the end, you’ll have a comprehensive understanding of code complexity and actionable insights to improve your software development workflow.

What is Code Complexity?

Code complexity is a measure of how hard a piece of software is to read, maintain, and modify. It is too simplistic to say that complexity is simply the length of the code or the line count — a tool with only a few lines of code could be very complex if the logic is convoluted or the code is poorly structured.

High code complexity increases the difficulty of debugging or testing and expanding features. The opposite holds true for lower complexity - Low- and moderate-complexity code generally corresponds to more clearly defined, modular, and maintainable code. The importance of knowing about code complexity comes when we apply it to software testing as well, as more complex code often means more work must go into designing meaningful tests and maintaining quality.

In short, code complexity directly relates to whether you can build software efficiently, reduce bugs, and remain confident while scaling your features.

What Causes Code Complexity?

Common reasons for complexity include:

Poor Design or Architecture: With no thought or planning, code dependencies and code logic can become tangled.

Frequent Feature Additions: Too many features added without modifying the existing code can create complicated logic.

Undocumented: If the code was written with no review and has repeated redundant code or multiple or different codes that do the same thing, it may become more complex over time.

Under-documented: Difficulties maintaining code happen if developers do not know why code was written a certain way.

Tight Deadlines and Fixes: Patches or fixes made in a timely manner may fix issues now, but it can become even more complex in the long run.

By knowing these reasons early, the team will be able to put practices in place that will lessen code complexity and avoid spiraling out of control and deteriorating code complexity.

Types of Code Complexity

Structural Complexity: Concerned with how classes, methods, and modules connect in harmony with the existing system.

Cognitive Complexity: Metrics of the mental difficulty required of a developer to make sense of the code.

Cyclomatic Complexity: A metric of the independent paths that follow the program's control flow, as well as what is needed for test coverage.

Essential Complexity: Complexity that is part of the problem space and not part of the code.

Once the type of complexity is identified, teams can focus on a plan of action to coordinate the removal of the complexity. Structural issues will likely require refactoring, while cognitive and cyclomatic issues will likely require more documentation or automated testing.

How to Measure Code Complexity?

The complexity of code is an important measure of software quality. Without a way to quantify complexity, software engineers are left to guess which parts of the code will be dangerous or hard to maintain.

Generally, complexity can be gauged by teams in several ways, such as:

Static Code Analysis Tools: Tools such as SonarQube and ESLint provide a risk of code complexity analysis, pointing out areas of the static code that might indicate complexity.

Automated Metrics: Tools could calculate cyclomatic code complexity, cognitive complexity, Halstead metrics, and other metrics that are measured.

Peer Review: Other engineers can review each other’s code, providing qualitative measures on areas of code that may be confusing or error-prone.

Unit Test Coverage: Ensuring every logical path has been tested goes a long way to help in estimating and managing complexity in practice.

Utilizing a code complexity checker on an ongoing basis will develop complexity awareness throughout the development life-cycle as remediation measures will likely increase the number of parts of the system that can be maintained and controlled for the introduction of unintended defects.

Common Code Complexity Metrics

Cyclomatic Complexity: The number of independent paths in a given code base.

Cognitive Complexity: How much mental effort does it take to understand a given code base.

Halstead Metrics: Measures the number of operators and operands in code to measure program difficulty.

Maintainability Index: A Measure of how easy a developer can maintain a given code base.

Applying these metrics will help you and the QA team to make better data-informed decision-making for testing, refactoring, and QA. Additionally, it can assist with making determinations of high-risk areas of code that require immediate attention.

Challenges of High Code Complexity

High complexity introduces multiple challenges for software development teams:

Longer debugging cycles and harder maintenance: More complex code is difficult to read and comprehend, which takes longer to find and fix bugs. You can spend a lot of time finding and fixing even a simple bug that requires checking a bunch of modules that are dependent on each other.

Greater risk of regression bugs: Complex logic and dependencies mean that modifying code can break another part of the code and create a new bug if you modify one part of the code.

Reduced scalability from tightly coupled code: Very complex code typically has tightly coupled code, which makes it hard to add to, or scale with new features to the system without adding additional bugs in existing functionality, or needing a lot of refactoring to separate code into new files.

Greater cognitive load on developers: More complex code takes more mental effort to comprehend, test, and modify, which results in either slower development cycles, more mistakes, or onboard additional programmers to a team and so on.

Difficult to achieve full test coverage: Complex code paths, conditional statements, and deeply nested logic make it difficult to write all the test case scenarios and achieve comprehensive full coverage.

These issues ultimately slow down the rate of development, increase cost, and reduce quality; however, it is possible to overcome these obstacles and challenges by doing regular refactoring, coding modularly, consistently testing code, and using automated code analysis tools to give feedback. Taking steps to manage complexity up front results in a more efficient development cycle, greater tool maintainability, and more reliable software releases.

How to Reduce Code Complexity?

Refactor regularly:  simplify nested logic, avoid duplication, and improve naming.

Design modularly: break up existing large functions or classes into smaller, more self-contained modules.

Review code, and practice pair programming: these processes will help to build shared understanding and surface potentially overly complex logic early on in the process.

Automate testing: automate the maintainability of your test coverage with tools; otherwise, assessing coverage manually adds time and overhead to manual testing methods.

The take-home here is that teams can and must systematically implement the less complex strategies for a simpler, more reliable, and more scalable codebase.

Why Code Complexity Metrics Are Crucial for Software Development?

Code complexity metrics provide concrete and actionable information related to the state of a software project. By measuring complexity, teams can identify areas that warrant greater testing effort, need to be refactored, or need design improvement.

Metrics also help project managers with key decisions around timelines, testing efforts, and resource allocation. They establish an environment of accountability and quality by empowering developers to emphasize not just writing code, but also sustainment and quality coding.

Why Does Ongoing Maintenance Matter?

Without ongoing maintenance, even code that is cleverly structured will warp over time and create increased opportunities for bugs and test development slows. By continuously revisiting the codebase, and just enjoying the process of improving it, you can maintain complexity, as well as performance, readability, and testability over the development of the software in terms of quality over time.

Leveraging Keploy for Smarter Complexity Management

Managing code complexity effectively typically requires contemporary automation. Developers face the challenge of managing complexity in general while working at speed to develop and test features. This is the space where Keploy operates as a future-looking tool that addresses new norms in terms of AI and automation.

Keploy automatically analyzes code paths, locates potential complexities, and generates test cases to quickly validate code updates. By tying requirements to tests and tracking data flow, it allows teams to proactively address complexities before their impact requires more significant remediation. With it, Keploy helps development teams focus on significant innovations while maintaining quality, maintainability, and scalability; truly a futuristic approach to code complexity management.

Conclusion

In today's world of software development, code complexity is an inevitable challenge, but shouldn't be considered a roadblock. Understanding the types of code complexity, causative factors, and correct measures can help development teams gain visibility and control of their codebase. Dealing with high complexity in a manageable way through refactoring, managing continuous improvements, and product testing not only produces better software quality and better scalability but also lowers the chance of defects being introduced. This ensures that teams can deliver safe, maintainable, and high-performance software that matches the pace of contemporary application development.

FAQs

1. How Do I Determine the Time Complexity of My Code?

Time complexity indicates the increase in code runtime as the input is scaled. You can determine it by examining loops, recursion, or nested operations, and then expressing it in Big O notation (e.g. O(n), O(n²), etc.). There are tools available that will analyze your code for complexity automatically (code-complexity-analyzers, etc.).

2. What Does Cognitive Complexity of Code Mean?

Cognitive complexity is how difficult it is for a person to understand the underlying code. It considers readability, nested structures, and the mental capacity to retrace logic. If logic is optimized or large functions are categorized into smaller sub-units, cognitive complexity can be lowered.

3. How Do I Eliminate Cyclomatic Complexity in Coding?

Cyclomatic complexity increases when you have many logical paths (loops, conditionals, branches). Keeping functions small, limiting nesting, and avoiding large functions with many paths are all ways to limit cyclomatic complexity. There are tools that continuously check code complexity (even if those tools use cyclomatic complexity for prediction).

4. How Does Code Complexity Affect Software Testing?

Code that is more complex will be much harder to test due to the sheer number of likely testing scenarios and paths that need to be entered by the developer to conduct the testing. So, simplifying complexity and using code complexity checker will help to ensure that the most thorough and efficient testing can occur.

5. Are There Tools That Can Automatically Measure Code Complexity?