SeeSharpRun

Using Style & Triggers For Complex Interactivity

Sidney Andrews — Thu, 11 Aug 2011 17:06:50 +0000

Many times I try to take as much of the presentation logic out of the viewmodel as possible. While using a MVVM pattern, sometimes it’s easy to be lazy and create boolean or visibility properties to handle logic on the front-end. This week I’m showing a quick way to abstract that logic to the view only and not have to worry about cluttering your viewmodel.

Simply, I use Style.Trigger to handle the different ways I want my view to appear dependent on a DataBinding. In WPF, this is incredibly easy using the DataTrigger class. It allows you to bind to a datacontext property and then change the appearance of your object based on the property’s value.

The Style easily set some default values I wanted for my control and a ControlTemplate. In this example I wanted to create a rounded banner that shows in certain conditions:

[DEFAULT] By default I want the Control to have an opacity of zero and empty Content
[ListItems.Count = 0] If the List exists but it is empty, then I want the item to show and alert the user. This usually happens if you complete a search and get a empty result back. It’s also very informative to the user that their search did complete but returned nothing.
[ListItems = null] If the List is null and never existed, then the user should know that they need to search. It’s easy to have the List value null at the creation of the viewmodel and then populate the property on searches with a collection (either empty or with values)

The style properties appear near the top are the lowest precedence. They are the “default” values in this scenario and the triggers override any of those properties when their conditions are met. One easy mistake to make is to forget that if you set a value on the ContentControl itself (not in the style) then that would have precedence over the trigger.

Using Dynamic SLA Documents in Web Service Testing

Sidney Andrews — Thu, 06 May 2010 17:49:00 +0000

As part of my Computer Science M.S. degree, I tend to write pitiful papers from time to time. I’m posting this paper online because I want fair and honest critique. I’m not a strong writer but I believe my ideas may be of some use. This paper details using dynamically-generated SLA documents to create an expansive test suite over a web service above and beyond what unit-test generation from WSDLs can do.

Original Document: Final CMSC Paper

Use of Dynamic SLA Documents In Expanding The Depth of Web-Service Testing & Validation

Sidney Andrews

Introduction

In the software development field, the quality assurance of an application can be directly related to the time and effort spent in testing & verification. As long as a development group has access to source files and code, there is a large amount of flexibility in deciding the level of acceptable risk and defects for the particular project and finding methods to verify the project meets the requirement.

When project groups utilize executables and software libraries from third-parties, their attempts at quality control are severely limited. Since developers are not able to “prevent the introduction of faults during… development” 1 they cannot be involved in any form of constructive quality assurance. However, analytical quality assurance is still possible. Faults in a software library can still be found post development by a development party consuming another group’s application interfaces and libraries. The depth of the tests and the amount of faults that can be exposed are primarily dependent on the amount of information made available to the testing group. Reasonably, with more information available to the testers, their testing capabilities will increase. Items such as source code, algorithms, program logic descriptions, unit tests and many others can help increase the depth of possible tests.

With source available to a development group, the group can use white-box methods to develop and generate tests to ensure that the project meets its stated requirements. This is possible because the source allows the testers to understand the control flow of the application. With an understanding of the program’s logic and control flow, the testing methodology qualifies for the distinction of white-box testing. Armed with this information, we can expand the depth of the test and validate many possible execution scenarios. Without information on a software project’s code or implementation, the testing group is limited to “black-box robustness testing” 2. Normally, black-box testing is considered the only method of testing an application where it is not possible to ascertain any knowledge of the internals of the various operations available for use. In some cases, other information about a software library or service can assist with increasing the depth of a black-box test but it is debatable what level of information can provide a clear distinction between black-box and white-box tests.

Many modern desktop and web applications rely on a service-oriented architecture. While not an entirely new concept, SOAs have become increasingly popular with the splintering of work between multiple parties. The world of service development and utilization introduces some unique constraints in testing and validation. Software services can easily be “accessed without of its underlying implementation” 3. Testing is usually constrained to verifying the model of the service. As a service consumer, the only information available to use in testing is the model of the service. This information is useful however, because the model information distributed to the service consumer is enough to construct an UML diagram of the service application. This is possible because the consumer of a service application is allowed to download the interface(s) of the externally visible classes that the service uses to respond to client requests. These interface classes allows a service consumer to generate a class inherited from the mentioned interface to “consume” the service.

