Coding Blocks - Static Analysis w/ NDepends – How good is your code?

Episode Date: August 10, 2014

This week we’re discussing NDpend, a static analysis tool for .NET. Triage your biggest problems, Prioritize your refactoring, and CYA with real metrics and trend lines. We also discuss hidden nuggets, Pintrest-envy, and we pour another one out for google reader. News Check out our YouTube channel! Angular 2.0 is coming! Beginning XML in SQL […]

You're listening to Coding Blocks, Episode 15. Subscribe to us and leave us a review on iTunes, Stitcher, and more using your favorite podcast app. And visit us at CodingBlocks.net where you can find show notes, examples, discussion, and much more. And send your feedback, queries, and rants to comments at CodingBlocks.net and follow us on Twitter at CodingBlocks. Or head to www.CodingBlocks.net and find our us on Twitter at CodingBlocks, or head to www.CodingBlocks.net and find our other social links at the top of the page. That would be LinkedIn, Facebook, Google+. Yeah, I think there's some Google Plus on there.

There's a few other ones, so yeah, just go over there. Facebook, maybe? Did you already say Facebook? I think I did. So, yeah, they're all there. Everything but Pinterest. Wait, wait, what? No Pinterest?

No Pinterest. I wish we had a Pinterest, actually. Really? I see all these cool infographics all the time. I got nowhere to put them. All I wish we had a Pinterest, actually. Really? I see all these cool infographics all the time, and I've got nowhere to put them. Alright, we're going to set up a Pinterest account for Joe. Alright. And with that, welcome to Coding Blocks. I'm Alan Underwood. I'm Joe Zack.

And I'm Mike Wattlaw. And today, let's go ahead and get started with a little bit of podcast news. And I'm Mike Wattlaw. They're coming out with a new version of that. But every other thousand JavaScript libraries on the web are being currently deprecated. Daily, it seems like. But no, it took me a little while. But between looking at the various different apps and actually going through a few tutorials and messing with the code, it finally started making sense. I will say, though, that at least angular you know having the google back it makes it feel a little bit more safe that it's uh going to be around uh but uh what is it gw uh gwt it died well okay that was google as soon as i bring up one good you have to go and bash it

yeah i'm gonna pour one out a Google reader right here right now. What about Google Wave? I liked it. Well, you were like one of the three people on the planet. I think they used it. It was great for my Dungeons & Dragons campaign. Awesome. But yeah, so hopefully here in the very near future, we might actually have a little bit of information on Angular.

I might come with some tips and whatnot. So yeah, we'll see. Yeah, I'd love to talk about Angular. I've always heard it's one that you can't sprinkle in there like you got to go full bore yeah that's absolutely true one of the things that i did learn this week that i'll throw out there that was kind of interesting is i wanted to do some server side authentication or no authorization on on portions of it that's not how that works like when you create your html template files those actually get compiled into javascript string templates that are then used in your app so it's not it's not doing any um ajax calls out to the server to get those templates so even though

you're creating html templates those get compiled down in javascript so that was one thing that i found really interesting so that's just you know did he just say an oxymoron? Compiled JavaScript? Okay, not compiled. I thought I heard that. It gets broken down into. But it's actually through a build because I'm using Grunt and Bower and all that stuff. So, yeah.

Anyways. All right, moving on. Interesting. Also, we just got done talking about SQL. It had to be two-parter there. But I actually just went to a meetup on beginning XML and SQL Server, and there was some stuff that I knew about. Like I knew that XML was kind of like a native type in SQL,

and that you could query and do some cool stuff with XPath. What I didn't realize, and this was the big takeaway for me personally, is that you can generate XML really easily and really complex XML. So you can actually do joins and do things and it'll group by and it'll come out well formed XML documents, which is great for integration type projects. So that was really awesome. And that title that was beginning XML and SQL server with Don Wirt and we'll

have a link to that. Cool. And yeah. And I also want to give a shout out and thanks to uh rye guy welch we got a five star review on itunes from him nice little write-up here says uh informative and entertaining bets best podcast for programmers maybe the only one of its kind discusses current trends issues and technologies and software development great quality and easy to listen to so thank you yeah and we got another one also from glenster 75 it was also a five-star review on itunes

and he writes best coding podcast i learned something new every episode that's excellent that's what we're here for so thanks again for taking the time to write that and click the uh the review in itunes yeah and and we really appreciate those reviews. We talk about it all the time, but one of the big reasons, I don't know if we ever talk about why we like them so much, is aside from letting us know how we're doing and if there's anything we can do better, it also bumps us up. And so a lot more people end up seeing us whenever we get a review.

So it really helps us get the word out there, and it's awesome. Yeah, and we're trying to make people better programmers, including ourselves. Not to mention that it's just motivation in and of to make people better programmers including ourselves i mean not to mention that it's just motivation in and of itself yeah it really is anytime we get that it's it's a super booster to us yep so that's awesome all right so what are we talking about speaking of super boosters today we're talking about a tool called independ and what it does for you so um first of all we should probably say that we actually got a free professional license

from Patrick's, I'm not going to be able to say it, Smatia. Close enough. Sorry, Patrick. We did write you an email to see how to say your name, but we sent it a little late, so sorry about that. I'm William Allen. Yeah. Very lame.

So take that into account when you think about it. So some of the stuff, you know, we're saying we did get free copies, but we're going to try to be brutally honest and say what we feel. So, you know, there you have it. Yep. And just before we get started, one of the roadblocks to us getting rolling with independent, at least I know myself and I think Outlaw also had some some issues as it seemed like we were having some pretty major instability

for for me well before you get into that though just in all fairness because i actually did have a little bit of a back and forth with patrick on this and and because he was saying that he i i did have some instability with it like it brought studio down to its knees for me and uh you know i had some back and forth with him and with patrick and he was saying that he didn't have any of the problems that i was having and he was using similar plugins like a web essentials or a resharper or dot cover or anything like that post sharp maybe and um you know even though we had similar plugins he wasn't experiencing it and we even compared you know like size of projects so yeah so with that what i found was causing

the problem for me is i had updated to visual studio 2013 and the project i was working on was basically hosted in a git repository and with visual studio 2013 there is a new git plugin that is on by default and what i found is that was eating up like 30 of my cpu on an i7 with 16 gigs of ram like it was just it was destroying my machine like i couldn't even type in visual studio i disabled that plug-in by going into the options and basically had no more problems so independent worked for me after that so if if anybody's seeing these kind of issues and you've got a fairly large project you're working on or a big solution i would recommend going in there and disabling that get plug-in well we've

actually talked about git plugins in the past um in a past episode shoot i think it was episode two but uh um yeah they really don't work very well yeah no like i i have i know that there are some people that just absolutely love them but for me i haven't had good luck with any of them. And this is an example of one. Sorry, it was episode three. This was episode three, source control etiquette. But I haven't had good luck with any of them. This is an example of one that was straight from Microsoft. Here's the horse's mouth.

And it still started causing problems where it was causing Studio to just churn away. Yeah, I mean, it was pretty ridiculous. My CPU sat at 30% constantly, and it was that Git plugin running. So I just wanted to preface that. That's one of the reasons why it took us a little bit of time to get around to finishing this kind of thing up, because we were trying to figure out exactly what was going on. And I want to say, too, it's actually been great for me.

And one thing that kind of didn't make sense when we're talking about the performance problems initially is that uh an end of it doesn't really seem like it's doing a whole lot when you're just kind of doing your day job like most things you kind of need to run something specific or pull up a dashboard and click around into it so i don't really know where that kind of thing would come from yeah that's a good point yeah i don't know. But I do want to point out there are a couple different versions available of independent. One of them specifically is a build server license that you get that would be perfect for your CI server.

