I’m writing this post from the Austin airport as I’m getting ready to head home after a very educational 4 days in Austin for VSLive 2015. I wanted to quickly write down a lot of key points from all of the sessions I attended. I figure writing about something is a good way to retain a lot of it. All of them were very interesting and everything was run very smoothly, overall a great event.
Workshop: ALM and DevOps with the Microsoft Stack
Presented by: Brain Randell
I started off the conference with a workshop presented by Microsoft MVP Brian Randell. We spent the majority of the session navigating around the new VS Online. Brian was able to stand up a new TF Build Server in the cloud in approximately 15 minutes, very impressive. There is something definitely appealing but having that manged in the cloud versus having everything on-premise, and I will definitely try to push for this in the future 🙂
- If you have an MSDN license, you can already be added as a free user in VS Online. This saves a lot of extra licensing fees from having to add a bunch of extra users, since I’m guessing 90% of your users will have MSDN subscriptions anyways.
- I believe Brian mentioned the use of a “Best Practices Analyzer” for VSO, but I cannot find a link at this time. (*Correction, this was for TFS, and is included in the TFS power tools, thanks Brian for the update)
- Stand up a new build server with redundant backups to 3 different geographical locations, all in 15 minutes.
As guessed, the easiest way to move from an existing TFS on-premises install, was to basically start from scratch in VSO. But, if you can’t do that, there are companies out there like OpsHub, that have a migration utility you can use. The utility is free for basic migrations, and has pricing for more complex migrations.
Overall, I enjoyed this session. Brian is a great speaker, and kept things very interesting, even though version control is not always the most interesting topic in the world. He did a fantastic job and was able to answer at least 15-20+ questions from the audience.
Keynote – The Future of Application Development – Visual Studio 2015 and .NET 2015
Presented by: Jay Schmelzer
- If I could take one thing away from this talk, it would be…… Lambda/LINQ expressions can be run in the immediate window in VS 2015! I have complained so much about the lack of this feature over the last few years. I think this will save me a lot of time. The alternative was writing throw away code just to break apart your LINQ queries and see the results.
- There is also another nice feature, along the same lines as the first one I talked about. The ability to step over a single line, and get a timed result from it. This was another scenario were I was always having to write throw away code with time span objects, just to see how long certain calls were taking. With VS 2015 this is all nicely shown to you, without the need to write any code, and the best part is, it doesn’t care if you sit there for 5 minutes in debug mode, it only records times for an actual call. Much easier to get an idea of how long things are taking in your code.
- Easier conditional debugging. Rather than having to switch your context while debugging, you can now use the inline conditional debugging editor to create conditional breakpoints. Plain and simple: less switching of your context = more writing code.
- Deploying .NET applications “side-by-side”, meaning the necessary libraries are bundled with your application. You can run as many .NET framework versions on your server as you want. No more in-place framework upgrades like 4 to 4.5. This is to support the ability to run .NET applications on non-windows machines, which is also very exciting.
- In-memory compilation with the new Rosyln compiler. This means you can make code changes, and simply refresh your pages to see the results. Everything is complied in memory, no more having to build new DLLs over and over when debugging and working with your code.
- Of course Azure was mentioned, and the ability to use Test Labs to quickly spin up new VMs for testing.
Lap Around Visual Studio 2015
Presented by: Robert Green
To be honest, I think Jay stole a lot of Robert’s thunder, with his keynote being right before this. But this session was still interesting.
- Application insights integration is made easier, with an option to enable it when creating a new project.
- Microsoft has added a lot of extra functionality that is included with ReSharper. The ability to easily remove unnecessary references and unused variables, just to name a couple. Although, it doesn’t appear to be as robust as what ReSharper currently offers, it does look like MS is moving in that direction, which makes perfect sense.
- Diagnostic window for monitoring code execution and memory consumption. This looks very helpful for troubleshooting performance issues with your application, easily right inside Visual Studio.
- A quick overview of some of the new C# 6 features. I’m particularly excited for the new null condition operator, which should cut down on unnecessary null checks. I won’t go into much detail here since the linked blog post does a much better job of explaining all the new features.
Coded UI Tests
Presented by: Donovan Brown
Donovan started off his talk by giving a few facts about himself. One was that he was the #12 air hockey player in the world, and I honestly thought he was kidding, but he was not. This dude will whoop anyone who tries to challenge him.
Anyways, this session was excellent, and I hope to apply it directly to my work. Donovan showed us how to quickly and easily create UI tests using the Microsoft Test Manager. He was able to quickly create a recording of his actions, and then showed us how to modify that recording, and add custom code to our tests. He also showed us how to use data bound variables, such as a list of user names, to quickly spin through multiple test cases. Even multiple browsers. I had previously used tools such as Selenium to do this, but the Microsoft Test Manager looks like it will do everything I need. I am hoping to incorporate some new UI tests with this when I get home. Unit tests are only half of the equation, and they won’t pick up things such as browser incompatibilities or JS errors, etc. So this is why I believe UI tests are also very important in gauging the overall health of your application.
This session helped me realize how quickly these test can be created with the recorder and easily customized with code.
Presented by: Adam Tuliper
This one was a completely packed house, understandably, and I had to stand the entire time. But it was worth it. Adam is a great presenter and this was very interesting and educational for everyone there. Some interesting notes:
- Good bye web.config files! And hello JSON configuration files. This one will take some getting used to. It’s not that I’m particularly fond of XML over JSON, but just used to it. Starting with ASP.NET 5, your projects will now have JSON files which have references to your nuget packages, and so on.
- Dependency injection is built right in. No need to wire up any 3rd party containers like Ninject, although you do still have the ability to use those if need be. It’s nice to see a DI container built right in, and hopefully this will encourage even more developers to embrace DI and the loose coupling that comes with it.
- Tag helpers. Another new syntax for your MVC views. An alternative to Razor. I was not 100% clear on the pros of using the new tag helpers, other than adding more VS support for things like CSS classes, and so forth. Things that were not included when using Razor syntax and defining your classes in anonymous objects for example. This will take a little more getting used to, since I’m so used to Razor currently, but I am hoping that it will be a change for the better/easier. (Update – Reply from Adam – “PS Tag helpers clean up views (can still use razor),allow better intellisense, plus you can write custom ones as well :)”)
Hack Proofing Your Web Applications
Presented by: Adam Tuliper
This was another full house presentation by Adam. Obviously with web applications being so prevalent now a days, security is a major concern.
Adam went through many common hacks such as SQL injection and XSS (cross site scripting). He then showed how to mitigate against those attacks in various ways.
Overall the presentation was great, but I felt like I knew about a lot of the more common attacks already, such as SQL injection. But I am sure there were several people that were not previously aware, and this was a major eye opener for them. Especially after Adam mentioned seeing these vulnerabilities in quite a few production websites. Bottom line, always sanitize user input, and use parametrized SQL queries. That will cover a lot of common scenarios, at least the easily mitigated ones.
Adam also mentioned using HTTPS on all your sites, even intranet sites, and the use of “Retail” mode in your machine.configs. This will prevent applications from being deployed with debug set true, and will disable any tracing. (Another common security issue he has seen in many production apps).
I think security needs to be at the forefront of web developer’s minds, and is something that can be easily overlooked if you’re not careful. I learned quite a bit about these hacks actually work, and it was a very informative session.
To Git or Not to Git for Enterprise Development
I did not know a lot about Git before attending this talk, and that was perfect. Ben and Edward started out at a really basic level, going through the differences between Git and TFS version control. Edward works for MS on the Visual studio team, specifically with Git integration in VS 2015, so he is about as good an expert as you could have for this session. I am very interested in starting to use Git (currently use SVN and TFS VC). It offers a lot of advantages, namely being distributed, so that it leaves a small footprint on your machine (depending on repository size), and also allows you to work offline. I tend to check in quite frequently with TFS VC currently. I was a little unclear on the differences between creating shelve sets using TFS VC, and just committing without pushing in Git. This was even asked as a question from the audience, but the answer escapes me now. There is a whole new set of terminology I’m going to have to adopt for Git.
Anyways, Ben was a funny guy who was not afraid to take shots at MS, in a funny/constructive way 🙂 He kind of represented the “layman” developer in this session, who was brand new to Git version control, mostly because Edward had so much experience with it.
One large obstacle, at least for the time being, is that VS 2015 Git integration does not support gated check ins. Edward did comment on this, and said that it would be supported at some point. I forget when. But for right now, that’s kind of a deal breaker for me. I can still use Git for personal development I suppose. From this InCycle Software post:
- Git in TFS has a few limitations, although Microsoft has indicated that they intend to address these limitations in the future:
- The built in TFS Code Review tool does not work with Git yet.
- You cannot use Gated Check-in builds with a Git repository.
I see myself moving towards Git, but maybe not in the super near future, at least not for non-personal use.
Load Testing ASP.NET and Web API with Visual Studio
Presented by: Ben Day
I had a little experience with web tests before, mainly availability tests in application insights, so this talk was not completely unfamiliar. Ben went through creating our use cases, creating tests around those, and finally adding load. Ben talked about one particular example with a client that had an application that would fail after 20 concurrent users were using it. After Ben came and profiled the application, and diagnosed the issue, that client was able to support up to 4,000 concurrent users. (Hint: close your database connections 🙂 ) . These types of test do support data binding from a data source , mainly XML files, but SQL server is a possibility, just not as elegant as you’d like. (cannot run custom queries, it’s “all or nothing” on a table).
Anyways, I think this type of test would be very beneficial to some apps I work on, however I would have to investigate how to do this type of load testing with concurrent Active Directory accounts. Overall, it was very easy to setup one machine to do your load testing, and depending on your needs there is support for setting up distributed load tests across multiple machines, or spinning up VMs in Azure to do it. (You’d just be charged for the computing time with Azure)
Automated Build, Test, and Deploy with TFS, ASP.NET, and SQL Server.
Presented by: Ben Day
This session was largely an overview of the ALM process with TFS, and using Sql Server Data Tools (SSDT) to version your database schema alongside your code. I was not familiar with SSDT before this, so I am interested in looking into this more. I had previously used RedGate’s SQL Server Version Control to accomplish this.
Ben really stressed the importance of automating your build and deployment, and he’s right. This can really save a lot of time, and let’s face it, anything that is manual has a higher risk of error.
We use Octopus Deploy for our deployment process, and I love it. With a little bit of PowerShell scripting, you can have your whole build automated end to end.
Overall message: Use SSDT to manage your database schema, alongside TFS build servers for your gated check ins, and use some sort of automated deployment. Octopus Deploy is one such system.
Overall VSLive was great, and I would recommend it to any other .NET developers looking to increase their knowledge base in a fun environment. There was a large selection of sessions (4 going on at any given time), and I felt like those sessions really covered a lot of different bases. From deep technical dives (micro services with an Amazon development manager, Rick Garibay), to creating UI tests, to hack proofing your apps, to learning about the new features of ASP.NET 5 and Visual Studio 2015, Angular, etc, it goes on and on.
I am already looking forward to coming back again.