The transmission of a service application’s interface to client applications is both platform agnostic and independent of any particular language implementation. This is due to the use of Web Service Description Language (WSDL) documents. While the name specifies the use of WSDL files in the world of web services, it is not possible to use WSDL documents with any service-oriented architecture. What makes the platform and language independence possible is the fact that WSDLs are xml-based files that “describes the public interface of a service” 4. In the raw xml data, a WSDL file is primarily composed of operators and messages. The operators are language-independent constructs that describe the methods in an interface. The messages are the other constructs in the document that describes both the standard and unique types in an interface. When combined, both are useful enough to create an interface in a modern object-oriented language. This interface can be easily used to allow a class in your modern language to implement that interface and create the matching method and types for your operators and messages.

WSDLs are very important in the web services realm so that applications can automatically discover and consume web services. However, WSDL files can only model how an operation works but they do not provide any information about the performance of the service. This is where Service Level Agreements SLAs come into play. These documents provided by the authors of the service application guarantee a level of performance to the client applications that consume the service. In the context of web services, SLA documents guarantee a quantifiable network performance at defined levels to the client 5. Web services provide a unique challenge in both the creation and validation of SLA documents between the service provider and potential service clients. With web services, the provider faces the challenge of guaranteeing service performance with no control over third party conditions that directly affect the web service. Possible conditions could include the network connection, shared hardware resources, traffic congestion on the client backbone, etc. Also the size, scalability and popularity of a web service can directly affect the performance 6. Secondly, SLA documents also provide penalties related to violations in its terms or deliverable metrics 7. The violations and consequences are two-fold and relate to both the service provider and client.

Methods

Current Methods of Testing

Client applications and users of web services have an explicit need to test and verify the web service. Business-critical applications may rely on these web services and metrics are necessary when developing client applications to consume the services. Having metrics and performance data for the web services can help create a baseline when testing and validating the client application.
Most research into the testing of web-based services primarily revolves around model-based testing 8. Clients have used an abundance of black-box techniques to validate the model of the web service. With the interface information provided by a WSDL document, a client could write a suite of tests to surface test the operators and messages to validate that they function as expected and per the SLA. SLAs usually contain clauses with expected exceptions and some data about the constraints of the message types and operator methods. Since the interface information is provided in a standard XML format, this gives the testers the freedom to write automated test suites or applications. Many testers use automated software to test the endpoitns of an application and write a test suite that looks for scenarios where the service would crash or exhibit unexpected behavior 9.

Many researchers use automated unit test generation tools (such as JCrasher and Pex) to isolate and white-box test the class generated from the interface of the web service 10. Since implementation data and source code is not available, the in-depth testing of the generated web services class only effectively surface tests the endpoints of the web service itself. In this interesting phenomenon, the web service can only be effectively black-box tested since the knowledge of the internals is severely limited. This testing method, however, very quickly generates a large number of unit tests to create a suite of tests with great breadth over all possible endpoints to the web service.

Limitations of Black-Box Testing

Surface testing endpoints is an effective way to quickly create a test with a large breadth of search space, but it does have a few disadvantages. First, without knowledge of the internals and execution paths of the web service, we can only truly test a subset of all possible method and type scenarios. A simple example would be an operation (method) that takes an integer data type as input. This method would increment the integer and use an if-else construct to determine an execution path based on the value of the integer. Surface testing using black-box methods and unit test generation tools would not quite fit the job for this scenario. An endpoint examination would return that this operation takes an integer type as input and returns some arbitrary type or nothing at all. From this, a unit-test generation tool would assume to surface test the operation by sending it various and random integer values. Values such as the minimum and maximum integer values, 0, 1 and -1 would be posted against the operation and the test suite would record the resultant information. In this scenario, we would almost definitely find an integer overflow situation with the maximum integer value if the web service provider did not account for that in their program logic. However, a tester is not guaranteed that the values sent in for the integer would test both possible execution branches for the if-else clause.
This is the main utility of using unit-test generation tools. They test endpoints and make sure that the endpoints behave as specified in edge-case scenarios. If the message was using a string type as input, the unit-test generation tool would’ve checked the resultant values when the operation is passed in values such as an empty string, null value, special character symbol and foreign character symbols. Unfortunately, this method of surface testing could not guarantee that it tests every possible execution scenario. In order to do that, most unit-test generation tools would need access to the source code to account for all possible execution paths. In the world of web services, this information is simply not available in most cases.