However, we're not going to be focusing on that version in this episode. We're going to be talking about the features of the Visual Studio add-in. But I will say one thing about the build server that sounded pretty cool when you look at the feature set was if you have that integrated, it'll do your snapshots for you, build your reports for you on the fly. So it is a cool feature if you've a team working on you know doing multiple releases and whatnot being able to see how your code changes over time so absolutely um so let's get into some of the feature set of independent and this thing's uh it's a pretty big monster like there's a lot of functionality in here so we're not going to be going over them all in depth

because this would turn into hours and hours but we do want to hit on a lot of the key parts so one of the things i want to point out is when you install this thing into visual studio down in the bottom right corner of visual studio there is a little circle that shows up and it is kind of like a little quick type thing for independent so you can get to a lot of the functionality so that that's one way you can do it and the other is to hit the independent menu up at the top i didn't know about the circle that's awesome yeah so um yeah i made the mistake of turning that on for resharper mistake so in that thing you just mouse over and it kind of gives you a little pop-up menu with a lot of your top type things. So it's almost like a quick, I don't know, like a running dashboard for you there.

And speaking of the dashboard, that's actually my favorite feature. I think that's kind of the main thing. It's really the hub of Endepen. So it sets up a little menu here in between like SQL and tools, depending on the version of Visual Studio that you're running. And you just click Dashboards right at the top, and it brings up this beautiful dashboard with a bunch of numbers. And you can drill into these little lists and graphs and kind of see what's going on. But it gives you a great snapshot of your project. All right, so the next feature that I want to talk about are the rules. And this is what I found to be pretty amazing in NDPend was when you open this thing up,

you basically get a panel that shows you the type of thing. So you get critical rules violated, rules violated, syntax or execution errors, okay rules, queries, all this stuff. It's really amazing now when you open this up what you get is you get this list and if you click like on the critical rules and you say all right drill into it it gives you this summary window that at the top of it gives you the link query and yes i said link that basically queries the output of your code base. So it queries both the IL and your code to join this stuff together to generate these reports

to find out where either problems in your code or where your dependencies lie and all that. And what I really liked about that in this is at the bottom of the link query on most of them that he usually has a link at the bottom that you can click that will take you to describing what you're actually looking at because i mean you might get pretty overwhelmed when you're going through this stuff because there is a yeah i totally overwhelmed like when you first start getting into the rules years over well i guess I guess maybe the code that I was looking at weren't such great projects, but there were a whole slew of different rules.

It was like, oh, you're breaking this rule, you're breaking that rule, and I thought it was pretty good. Yeah, it's pretty in-depth. It can point out a lot of deficiencies in your code. Now, in all fairness, not every one of the rules is going to have that link so sometimes that can get a little confusing because you don't you might not know like well why isn't that one there right and so like one of the things

i'll point out is there was a uh there's a complexity report and for me that was a real eye-opener so the way that they define this if you click the link at the bottom of the link query, it would take you to the site. And they kind of give you just a real quick overview. And I'm talking about the ILCC. So it's the Interpreted Language Cyclomatic Complexity Score. And basically what it does, this one's good if you have Visual Basic Code versus just C Sharp. Because if you're looking at the other CC ranking, that's only for C Sharp.

If you look at the IELCC, then it's inspecting the IELCC code itself and does the rankings based off that. And so one of the keys they talk about is they calculate the score by doing a 1 is for an if. You add 2 if there's a for loop and so they basically said a general rule of thumb is anything over 20 you should probably think about refactoring anything over 40 turns into just a code mess in the way i've understood cycle mic um i haven't

read the description you have but the way i've kind of understood before i looked in like the enterprise version of visual studio is that it's the number of execution paths that run through that method so if you were to kind of go through by hand and you know test like every use case that that method handles then that's kind of where you're at so that means that there's 40 things that you need to test if your score is 40 if you're running through this by hand and that's a lot that's a lot of different things that's happening in that method, and that's probably something you should break up. Especially when the whole thing is to keep them simple, right? So here's a little anecdotal type thing that was rather humorous.

So I ran this on a code base that I've worked on, and so let's keep in mind, over 20 should refactor, over 40 is pretty horrible so one file that that was in here was a 775 a 775 and it actually made me laugh because i had to work in this file before and it took me three weeks to make some changes so i'm imagining like ifs within ifs, within loops, within switch statements. Cases, I mean, everything you could possibly think of, it was that. And when I saw it pop up, I was like, well, that explains it. And so circling back around, like this particular feature of independent, I found extremely

useful because if you, let's say that you were a project manager or something you got this report spit out to you you could look at this and say oh i have some people that need to work on these particular set of files and this thing is just a nested nightmare right this isn't going to be something that they're going to be able to knock out in a couple hours you know this is going to be something we're really going to have to slate some time aside for because this is going to take a little bit of work through because if there's that many you know code execution paths you're probably going to break something when you go in there and start messing with this yeah yeah well the thing that i found great about the the dashboard well there's also we should

mention too there's another report a version of that report from the dashboard that is an HTML version of it. But the thing that I found great about the report in general, though, was just like, if you were looking for a source of inspiration, like, you know, you had some free cycles, you're like, okay, what part of the code base should I go and fix, right? You have this kind of report available to you or to other developers on your team and you can say oh here's here's a class like your 700 one that maybe i should go back and uh you know clean up and refactor or you know break it apart it gives you like a priority list of things you need to fix and i also really like it from a cya perspective so i can go tell the boss like look here's why it took so long i'm not crazy it's supposed to be 20 or less and it's 775

so you owe me dinner right and and you probably want to have a before and after so that it wasn't you that created that 775 right that's right yeah those trend lines are really important yeah i brought it up from 20 to 775. Check it out, boss. Yep. So, yeah, that was, I found that entire section just incredibly helpful. What's really cool about that rule section is they have a ton of canned ones already, and then they let you modify them. And you can tell it what you think is critical or what's not, and you can write your own link queries to create your own custom reports, and you can use theirs as baselines to figure out what kind of report you actually want to write.

So that entire section was extremely powerful and, like I said, very eye-opening. Yeah, there's a whole slew of rules in there. Yeah, I was just thinking about a couple rules I might like to write, but they're all pretty much invalid because I was thinking about the actual source code, like variable names less than three or something like that. But I don't think that really applies here because independent acts on the DLLs. It's static analysis, so not so much the code but the actual generated files. The cool thing about that, though, is that you don't need the code to run this.

Right. Here's one thing. I'll go through just a couple of these they have so they they have rules for base class should not be used as derivatives um class shouldn't be deep in the inheritance tree no descendant should be sealed if possible overrides of methods should be call should call base dot method do not hide base class methods like i mean they have a dead code one potentially dead types potentially dead methods fields i mean the list of things that you can get out of your code base and things that you could improve or they're all there now whether or not you're going to be able to go through all these

man but but one that i'm not particularly a fan of instance fields should be prefixed with a m underscore i do not like that i've never liked that instance fields should be prefixed with a M underscore. I do not like that. I've never liked that. Yeah, ReSharper is okay with just the underscore and me too. So that's the rules section. Actually, while we're still there, we were going to talk about this a little later,

but it kind of makes sense to put it here. There's a couple of my favorite rules that I noticed when working on some of my stuff. And one of those is mutually exclusive namespaces. So that's when you've got one namespace that depends on another, and that other one depends on it. So A depends on B, B depends on A. While that's strictly not a problem,

and when you're talking about the namespace level, it is if you're talking about the DLL assembly level. But it's a good example of somewhere where you're crossing some boundaries and probably need to rethink some things. Also, another one that I really liked is methods that could have a lower visibility. You've got it marked as internal, or it could be

private, or maybe public that could be private. I like that sort of thing because it lets someone see visually when they're in the file the kind of things that are talking outside and who they should be talking to, which is really nice. And I love seeing very few public methods because that's really the footprint and the API of your application or assembly. Yeah, I mean, some of these rules, I mean, by themselves, they're great.

