Development
Day 3 and 4 of PDC were filled with more of the same as the first two days. The cloud, silverlight and parallel programming dominated the sessions. I managed to attend a session on SharePoint that was very good for me. It was a basic level class showing how to add silverlight to a SharePoint webpart. So what is my take away from PDC? I would hope that we decide to use these technologies sooner than later. We have, in the past, not jumped at using new things. We must break this thought process and move forward to keep our applications up to date with what the industry is doing. I took away a good idea of what is coming and what is already here for us to use. I also realized how much there is learn. Then I realized that there is so little time in each day to learn it all. Guess that is just part of life! My outlook for future development using Microsoft technologies is bright, if we actually use them at work. |
|||
Day 2 was very interesting. There was two keynotes addresses in the morning, which I must say seemed to drag on for quite some time, but that is because they showed off Windows 7. It was impressive, but showing this at a developer conference might not be the right time to do it. The best parts of the keynote were the few companies that showed off how they are using the new features of windows and silverlight. The last keynote of the day was actually a programming demo to show off how making calls to the cloud or local services was little more than just a few minor changes to the URI. I thought it was good that the calls will be consistent and easily repeatable no matter where your services are located. Moving into session, I managed to hit a session on Silverlight and business uses. This session had some very good information on what is coming. But again I failed to see when my company is going to be able to use this. Without coming up with a Roadmap internally to guide us in the right direction pending releases of products from Microsoft, we really are going to fumble around and most likely never use newer technologies. At least not until they are considered old technologies. After sessions were over, the group of people I came to the conference with went to the attendee party at Universal Studios. That is the most fun I have had in a long time. I have to plan a trip with my family very soon to let them experience how much fun it is. The nice part about any attendee party like this is the free beer and food. One event made me laugh very hard. We were at the Waterworld attraction and we sat very close to the water. A co-worker of mine was sitting sort of behind me and back a row of seats. At one point they had a bunch of explosions going on and a water cannon shot directly at us. I managed to run to the left and avoid most of the splash, but this poor guy took the entire brunt of the splash. (Sorry Jim, I had to mention it) Needless to say he was freezing until we got back to the hotel. |
|||
This is a review of the new features of Team Foundation Server 2010. I am not going to step by step blog this. I will however try to post a summary of what is going on, but I will more than likely end up with brain drain by the end. It may not be worth posting an update. --------- This session wasn't very good. It had some interesting new features for TFS, but overall lacked in character. It was a dull drone of what will be coming and showing off some of these features. Of note, the new build features allow for customization and workflow on builds. This will be interesting to see in action once my company migrates to TFS 2010, which will not be any time soon. It does however look as if they put quite a bit of work into the product to make life easier for developers, just wish we could plan to use it when the product releases. |
|||
The room is pretty crowded for this session. Didn't expect this many people to be interested in the future of C#. I am hoping the information is worth the attendance. --------- Anders Hejlsberg is running the session. He is a technical fellow at Microsoft. --------- He is going into the detail of the history of C#. It was a very brief walk down memory lane. --------- C# 4.0 is the discussion. Trends inlcude Declarative, Dynamic, Concurrent. The future has to think very hard and make sure that we consider concurrency. Declarative programming is about the how. We tend to over specify the solution to the problem. Using LINQ gives us a mechanism to move away from the bad of not being able to optimize underlying code, such as group by and order by. The reality of Dynamic v. Static is that both are useful. Both types of languages are borrowing from each other. Concurrency is becoming important because of the single core hardware isn't going to get any faster. We have to think about writing our applications this way, which there are many ways to think about how to accomplish this. He is making reference to the Parallels framework and how good this framework is going to be. --------- Co-Evolution, discussion the movement of VB and C# to grow up and not fight each other. This is the right approach to move both in the same direction. That way it doesn't matter what language you use. This doesn't mean they will be exactly the same, such as syntax. It will mean features in one will more than likely be done in the other. --------- C# 4.0, the main theme is Dynamic Programming. The idea is to be able to talk to anything out there that isn't tied directly to types. C# and VB will be adding dynamic support for their languages. This is much like IronPython and IronRuby. He is going into some code samples on how Dynamically Typed Objects will work.... Introduction to the new "dynamic" type which will allow the lanauge to dynamically determine the invoke required to call out to functionality. This moves all resolution of type from compile-time to run-time. We are moving into some demos on this.... Demo #1 was showing how you can call JavaScript from C# very easily. Very impressive demo.... Demo #2 was showing how you can use IronPython from C#. The demo showed how you get the native capabilities of the language you are targeting with dynamic. --------- IDynamicObject is the interface that you use to allow dynamics to work. We are doing another demo on this interface.... --------- Optional and Named Parameters - Default parameters values are now supported. No more overloading for all variations on methods. Named arguements also allow to specify one parameter without specifing the rest. These parameters must follow all other params. They can also be done out of order. Usage is NAME: VALUE. --------- Vastly improved COM interoperability is coming in C# 4.0. Many things to look at here. I will need to review this once the DVD of the sessions is handed out in a few months. We are doing a demo on this.... This all really cleans up the code when doing COM interop. This will be very useful with all the COM solutions at work. --------- Co-variant is dangerous when you move to the base type object. For instance going from string[] to object[], you can try to put a none string into the object[] which will cause an exception. New generics will allow the option to set the type T to co-variant or contra-variant. This is done by using the for co-variant and for contra-variant. Variance is restricted to interface and delegate types. Value types are always invariant. ref and out parameters need invariant type. --------- Sneak peek of things to come beyond C# 4.0 - Meta programming. The C# compiler will be rewritten in managed code. They are going to open up the compiler so that developers can take advantage putting C# into many areas such as workflows and allow for small compiles. Microsoft has been working on this for about a year now. We are doing a demo on this.... The compiler will be a service and have an API that we can use. I have to say there is much that we can potentially do with the new features coming in the future for C#. I look forward to getting my hands on some early releases. --------- |
|||
PDC has officially kicked off. It looks like Microsoft is really betting the farm on cloud computing and services. They announced the release of Windows Azure for early evaluation to PDC attendees. They showed quite a few things that support this idea, from SQL Services to many of their enterprise offerings being run using Azure. One interesting application that uses Azure is bluehoo.com. A very interesting take on the social networking storm that has swept the web. This one looks like it lets you see people who are close to you on your phone. There are many other features in this site, but currently it isn't open for registration. Sometime after noon it will be open for business. --------- Currently I am sitting in a session on VSTS 2010. They are showing off the new features around testing. There are some very interesting things that all developers to see what the user was doing for their test run. It also lets you to see their interaction with a video of the test run. --------- Another testing feature is Test Impact View. It show you the impact of the code change and suggests the tests that should be run to exercise the change. This is a very useful feature to target unit testing and would run test that manually you may not think need run. --------- After fixing the bug they have in the demo, they are not showing that there is a new item for check-ins. Gated Check-ins allow us to take this fix and queue it for build. This means no more broken builds. The build happens on the server on a good known configuration. if the build fails, the check-in of the code doesn't happen. --------- They are now showing a new modeling feature that allows the developer to model how they want their application to flow and work. It gives a graphical way to recognize where errors exist in code that break the model. Errors that are returned from builds give the model error and the spot in code where the error occurs. --------- There is another new diagram view that shows all the namespace connections. This is just another way to see a representation of how the code is all tied together. --------- Now they are showing the ability of generating a sequence diagram from a high level object in code. This show the call stack and how over the call they relate to each other. It appears to work well. Something that I am going to look forward to using. Bouncing back and forth between diagram and code make visual seeing the interaction and quickly getting to the code to modify could potentially be a real time saver to make sure you code matches your design. --------- My battery in my laptop decided to shutdown my laptop. The last section of the session talked about the new regression testing capture, basically it is a tool to capture input to applications. This capture can then be run like a unit test in the Visual Studio 2010 IDE. This could potentially remove the requirement to require manual regression testing and instead replace it with automated, developer run, regression tests. |
|||