Some other, smaller limitations of using black-box methods to test web services could be involved in physical resources 11. Buffers and network conditions can falsely change the results of a unit test. While this type of error could be easily identified and dealt with, it is very important to consider and include in your unit tests to avoid skewing your results. Also, unit-testing is resource exhaustive locally and can be doubly so over a remote network connection. A network timeout or SOAP exception can be added to a white list of possible exceptions that will not invalidate a unit-test. Another possible difficulty in unit-testing web services is the possibility of an update to the web service invalidating your unit tests 12. Obviously, this can be resolved by automatically updating your WSDL document and unit tests to reflect the new build of the web service. However, synchronization of your unit tests and the update schedule for the web service is necessary to avoid either updating your WSDL document too much or not enough.

Another issue with the current methods of testing lies with incorporating expected faults detailed through the SLA document into the unit tests. Since an SLA document is typically hand written, it takes manual labor to translate the SLA’s data into test cases. SLA information that’s important to the test team could include possible exceptions, performance metrics, and expected behavior.

Dynamic Service Level Agreements

Due to the dynamic and automated nature of unit-test generation, a static SLA document does not fit into this paradigm. What if the testers could generate unit tests from an SLA document? The only way to make this possible is to use an SLA document that’s in a format that is both platform independent and consumable by all clients. Fortunately, there is already a well-established method of providing this form of information across the web. WSDL documents use XML to transmit data across networks 13. This same strategy can be use with SLA documents to generate a document that is both human readable and consumable by software platforms.

There are two common dynamic SLA formats. The first is the WS-Agreement spec which was created by the Open Grid Forum to fill the need for a companion SLA document for a web service WSDL 14. The more common method, and the focus of the rest of this paper, is in the WSLA standard that was created by an IBM research group. A WSLA document specifies the parameters of an SLA document in a standard format with consistent measurement methods and metrics 15. Both of these document types were envisioned as dynamically generated documents. The standard method of generating these documents
usually falls on the testing and performance measurement of the web service internally by the service provider.

The provider can simply create a software suite for both exception testing and performance measurement. With the result baseline data generated from the tests, a provider can review the results and automatically generate a WSLA document from the results. This document can contain information updated in regular intervals to keep the WSLA document updated to the standard needed by the service provider and/or consumers.
Another, more interesting feature of the WSLA document is it’s capability to store data outside of the normal scope of an SLA document. Figure 1 shows some of the typical data that a WSLA document would contain. A WSLA document can also contain information about metrics along with information about the algorithms used within a web service. A WSLA document can also contain the test used internally to validate the web service and the results returned from those tests 16.

Conclusion

Dynamic SLA documents (WSLA) opens up a new realm of possibility of clients with the need to test web services that they’re consuming. The test cases and algorithms detailed in a WSLA document gives the testers a better idea of the context of a web service. With this information in hand, the testers can possibly automatically generate unit tests that traverse all execution paths of a web service operation. Also, testers can generate unit tests that match the tests that the provider development team used to initially test the web service. While this information does not give the consumers the ability to white-box test the web services, this is far and above beyond the limitations set when a consumer black-box tests the web service with the aforementioned methods. Black-box testing definitely created a large breadth of testing scenarios but this method may just help testers create large in-depth tests of their web services.
At the end of the day, some of limitations still exist. Regression testing is still difficult due to resource consumption. Also, network congestion and utilization is hard to predict when testing web-based services. WSLA documents only expand the list of possible things that can be tested against. It does not guarantee that a tester who is blind to the source code and implementation can fully test a web service.

Bibliography