But I just imagine, like we mentioned, the build server version of it, and I just see like how much more powerful that could be there to be able to like send out alerts or you know for the entire team to be able to see uh you know that that report there yeah to me like that's the real value add of an independent it's over time so i want to be able to see that error going up or down for each metric well i mean like like, there's one of the rules that can report on third-party code usage. Yeah.

Like, assemblies used, namespaces used, types. Like, you know, if you had, if your manager needed to know, like, hey, what are some of the other libraries that we're using? Like, what's our exposure here on third-party, you know, utilities, right? Then it's rules like that that might be able to help them out. And they don't have to go digging into the code.

Yeah, and actually I've got a blog post cooking on this that we'll have a link to whenever I finish the draft. But I actually looked at a couple of high-profile open-source projects like Entity Framework and SignalR. And what I thought interesting is Entity Framework had 92,000 lines of code and SignalR had 18,000. So it's like 15%, 16%, 18%, something like that of the code size. But the actual third-party assemblies, Entity had 30, and SignalR had 42.

So it's touching a lot of different stuff. But even further than that, you can actually see the number of third-party method calls. So Entity Framework had 4,500, and Signal signal r had 500 so tons of assemblies but not really doing much with them so i thought that was really interesting yeah it is cool to analyze all this stuff i mean and that's what this does it makes it really easy to kind of break down your code base yep yeah so uh you another one of the features there let's get into it the dependency graph all right so uh you know using the dependency graph you've we've seen these type of graphs before right where uh it just graphs out all your code into little bubbles and then has lines

linking everything to everything that's related right Except this one kind of goes a bit above and beyond your normal bubble, right? So if you hover over any one particular bubble, as you're hovering over it, you'll get IL instruction counts, lines of code counts, comments, percentage of comments. You'll get data about each one of these as you just hover over them. And then if you're not happy with the way it draws the dependency graph, you can change that. You can say, hey, you know what? Change the box sizes. By default, it's going to size the boxes based on the number of lines of code. But you could change that and say, you know what, just make them constant. Or instead, let me base it on the IL complexity, right? Now, there's an interesting view of your code, right?

So you could see, like, the bigger ones are the ones that you might need to go focus some more time on, right? And I like it. If you ever ask the question of yourself, like, what is all this crap? And this is a great way to answer that question. Well, we don't call it crap, for starters. Sometimes I like it. If you ever ask the question of yourself, like, what is all this crap? And this is a great way to answer that question. Well, we don't call it crap for starters. Sometimes I call it crap. Oh, he must have seen the projects that I ran this on.

I've called my code much worse. But, you know, a couple of other things I like about it were there are ways to actually exclude some of the items in here. And another feature that I really like compared to the one that Visual Studio has baked in is this thing generated fast, even on a pretty large code base. The one in Visual Studio, the last time I tried to do it, like I basically had to walk away from my computer, come back, you know, 15 minutes later. This thing actually cranked this out pretty quick, and it's a pretty useful utility. Yeah, I thought it was going to take a while to do it for entity framework, but it popped right up. Yeah, I mean, whatever they've done behind the scenes is pretty efficient. Yeah, kudos.

Yeah. And actually, while we're talking about that graph, there's the tree map view, which is actually really cool, too. The thing I like about it is that it really lets you see how your code is split up it's similar to the dependency graph it's just kind of a different layout at least that's how i view it but it's a good way of saying like 75 of your code is this or 13 of your code is that and so it's a good way of kind of visualizing just how big the various pieces are wait did you say the tree map yeah the tree map metric view weren't the squares oh the the honeycomb thing so yeah this one i wasn't as crazy about this one um that's the code metrics view from the menu just so only because like i guess maybe i didn't understand it maybe that's where

i had more problems with this one yeah Yeah, it's not my favorite visualization. I like the abstractness versus instability one the most. But really what I like about this one is it shows me, I'm looking at a project right now, and I can see that the test namespace or one of the test namespaces is one of the biggest sections of my code, and that's because I do a lot of code generation there and does a lot of repetitive type stuff.

And so it's just a lot of boilerplate. But I can see that it's probably 15 know 15 of my projects just looking at it yeah which is kind of what the the you know the dependency graph the default version of the dependency graph where it was based based off the lines of code could do something similar to that for you um but yeah you this this view like for anyone who's familiar with, uh, this tool, um, I remember a while back there was a tool called space monger and you could point it to, you know, any drive or folder on your, on your hard drive or in your computer. And it would, uh, you know, lay out a representation of what folders were taking up, uh, you know, the most space. And it used this exact same type of, uh, visual representation for it. And so I guess like when

I saw this, so it was like, wait a minute, what am I looking at here? But, um, yeah, I'm actually, I'm looking at color mine right now, which does a, you know, it's one of my projects that does a lot of color comparisons. And one thing that's interesting is I can see that there's one of my open source projects that does a lot of color comparisons. And one thing that's interesting is I can see that there's one comparison method, CIDE2000, is probably half of all the comparison code. And all the other ones are small. It's because it's just a really big method. There's a lot of math going on. But what's also funny is if I look at the actual tree view of the tests,

because I generated these tests and because I do basically a bunch of conversions from this to that and verify it's right. And I do it all based off of T4 and XML files. It's all like pretty much even. So I've got a nice honeycomb as Alan said. So it's a, it's got a nice little pattern here because each section is about even. Yeah. This,

this view on large projects kind of just makes my eyes go. Oh yeah. Yeah. And that, that might've been maybe why i wasn't as crazy about this this wasn't this was of all the features this was not my favorite yeah i would agree this the it's a cool view into your code from just a graphical representation but i don't know how useful it is for me yeah i mean like for example the the project i'm looking at it it breaks it down into uh each line of code represents 472.2 pixels right yeah i mean it's it's uh i don't

know i think on a smaller code base this one might be a little bit more useful i'm trying to think like how we can describe this better for the listener like it's trying to create a a bubble to represent the size of each class of within your code you know and then it based on the overall number of classes in the size in the number of lines for each you know it tries to give a respective size bubble represented as a square really for each one of those classes and that way you can see based on the size of the squares and how they mix in and it arranges all of those squares by namespace and then assembly too and projects yeah well well that's if you have it chosen in a particular level so you can have it recreate this graph for methods, fields, types, namespaces, assemblies. And that's, I mean, again, I think this is one of those ones to where you'd really have to spend some time in it to find out where the value would be for you. like everything's so tiny and dots going down because there's so much code and the stuff that

I've examined that it just, I don't know, it doesn't seem as useful to me. Yeah. I'd really love to find somebody that maybe, maybe somebody who's listening in that does use this tool and uses this specific feature that has a great use case for it. I'd love to hear your feedback on it and then it'll give me a new perspective on, that's how i should be using that thing more effectively i mean i will say if you if you click on something it will actually take you to the code like if you double click if you can double click on that one pixel where that you know well you can zoom in well no double click it it will take you to the line of code. Yep, yep. It'll take you to, okay, so like the current level that I'm looking at was based on methods. And it'll take you into that method, but you can actually just zoom in.

So in your case where you're having problems fitting, because the default is to fit in the window. Right. Right, and so that's why you're seeing such small little squares. But you could actually just you know zoom in and then click on it yeah it's interesting it's a neat view again uh you know yep it's kind of interesting for me to see that like look at a dll and say this section of the dll this namespace is much bigger than the other ones so it's just kind of an interesting view of it i don't know that i would really act based upon it but it's cool so tying

into this uh well going back to our conversation about the dependency graph tying into that there's also a dependency matrix which i thought to be a pretty cool view of like uh a cross cut representation of like which namespace is dependent on other namespaces, you know, and, and, uh, you know, what that representation looked like.

And then for any one of those, you could dig into it. So, uh, you know, if you clicked on that, it would then take you into back to the dependency graph to where you could see what was actually happening there.

