DevIntersection - Day 4

It was another day filled with learning and sessions. We started the day talking about a topic that everyone needs to pay attention to, Security. Cyber security needs to be our number own priority and it can no longer be a perimeter security, we need to take security to the identity level. Almost all security breaches have come from credential leaks. There are so many tools that Microsoft, Google, and Facebook have created to help in the area of security. We should try to take advantage of what they have already built to help with our own security. We need to build security that both satisfies our IT departments, but also the customers/users. This may be hard at times, but is usually do-able. Microsoft has taken some great steps and is able to determine if you are able to paste from word into outlook based off the word document and the email address you will be sending from in outlook. If it is a work document in word, you will not be able to paste to a non-work email sending address. pretty neat stuff.

The next session I went to was called Application Debugging with IntelliTrace with John Guadagno. I will be honest, there weren't many notes that I took during this session. He did mention that his slides should be posted and that his speaker notes would be really helpful. Here are some notes that i did take. A few quick notes on IntelliTrace:

• Allows you to record events and method calls for your application. The black box for your application. See Key events and see what it is doing throughout the lifecycle. Will also keep values of variable and objects.
• Allows you to examine its state at different points in the execution.
• You don't have to have Visual Studio installed and can just have a collector on the machine to see what is going on

IntelliTrace can collect many different events. You can configure what to collect and save the environment to be used later or with certain projects. It can collect:

• Debugger Events - Value in local window, auto window, and data tips
• Exception - handled and unhandled
• .NET framework events
• Function name
• Values of primitive data types passed as parameters as function entry points and returned at function exit points
• Values of automatic properties when they are read or changed
• Pointers to first-level child objects, but not their values other than if they were null or not

The tool seemed to be really helpful if you don't have Visual Studio on a machine, but you need to see the steps that were taken to get a certain error. I could see this being useful when we have bugs on client computers but cannot reproduce the bug locally. Install the client and see the variables and steps that were taken on the clients computer. Now we just need the clients to allow us to install on their servers...

The next session I went to was Enabling DevOps in the Cloud with Steve Lange. It was great to see that most of what Steve talked about we already do at work. He mostly talked aboutt he tools that help get to DevOps, which were Microsoft tools as he works for Microsoft. He discussed using VSTS and all the tools available through VSTS. All of which we already use. I did learn about extension called the Test and Feedback extension that allows you to record the steps you take through a browser and enter a bug directly into VSTS. Pretty nice tool.