Andrieux, Alain, et al. “Open Grid Forum.” 14 March 2007. Web Services Agreement Specification (WS-Agreement). 9 April 2010 <http://www.ogf.org/documents/GFD.107.pdf>.
Bai, Xiaoying, et al. “WSDL-Based Automatic Test Case Generation for Web Services Testing.” SOSE ’05: Proceedings of the IEEE International Workshop. Washington, DC, 2005. 215-220.
Berberova, Diana and Boyan Bontchev. “Design of service level agreements for software services.” CompSysTech ’09: Proceedings of the International Conference on Computer Systems and Technologies and Workshop for PhD Students in Computing. Ruse, Bulgaria: ACM, 2009. 1-6.
Bruno, Marcello, et al. “Using test cases as contract to ensure service compliance across releases.” In Service-Oriented Computing – ICSOC 2005, Third International Conference. Amsterdam: Springer, 2005. 87-100.
Chinnici, Roberto, et al. Web Services Description Language (WSDL) Version 2.0. Vers. 13. 26 June 2007. 2 April 2010 <http://www.w3.org/TR/wsdl20/>.
Chou, Li-Der. “Design and implementation of a policy-based monitoring system for Web Services.” Journal of Information Science and Engineering 25.5 (2009): 1357-1372.
Comuzzi, Marco and Barbara Pernici. “A framework for QoS-based Web service contracting.” ACM Trans. Web 3.3 (2009): 1-52.
Di Penta, Massimiliano and Gerardo, Esposito, Gianpiero Canfora. “Search-based Testing of Service Level Agreements.” Proceedings of the 9th annual conference on Genetic and evolutionary computation. London, England: ACM, 2007. 1090-1097.
Di Penta, Massimiliano, et al. “Search-based testing of service level agreements.” GECCO ’07: Proceedings of the 9th annual conference on Genetic and evolutionary computation. London, England: ACM, 2007. 1090-1097.
Hofmann, U., I. Miloucheva and T. Pfeiffenberger. “INTERMON: complex QoS/SLA analysis in large scale Internet environment.” WISICT ’04: Proceedings of the winter international synposium on Information and communication technologies. Cancun, Mexico: Trinity College Dublin, 2004. 1-13.
Huang, A. F. M. “An optimal QoS-based Web service selection scheme.” Information Sciences 179.19 (2009): 3309-3322.
IBM. WSLA: Web Service Level Agreement. 2004. 12 April 2009 <http://www.research.ibm.com/wsla/about.html>.
Ludwig, Heiko, et al. “Web Service Level Agreement (WSLA) Language Specification.” 28 January 2003. IBM Research. 20 March 2010 <http://www.research.ibm.com/wsla/WSLASpecV1-20030128.pdf>.
Martin, Evan, Suranjana Basu and Tao Xie. “Automated Robustness Testing of Web Services.” Proc. 4th International Workshop on SOA And Web Services Best Practices (SOAWS 2006). Portland, Oregon: NCSU, 2006.
—. “Automated Testing and Response Analysis of Web Services.” Proc. the IEEE International Conference on Web Services (ICWS 2007), Application Services and Industry Track. Salt Lake City, Utah: NCSU, 2007. 647-654.
Michlmayr, Anton, et al. “Comprehensive QoS monitoring of Web services and event-based SLA violation detection.” MWSOC ’09: Proceedings of the 4th International Workshop on Middleware for Service Oriented Computing. Urbana Champaign, Illinois: ACM, 2009. 1-6.
Myerson, Judith. Use SLAs in a Web services context. 29 October 2004. 11 April 2010 <http://www.ibm.com/developerworks/webservices/library/ws-sla/>.
Raimondi, Franco, James Skene and Wolfgang Emmerich. “Efficient online monitoring of web-service SLAs.” SIGSOFT ’08/FSE-16: Proceedings of the 16th ACM SIGSOFT International Symposium on Foundations of software engineering. Atlanta, Georgia: ACM, 2008. 170-180.
Skene, James, et al. “The monitorability of service-level agreements for applicaiton-service provision.” WOSP ’07: Proceedings of the 6th international workshop on Software and performance. Buenes Aires, Argentina: ACM, 2007. 3-14.
Sommers, Joel, et al. “Accurate and efficient SLA compliance monitoring.” SIGCOMM ’07: Proceedings of the 2007 conference on Applications, technologies, architectures, and protocols for computer communications. Kyoto, Japan: ACM, 2007. 109-120.

Wordle

Sidney Andrews — Mon, 19 Apr 2010 15:12:00 +0000

My Quest for a Codeless User Interface

Sidney Andrews — Mon, 22 Mar 2010 07:14:05 +0000