So I guess, you know, if you, for the listeners that, you know, to, to visualize what I mean by the dependency matrix, think of a set of rows on the left that are namespaces

and then columns that are the set of namespaces as well. And then there's interjection points where those namespaces interject or cross and how many references there are. Yeah, those are like logic puzzles, you know? Yep, that's exactly what i was thinking it's like sally's dog is not named jed and uh you know jed has a red collar and then you kind of like x this stuff out and you end up finding all the results but it basically looks something like that it reminded me of like a multiplication table when i was a kid

because i had one like that where you know numbers along the left and numbers across the top so going into this one a little bit more because this is also one of my favorite ones on here so talking about his cross-cutting type things where you know you have the same list of of assemblies on the left and the same list of assemblies going across the top where they intersect on that grid they have a number showing you the number of of dependencies and what's really cool is if you click that number it will actually open up your dependency graph and show you how these things cross relate right well it's the the number of the methods right yeah that are that are you know the number of times that those are used and it's beautiful because it'll actually the ones that are

used a lot it makes them bigger and the ones that aren't used as much it makes smaller like it's just really cool how they integrated this. I love this feature. And one thing we haven't actually mentioned is that Patrick and Dependent Company, whoever, has put a lot of detail all over the place. It's like hidden value. So I'm looking at one of the HTML reports right now, and there's this little question mark next to Dependency Matrix.

I click it, and it's got a wonderful description of it and more online documentation telling you all about this graph and what it means, what the number means, and what it's supposed to show you and what we can do with that. It's just these little hidden nuggets of value. You can actually even, like, within the dependency matrix, so where two namespaces cross, and there's, like, a number to say how many times one calls the other, right?

You could actually double click on that and zoom in on it. And then if you zoomed in again, it'll actually get into from the dependency matrix these specific calls of what's happening there. So you don't even have to go into the dependency graph to see that interaction you can stay within the matrix view if that happens to be your preferred uh way of viewing this oh they have a nice little animation yeah and even if you didn't want to do it that way too like if you uh um you know there's there's plus signs on both the top and bottom so you could expand it out uh you know the namespaces that you could see where these things were actually happening. So you didn't even have to do the double-click on it to zoom in.

So to Joe's point, as far as the hidden functionality, that's just another example where it's like there's multiple ways that you could get into this data. There's just like hidden little features where you know like maybe for some maybe for one person it would just be without even thinking about it they would just automatically start double clicking everything they see and then they get to the data or someone else might you notice the plus sign okay let me just expand this out i'll get to it that way yeah and just moving your mouse around they update little uh like info

windows all over the place so it's i mean it's a very interactive grid yeah we can talk about my favorite graph which one's that abstractness versus instability oh yeah that one was nice yep so it's a square one corner abstract one corner unstable. So the closer you are to the top left, more abstract. The more to the bottom right, unstable. But the other two sides of the square, the corners, are zone of pain and zone of uselessness. So this is great because I'm always worried about going too far towards the uselessness. And so it's kind of cool to see some of my projects and also some of the open source projects and see where they kind of line up.

So most of the ones I've seen have done a great job of staying in the green as far as being not too abstract, not too, I'm sorry, green being not too useless and not too painful. But most have been on the instable side, which I thought was interesting. Even my stuff, which I thought

I was kind of crazy with interfaces and whatnot. It's interesting to see that I wasn't as high on the abstract meter as I thought I would be. Yeah, I mean, that's what I found a lot, too, was that more often than not, I might have one or two, three namespaces that leaned more to the abstract side, but the bulk of everything was like oh crap that's in the stable but i loved this view though because this view was totally inspiring to be able to see like oh that that needs to be fixed you know it's funny to see here though is um like the test dlls are often very much to the instable sign and sometimes into the zone of pain so actual like the core

library logic is doing good but the tests are not so much they're fragile they depend on concrete types yada yada now this was an example though like i wasn't able to find this this graph in the online within the dashboard within the app i only saw this one within the html report yeah i noticed that too and one thing that i i didn't like about this report is that if you're doing something that has a lot of dependencies, like I think I was looking at SignalR, then a lot of them end up kind of crowding into one section sometimes. And you can't actually read the labels anymore because it's just text overlaying text. And it looks like a big black hairball. Right.

Yeah. I mean, it's got to be in there somewhere. I just haven't seen it. And I guess I'm assuming that the reason for this HTML report was just so that if you had it on a build server, maybe that you could just have people point to that, maybe management or whatever. They could be able to see that report without having access to Visual Studio per se.

But, I mean, that's just an assumption on my point. I'm not sure if that's how the build server portion works. Yeah, and what I can imagine doing is you can correlate with management and say, you know what, we've been having bugs in this area and we can see that this DLL is in this zone. So if we can improve this metric, then maybe we can improve the bug metric well i guess kind of jumping ahead a bit though but another one of the features that um independent provides is that as you're making changes in and you you're running you have

independent attached to your project it's tracking these over time so you see charted data as to like you know how did your lines of code did the line of code increase or decrease did your rule violations increase or decrease like you know you see all of these over time like how's happened so to your point about going back to management being able to point it out you know you maybe, a case might be that you could say, hey, look, we specifically implemented the feature XYZ went out. Here's where the complexity went up and coincidentally, so did our errors, right?

Right. And I actually attached a number to this crazy technical debt word. And also you can even, forgetting about the trend charts, which are awesome, the trend lines and the kind of up-down stuff you can get on like a build-to-build basis. You can also diff snapshots.

So if I've got, you know, release five, release six, I can take a look at those and see how it went. And I think that's really powerful. That to me is like the main thing, is being able to see how this stuff tracks over time. Yeah, I mean, again, from a management standpoint, I mean, as a coder, you like to see your code get tracks over time. Yeah, I mean, again, from a management standpoint, I mean, as a coder, you like to see your code get better over time,

but that's really for your own edification. But from a management perspective, these kind of reports could be really valuable because we all know as code gets more complex, not only do you get more errors, but it's harder to maintain. So the next time you've got to go back and touch it, it takes twice the amount of time or three times the amount of time it's hard to say well i think that's also a key differentiator between this and other products is the fact that you do get this reporting over time yeah that you can go back to you know your manager and be able to point it out

exactly like no here i can quantify it yeah there you go it's it's not just the developer saying no no no or you know we shouldn't do this right you can actually show it so um and in a way that they'll at least be able to to somewhat understand even if they don't understand what the aisle number is you can you can easily explain that they want numbers right exactly having a chart definitely helps your situation. Yep. Yeah, so, oh, you can also import the code coverage. And so, like, if you're using a tool like a dot cover, for example, you can import that and get it, you know, as part of your dashboard, you know, output there.

Yeah, and that's nice because a lot of times if you're using a code coverage tool, you're probably generating some sort of report already. You don't want to have two reports. That's just annoying, so why not bring that into the independent report? Yeah. Another feature and this is a little baffling. Well, hold on just to, I mean, I guess

I don't know if that was clear. I want to make sure that that was known for like, that's code coverage for tests so like you can actually see and quantify like, we have tests that are covering X percentage of our code base, right? And you can see that on a namespace level or a class level, right? And this is bringing that data in from some other tool

and including it into this report. So going back to the example that we gave about going back to your manager with specific numbers, now they could see, hey, we're doing pretty well. Look at our code coverage. I think we're doing pretty well on it. Or maybe you're not doing pretty well, in which case you might have to have it talking to you. Right.

So the next feature I want to talk about, and this is, I mean, it's a feature, but it seemed like all this already existed in the Visual Studio plugin, but they have this Visual Endepen standalone that you can actually launch from the tools submenu under Endepen. And what it seems to do is really just bring up their own interface that they created at one point that has all the same functionality, but it's laid out slightly differently so so the menus that were sub menus of independent are now main menus and it's i don't know maybe it's laid out a little bit more more coherently in that everything kind of has its own space uh which for me was nice because that was one of the things about independent in the Visual Studio thing is it seemed like the windows were just everywhere.