Steve also talked about Azure App Insights (can be used by non-Azure apps to get data and do analytics on the apps.

I then jumped around from The Intro to Xamarin and ASP.NET MVC - Development to Deployment. Neither one of these sessions provided any real new information. The Xamarin session was talking about how to load Xamarin onto the your computer, but wasn't about creating any apps.

I then went to ethe ASP .NET MVC class. This was maybe a mistake. I walked in and was a little lost on what her was talking about. there were pieces that I did know form working on our applications at work, but it seems I should have been in the session the entire time.

We finished the day with a key note on Angular 2. It was called Angular 2: Released, Greased, and Increased. This was a repeat of what I was told on Monday and Tuesday in the workshops. Really, the only new information was how come Google took the direction they did on Angular 2 and the performance benchmarks they used to increase the speed of Angular 2 (which is much faster then Angular 1)

Tomorrow is the last day. I hope the sessions are great and we get to end strong.

DevIntersection - Day 3

Today was the first day of the sessions at DevIntersection. It started with a keynote session by Scott Guthrie of Microsoft. The title of the talk was "Movile-first, Cloud-first Development." It was a good speech by Scott. I always feel the keynotes are more about a quick glance of what the speakers can do without much team to show you what was done. I guess it leaves questions and will have you go experiment more on your own. Microsoft is coming out with some great products and I will definitely look at more information on the Microsoft products.

Then the sessions began. The first session I attended was Understanding the Windows Desktop App Development Landscape by Brian Noyes. The first topic, the mortality of the different UI frameworks. The question when looking at the frameworks that we need to ask is, what do we consider dead vs. matured. The different frameworks may be at different stages in their lives. The frameworks we currently have:

• Windows Forms - Many will think that windows forms are dead. There are many projects that are built on Windows Forms and should not just be dropped due to thinking Windows Forms are dead, just mature. Forms are just mature. However, Brian would not start a new project using Windows Forms.
• Silverlight - This also not dead...yet. The browsers are the ones that are killing Silverlight. It is not yet yet, but it is in the trauma unit on life support. Definitely do not start a new project using Silverlight.
• Windows Phone - Bloodied on the battlefield. Survival: questionable. Only time will tell.
• WPF, UWP, Xamarin, Single Page apps are all alive and well.

WPF is mature, it has been around for almost a decade. In computer time this should be gone. However, it still lives on and probably will for a long time to come. There are many features WPF that are great. Some of them:

• Data binding validation
• Implicit Data Templates
• Dynamic Resources
• Custom MarkupExtensions 
• Multi-Bindings
• and more!

UWP allows you to develop for many different platforms, like the desktop, mobile, and XBox. Great for touch, pen, or keyboard/mouse. UWP provides a better app security and provides isolation from other apps on a computer. You are able to sell these apps in the Windows Store. Great features available such as:

• Cortana integration
• Low power consumption
• Ability to move apps into UWP using wrappers

Xamarin is a great crossplatform tool using C#. You can write an app and share it across platforms including iOS and Android. The logic code can be reused across platforms and only UI will have to be written for each platform you would like to include for your app. Finally! Windows can develop for iOS (although to develop for iOS you still are required to have an Apple computer).

Single Page apps are cross platform are well. All they require is a browser. This can be written in HTML, CSS, or Javascript (hey! My workshops were about typescript and Angular 2 which compile into JavaScript!). The single page apps can use the same architectural patterns as a well designed XAML desktop app, just using different syntax. With a responsive design you can create an app that will work on desktop and on mobile web browsers beautifully, or at least sufficiently.

The next session I attended was How to Be a Good Community Member by Contributing to OSS with Brian Clark. Apparently, I like the sessions by the Brians. Throughout college I was involved in the community and did many hours of community service. Open source allows companies to use their products/frameworks for free. Why would anyone want to do this? They probably build something they needed to solve a problem and sent it out into the world for consumption. Should companies pay to use open source? Maybe the payment should come in the form of allowing employees to contribute on work time (my own thought, not own that Brian brought up).

Well there wasn't much I didn't already know or think in this session. It actually was a shorter session and we got out a little early. I think the main take-away from this session was the resources for doing your first contribution to Open Source. Below are some resources shared:

• github.com/code52 - starts a one week project that is easy to jump into at any point
• upforgrabs.net -
• firsttimersonly.com - aggregate certain projects
• yourfirstpr.github.io
• issuehub.io - allows you to focus on the language you are looking for
• github.com/mungell/awesome-for-beginners

Things to think about before starting on an Open Source project: the process for the project, the rules, what are the guidelines of the project, is there a code of conduce, can you run the project locally, is it in a language you are familiar (maybe you don't want to stretch on your first pull request), and more.

Really, think about the project and find one that fits for you to contribute. Communicate with the team and make sure they know who you are and what you are doing. And, start simple to get your name out there to allow people to see you can be trusted and you do work well with others.

My third session was Create an Angular 2 app from Scratch with Dan Wahlin and John Papa. I probably should have skipped this session. It was much like the workshop I did on Tuesday. I hoped that they would start from a blank sheet and add everything we needed. Well, they started with a project that already had the needed files for an Angular 2 app to start working. In fact, they already had a page, Hello World that would pull up. I stayed to see if any new information would be given. There was no new information and I was disappointed. Still Dan and John did a good job.

The final session I went to was Automatic UI generation in .NET by Mark Miller. Mark is a great presenter and had a lot of, shall we say, love for UI. There was a lot of code that Mark had done before the session. He then went through what the code he put in before did, and showed the code a little bit. The dynamic response of the UI is pretty cool and what showed was dependent on what you clicked and the properties on the UI. It was nice to see, I just wish he would have gone more into the code of how to build the responsive UI. 

Onto the sessions for tomorrow. I hope I pick a good set of sessions.

DevIntersection in Las Vegas - TypeScipt, ES6, and Angular 2

Last year I started my Twitter account while I was at Visual Studio Live! in Orlando. I blogged at the end of each day. I meant to do that this year while I have been at DevIntersection in Las Vegas this year. We got to Vegas yesterday for the pre-session workshops and will be here until Friday. There is a little different feel in the Las Vegas vs Orlando environment, but I am not here for the city, I am here for the conference.

Day 1:

Yesterday I went to a session called Making the Jump to ES6 and TypeScript with Dan Wahlin and John Papa. I thought this was an ambitious decision as everything I have done has been done in C#. I was afraid that I would not be able to keep up or understand what was being said. I was in for a pleasant surprise! I was very surprised at how close ES2015 and TypeScript have many features that are very similar to C#.

First, John and Dan talked about the tsconfig.json file and how you can set sourceMap to true in order to enable debugging in TypeScript. How do you get TypeScript to work? You transpile TypeScript to JavaScript or ES. You want to use ES2015? Transpile your TypeScript to ES2015 and you have ES2015 version of your code. I guess the good news is, that if TypeScript is ever not supported, you just transpile it to ES2015, or ES5, or even ES3 if you wanted.

We then started talking about ES 2015 and some of the features now available. These are not all the functions available but the main ones that were covered. I understood most of these. Maps/Sets are like dictionary pairs you can use so that you no longer have to use arrays and splice and slice the arrays. Maps store a collection of key/value pairs with unique keys. Sets can store a collection of items where the items must be unique.

What about those classes? HEY! I use those all the time in C#. There are some that probably don't like this, but it sure helps me understand what is going on in TypeScript. And those Arrow Functions look real familiar! A few weeks ago (maybe two months, who knows) I learned about LINQ  statements and Lambda funcitons. The Arrow functions look close to the same as LINQ statements

Other features we talked about template strings (embed a variable in a string literal), destructuring (create multiple variables, along with their values, in one line of code), default parameters, and rest parameters. All look close to stuff I have done in C#.

We then went to a TypeScript playground at http://www.typescriptlang.org/play/index.html which allows you to type TypeScript and immediately get the JavaScript equivalent back. We then went into types in TypeScript. For example, you can now go:

var age: number = 5;

This will set a new variable age of type number with a default value of 5. Very similar to how variables can be set in C#.You can also used inferred types, where the variable will either be a type any or the actual type if TypeScript is able to infer what the type should be. You can do Enums, again similar to C#.

The next piece I liked talking about where the classes. They  classes look just as they do in C#. Helpful for me!

One piece I really liked in the auto generated properties. These are a little different then auto properties in C#. For TypeScript you create the auto generated property in the constructor. An example:

class CoolCode {

  constructor(public greeting: string)
   {
      this.greeting = greeting;
   }
}

This creates the property greeting in the class CoolCode and also has the value of a string in the constructor called greeting. You can also create gets and sets on properties. This is almost the same as  and auto property in C#. Here is an example in TypeScript:

class Address {
  _houseNumber: string = 0;

  get houseNumber() {
     return this._houseNumber
  }

  set houseNumber(houseNumber: number) {
    this._houseNumber = houseNumber;
  }
}

You can now do class inheritance and interfaces just as you can with C#. In order to use inheritance you need to use the keyword extends. For interfaces you have to have a class with the key word interface and then your class that is implementing the interface will do something like:

interface KillerGame() {}

class AwesomeGame implements KillerGame{}

Other things that are similar to C#:

• Generics are now available
• You can know use namespaces - if you use modules do you still need namespaces?

Day 2:

Today I went to Building Single Page Applications with Angular 2, again by Dan Wahlin and John Papa. The discussion started with the differences between Angular 1 and Angular 2. Since I have never used Angular 1 I did not have any reference. They then touched on what we had gone over the first day in the TypeScript and ES6 workshop.

There was not much more added from what we learned in day 1. We used a tool called Plunker (in order to avoid having to get the correct setup on all the machines in the room) to enter TypeScript and use Angular 2. What was added to our knowledge for Angular 2:

• How to build components - importing and exporting
• Creating and using templates
• Angular Modules
• Binding and Directives
• Services and Dependency Injection
• HTTP and ReactJS
• Routing

Ok, I type it out and it is a little more then I thought. This post is getting really long already, maybe I will have to write another post after I have been able to research them a little more. The workshop today was nice, but they moved so quick that I would like to understand them a little better.

We went through many examples using TypeScript from the day before to create/change single page websites. Of course, we started with Hello World and went from there. I learned today that Dan and John went pretty fast while editing the code and a few times I fell behind getting to a state where my pages weren't working. Luckily, they would save their Plunker and I was able to get to a good state before we moved on too much.

In addition to examples from examples using TypeScript from the day before, I got to learn a little HTML. I did HTML years ago in a college course but nothing big. It was nice for a little refresher.

We were pointed to a tutorial on angular.io that will help getting more familiar with Angular 2.