There is not doubt about it. I love XAML! Coming from someone with a web application background, I understand the importance of using markup to define visual traits of an application. I also understand that the transition from HTML to XAML is very smooth and will lead to a new generation of .NET developers who design user experiences for both the desktop and web. What I have yet to see, is a complex User Interface written without a lot of unnecessary code-behind. XAML was designed so that you keep all of your user-interface logic in the markup and your business logic will dominate your code behind and libraries. Unfortunately, I have yet to see this pattern manifest.

The problem is not just in WPF/SV3 code samples from co-workers and friends, but even online with tutorials and code samples. I would think that most of the MSDN and Microsoft-based web samples would encourage the use of Triggers, Behaviors and Styles as opposed to code-behind logic. Here’s an example of what I mean http://msdn.microsoft.com/en-us/magazine/cc163421.aspx. Many of the things that the code-behind is used for can easily be done with behaviors and triggers. Instead these features are treated as “nifty” and “advanced” thus alienating the common developer from using them. I was an immediate WPF/SV2 convert and it took me almost a year to fully understand the power of XAML.

So here’s the point. Every time there is a new release looming for Silverlight, I step back and try to develop an interactive user interface without any code-behind at all. I even go as far as to not write library classes and behaviors by hand, but sometimes that just can’t be helped. I usually imagine a product that’s being used for an elementary school. These products normally need good animation, have to be colorful and would need to be VERY interactive. Sometimes I do throw in LOB (line-of-business) components in there just to see what they would look like. This project was done using WPF 4 & Silverlight 4 Here is a sample of the project:

I found that WPF was FAR easier to develop with. Silverlight does have the advantage of industry acceptance and reach, but it is (sort of) a subset of WPF. The XAML for the WPF version is posted below for your review:

I just wanted to make three points about this code sample:

I tried to use the PathListBox multiple times, so that I can get used to how powerful this is. By controlling our layouts with a Path, we can do some really amazing things. Specifically, I can see people creating dynamic menus using a combination of Paths and Animations
The Silverlight Triggers are a bit less intuitive then in WPF. In WPF, I could write triggers that were nested in the top-level control and affected any component I would like. However, the Silverlight way of nesting Triggers forced a trigger to be within the hierarchy at the point where it would be used. That IS much more readable.
The PathListBox operates very much like a regular ListBox, and I had fun binding to it’s selectedItem. In Silverlight, I used Element Property Binding, but I preferred the much better method of using “IsSynchronizedWithCurrentItem” like in WPF. This option is available in SV4, but for the PathListBox, and error is thrown when you use it in SV4. This may be a bug.

Pure XAML

WPF AutoCompleteBox

Sidney Andrews — Tue, 09 Mar 2010 09:00:02 +0000

Thanks Microsoft… for two things 1. Making a new AutoCompleteBox for WPF included in the February 2010 relase of WPF Toolkit: http://www.codeplex.com/wpf 2. Not letting any devs know that this was in the pipeline, since half of the internet’s WPF developers went on ahead and recreated their own imperfect (read: basterdized) versions of the AutoComplete …

Libraries

Sidney Andrews — Fri, 05 Mar 2010 10:48:11 +0000

No need to go in detail over this issue. When you write code, always separate your development into tiers. Even if it’s a simple “Hello World” project, it’s not overkill to have a data layer with your strings, a business logic layer that will manipulate or handle the string and a UI layer that does your console/window/website display logic.

It pains me to see how many times in the industry, this is not adhered to. Today, I was reminded why I do this. I created a separate layer (Project under Visual Studio) of my application that connects to a web-service and returns a ReadOnlyCollection. It handles my data manipulation and craziness. When my boss said “Hey, let’s try doing your application with an Access front-end as opposed to Word” I was able to swap the front-end with minimum effort.

End of the day, I had three front-end technologies… I used a console window for my own personal testing, a Word VSTO document for the original application front-end and a Access file with multiple reports for the final front-end. By encapsulating all of my business logic in another layer, switching front-ends is as easy as selecting which project to build.

Failing Programmers

Sidney Andrews — Fri, 26 Feb 2010 09:42:45 +0000

I promise this will be short. After having a heated discussion in StackOverflow I feel like I have to say something about this. You can find the dicussion here:

Good (non-code) interview questions for college intern candidates

http://stackoverflow.com/questions/2342750/good-non-code-interview-questions-for-college-intern-candidates/

In lieu of copying the text of the entire question I will summarize. An individual is going to hire sophomore and junior level programming students as interns. Since they aren’t professionally experienced and their programming level is pretty low, he wanted ideas for good interview questions.