So this kind of lays it out a little bit better and you just get more direct access to everything. But it seems like it's all the same exact functionality that exists inside Visual Studio itself. So you just can't drill down so much. You know, you lose some of that kind of interactivity. But but for me i prefer the report because it gives me the high level information that i want yeah it's it's kind of interesting i that double click thing on the matrix is just awesome i didn't know that was there i'm still doing it you're still fascinated by the animation i like the animation i like the fact that it actually does something. It's the little things in life.

It really is. So thank you for the animation. Yeah, you know, maybe now we've talked a little bit about some of the features. We're going to talk about some of the good. But I want to go ahead and mention this before I forget. I think sound effects would be really cool for this plug-in. What do you guys think? Oh, God.

Like a toilet flushing when you went to the critical. That's right. Is that if your code was really bad like oh crap yeah like if you did good play a little happy song if you did bad and like i don't really want to oh man i hear like the price is right every time the price is right wrong horn should be played at some point wow wow yeah that's definitely a feature ask yeah that's hilarious. Yeah. So we've already talked about a lot of the features,

and while doing that, we've already crossed over some of the really good features of this. We've mentioned the rules about it. We've mentioned... What else have we mentioned? Well, about the rules, we mentioned that if you wanted to see exclusive namespaces, if you want to see dead types or methods or methods that have lower visibility.

Or too long. Yeah. We've talked about our love for the dependency graph and matrix. And my favorite, the report. Love the report. We've talked about the abstract and instability craft as you know these are all like great pros of this uh and and um you know specifically like i think did we did you already mention about like what how independ defined

that i know we covered the pain versus the um oh shoot what was it called again abstract first instability yeah yeah yeah but pain and zone of uselessness there you go the zone of uselessness in the zone of pain right which were fantastic names for that but you know specifically there was a section where uh in the independent html report where you know like if you clicked on that little question mark and went in and defined it and says that the abstractness versus instability diagram helps to detect which assemblies are potentially painful to maintain, i.e. concrete and stable, and which assemblies are potentially useless, i.e. abstract and stable. And then abstractness is if an assembly contains many abstract types, i.e. interfaces and abstract classes and few concrete types, it is considered as abstract versus

stability and assembly is considered stable if its types are used by a lot of types of tier assemblies in the in these yeah in this condition uh stable means painful to modify so you want to strike the balance which is yeah well i thought that's why I really liked that graph though is because there's this line that goes from the top left of the graph down to the bottom right of the graph. And ideally, you want to be on that line in this zone of green, but you really want to be somewhere towards the middle of that. You don't want to be towards all the way of that. You don't want to be towards, you know, all the way to the left or all the way to the right. Um, yeah,

it should be, this should almost be called the, how am I doing graph? If you just want to see one graph, so how am I doing? You know, and there was one other thing though, that I don't know that we mentioned that I thought was kind of interesting

though. Uh, at least from, because you like, there's plenty of tools out there that talk about your lines of code this one talks about also your percentage of comments oh yeah yeah that that was cool yeah and and not only so not only could you see that from the dashboard point of view but you could also go into there was another place where i have to remember where i found it where you could actually see the relationships based on on uh the comments uh that were in there speaking of which uh you

know we talked about uh i pulled some metrics off some some kind of top metric some top projects uh 36.72 percent of jason.net is lines is. So I didn't say that very elegantly. You got entity framework. Nope, sorry, this is all tech too. I got a bunch of reports here, sorry. But it's really cool to be able to see that percentage. And yeah, 18% of color mine is commented. I actually wasn't able to pull the comment percentages

for entity framework and SignalR, which is what I really wanted to tell you because apparently they exist in multiple languages, so that metric doesn't make sense. But at least the tool is good enough to tell me why it's not going to give me that number. Very cool. What else did we like about it?

Found some. The interactive dashboard. Yeah, I mean, the interactive dashboard was cool. Again, the rules, we love those. Yeah, also just a very helpful UI. So, you know, I just mentioned an example there. Another one I liked is I was clicking around in the UI in Visual Studio, and I came across a link that said generate a graph of something,

and I didn't really know what it meant, so I clicked it, and it actually brought up this little window with screenshots of how to do it and what it meant and links to more information. So through and through, this product is very well well documented and it's very much targeted for developers and what you want to be using it for so i thought that was really cool and really helpful yeah i mean this project is also like 10 years in the making too so yeah there's been a little bit of time to document a thing or two here or there yeah but i like i don't i didn't have to go googling anything really it's it's nice to think that like the information that I want is right where I want it to be.

So when I wonder, hmm, what does this button do? There's a little help tip that says, this is what that button does. Yeah, because, I mean, really, it's almost an overload of information, but they did a fantastic job of bringing that information to meaning very quickly without having to hunt around for it, which is, is excellent. Yeah. So, you know, we talked about a lot of, a lot of the pros of it. And before we go on, I just want to ask dear listener, leave us a review on iTunes or, you know, leave us a review on Stitcher. Just leave us a review. We love those reviews. Yeah.

As Joe mentioned earlier, they really do help other listeners, new listeners to find us. So we really appreciate it. And it provides a lot of motivation for us. And we like getting that feedback. So leave us a review. Share it with your friends. Share us with your enemies. You've got to keep those guys close.

That's right. Right? You don't want them knowing more than you know, so share it with everybody. As Alan mentioned, you can find links at the top of codingblocks.net for Twitter, linkedin google plus pinterest and uh oh wait no no no pinterest not yet sorry i want to keep my infographics sorted it's coming it's coming okay but the other ones are there yeah all right all right so now let's let's get into the part that nobody really likes but um but the know bad parts of the review the bad parts like so the things that we found a little bit frustrating so uh yeah and for me um should

we all talk sad now for the part right yeah we're not we're not happy about this but uh information overload information overload was the big thing for me so coming into it, there is a bit of learning curve. There's kind of a lot of stuff you need to know. And if you just kind of click to that dashboard after installing it, then there's just a lot of numbers in your face. And it's overwhelming. But the information is there for a reason. It's there to guide you. I get it.

But sometimes it's just a little bit overwhelming and a little bit confusing. It takes a while to really learn it and figure out, like, hey, man, what does this number mean? Why do I care about that? Yeah, and one of the things that we actually mentioned that we liked was about the rules and how it shows you exactly how it found that code. It's got a nice description. But the first time I clicked on a rule to see what the heck does this mean. Why is it showing me late code? I'm like, the heck this is is this is a bug what happened here so that was a little bit confusing so not a big deal but yeah it did it did take a moment to uh to get

to appreciate that yeah uh he also had here uh were you going to talk about the wish you had better separation yeah so some of the graphs will actually show you on an assembly level you know where the issues are it graphs it really nicely but some of the things it just kind of aggregates for the whole solution so i know for me a lot of my tests were just kind of the actual unit test code or functional test codes was kind of dirty stuff it was talking directly databases file system sometimes it was doing all sorts of weird wacky stuff particularly the functional tests or the integration tests. And that kind of stuff really brought the scores down, and I didn't like that it was kind of combined with my other stuff,

but I also didn't want to lose it. I could have just not selected that assembly, but then I want to see that stuff too. It's just I don't want it tarnishing my baby. Nobody talks bad about my baby yeah all right so some of the things that that i had on my list were one and and this one was big for me is i wish it honored the theme oh my god yes i use the dark theme inside visual studio and and Inside Visual Studio. And all the windows that came in for End of Pen were white. Are brights dark white?

Yeah. In my dark cubicle, I almost got blinded when I first saw this pop up on three monitors. It's actually, it's pretty funny because once you go to the dark theme, you just get in that relaxed state. Once you go dark, you don't come back. Is it like this to you? When that screen came at me, it was like it was screaming at me. I was like, why are you yelling at me? We talked about my love for the Visual Studio dark theme

