CodeIt.Right Feature Tour

Instant Code Review

We've all been there. You're new to the team and want a sanity check before committing your code for the build. But the senior devs on the team are pressed for time and can give you only a cursory - and sometimes grouchy - review. It's frustrating.

So forget the waiting. Get instant code review feedback as you work.

• Automated review rules run in the background, reviewing your code as you type.
• You can see violations right in the editor, without even glancing away from your code.
• Want a more detailed explanation? The detail window can tell you why your code has been flagged, helping you learn and improve.
• Combined with instant refactoring, you can correct mistakes with a single click.

Microsoft Guidelines and Best Practices

Think of the last time you switched jobs. Did you find yourself staring at a codebase with deeply unfamiliar conventions? Or have you ever banged your head against a wall upon finding yourself in a codebase that ignores the "interfaces start with I" convention? Or perhaps you've never used that convention, and you're mystified by your teammates giving you a hard time about it!

Whatever you may think of the conventions, nobody can deny that the .NET ecosystem tends to be extremely uniform and opinionated on code conventions, both cosmetically and from a design perspective. So for .NET developers who are switching between teams, groups, or jobs, not conforming with Microsoft's guidelines is like a metaphorical record skipping.

But getting things in line doesn't have to mean searching for conventions in a giant document or endlessly looking up the "Microsoft Dialect." CodeIt.Right checks for this conformance out of the box, automatically keeping your code in line while teaching you the standards:

• Naming conventions
• Performance guidelines
• Security best practices
• Design guidance
• Exception handling standards

Automatic Code Refactoring

Keeping your codebase clean takes a lot of time and effort. And you often don't have that time. If you don't believe it, think of that one class in your codebase that everyone's been meaning to do something about: it's just never the right time.

But what if you didn't need to spend time thinking about how to clean up and refactor? What if you could automate that process?

• CodeIt.Right calls attention to code smells you know about - and it even points out ones you don't.
• Once they're detected, you can fix the problems with a single click.
• In many cases, you even have multiple options for how to implement a fix. Pick the one that suits you.
• CodeIt.Right helps you effortlessly refactor towards well-established design patterns.

Follow Your Own Standards

A lot of tools that check your code for issues have very binary configuration options. They start out with a lot of noise, forcing you to shut individual warnings off until only the ones that matter to you are left. But then, well, that's kind of it.

What if you want to define your own rules?

Way too often, this is incredibly cumbersome or simply impossible. You'd have to basically write your own tool from scratch.

With CodeIt.Right, you can easily customize to your heart's content. Use the rules out of the box, or build your own that's hyper-specific to your needs and your team.

• Configure rule instances in accordance with your own standards.
• Define base behaviors and then create specific instances, in a paradigm familiar to anyone that knows OOP.
• Have multiple profiles with subsets of your rules.
• Develop custom rules using an API, or modify ones that come with CodeIt.Right.
• Use T4 templates to customize rules.

Reducing the Noise

Have you ever brought in a linter or static analyzer to help you improve code quality? How did that go? Was it fun to stare at 34,995 warnings and try to decipher which mattered and which didn't? And what did you do next? Did you just say "forget it" and uninstall the tool?

Most tools bury you in warnings to demonstrate their comprehensiveness. But as an automated code review tool, CodeIt.Right emphasizes making it easy for you to see only the warnings you want to see.

• Filtration by severity gives you a one-click way to get started with only the most important issues.
• Filter to ignore auto-generated code or code within designated regions.
• Exclude warnings by project, file, rule, or violation.
• When all else fails, add a convenient suppress-message attribute.
• Each individual user can create their own specific profile with their desired subset of rules.
• And you can do all of this with the command line version, as well.

Automate Code Reviews

Can you picture this? You find yourself staring off into space while two of your coworkers bicker about a naming convention. Six of you sit around in a conference room, with someone's laptop projected on the flatscreen TV, and you're entering the fourth hour of a marathon code review. Does this sound familiar?

These reviews can be boring and contentious, and frankly, they can waste a lot of time. But you don't abandon the practice of reviewing; the underlying concept is important.

Well, you can have the sanity check without the expensive (and often soul-crushing) time investment. By automating your code review, you can completely eliminate the low-hanging fruit and save human interaction for concepts and overarching design discussions. CodeIt.Right will help you facilitate this change.

• Build code review into everyone's routine.
• Save countless person-hours in conference rooms.
• Perform checks prior to commits, rather than after the fact.
• Incorporate code review into the team build.
• Avoid needless team conflict.