I am under the belief that most Computer Science students would have worked on a fairly big project in their first & second semesters and would have had numerous team projects under their belt before the end of their fourth semester (sophomore year). So after looking at the date and the question, I inferred that he would be looking at hiring students who had a minimum of 4 semesters of college programming courses. Boy did I get flamed for believing that! Some posters constantly reiterated their belief that students in their second and third year would not have significant programming experience.

The interview question that I suggested fell along the lines of “What project failures have you experienced and what have you learned from them?” I thought this was a great question because I want a student who can independently learn from their errors and who’s had the experience of a project not being fully realized. It’s my belief that we can teach programming (read: Computer Science) students about the complexities of actual projects through their realization that every programming project won’t be an instant success like Hello World.

After making this remark, I heard the most air-headed comment ever made on the internet! One poster said “None of my school projects failed”. Remind me never to hire this guy because I want a humble programmer. Debugging and testing is one of the most humbling processes I’ve ever experienced in my life and I know that I want a programmer who doesn’t believe his code is made of gold. Most programming projects fail in the real world! If a school is not teaching their Computer Science students this, then I don’t want to hire these kids with “bulletproof” code. I rather have a kid who loves to read API documentation and can learn from the mistakes he or she will make while growing as a developer.

For your edification I have posted the dialog that i’m speaking about. Click on the image for a larger version. Please comment if you believe I am wrong! I love academic debate and will be happy to admit if I’m mistaken.

Technical Presentations

Sidney Andrews — Thu, 18 Feb 2010 15:03:47 +0000

About two years ago, I read Scott Hanselman’s incredible post on Tips for a Successful Technical Presentation. It was a great post and vastly changed the way I presented to any audience. A few years later, and I find myself frustrated. I have to sit through some very interesting workshops and presentations where the presenter is either socially awkward or doing things to detract from the presentation itself.

As someone who has taught at a community college for two semesters, earned a Virginia Community College System (VCCS) distance education specialist certification, was placed in oratorical competitions by his family since elementary school, and currently working on a post-baccalaureate certificate in Instructional technology; I tend to nitpick with details about how people present technical topics to students. I shoot through the roof when I see presenters fumble the ball with remote or teleconferenced presentations.

I’m going to clear my chest and discuss a few points about technical presentations:

Rehearse, Rehearse, Rehearse! – While this point is stressed by many people who write on the topic, I feel it is a bad idea. With student presentations, I find that the students who rehearse the most or the least agile when a curveball is thrown. If you practice day & night with your notebook pc and have a set ebb & flow (or god-forbid, PowerPoint slide timings) then you will crash & burn when doing a technical presentation. Engineers & Developers are a curious bunch and we WILL interrupt your flow to ask off-the-wall questions. I think the best advice is to rehearse any portion of your presentation where you’re going off-slide (demonstrating code, command line, etc.) but to just RELAXand get comfortable with your material. Don’t forget, you are the subject matter expert and your audience can tell whether you feel comfortable talking about your material or if you’re reading from a rehearsed script. The latter definitely sells short your credibility.
Desktop Zoom– I am absolutely astonished by the amount of people who do not know how to use the Windows magnifier or Mac equivalent. When I am in my graduate courses, sometimes I want to yell at my professor to magnify or zoom in on their graphics or Smart Art with tiny illegible fonts. The worst thing you can do as a presenter is tell your audience “I’m sorry about the graphic, but that’s the best quality I could find”. Now we are not only upset about the illegible graphic, but we’re upset that you could not either magnify the graphic or create a larger version using Visio. This is definitely a simple problem with an even simpler fix that no-one seems to discover.
Text Legibility– This is a biggie. Many times we do presentations with the intent to record, distribute, or broadcast them live. Almost every presentation expert warns against using small fonts during a PowerPoint presentation, but many people forget that this transfers to many other things. If you’re showing a diagram or chart, that’s not an excuse for tiny fonts. If you switch over to Visual Studio, Eclipse, or any other IDE; there are settings to show larger fonts. This not only strains the eyes of people locally, but it makes your presentation almost impossible to watch remotely via teleconference. We live in a world where our knowledge is stored and distributed. When you plan fonts for a presentation, ask yourself “if this was to be shared on YouTube or on an intranet at low-quality, would someone be able to read my fonts?” If you have a Google account, go test this theory out and let me know what you discover.
Presenter Movement– I understand that you were taught in grade school to move around. I appreciate your instructor’s enthusiasm, but it doesn’t have a place in a professional technical presentation. Let’s consider a few things. First, when you move around you tend to focus on what’s being said as opposed to where you are. This leads to the presenter, blocking information or just plain moving around in an awkward disruptive manner. Secondly, many technical presentations are now being either recorded or teleconferenced and your movement will do more to detract from the presentation then add to it. Moving off camera and allowing your dialog to be at various volumes do more to confuse a remote viewer or individual viewing a archive of your presentation. I’m not saying to stand absolutely still, but many of the greatest presenters and orators can look convincing and strong by keeping a good base. Move your feet very little, keep your hip in the same place and use the top of your body to present. Pivot your waist, move your arms, shift your focus; these things help you to appear confident and knowledgeable about your topic.
Available Documents – This is a small gripe, but I feel it’s important and often overlooked. Many times I hear presenters say “this document will be available on (Blackboard, web site, blog, e-mail listserv) later if you can’t read it now”. This is a bad habit to start. Let’s start with this assumption, most diagrams and charts are too complex or too detailed to let the audience decipher in the middle of a presentation without a long, awkward pause. Make these documents available to the audience before a presentation. If you don’t have contact with your audience, make the documents available anyways and let them know that they can go to your website at any time to see a detailed version of your presentation. One habit I have gotten myself into is to give my audience business cards with the name of the presentation, hyperlink to a .Zip file of the charts & diagrams, SlideShare (a presentation hosting service) hyperlink, and any necessary contact information