back when we were talking about IntelliJ one time before. That theme is awesome. Once you go to the dark side, you're there. It's fantastic. I came back, man. Especially if you already work in a dark area. You don't want that bright white screen straining your eyes. So the dark screen is great.

Why don't they print books on black paper? It would be expensive. But the book isn't lighting up the room. You would have to ink the rest of the page. That would be expensive. But the book isn't lighting up the room, though. to ink the rest of the page that would be expensive but the book isn't lighting up the room though yeah that's a good point burning my eyeballs yeah yeah so uh that was one um i mean i got a suntan from the first time it opened up and there's so much uv it was just like now the the next thing that that killed me and i don't know how you solve this but dude there were pop-up windows all over the place

like if you click something you would see some extra additional pop-ups and they would just randomly it felt like show up somewhere in this goes back to like when joe was clicking on rules and like code was suddenly popping up like wait a minute did i just did i just break something did i just like hack this thing? What happened? Why is it suddenly showing me the code? I will say this. The counter to that is you can dock those windows, which is cool.

I ended up doing that, but that brings me to my next point of this. There's so much information on there that if you're using independ you need more than one monitor well hold on okay well wait before we go before we go off that window a moment though because like one thing that i did find frustrating is that um i'm probably in a small minority of people that because even microsoft doesn't seem to if they're listening test this feature properly that they've supported in their operating system for God knows how long. But I like to have the taskbar at the top.

Not everybody likes it in the default bottom of the monitor position. Are you talking about Windows taskbar? Yes. Why would you do that? Oh, man. No. Because. That's your fault.

You have to live with the consequences. No. It's just awesome. It's just, that's, I like that. That's how I like it. All right.

And even Microsoft has had this position and I've noticed that like sometimes with the independent Windows and I don't know if it's independent that's deciding

where to lay the window out or if it's just the, you know, Windows that's telling it where to lay the window out. But even with, but I'm trying i'm

saying that even with just basic windows applications i've seen this problem too where it doesn't it doesn't account for someone having the taskbar in any other position other than the bottom and so it's like oh well let's just go to zero zero right and it throws a window up there or somewhere where it's below the taskbar to where now when you want to move it, if it's an application, then maybe you could just alt space to bring up the context menu to get to the move option.

But in some of these dockable windows within Studio, I haven't found a way to get to those like that and you're like, oh my god, it's stuck. How do I move this window yeah i'm like well it's in my way i was willing to let the dark theme go but this is too much yeah i say you move that taskbar back

down to the bottom you know what i would gladly trade i'll take the dark theme over you know lay the windows wherever i don't care outlaw just likes to cause problems for other companies oh yeah thus his name so um so what was the other one i had on here oh this one drove me crazy and this is not just independent this is anybody who has a grid that they put in a window if you double click that little divider bar in the column header at the top it should expand that thing to fit the contents and i did that a couple of times because that's what i'm used to doing and it shrinks it down to nothing i i about lost my mind so i have never written where where did you run into that like you know if you're that's

weird i think you're like really nitpicking now. No, no, that's not nitpicking. We've gone beyond color. You know, like if... I want to double-click stuff and it get big. No, man. If you go to the expander of a column, typically if you double-click it... Oh, I know the use case shit you're describing.

I just didn't see that anywhere within... You didn't try it. I guess not. Go do it on any one of them. It shrinks down to nothing. And then you have to expand it a lot. I'll have to go looking to find one. So that killed me.

I want quick stuff mega big. Yes, that's right. That's exactly what I want. What was it? Oh, here was another one. I don't remember which report this was on, but on most of the things, as we mentioned earlier, the interface is really helpful.

As you mouse over things, it updates little information windows all over the place. It might update two or three. There was one that you could actually highlight a row. You could click a row, and I wanted it to lock in that information but if i tried to mouse away from the row if i accidentally moused over another row then it would update the information in those pop-up windows and that was kind of frustrating because i highlighted the row that i wanted the information for and if i moved the mouse and it would try and update them anyway oh you gotta mouse fast

that's what no you gotta mouse perfectly horizontal no no no you don't no you don't no you don't you just gotta you just got a mouse fast oh so i had to speed mouse across it no i mean it's not like when i say fast i mean like you can see uh okay so for example i'm looking at the dependency matrix right and if i highlight where i was if i if i highlight an intersection and you can see like if if you're you're the speed of your mouse is moving uh fast enough to where it continues showing you the highlights versus if you're not like so for example there's a show info window when once you get to an intersection and then at that intersection it'll show you uh things about that like what methods of the namespace uh are you are the reason for the intersection right and if you want to get to that if you just

mouse to it quick it doesn't have to be a perfect horizontal line to get to it you just don't take your time well my whole thing is it's not it's not an unreasonable speed that you got to do it no but but if you click a row wouldn't you say that generally speaking that's the row that you want the information for well okay i'm not yeah yeah okay all right so that that was a nitpick i mean again this is not a show this is not a deal breaker just you know some of the things that if they're listening that'd be awesome to check out so far we got a little bit of learning curve and some UI issues. Michael? Yeah, so I wasn't crazy about the way you had to install it, though.

I really wish it was a little bit more seamless because you have to download the zip file and then unpack it, find some place that you decide you want to put it, and then run an installer on top of that to add it in. I really wish that it was a little bit more seamless in the msi but i like that it doesn't stick stuff in the registry i'm not big on the

whole windows kind of install that part i'm fine with i'm fine i'm fine with that it didn't require like you know well uh i'm fine that the bulk of it was self-contained let's put it that way right um i i just wish that had been a little bit uh you know that the installer wasn't so manual such a manual process right right so yeah i mean that seems like easily done but i think maybe maybe my least favorite feature like the thing that I wish would change the most was that I didn't like that my solution file actually had to change in order to incorporate independent. So if I wanted to see the reports from this,

I had to attach it to the solution in order to see that. And as part of that, like it's actually making a change to the solution, which for your environment, that might not be such a big deal, but maybe... Okay, so as an example, Joe, you ran this on multiple open source projects, right? Right. You wouldn't want to commit that back up, right? Because then whoever's looking at that pull request might go, well, wait a minute.

I don't have independent. Why are you introducing some new tool that, like, who knows what plugins people are going to have? You can't assume that they're going to have a plugin. Right. It shouldn't break anything, but it is weird to be checking that sort of stuff in, or like a work situation or something, you know?

Right. And that's what I mean by is it is it it's not necessarily that i'm worried that it's going to break something just it felt weird that it was it was a required step and i just i'm sure that there's a good reason why it's doing that i don't know what that reason is but i i just wish that it could wish there was a way like if there was any one request that i would have for that team it would be figure out a way to make to make this thing not have to modify any of the project or solution well it's only modifying the solution but you know i would agree with that so um and uh there was one other gotcha though that I ran into and you guys didn't seem to

run into this one because you'd already, uh, I suppose you already had it, but like if you didn't want older versions of.net on your system, um, when I went to, um, go through this all,

or I actually had a pop up where, you know, a message where I had to install the older, uh, .net three,5 for backwards compatibility. It was required. I mean, you guys didn't run into that, but that was one thing I was like, well, that's a shame because what if I just don't want that?

Why should I be required to install a version of the framework that I don't want? And I wasn't sure if that was because maybe there's some, like I said, this is a 10 year old project. So I wasn't sure if maybe there's some parts of the project that, you know, we're still built on that or something. I don't know.

I think cause I have 20 different versions of visual studio that covered it. One of those took care of it. Yeah. I'm pretty certain. Yeah. So, so some of those things that I mentioned, you know, I mean, yeah, they're in the bad,

