I sat in on a very informative roundtable discussion about WCF tips, tricks and pitfalls this afternoon here at the MVP conference. In that discussion one of the topics that came up was load balancing. After some brief discussion, I chimed in with a pitfall that people would need to watch out for which is that, if they’re using something like a BIG-IP box from F5, which proxies SSL communication for them, they will have problems getting their message credentials to flow through to the actual web server since communication between the F5 and the web server is done over just plain HTTP. After I finished talking, people were asking for more detail and whether or not I had written something up on the topic. I thought maybe I never ended up writing anything, but it turns out I did! So for those MVPs who are probably here looking for that info now, or for anyone else who might have missed it, here’s a link that write up.
Also, I mentioned it in the original article, but I again wanted to give credit to Pedro Felix because he was a big help in guiding me down the right path to get this all implemented originally. I finally met Pedro today after he recognized the topic and my URL in the roundtable discussion. Thanks again Pedro, nice to finally put a face to the name!
Alright, I’m reaching out via my blog for anyone in the NYC area who has strong experience writing web services and wants to join an awesome team, using awesome, bleeding edge technology to develop an enterprise level API for Mimeo.
- At least 5 years programming with C# and .NET
Strong understanding of and production experience with WCF
- Must understand .NET 2.0 concepts such as generics, anonymous methods, etc.
Familiar with the concept of an Enterprise Service Bus
Understanding of web service standards such as:
- Must be able to explain the ABCs
- Must understand security features
Strong understanding of asynchronous programming patterns in .NET
- Atomic Transaction (implies Coordination)
Experience with O/R mapping frameworks (ADO.NET Entities a big plus)
Experience with caching (MemCache a big plus)
Experience with parallel programming (ParalellFx a big plus)
- Latest WCF enhancements
If you think you fit the bill and want to join the team, drop our HR department a line and reference this posting so they know exactly what job you’re interested in. For more about Mimeo, check out our “About Us” page.
I’m sitting in JFK waiting for my flight to Seattle to depart as I head to this year’s MVP Summit. The MVP Summit is always an interesting event. Sometimes there’s some new tech revealed, but it’s not like a PDC. Mostly it’s about networking and providing feedback to Microsoft on what they could be doing better based on our experience in the field. Either way, it’s always worth the trip and, as always, I’m looking forward to it.
Check out this Mix Session for all the skinny on the enhancements coming in the WPF 3.5 “Extensions” later this year. Unfortunately the Mix sessions site is designed quite poorly in terms of being able to provide direct links, but if you just go to there and look for session T11 – “What’s New in Windows Presentation Foundation 3.5″, that’s the one that shows off all the goodies.
Rob shows off new work on the virtualization front, Microsoft’s prototype DataGrid control, performance enhancements and so on. The topic I was waiting to hear about most however was the new Effects API which we finally get our first in depth look at with this session. If you jump to about the 45 minute mark you can get right into it.
First I must say the Effects demo was very impressive. He basically combined 6 different effects on a live 3D object with physics and video playing and it worked flawlessly. In this demo we finally got to see the code that drives that demo and I must say I am supremely disappointed with how quickly he blew through it and how little detail was given. I’m also very disappointed with the implementation. First off, the code was pure shader code in .fx files. A far cry from the beautiful LINQ implementation I had envisioned and no where even close to the Microsoft Research Accelerator project that at least seemed to do it through inheritance and reflection. Upset as I may be with the implementation, I am just glad we finally have some way of actually accessing the GPU for effects.
The next thing I was looking forward to is the WriteableBitmap API. It’s not something I personally need, but I know a lot of people do. WriteableBitmap basically gives you GDI+ like pixel based bitmap graphics. Those graphics however are still fully integrated nicely into the rest of the WPF graphics stack, so you can paint on a 3D surface for example. It does look however like the WriteableBitmap API requires some unsafe code. How much and whether it’s usable at all in a partial trust scenario as a result wasn’t clear.
Not much to say about it other than I love it. So, I highly recommend you go get it too.
Well they demo’d the new WPF effects at the Mix keynote, but they didn’t show off any code. Guess that makes sense since it’s the keynote, but I’m really itching to find out how they were implemented. Anyone know where I can find some sample code??? Maybe I just need to wait for one of the Mix sessions to be posted up.
Microsoft has made the Internet Explorer 8 Readiness Toolkit available here. Note some of the links that go into detail are still not working as I write this, but the main page gives a glimpse of what we can expect. You probably want to check out the new developer features that IE8 will bring to the table. My favorites are the selectors API support and the AJAX enhancements… especially the news that they will up the number of connections IE uses to communicate with the server from the traditional two to six!
Just saw this over on Ars, the Singularity OS from Microsoft Research is now available for download. In case you’ve never heard about this project, it’s an operating system written almost entirely in managed code. Very cool stuff.
Just announced over on the IE blog, they’ve listened to the community and changed the way IE8 will behave with respect to rendering modes. Originally you would have had to put a tag in to tell it to behave the “right” way… now you have to put a tag in to tell it to behave the old, “broken” way.
This was a damned if you do, damned if you don’t decision. Some people wanted it backwards compatible and some people wanted it forwards. I agree with the forwards compatible personally and am glad to see them change their stance on this.
One thing’s for certain: the IE team is listening… and that can only be a good thing.
So what do you think? Will IE8 use the CLR implementation of the JScript engine or keep on using the legacy ActiveScript engine architecture that is plagued with COM circular reference issues resulting in memory leakage and a plethora of other performance problems? Seeing as how FireFox 3 is running about 10x as fast now and is only still in beta, IE has a lot of catching up to do.
Performance aside, JScript.NET was designed as closely as possible to ECMA standards at the time which means it already contains several of the features that ECMAScript 4 (spec here, examples of features here) is planning on bringing to the table. These features include:
- Strongly typed programming
- Data types like decimal, byte, int, double, etc.
- Classes as first class citizens (including inheritance)
- Properties as first class citizens (i.e. set/get accessors)
- Static properties/methods
Now the problem is, this was a version of ECMAScript that was being developed back in 2000. Now that the rest of the world has woken up and realized the potential for such features, the spec has changed a little bit, so Microsoft will need to update JScript.NET to support these standards1. The good news is that, since JScript.NET is built on the CLR, it’s really just mapping of concepts to features the CLR already offers. What features are missing? Here’s a few:
- Namespaces – straightforward mapping to CLR namespaces
- Generics – straightforward mapping to CLR generics
- Nullability – maps straight to Nullable<T>
- Generators – same concept as “yield” in C#
- Maps/Vectors – easily mapped to Hashtable<T>/List<T>
- Type meta-objects – basically maps to reflection
- Union types/Any type – this one’s interesting, it’s basically like saying “I expect this thing to be any one of these types”. Strange concept if you ask me, tough one to map to the CLR without some trickery under the covers.
- Record/Structual data type support - basically like anonymous types, but also enforces some strong typing over duck typed objects
- Meta-level hooks – interesting concept that enables you to intercept calls to get/set/invoke generically… basically let’s you play “tricks” with the runtime
- Static generic helper methods - maps to extension methods introduced in .NET 3.5
- is and cast - obvious map straight through to CLR concepts
- like and wrap - for working with the Record/Structural data types and basically allow you to dynamically determine if an instance is of a compatible duck type
- let – a “better” way to declare variables that gives block scope
So whattya think? Will IE8 use JScript.NET? Even if it’s in an ECMAScript 3 compliance level only today we’d gain all the performance benefits. Then, for Microsoft, implementing these features would sure be easy on top of the CLR. Let’s just hope they don’t try and actually build all this crap into the legacy Active Script engine.
1 Reminds me of the whole DOM fiasco they’re still suffering from. They were the first to implement all of the neat features that make up the DOM today, but when the world caught on and came up with an official spec, Microsoft fell behind. Now they get no credit for their innovation in IE4 and catch (well-deserved) flak for not still not being up to spec.