Organization/Team Policy Management

There's nothing worse than having a defect assigned to you. Well, unless it's having a defect assigned to you that resides squarely in Steve's section of the code. And Steve's on sabbatical.

You go into that section of the code, and it looks nothing like the rest of the codebase. Different naming schemes, different design patterns, the works. Fixing the defect is like walking a digital minefield.

What if you could have consistent code throughout the codebase, but without nagging people or arguing endlessly? CodeIt.Right's team collaboration helps you do exactly that.

• Create a unified standard and publish it for everyone's use.
• Instantly share updates to the standards among everyone on the team.
• Have code commit policies that check each individual file for compliance, ensuring that the code stays consistent.
• Revisit standards in a meaningful way with team usage statistics.

Custom Rule SDK

"Ugh, for the last time, remember to inherit from the BaseViewModel class!"

We bet you've said something like this before - or that someone has said it to you. This happens all the time, in every office with software development. Team members have to nag each other about things that would be conceptually easy to check for in an automated fashion.

So why not check for them in an automated fashion?

With CodeIt.Right, you can build custom rules that address your specific conventions and needs. Don't nag your teammates, and don't write the convention down in some dusty, already-too-large Word doc with coding conventions. Automate a check for it!

• Get an SDK license completely free with CodeIt.Right.
• Develop as many custom rules as you want and modify them as needed.
• Get started quickly with the graphical Rule Wizard to generate a custom rule template.
• Use T4 templates to drive rule creation.

Code Metrics - Understand Your Code Better

If you've ever found yourself in an argument with a team member about code quality, you know that tempers can run hot. But you also know that things tend to be quite subjective, with each side digging in about preferences. How do you know that it's your teammate, not you, that's committing questionable code?

Code metrics can help you pair your arguments with actual data. While it's of course not a universal source of truth, code metrics nonetheless help you quantify aspects of your code and identify trouble spots. That's what you'll get with CodeIt.Right:

• Metrics like cyclomatic complexity, nesting, and inheritance depth help you reason about the complexity of your codebase.
• Looking at the number of fields, locals, methods, and properties can tell you a lot about whether your types conform to good design practices.
• Get metrics on how prevalent your code documentation and commenting is.

Continuous Integration

There are a lot of painful workflows when it comes to code review. Perhaps you've encountered some of them. Maybe you use pull requests to trigger code reviews, but approvers lack the time to get these done quickly, resulting in upstream merge issues. Or perhaps you merge frequently and take code review action items as another round of changes to trunk. None of this is great.

But what if you had an automated review? And what if that automated review acted as a gatekeeper via incorporation with your build? This sort of automation is how organizations like Facebook can push code constantly into production. And with the right tooling, you can move in this direction, too.

• Invoke CodeIt.Right from the command line to use with your build, or use provided NAnt and MSBuild tasks.
• Have a custom exclude list specific to the build machine so that you only fail the build for the right reasons.
• Ignore minor warnings using the severity threshold feature.
• See nicely formatted reports of review results using the reporting feature.
• Create specific violation reports by using custom profiles.
• Use as a gatekeeper, with a nightly build, or as part of smoke testing.

Reporting

One of the biggest sources of frustration for developers and management alike can be conversations about trends in the code. Management is often desperate for some insight into what, to them, is a mysterious black box. And developers tire of management oversimplifying the complexity of what they do with easily gamed metrics, like code coverage or how many lines of code per day someone commits. This is why reports on the state of the code tend to be anecdotal.

But it doesn't have to be this way. Developers can agree amongst themselves on important violations and metrics to track, and then they can share simple reports to mark progress. Again, CodeIt.Right has features that can help you.

• A simple violations report lets everyone track the progress toward making a codebase healthy.
• You can also produce a simple pivot view of the entire solution's health.
• Generate reports on code metrics and usage statistics.
• Do whatever you need with the data - generate stock reports or export it for use in other contexts.

Integrated With Visual Studio

Visual Studio is a powerful tool, and it's designed for powerful integrations. You can do everything from building your code to generating class diagrams inside of it, and you get used to that. So isn't it awful when you have some tool that you have to launch in another monitor and use independently?

With CodeIt.Right, you don't need to worry about that. In fact, its Visual Studio integration is so seamless that you'd think it came out of the box.

• Analyze your code right within Visual Studio.
• Enjoy automated navigation from violation report to the relevant line in your code.
• See changes highlighted right in the code editor.
• Undo and redo automated changes just as you would with things you'd typed.
• Set VSTS check-in policies around automated review.