but they're also, like, features I'd like to see changed or added. Yeah, so just to recap real quick, so as far as good type stuff, we really like the graphs, we really like the interactivity, we really like some of the rules and the ability to use this stuff over time. Stuff we're not so crazy about is the learning curve and kind of information overload, some of the UI issues, and just like the install, actual integration with the projects we're not crazy about.

But also in the light, we really like what it gives you right absolutely what it does for you in terms of your project and your code base i mean it above and beyond all the features what it actually drives you to doing is pretty awesome so uh you know along the topic going along the lines of you know features we'd like to see in it. One feature that I thought would be nice that I'd like to see is if, let's run through this scenario where I'm a developer in a team and maybe I have my own copy of Indipend. I would like for those reports to be in a more shareable format. Right now, yeah, I could run the dashboard inside of Visual Studio and I could see that. But the closest thing that I have to something that I could share

with my manager would be if I take the zip, if I zip up the HTML files and say, yeah, here you go and look at that. And hopefully he'll understand what needs to be done and be able to see that correctly. But I wish that there was

a more easily shareable version of that report. a pdf that'd be one option sure a series of tweets um that might not be the option i was thinking of maybe maybe some like you know instagrams of like hey here's the picture of this report here's a picture no i'm just kidding yeah although that would be an option for you or maybe a Pinterest for all your... I almost wonder if that build version of this wouldn't solve some of that, you know, because it builds those HTML files for you. But again, the scenario that I'm describing, though, is like,

let's picture that you are in a team of, you know, you're bringing your own tools with you. So, like, maybe you have your own copy of Independent. Maybe you have your own copy of ReSharper. And these are tools that you've grown to depend on, no pun intended that, that, uh, you want to continue to use, right. Even, even, uh, you know, when you are at work. So, you know, you're the only person on your team that has that. And you want to be able to create this report so that you can give to your manager and say like here's things that we should look into and i can back it up with fact and here's the reason right so fair enough that's something i'd like to see change uh oh and another thing that i thought

would be nice to see was that um and you know this might be one grasping for you know more but uh if you had the ability to do analysis on more than just your.NET code, so maybe if you were in a web-based project, if it could do analysis on your HTML and JavaScript, maybe your CSS. Who cares about CSS, really, though? Okay, fine. Fine. CSS, too.

I was trying to bring in some sort of JSLint or CSSLint information and incorporate that somehow. It'd be nice. Yeah. I mean, however it got done. Yeah. Also, kind of in the same vein as you're talking about reports being more shareable, I thought it would be really cool to have some sort of GitHub integration. I know there's all sorts of GitHub plugins now,

so you can go to a project and see latest build, code coverage, build status green, that sort of stuff. I thought it would be cool to show some of my stats if I could, even if it was just a little plug-in that read an XML file or something that I had inside the project. I don't really know how that works, but I thought it would be cool to kind of show, like, you know, one of those graphs on my actual GitHub page.

I thought that would be really neat. And also, I actually emailed Patrick about this. I read a white paper from Google. I've been thinking a lot about, lot about metrics-based refactoring, and this is the perfect kind of tool for that. But one thing I read from there is they're talking about how you can find the worst parts of your code, the parts that need the most refactoring,

by looking at source code history of bug fixes. And so if you see the top 10% of your bug fix files, then that's where your biggest problems are and so i thought it'd be cool to see something like that if if this product could integrate with source code i know that's a whole lot of work and there's a bunch of different source control vendors and i don't really know how well that would work but i thought it'd be cool to see something like that so that was my idea cool so the big question who would you recommend this to so go ahead well for me i i see the most value in the sort of trends over time so if you have got

those kind of craftsman type people if you've got a big messy project that you're having problems with or you just like to keep your stuff clean then i see this as a definite win so especially the build build but i'll see that stuff over time and see am i getting better am i getting worse and i think it's just really valuable so if you're that kind of person who's got that kind of itch and who really wants to see those numbers getting better then this is a great tool for you yeah i, personally, I think that there's a couple places where I could see this. If you're working on either a large code base, whether it's legacy or new or whatever it is, if you're working on that and you want to get it to a point

to where it's maintainable and you can make edits to it without spending weeks and months trying to do that kind of thing, I think this could be an invaluable tool because as you go, you make make your improvements it's snapshotting you see your trends of how things are improving and hopefully in the future things would go a little bit easier also i i would see this tool um fairly much for a management type position maybe the build one if you can integrate it into a CI pipeline for having a manager be able to start basing his estimates off the kind of stuff going on. If you know that your developers

are going to go into a certain section of the code and it is notoriously nasty reported on in there, then you can kind of know that, you know, these time estimates are going to take a little bit longer. And then the last one I would say is if you are somebody that likes working on open source projects and you really want to show that you're a stud, this might not be a bad way to get your foot in the door doing some cool stuff. I mean, this is kind of thinking outside the box, but you get a hold of some open source projects that have some glaring deficiencies

and you go in there and you clean them up because you kind of have, you know, a little, just don't check in the modified solution. Don't check in the modified solution, but you have a bit of an advantage, right? Cause you see these things a little bit easier than somebody else would. So you could go in and really help out a project by doing something like that. So I can definitely see this tool being useful in more than a few situations. And as somebody who just wants to be a code craftsman, this can really help you out. I definitely see it in that same light, too. If you're the type that does care about trying to improve your own craft, this can definitely help you there. And find places of inspiration that, oh, here's something that I should go and update.

This is too complex or this is too big or whatever the reason might be, whatever the rule that it's violating might be, then this can definitely help you find that and then go and clean that up. But as you mentioned, you stole my thunder because the one that I was really thinking about, but this is pure conjecture on my part because I haven't seen how the build server version works, but that's the one are being generated in that HTML that we mentioned was automatically being shared on some public server where, you know, developers and QA and managers and like could, could see that and be able to easily comment on it and discuss it. Then you, I see that as a huge value for the team, not only, but that,

but, you know, as well as being able to view all the trending across that as well. That would be huge in terms of collaboration, that being able to be a discussion point among your team. But I say that, though, because keep in mind, at the price per developer seat, you're talking about like 400 bones. Yeah, it's not cheap. I mean, it's an investment. And I don't know what the upgrade path is for it. I didn't see that anywhere.

But... You know, I was just thinking what would make me most likely to buy this if I didn't already have it, if I had to go buy it right now. And I was thinking if I was working with a crappy team or maybe a few crappy people that I don't really know how to say it, it's like, hey, you know what? Maybe I can go get this tool, hook it up to the build server or just kind of run it on my own and be able to say in some sort of meeting like,

hey, guys, check it out. We're making this piece of crap even worse. Maybe we could take a look at some of these specific rules and talk about it again next week and just kind of use that as a nice way of kind of improving the quality of your and everyone else's life. Yeah, I mean, I kind of see this as one of those tools and I think we can all agree that we'd recommend this, right? I mean, I don't know that it works for every situation,

but from the functionality we've seen, it's a very nice set of features. The only thing I can say is, like, typically when you're looking at this kind of price of tools, it's generally used more in large businesses where they're maintaining large code bases right so i i would think as a manager if this is if you are if you care about technical debt then this is probably something you should look into yeah well if you think about how many hours like how many developer hours does it take to hit 500 bucks you know it's not that much so if you can save a couple days every year then you're doing great right well are you talking about like on a per developer seat or are you talking about there for the build

server i'm still thinking build that's probably how i think about it maybe that's wrong but so so if for one build server we're talking about 603 dollars at the moment based on current yeah uh so if you've got a team of 10 developers euro to us dollar yeah you save a half hour each over a course of a year then you've you know you've more than made your money back i'm sure you're going to save much more than that yeah and even at the developer seat i mean you could probably argue that having the developers have instant access to that through a developer tool set visual studio might save you more than the cost of it. Oh, yeah. I'm not arguing that. I'm just saying that you'd have

