 Friday, August 05, 2005
Time for everyone to update your RSS readers. The Atlanta .NET Regular Guys will not be posting to www.devcow.com/weblogs anymore. We've moved to www.devcow.com/blogs.
Why?
Because the new blogging engine we're using will allow us to host other people's blogs. We have recruited a few select individuals to blog with us:
- Todd Fine - RDA consultant/Microsoft Regional Director
- Mark Dunn - .Net Rocks co-founder/VB.Net MVP/Training guru
- Eric Thompson - all around bright guy who got in b/c he and Brendon are good friends (I suppose now I'll have to be his friend too)
- Dan Attis - co-leader of the Atlanta Microsoft Professionals User Group and part of the team designing the content for the SharePoint 1, 2, 3! event
Of course, you can continue to expect the same quality content from Brendon and myself, posting together as the Atlanta .Net Regular Guys. Feel free to read the blog's aggregate post or jump directly to the ADNRG blog.
-- Matt Ranlett
Saturday, July 23, 2005
Brendon and I hyped the SharePoint 1, 2, 3! event to the INETA board and they loved the idea. So much so that they want us to give them the content and they'll spread it around the community. They all had some useful and constructive advice for us as well.
Check out www.SharePoint123.com and learn about the event being hosted by the Atlanta Microsoft Professionals - a new user group in town. Sign up for the newsletter on www.atlantamspros.com and be among the first to know when registration for the SharePoint event opens.
-- Matt Ranlett
Thursday, July 21, 2005
Bill Baker is visiting Atlanta this week for the Microsoft Global Business conference, and he graciously volunteered to come speak before the SQL Server User Group for the second year in a row, although this is the first time I’ve seen him speak. Bill Baker is the program manager for the SQL Server Business Intelligence products, including Analysis Services, Reporting Services, Integration Services (DTS), and more.
Bill is an extremely entertaining person to watch – complete with Steve Ballmer imitations. We talked about SQL Server 2005 in general and how the new release is going to really help everyone out with some really cool new features. We talked about the new licensing SKUs – Enterprise, Standard, WorkGroup (a new SKU), and Express (MSDN). The cost has gone up a bit, from $20,000 to $25,000 for the Enterprise Edition. Standard now costs $6000, Workgroup costs $3,500, and Express is free. Special note – the Developer Edition, which is the Enterprise Edition with a single connection license, costs a mere $49!
I can’t really tell you what Bill talked about because he was all over the map – the presentation was entirely question and answer. This was the first technology presentation I’ve been to in years where the speaker didn’t even use a computer. Not even a projected My Name Is slide! No props at all. We did cover lots of cool ground. For example, did you know that the most requested feature from the community (submitted through the Ladybug system) was a bell at the completion of a query? Who thinks of that stuff? Did you know that when Beta 1 of SQL 2005 came out, that the favorite feature of the community was the new SQL Management Console tool that replaces Enterprise Manager? Can you guess what the least favorite feature was? That’s right – the new SQL Management Console! Talk about a schizophrenic user community! We apparently will not be getting hashed indexes. We ARE able to run SQL 2000 and SQL 2005 side by side. Database mirroring is a great cool new technology that requires three computers – a primary, a mirror, and a monitor that votes which system is the primary and which is the mirror. Did you know that you could potentially have all three systems in the same box? Sure, why not? Hardware is way more dependable these days than software. That’s job security for us! We covered so many topics – ETS, OLTP, building cubes as a background process, etc, that I can’t even remember everything we talked about.
We had some great sponsors – Microsoft, Unisys, ProClarity, and Doug McDowell himself (or whomever reimburses him) – who brought in some incredible barbeque for the meeting. Thanks guys!
Quick note #1 – when you have SQL or technology questions, be sure to post them to the MSN groups. Doug was telling me that before the meeting he was hit with 10 technical questions and he didn’t have the time to sit and really think about the answers. By posting to the MSN groups, you have a much wider community than just Doug looking at the questions and suggesting answers.
Quick note #2 – There is a SQL Server Road show $99 one day training event occurring at the Cobb Galleria hosted by Windows IT Pro magazine and the SQL Pass organization. There will be three tracks – DBA, Dev, and BI. Register through the www.AtlantaMDF.com banner and you’ll get a free $25 AMEX gift card. If 25 people register through the AtlantaMDF banner, the AtlantaMDF organization will receive a donation that will help us continue to provide pizza and beverages to the members.
-- Matt Ranlett
Last night was the first time I’ve ever attended one of the Atlanta SPIN meetings. This group seems to be targeted at project managers and seems to cover topics like Scrum and CMMI. These are great topics, but outside of my personal area of interest so I probably won’t be going back unless they get another headline speaker like Mr Randy “Granville” Miller. I will say this about the group – they had the most formal meeting and leadership structure I’ve ever seen in a community user group! We had about 35 people in attendance, which one of the SPIN leaders said was extremely good turnout for their groups.
Randy Miller has an impressive pedigree in the Agile development community – he’s worked for years at Borland and Microsoft to bring eXtreme Programming and Agile techniques to the masses. He’s written several books, including an upcoming book soon to be released. Randy came to the SPIN meeting to talk about his work with Microsoft and the Microsoft Solutions Framework (he actually got “yelled” at for starting his talk too early!).
For those unfamiliar with MSF, you can learn a lot on the Team Systems MSF homepage. Essentially, MSF is a set of software tools which help you stick to a software development process. For example, you have a business analyst talk to a customer and write up a list of requirements. The list of requirements is broken down into small tasks by project managers. The developers estimate how long each task will take and hand the task list back to the PMs. The PMs schedule the development cycles and turn the tasks back over to the development team. The devs work like mad getting quality stuff (including automated test (we hope) out to the test team and finally everything is built for the customer. In this development process, there are some tools helping you get through the process. The business analyst might use Excel spreadsheets. PMs might use MS Project. Devs and Tests might use Visual Studio. Visual Studio Team Systems can actually link all of these tools together with the built in issue tracking and reporting system so the experience of managing the software development process is seamless. MSF for Agile is one type of software development process. There are countless other methods which can be used with VSTS – Scrum, CMMI, Iterative, Rational, Waterfall, etc. That’s actually the coolest part of MSF – it can be completely customized to your particular method of development. MSF for Agile, out of the box, is simply a set of recommendations and process guidance for Agile development.
Randy spent 99% of his time showing us the tools, only resorting to PowerPoint to display a graphic and web links. We watched as he started a brand new project and talked us through adding requirements, planning out iterative cycles, breaking larger tasks into smaller tasks, reporting on the status of those tasks, etc. The “business analyst” persona created a spreadsheet of requirements, which was checked into a SharePoint work area. The spreadsheet was imported to Project, which automatically populated the VSTS work items. We did some fake scheduling and prioritizing and we were ready to develop. We looked at several reports showing our status and what things would look like as they went wrong.
Randy was a great presenter and I’m sorry that he only had an hour to talk to us. I felt that he had more to say if only he had the time. Oh well. If you were unable to make it to the presentation, I hope that my blog entry piques your interest and you start to learn more about the extraordinarily flexible toolset that Visual Studio Team Systems offers.
-- Matt Ranlett
Wednesday, July 20, 2005
This is just an alert for those of you who are not keeping up with the calendar:
Tonight: the SPIN group is hosting Randy Miller from the VSTS team at the Microsoft offices
Tomorrow: the SQL Server UG is hosting Bill Baker from the SQL Server Business Intelligence team at the Microsoft offices
Monday: the main .Net UG looks into application platform migration with Mike Sorrentino from BrightStrategy Inc.
-- Matt Ranlett
Thursday, July 14, 2005
I’ve recently blogged about SharePoint123 – the upcoming series of SharePoint training hosted by the Atlanta Community. The Atlanta Community organizing the SharePoint123 sessions has decided the best way to keep things organized is to form a new user group – the Atlanta Microsoft Professionals. The mission of the Atlanta Microsoft Professionals is to study in depth some of Microsoft’s tools, including SharePoint.
We’ve finally gotten a rough web presence online for the Atlanta Microsoft Professionals User Group at www.atlantamspros.com. We will be putting up a site for the SharePoint123 events very soon, but the user group site at www.atlantamspros.com will be the central point for membership registration. Register with the site to receive all future newsletters and e-mail communications.
— Matt Ranlett
posted with BlogJet
Wednesday, July 13, 2005
We had a mid-sized group at the meeting tonight – 13 people in attendance.
Sandy Roach began our meeting with the second part of his presentation on Delegates and Events. This time we focused on Events and how Visual Basic syntax looks different for events as opposed to delegates. Where a delegate is essentially a function pointer, events are the Visual Basic implementation of the Observer pattern. An event publisher defines an event and maintains a list of objects interested in receiving messages about that event. When the event is raised, each of the interested objects, or subscribers, is notified and their event handling code is executed. Multiple subscribers can register interest in an event, and the object actually defining and registering the event is not notified whether or not any subscriber actually receives the event. Sandy showed us several demos illustrating events – two console events and one familiar GUI app showing button clicks raising events.
After Sandy, I took the floor and showed off a 100 level view of DotNetNuke. We looked at what web portals are in general as well as what kinds of functionality you get out of the box with DotNetNuke. We examined several of the modules, their edit pages and their admin pages. We looked at how DotNetNuke supported multiple portals from a single install. After talking about DotNetNuke in general, we discussed the upcoming DotNetNuke project, where we are going to build a working module in the VB.Net group and turn it over to the open source community. After we talked about DotNetNuke, we took a quick look at Windows SharePoint Services and how that differs from DotNetNuke.
— Matt Ranlett
posted with BlogJet
Introducing a new concept in Atlanta User Groups – SharePoint123! (website coming soon!)
I’m pleased to be the first to introduce a new concept in User Groups here in Atlanta – SharePoint123! Organized like one of those expensive training classes, complete with syllabus and hands on labs, SharePoint123! is designed to rapidly introduce developers to Microsoft Windows SharePoint Services and the intricacies of developing for this relatively new groupware product.
Windows SharePoint Services is a free product that integrates with Microsoft Office XP and 2003 to give users an excellent team-based approach to work. Have you ever had to work with someone further away than the next cube, and wanted to let that person or group of people know when you make changes to task lists, documents, slide shows, and spreadsheets? Sometimes storing these documents in a public location like Outlook’s Public Folders or VSS isn’t enough. Sometimes you need more. What if you want to ask someone who previously worked on a document a question – wouldn’t it be nice to be able to do that directly from Word? Windows SharePoint Services addresses these needs and many more! SharePoint technologies encompass the highly scalable and extensible Windows SharePoint Services and the Microsoft Office SharePoint Portal Server to offer web-based portals ranging from individual sites and team sites to entire corporate intranets and even extranets.
Come to the sessions to learn more about using and developing for SharePoint!
-- Matt Ranlett
Wednesday, July 20th, Randy Miller from Microsoft’s Visual Studio 2005 Team Systems group is coming to the Microsoft Offices to talk to the SPIN process User Group about the newest features of Visual Studio Team Systems and MSF Agile. For more information, visit www.atlantaspin.org. To prevent us from having three User Group meetings in a single week, we have elected to cancel the Monday meeting of the Atlanta Mobility User Group.
-- Matt Ranlett
posted with BlogJet
Bill Baker, program manager of the SQL Server Business Intelligence team, is coming to town on July 21st to speak to the SQL Server User Group. To accommodate Mr. Baker’s busy schedule, the SQL Server group will be meeting in the Microsoft Offices off of Mansell Rd instead of their normal meeting location in the Concourse buildings. Be sure to visit www.atlantamdf.com to register for the meeting. Registration is used to calculate how much pizza should be purchased.
-- Matt Ranlett
posted with BlogJet
Friday, July 08, 2005
Sandy Roach began the group meeting with a presentation of delegates and event handling. Sandy tried to show us some simple examples of delegates in Visual Basic – including a sample which uses delegates to invoke a class’s instance and shared (static) methods. Sandy also covered multicast delegates, which invoke multiple methods from a single call. The power of delegates is that you can write code to call a single method, and then use delegates to have that one method call actually make calls to multiple methods.
Reading that sentence, it seems unclear. So let’s try it with an example. Suppose we have a program which deals with books. We have two significant functions: PrintTitle and Totalizer. If we create a delegate for each of those two functions, we can pass the pointer to the functions into a method call: ProcessBooks. ProcessBooks with then either print the title of the book or perform the logic in the totalizer function, depending on which delegate was passed to it. Notice that these two functions do nothing like each other – one handles strings and the other handles numbers. The fact that the delegates for both have the same signature (number of parameters) means that you can use either delegate from the same method call. Check back with the original post I wrote covering D’s presentation on delegates to the Mobility User Group.
— Matt Ranlett
posted with BlogJet
Tuesday, June 28, 2005
Top announcement of the day: the mini Code Camp in Charlotte on August 20th. Brendon and I are already registered. Keep an eye on Maxim’s blog at www.ipattern.com for more details as they become available.
In other news, we had four companies looking to hire developers, including Magenic and Avanade. This does not include the recruiter who showed up for the first part of the evening.
After a bit of fun with the projectors and laptops, the presentations got underway. Doug Turnure filled in for Marty Mathis (unable to make it) and gave a brief look into how Reflection can expose your innermost private values. Just to review, reflection works by reading the .Net metadata to dynamically discover methods and fields. Doug began the presentation with a simple base class that he used as the object of reflection:
public class Customer
{
public string FirstName;
public string LastName;
private string Secret
public Customer(string firstname, string lastname)
{
FirstName = firstname;
LastName = lastname;
Secret = "SerenityNow";
public void Buy()
{
Console.WriteLine(me.FirstName + " is buying something");
}
private void SecretBuy()
{
Console.WriteLine(me.FirstName + " is secretly buying something");
}
}
}
Then we took a tour through reflection with the following code (I’m not bothering to write everything out)
using System.Reflection
Customer c = new Customer("Doug", "Turnure");
Type t = c.GetType();
foreach(MethodInfo mi in t.GetMethods())
{
// write out all the public method names
Console.WriteLine(mi.Name);
// invoke the Buy method
if(mi.Name = "Buy")
mi.Invoke(c, null);
}
// use the binding flags to specify which types of methods and fields to reflect on
BindingFlags bf = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance | BindingFlags.FlattenHeirarchy
// show all methods
foreach(MethodInfo mi in t.GetMethods(bf))
{
// write out all the method names
Console.WriteLine(mi.Name);
// invoke the private SecretBuy method
if(mi.Name = "SecretBuy")
mi.Invoke(c, null);
}
// this can be done to fields as well - even allowing changes to fields
foreach(FieldInfo fi in t.GetMethods(bf))
{
// write out all the field names
Console.WriteLine(fi.Name);
// change the value of the private field Password
if(fi.Name = "Password")
fi.SetValue(c, "New Password"); //this will also overwrite readonly data
}
The reason this scary stuff works is because the runtime needs to know about your code, so everything is exposed. The only way to prevent someone from hacking your assembly is not to give it to them. Use web services. Or partially trusted permissions.
Doug finished his presentation and received polite applause as most people in the room looked around at each other in shock that their private data wasn’t actually private. Similar to the SPIDynamics presentation on SQL Injection and cross site scripting – there were several panicky looks…
Up next after Don was Steven Tynes from Avanade to present the Enterprise Library. For those who don’t know, Avanade is a joint venture between Accenture and Microsoft. They’re looking for bright people, so if you want a traveling job….
The Enterprise Library is the next logical growth after patterns (atomic solutions to common programming problems) and application blocks (subsystem level guidance for common services). The Enterprise Library helps to make the app blocks more consistent, easier to configure, and work together better than they did previously. Entlib is actually part of the patterns and practices guidance library and is a growth from Avanade’s original Application Connected Architecture for .Net (ACA.Net). The entlib is entirely free and is used as part of the framework for hundreds of software projects. Avanade has actually integrated the Enterprise Library into their new version of ACA.Net and is using it in over 30 clients’ projects.
We listened to Steven talk about the entlib configuration tool and the Data Access block for the majority of the time. There were so many questions from the group that the presentation quickly and frequently wandered away from the core material. Rather than try to cover what actually was said (the continuous questions were so distracting I stopped paying attention), I’m going to paste in a review of the Entlib I wrote several weeks ago when I saw Richard Weeks from Avanade presents the Enterprise Library:
The Enterprise Library wraps several of the PAP application blocks (Data, Config, Crypto, Security, Exception, Logging, etc). The goal of the enterprise library is to simplify the use of these blocks. For example, the extremely slick Configuration tool (add to the Tools menu by customizing the menu) will create all the XML in the App.config file based on a user friendly GUI as opposed to writing the XML on hand. The Database block allows you to connect to a DB, execute a stored proc, and bind the results to a grid in three lines of code. The logging component makes logging so easy it’s almost hard to believe. One line of code – Logger.Write(“text here”) – that’s it! Based on the config, we were logging to two places at the same time with independently configurable levels of detail. The exception component allows “exception policies” to be defined and log, wrapping an exception with another exception, replacing an exception with another, or create your own action. The exception policy tool was really sweet – complete with a list of potential exceptions (reflection, anyone?) you can select from. Dan and I both enjoyed this presentation – it looks like something really useful.
— Matt Ranlett
posted with BlogJet
Thursday, June 02, 2005
Jim Wooley and I showed the group a little higher level material this time. Jim showed off Generics, using the WhiteHorse class designer and separate code implementations contrasting inheritance, interfaces, and generics. Using simple examples he showed us how generics preserve Intellisense and provide faster runtimes over 100,000 iterations. Despite being a contrived example, we saw clear differences in performance over significant numbers of element access.
I showed off the Observer pattern using the example provided by the Head First Design Patterns book (this went on the white board) and an article from OnDotNet where a reproduction of a binary clock sorta demonstrates the concepts of an observer pattern. The thing I learned most from my own presentation is that I need to spend more time reading that Head First Design Patterns book. I felt like I understood what I read, but I had a hard time explaining it in a way that made sense to everyone else. Actually, I had a hard time explaining the example they used in the book to illustrate the bad way to do things. Everyone got the correct “pattern” method right away.
— Matt Ranlett
posted with BlogJet
Tuesday, May 31, 2005
Bill Baker, the general manager for SQL Server Business Intelligence with Microsoft is coming to present to the SQL Server User Group. To accomodate Bill's busy schedule, the SQL Server group will be meeting in the Microsoft Offices in Alpharetta on Thursday, July 21st. The doors open at 6:30 and Microsoft will be providing some refreshments.
Come one, come all, learn the magic that is BI. Be sure to register at the SQL Server group website
-- Matt Ranlett
Wednesday, May 18, 2005
Richard Conn introduced the Academic Relations Program – where Microsoft attempts to establish a relationship with various universities around the country. Pretty much what this means is discounted Visual Studio and Office licenses for universities and university students. Microsoft has even started to reach into the high schools, with 20 high schools in Atlanta alone participating. If you have a high school student or college student interested in the computer sciences, Microsoft offers some excellent internships and scholarships. Another interesting facet of the ARM program is its tie to Microsoft Research and a curriculum available to all for teaching Microsoft technologies.
David Chappell introduced himself by making sure that everyone knew he isn’t Dave Chappelle. Nor is he Dave Chappell from Sonic Software (who ironically also writes books and give technical presentations on enterprise messaging). After some fun at his own expense, David jumped into his presentation by postulating that there is always some kind of application architecture for enterprise systems. This started with mainframes, moved on to client/server systems, and then on to multi-tiered architectures. We may now be on the verge of shifting into the fourth evolution of enterprise systems, service-oriented architecture. The reason this shift is possible now and not before is due to the global vendor agreement on how to consume web services. Service-oriented business logic needs to rest on a foundation that is standard and ubiquitous. On Windows, this platform will be Indigo.
In the simplest sense, Indigo is a bunch of C# classes that extend the .Net framework with a new namespace. Indigo communicates through SOAP messages, functioning as an über SOAP stack. This unifies existing MS technologies (ASMX, .NET Remoting, Enterprise Services, WSE, MSMQ) for distributed applications. It also provides interoperability between .Net apps and others (EJB and WebSphere). Finally, Indigo offers the idea of explicitly building service oriented applications.
An important note is that Indigo is not backwards compatible with existing .Net distributed technologies. . Indigo actually implements much of the functionality of the existing technologies, including SOAP over networking channels and many of the WS-* standards. Once Indigo is release, Microsoft will no longer be enhancing the existing technologies. Indigo will not replace the existing technologies, and will not prevent those technologies from working.
Service-Oriented Applications are generally abstracted into Data (relations), Logic (objects), and Presentation (GUIs). Indigo fits into this picture between the logic and presentation and can be thought of as Access to Services. In the past, the link between Data and Logic has been the mapping of tables to object hierarchies and of SQL types to Java/CLR types. When the object-oriented Religion hit the world, OODBMS systems hit the market, only to fail. It turns out that mapping between the relations and objects is easier. Similarly, when the object religion hit the relationship between Logic and Presentation, Microsoft introduce a way to expose object interfaces –> COM and DCOM. That turned out to be very painful. Indigo goes back to the concept of mapping between services.
Having covered the basics of Indigo’s intentions, we now looked at code.
To create an Indigo service, you must implement a service class – the methods the services provides. You must select a host – the app domain and process the service runs in. Finally you must specify one or more endpoints in which to access the services. You have 2 methods for implementing a service class – mark a class with the ServiceContract attribute. Or mark an interface with the ServiceContract attribute then create a class that implements the interface. A caution – Indigo attributes (OperationContract) and C# modifiers (public, private) are completely separate – you can tag a private method with an OperationContract, thus exposing it to applications OUTSIDE the AppDomain. However, that same method is private within the application. David tried to convince us that this is actually a good idea by explaining that you can create a facade of classes which invoke internal methods and expose their methods as services. However, the facade of classes are not supposed to be called from within the application. The group seemed leery of this – much grumbling about a new “method type” was heard. My personal impression is that this seems to be an attempt to encourage good design (i.e. – the Facade pattern) on future projects.
Additional options in Indigo development: One way calls adds a modifier to the OperationContract (IsOneWay=true) for events. Duplex contracts for both the client and service invoking operations in the other. Message contracts allow working directly with the SOAP messages. all data sent and received by operations must be serialized and de-serialized. The way that they are serialized is based on the data contract. To create and pass your own types or enums, you must define a data contract (more attributes).
A quick aside: SVCUTIL can be used to generate a skeleton service class from WSDL contracts if you want to design your interface contracts before writing code, or contract first development. By contrast, writing the code first and adding the ServiceContract and OperationContract attributes as needed is called code first development.
When defining a host, you can host a service in an arbitrary process (exe, NT service and winform/avalon processes) or host a service in IIS or the Windows Activation Service (WAS) – a lite webhost for machines not running IIS. An app or service would use the ServiceHost generic type. IIS/WAS require virtual directories and a .svc file. Just like ASMX, an instance of the service class will be created when a client request arrives.
Finally, you must specify an endpoint – every client connects to a specific endpoint. Every endpoint has 3 things: an address (where to find it), a binding (how to communicate), and a contract (what can it do). Addresses are usually URIs. Bindings wrap together may aspects of communication such as protocols for conveying SOAP messages (HTTP, TCP, etc) security options, support for wS-* specs, and more. Several predefined bindings will ship with Indigo but custom bindings can be created. An example of a predefined binding is BasicProfileBinding which conforms to WS-I Basic Profile 1.0. WS ProfileBinding supports WS-ReliableMessaging, WS-Security, WS-AtomicTransaction, and other WS-* specs. NetProfileTCPBinding sends binary encoded SOAP with support for reliable messaging, security, and transactions directly over TCP (Indigo to Indigo only). One service can expose separate endpoints, each with a different binding for different clients. Contracts are the name of the class that the endpoint exposes (service class or interface). Endpoints are likely to be defined in config files, but they can also be added directly within the code assembly.
To create an Indigo client, create a channel to a service (typically hidden by a proxy which has been created by SVCUTIL or Visual Studio). Clients also specify a specific endpoint that they will communicate with. That’s about it – nothing very complex.
Services built on Indigo can be reliable, secure, transactional, and queued. Indigo also offers reliable messaging; raw SOAP doesn’t guarantee reliable message transfer but some of the Indigo bindings such as WsHttpBinding, support WS-ReliableMessaging. However, WS-ReliableMessaging doesn’t directly support message queuing – this is still an area where the vendors can’t agree on a standard. Since that the world in general and Microsoft in particular has caught the Security Religion, Indigo allows for security configuration via authentication, message integrity, and message confidentiality. Indigo also uses the .Net security model and the PrinciplePermission concepts. Indigo transactions are built on the new 2.0 System.Transactions namespace. Now transactions are separate from state management (different from Enterprise Services, COM+, and MTS). Indigo apps can use System.Transactions explicitly or can use OperationBehavior attributes (which use System.Transactions under the covers). Indigo supports queuing by running on MSMQ as the transport. This means queuing only works on the Windows platform. There are predefined binding choices which wrap queuing.
When considering upgrading to Indigo services, keep in mind that all existing apps will continue to work. However, if you do decide to upgrade, keep in mind the following questions. Will my Indigo app and apps built with existing technologies be interoperable and will my apps be portable? The Indigo team says yes to both questions for ASMX. Remoting will not be interoperable. Enterprise Services interfaces can be wrapped with an Indigo-supplied tool. ES clients will communicate use an Indigo moniker. WSE 1.0 and 2.0 are not interoperable or portable. WSE 3.0 will be interoperable AND portable, but it hasn’t been released yet. MSMQ is interoperable using MsmqIntegrationBinding, but portability is not a simple task.
Indigo vs Biztalk. Indigo is a platform for building services on .Net. Biztalk is an integration tool which maps between various heterogeneous environments. Biztalk already has adapters for technologies like MSMQ and SQL. Expect an Indigo adapter in Biztalk soon.
There is a March CAP currently available for Indigo and we expect the Beta 1 of Indigo in a matter of weeks.
Questions from the audience included:
Indigo talks to a service, what do I get back, a Dataset? Actually you get XML (SOAP), but the data in the message is some kind of serialized object. So it could be Dataset or objects.
What about the rich type support of Remoting? Indigo can serialize any .Net type when talking to other Indigo services. However, when interacting with other environments, use contract first development to ensure data type interoperability
How will Indigo handle big objects like Datasets? Indigo serializes an object sent to it and drops it on the wire.
MSMQ has a max message size, how does Indigo use MSMQ to transmit larger objects? MSMQ is a transport mechanism like TCP – large files are broken up and sent across the wire in discrete chunks.
Does Indigo require full trust to run on a machine like .Net Remoting does? David Chappell wasn’t, but Doug Turnure doesn’t think so. Research is required.
Can you serialize custom types? Yes with a data contract. Alternatively you can drop in your own seralizer.
I ran across this link a while ago in my RSS aggregator and thought I’d post it here as it’s extremely pertinent: Don Box’s Five Minute Indigo Challenge.
— Matt Ranlett
posted with BlogJet
Tuesday, May 17, 2005
Our own local Delta representative, Venkat Polisetti kicked the meeting off with a presentation about web services on the Compact Framework. To begin, we compared synchronous web calls to asynchronous web calls:
Synchronous calls to web services:
- can be dangerous because they have the possibility to freeze your user interface until the call completes in the primary thread.
- can be useful when the web method returns quickly and they are very easy to code.
Asynchronous calls are:
- executed on a different thread
- more complex to code but
- won’t freeze your UI when the web methods are slow to respond.
Consuming a web services on the Compact Framework is pretty much the same as with web and winform apps. When a web reference is added to a project, VS.Net creates a proxy class in the project and creates Begin and End methods for asynchronous operations. Call the Begin method to initiate the web service call and call the End method to complete the web service call. Venkat had prepared a demo for us to help us understand the complexities of using web services and the Compact Framework but his demo misbehaved a bit; the group tried to help out but the problems were initially beyond us. So Venkat took a seat to work on his laptop and gave the floor to Dhamayanthi (D for short). We ran out of time, so Venkat will show off his demo at the next Mobility UG meeting (he did get things working before the end of D’s presentation)
D started her presentation with a quick recap of polymorphism and inheritance. The example she gave was to create a base class with multiple layers of inheritance – ProjectManager inherits from Employee which inherits from Person. She then posed a question to the group, “How do you create the correct object when you don’t know which type of object is required up-front?” The answer is to have the code look up the correct object type and then return to the calling function a reference of type MyAbstractBaseClass. The reference will point to the correctly created object type. This explanation of an Object Factory also encapsulates the concept of dynamic polymorphism. We had spiraled out to a discussion of the Abstract Factory design pattern before D reigned us in and brought us back to dynamic polymorphism with an explanation of how delegates help simplify function calls which have the same signature. She showed us how to use a delegate in C++ before showing us the differences in C#, making sure we all knew our roots.
A delegate in C# is an object-oriented, type safe function pointer. This complicated concept is easily explained by Chris Sell’s article, “.Net Delegates: A C# Bedtime Story”. The story tells of an employee with a mean boss. The employee writes code to notify his boss every time his status changes and the boss is happy. But the next day the boss’s boss wants to be notified of the employee’s status changes. This continues (adding bosses to the list) until the employee is forced to allow any interested party to subscribe to his status change events. To do this, the employee defines an interface that the various bosses will implement (thus inheriting from the employee’s class (Interface Inheritance)). Now anyone who implements the interface can pass their own objects into the interface methods as parameters. This demonstrates polymorphism b/c the functions don’t know ahead of time which objects (bosses) are going to ask for status updates but they are able to take any objects that implement the interface.
The next step in improving the code is to allow the boss objects to implement only the interface methods that they are interested in, not the ones they don’t care about. The other thing we can improve upon is not requiring the use of specific method names. Delegates are interfaces with one method which don’t require interface inheritance. This is good b/c in .Net we are only able to derive from a single base class. By taking each method in an interface and declaring them each as an individual delegate (essentially wrapping the method call in a delegate) the coupling is much looser – improving the flexibility of the code. Delegates are capable of wrapping both instance methods (created when you new up an object) and static methods (which don’t require the creation of an object).
A problem of delegates is that they are public methods and can be directly invoked (skipping the notification feature of the delegate). Another problem of delegates is that a delegate only returns to the last registrant. If multiple people register for the event and they don’t register for an event with +=, then they will erase all the other registrations. To prevent this, wrap the delegates in events. The framework will then create the register and unregister events. If someone then tries to use the event without using += syntax they get a compiler warning. D was on the ball tonight, even breaking out ILDASM to show us what was happening under the covers with delegates and events, and how += completed and -= completed are both overloaded in IL as add_completed and remove_completed (where completed is our delegate name).
The next problem we had to solve was how to get the return value of each delegate or event call when multiple objects (bosses) have registered. The answer is to use the event’s .GetInvocationList method and save the results in a delegate variable. Of course, we don’t want to do this synchronously – we need to make sure we can pass by registrants who aren’t ready to report their results. This is where the BeginInvoke method of a delegate comes into play – you can call the event’s BeginInvoke on the method without passing anything in or retrieving anything out. This is the Fire and Forget method of handling this problem. A better way to handle this problem is to use the IAsynchResult interface and the callback functionality (which takes advantage of the threadpool). The IAsynchResult interface exposes an IsCompleted method which can be used to poll a thread’s status. Once IsCompleted = TRUE, you can call the event’s EndInvoke method. However, EndInvoke is a blocking call so you don’t want to call it unless you’re sure that job is done. The most elegant method of handling the check of return results is to define an AsynchDelegate (type AsynchCallback) to do the checking for you.
A great question was asked by the group – what happens if the event you are calling on a different thread throws an exception? How do you inform your main thread? This question is left as an exercise for the reader! We didn’t have time in the group to really explore the issue.
Positive feedback all around – everyone though the topic was fantastic and that D was a great presenter. In fact, if she ever comes back to Atlanta, we’d love to have her back to present another topic. She told us she’s got a great presentation on design patterns. Maybe I’ll be able to get this presentation from her and let the group work with it on their own time.
Thank you to everyone who showed up and thank you to both Venkat and Dhamayanthi for presenting!
— Matt Ranlett
posted with BlogJet
What’s left in the month of May?
— Matt Ranlett
posted with BlogJet
Michael Earls, Brendon Schwartz, and I went out for snacks and beer (mostly beer) after the Mobility UG tonight and sat there chatting until after midnight. While most of the talk hovered around career paths and war stories, one of the topics of conversation might be interesting to the rest of the Atlanta .Net User Group attending public. We were talking about what kinds of topics we wanted to see in the near future. We sat there brainstorming and blurting out ideas. I thought I'd list a few that we mentioned and then open the comments up to the general (blog-reading) public to see what interests the community at large.
Here are a few of the topic ideas we discussed:
- Biztalk - Microsoft is on the verge of releasing Biztalk 2006. Do we all understand the value of Biztalk in general?
- Sharepoint - this communication and collaboration tool has helped to shape ASP.Net (webparts)
- Analysis Services - what good is having data in a database if you can't understand what it's telling you?
- WMI scripting - system administrators understand the value of this tool. Do developers?
- Typed Datasets verses Objects and abstracted data - an architectural decision you can't make until you understand both concepts
What technology topics (not just development topics) do you want to see? Do we want to get ever deeper into code like we have with the CLR team and our recent discussion in the Atlanta Mobility User Group about delegates or do we want to learn more about some of the tools that Microsoft is providing to make coding easier? Don't be silent - let your voice be heard! This is about all user groups in general and not a single user group specifically.
-- Matt Ranlett
Monday, May 09, 2005
Thank you to Unisys and Melanie Marks for providing the pizza and prizes for the evening.
Doug kicked off the meeting with a quick demo of the DTS Integration Services Data Flow interface in the new 2005 Reporting Services Reports Builder UI (part of Whidbey’s 2005 Visual Studio interface). In Doug’s quick demo, he showed how easy it would be to take a flat file, pipe the input from the flat file to a pair of tables using Data Flow sources (flat file), transformations (to pipe the raw input to one table and the summarization of the raw input to another table), and destinations (database tables in this example). One of the really neat things about the demo was how the drag and drop tool turned from the design environment to a graphic |