I could go on for days with other presentation nitpicks, but I feel this is enough to get off my chest at this moment. I don’t know if i can survive grad school if I have to sit through many more of these unique presentations.

Lambda What? Lambda Who?

Sidney Andrews — Fri, 22 Jan 2010 11:40:19 +0000

I promise this is a short post. I have recently fallen in love with LINQ, but more recently I have grown to appreciate Lambda expressions. I don’t know if this is because I find them simple to read, or because I once took a class as an undergraduate student where we built a modern language compiler using just Lambda expressions. One of the things I notice often is the lack of Lambda expressions in C# 3.0 code that I read at different employers.

Maybe it’s because I previously spent most of my career as a state IT professional where .NET 2.0 is considered a fairly young, high-risk technology. Salivate on that for a moment…

Now that you’re back and covered in drool, I just want to point out 2 scenarios where I think a Lambda expression actually makes code more readable to someone not familiar with modern OO languages. One of my personal favorites are event handlers. You’ve always seen them like this:

_object.actionCompleted += new actionCompletedEventHandler(object_actionCompleted);
_object.actionAsync();

static void object_actionCompleted(object sender, actionCompletedEventArgs e)
{
     (sender as ActionObject).Property = (e.Result as PropertyType);
}

This is the standard .NET way of doing even handling. For us longtime C# developers, this seems very elementary. Sometimes when I have to introduce a JAVA guy to C# or some other OO language, I end up having to explain the idea behind event handlers and also go into a long winded discussion about asynchronous programming. I find it a lot easier to just drag lambda expressions into the conversation and introduce event handling to them like this:

_object.actionCompleted += (sender, eventArgs) =>
{
    _object.Property = (eventArgs.Result as PropertyType);
};
_object.actionAsync();

I know there are some people out there that disagree with me but amuse me by at least considering this. When you write this as a lambda expression, you tell the none OO programmer that this method is asynchronous, it will run whenever the object’s actionCompleted event is fired. Obviously in the context of this example, the event will fire when the actionAsync() method is finished running. It’s much simpler to explain that the code in the brackets would run at that point then it is to say that another method would be called. It makes it also easier to read when you don’t have to implicitly or explicitly cast the sender object in the event handler method.

Let’s look at a LINQ method. First I’ll give you the collection as context for this situation:

var animals = new Dictionary
{
    {76518, "Frog"}, {9865, "Eagle"},
    {4809, "Gazelle"},  {21849, "Panda"},
    {56547, "Elephant"}, {10365, "Ape"}
};

Pretty zoological, huh? Well, this collection could easily be sorted and organized using LINQ statements. Here are some examples:

var LongNames = from a in animals
                    where a.Value.Length > 5
                    orderby a.Key
                    select a;

var KeyCodes = from a in
                    from a in animals
                    select String.Format("{0}-{1}", a.Key, a.Value)
               orderby a.Length
               select a;

This is a nice query in LINQ format and if your developer has any DBA experience this should be sufficient. But I find it easier to read when you give it some Lambda spice:

var LongNames = animals
                    .Where(a => a.Value.Length > 5)
                    .OrderBy(a => a.Key);

var KeyCodes = animals
                    .Select(a => String.Format("{0}-{1}", a.Key, a.Value))
                    .OrderBy(a => a.Length);

Yes, I did run Enumerable.SequenceEqual() to make sure they come up with absolutely equal collections. I am of the opinion that the Lambda expressions make this a lot easier to read. However, I know there are many out there who disagree. Please respond in the comments, let’s start a discussion. I am very curious as to whether people think Lambda expressions make C# easier or harder to read.

Utility Extension Methods [Part 2]

Sidney Andrews — Wed, 20 Jan 2010 06:57:06 +0000

I rather enjoy this theme. I find extension methods very useful when you have to repeat the same short group of code again & again. Here a few other extension methods that I find handy.

GetSOAPObjectsThis method is a personal favorite of mine. My current employer requires that I pull a large amount of data from web services. I usually check for web service unique errors before calling this method but in this example, i have wrapped logic into this method. Most SOAP web services that I have encountered returns a custom object with both an error and results property. You are usually returned an array of “Result” objects from the web service, but for most lightweight queries you will only ever use the first item. Usually the results property is an array object that contains data only if the error object is null. This method allows me to convert the results to an IEnumerable. I am definitelynot stating that this method covers every case, but it does cover most of my personal use cases.
```
public static IEnumerable GetSOAPObjects(this ReadResult[] results)
{
    return  (results.FirstOrDefault() == null)
        ? new Collection()
        : results.FirstOrDefault().objects.Cast();
}
```
NullorArrayThis method is simple. I have a few cases where I have to convert an IEnumerablefrom a LINQ query to an array. This is definitely the case for web services. My issue was that I was required to call ToArray
() in the middle of a nested object initializer. I’d rather call an extension method than always try and wrap the logic for the multiple calls.
```
public static T[] NullorArray(this IEnumerable inputCollection)
{
return (inputCollection == null)? null
        : inputCollection.ToArray();
}
```
ToStandardIntThis method is almost identical to the extension method ToStandardBool I mentioned in the original article. This takes a “string” value that represents an integer and returns 0 in all cases where it cannot be parsed. I was not sure about the behavior or Int32.TryParse()on a null or empty string value, so I put in an extra layer of validation.
```
public static int ToStandardInt(this string thisInt)
{
    int retVal = 0;
    return String.IsNullOrEmpty(thisInt)
        ? 0
        : Int32.TryParse(thisInt, out retVal)
            ? retVal
            : 0;
}
```
ToObjFmtStringThis is a very fun method. I wrote it for a project where I had non-programmers who wanted to be able to read my code. I tend to use StringBuilder.AppendFormat() and String.Format() a lot! I found that writing a method that makes string formatting a little more obvious to my non-programmer code reviewers helped out a bit. So here’s an example:
String.Format(*, obj)
String.Format(“{0} has {1} apples”, bob.name, bob.appleCnt);
obj.ToObjFmtString(*)
bob.ToObjFmtString(“{name} has {appleCnt} apples”);
This method allows me to put in the name of properties as opposed to indexes of an array. It’s very helpful for simple String formatting. You do lose all of the integer and padding customizations with the original method but gain a large amount of readability. To pull this off, I used simple reflection and a regex.
```
public static String ToObjFmtString(this Object obj, string format)
{
    return Regex.Replace
    (
        format,
        @"\{(.*?)\}",
        delegate(Match m)
        {
            return obj.GetType().GetProperty(m.Groups[1].ToString())
                    .GetValue(obj, null).ToString();
        }
    );
}
```

What extension methods does everyone else use? I am highly curious as to how people are using this cool new C# 3.0 feature.

*String.Format(, obj)**	String.Format(“{0} has {1} apples”, bob.name, bob.appleCnt);
*obj.ToObjFmtString()**	bob.ToObjFmtString(“{name} has {appleCnt} apples”);