to weigh it based on the size of your team, size of your project. Which one do you think is going to be the better spent money for you per developer seat or per build machine? Again, it's not cheap, but most tools aren't.

But I love the fact that there was the option for that, though. Yeah, it is nice. So I thought that was a great feature. Oh, hold up. I was completely wrong. So check it out. Updates with a version are free as a support context. No, there's...

Within a version. I'm sorry. It doesn't have the upgrade. Yeah, there's totally an upgrade. So, like, you know, if you wanted to upgrade the license, you can get a quote for it, but it's going to be based on whatever you previously had. Right. And then see how that goes.

Yeah. So that's all that part. That pretty much wraps that up, but let's get into the resources we like. So as Joe mentioned, one of the major drawbacks was there is a lot, a lot of information to take in that you can easily be overwhelmed with. And here comes Pluralsight to the rescue once again. Believe it or not, there is a Pluralsight training course on Indepen. You know, it's almost like these are just the tools of the trade like if you're going to be a dot-end developer you got to have resharper you got to have plural site

and um you know maybe independent is good for you too yeah i i when when i found that and there i was like oh my god plural site are you kidding me if you've thought about it you've got everything plural site it's like you knew what I wanted, and boom, there it is. You're like the Google of learning. That's awesome. And also, I want to mention, I'm going to have a blog post coming up here. I actually went and I mentioned this a few times. I went and compared some high-profile open-source projects like Entity Framework and SignalR.

And so I've got a spreadsheet that you can see in tables. I'm going to talk about some of the differences. Of course, you can't really compare projects. It doesn't make sense. It really makes more sense to track yours over time, but it's still cool to see. Hold on now. The last time somebody pre-discussed their blog entry,

Pascal Coder had some words. You've got to be careful about that. The link one is still in the word. I'm typing a word a week. I'm just saying. I'm just saying. I already got this as a draft. It's cocked and ready.

Yeah, right. Okay. Me too. Okay. All right. So let's get into the tips of the week. All right. And I'm first up here. So there's a bookmark that I used years ago, and I recently have been working on a big HTML form and need it again.

And it's wonderful. It's called form auto-fill, and there's a couple of them, but this is the one I think is easy to see. Just drag it from the page to your bookmarklet bar in, like, Chrome or whatever. Then if you're on a big form, you click it, and it fills text areas in with random stuff phone numbers get phone numbery type stuff emails get email look oh wait a minute so i thought i thought you were talking about like a chrome autofill type feature this is a garbage autofill this is like lipsum oram greeking but it's like real words i think it like takes a paragraph and kind of like puts

one word in each form field so it's nice about about that. So it doesn't do the Steve Ballmer, Ipsen... No, I don't know where it gets the text. It might get it from somewhere funny. I don't really know, but that would be pretty funny. But what I like about it is that because it does these real human-readable words, I can kind of go back to the form, hit refresh, and make sure that things kind of show up in the right order, and I didn't have to fill out these 17 fields by hand, so that's really nice. That is nice. I kind of feel like we we got to mention this for a moment real quick before we continue on the tips of the week since since i kind of i don't think we've discussed

this before but you know we've all heard about you we've all used various greeking uh type generators before you've seen it before the ipsum lorem blah blah blah blah you can't read it doesn't mean anything type generators where if you just want to block a text right so if you haven't already found it we'll include a link to this the bomber ipsum.com which is the steve bomber ipsum generator and it's fantastic because you could just generate some random text and it'll say stuff like linux is not in the public domain windows innovation windows phone microsoft word winning I've got my kids brainwashed. Woo! Google is not a real company. Programming being developers, developers, developers, developers, developers, developers, just like that 50 more times. It's hilarious. So I highly recommend that for your next project

where you just want some random text in there. Beautiful. in that for your next uh your next project where you just want some random text in there beautiful all right so uh i actually had one tip of the week and it grew so uh real quick again disable get in visual studio 2013 if you see that it's killing you the one that i was initially going to do and i'll still do is called con emu and i believe it stands for console emulator and it's like a replacement for your dos command so it's not windows powershell but allows you to maximize your window and do like tabbed consoles which i find very useful for doing like you know various different command prompt type stuff so that's one i'll have a link in the show notes. And then the other one, and this only came up because Joe talked about his meetup with SQL and XML.

And have you ever run into a situation where you had a text field coming from a database query, and it would cut off the characters because it'll only return so much in the grid? Or even if you try to do it to text, it'll still cut off the characters. And so then you're like well how am i going to get all this out of here i just want to run this query and get the data back out so i can see what's in there right a way that you can cheat it in sql server management studio is you can cast that field as xml it'll turn it into a clickable field in the grid and then it'll open it up and you'll get all the text so i love that i i so love that feature i just used it the other day so yeah if you ever need to get all the contents out of a

data field and it keeps truncating it cast it as an xml you can't just like make your column wider to the right that's what i do i just click the line. Yeah, just double-click it, and then it all expands. And it cuts off after so many hundreds of characters. Then you can see it all. Yeah, and I've even tried to go into the options in SQL Server Management Studio and max out that. It won't do it. So cast it as XML, you're good to go.

You can click that cell, and it'll open up in a new window, and you can get all the content. So maybe this is another one where Microsoft 2 isn't honoring when you double-click it, it's not getting big enough. No, theirs does. Theirs does. It works properly. Well, apparently it doesn't get all the content. So maybe this is another one where Microsoft 2 isn't honoring when you double click it, it's not getting big enough. No, theirs does. It works properly. Well, apparently it doesn't get too big enough. It's limited. They truncate the cell though. Right, so

I was just saying, maybe they need to fix that. But their double click cell column thing works the way it should. Did you already mention, we talked about it about our disdain for the Git plugins you already mentioned that one too yeah i did yeah um sorry i was in my uh steve ballmer ipsum generator appreciate that well you know developers developers developers so uh here here was an awesome little

tip i didn't even know this existed and i just you know happily stumbled upon it But did you know in Chrome, if you are like me, you have multiple tabs open, you can pick multiple tabs in a single time and move them. So if you wanted to rearrange the order of your tabs, or maybe you want to take five tabs and move them into their own separate window, here's what you do. You hold shift, you click on the tabs that you want to move, and you'll see them start to line light up. And then you can move those tabs and you can either move them into their own separate window or you can move them into rearrange them in the tabs. But the tabs that you haven't selected are going to be kind of grayed out. And these other ones are going to be brought to the forefront. They're going to be highlighted and you can move multiple tabs at one time to add to your tip you can use control as well so if you

don't want if you don't want things that are right next to each other you can choose you can control click and get them if they're separated and then if you move them it slides them together oh yeah true sorry that's beautiful That's beautiful. Yeah. Beautiful. I didn't even realize that was there and I just happened to accidentally stumble across that when I pressed the button and I'm like, what just happened? How did I move those two tabs at the same time? Yeah, that's

awesome. Black voodoo magic. Beautiful. Alright. So with that, we'll be putting the links and the show notes up on codingblocks.net slash episode 15. Subscribe to us on iTunes, Stitcher, or more using your favorite podcast app. And please be sure to give us a review on iTunes and Stitcher. And visit us at codingblocks.net where you can find the show notes, examples, discussions, and more.

And visit us at codingblobox.net where you can find us. Somebody wasn't paying attention. We just had to nudge him to wake him up. How do you guys listen to us? I don't know. So send us your feedback, your questions, and your

answer comments to comments at cuttingbox.net and follow us on Twitter because I'm starting to get a complex about it at Codingbox. I don't know, he really is. Like, we get retweeted, we get all this stuff, but nobody follows us. It's really crazy. It's like 60

If somebody's living alone. Complex has been initiated. Alright, that's it guys we'll be back soon with episode 15 well this was episode 15 or 16 or 17 that might get cut

who's not paying attention now I was awake it's 11 it's 11 10 almost