Baby.msi Installation complete, reboot?

I'm proud to announce that at 1:07am this morning Christina and my first major release went gold. Claire Elizabeth Whittington was born at 8 pounds even.  Mom and baby are both doing fine and are asleep.  Dad is sooo sleepy.  Guess I've got plenty more of that to look forward to :)  What, you thought you were going to get away without having to look at pictures?

[Managed Space]

Jason! In all our emails you could have told me you were expecting-) Conrats!

1:36:48 PM    

My work lately led me quite naturally to the seminal book, Generative Programming: Methods, Tools, and Applications. I read most of the book yesterday in one sitting (yikes!) and although I found much of it tough going, I want to share one key insight I got. I have always had a lot of trouble understanding the Smalltalk argument as put forth on places like Wiki when I used to be there and indeed the real  advantage of late binding languages. I always viewed the safety of static type checking as a given. Well, in Chapter 6 on Generic Programming, in the area of Overloading and Parametric versus Subtype Polymorphism, is the example that lays it bare before my eyes and makes me see it.

Consider writing a function for squaring a number. In pseudo-code, it looks like:

sqr(x)

return x * x

In a dynamically typed language, such as Smalltalk, this pseudo-code code can be typed in almost "as- is":

sqr: x
^x * x

However, if we want to implement it in a statically typed language; we have to declare the type of x and the return type, for example in C++:

int sqr(int x)

{ return x * x; }

This only works for int types; it is more "special" than the pseudo-code or Smalltak, which understands the message "*", or for any type including the operation "*." In C++, you could have a whole series of squaring functions for different types, but you would eventually come to the solution: a function template:

template <class T>

T sqr(T x)

{ return x * x;}

Of course, the compiler will automatically generate a concrete function for each parameter type. The interesting thing to note that the sqr() template will work, not only for number types, but for any type providing the operation "*", just as the Smalltalk implementation of sqr().  However, there a difference between these implementations and here's my revelation: The sqr() template is statically type-checked and no run-time errors of the type "operation * are not found" are possible, whereas the Smalltalk version is dynamically type-checked and a runtime error is possible (no suprise there; thats been my main objection to dynamic languages in general). But, on the other hand, the Smalltalk version if more flexible of x is not fixed at compile-time and objects of different types can be passed to sqr:. Wow, thats pretty more powerful and certainly leads to the rapid Refactoring that they have always talked about. This example is also a good one of just taking the proble semantics and "just typing it in."

9:28:31 AM    

John Giudice has started a weblog.  John is another Product Manager here at Groove.  He is in charge of the Groove Developer Kit and its various tools and utilities.  John says:

Over the coming days I will try and share ideas on what is involved with creating collaborative applications and making them succesful

[Matt Pope's Radio Weblog]

Cool! I worked with John a lot on the Toolkit. One of the very cool things that I always loved about John is he is one of the very few Product Managers I have ever seen anywhere that gets as dirty in the code as he does. He codes at home too. Cool!

6:32:44 PM    

Distributed Programming Runtime Systems: Inside Rotor
Gary Nutt. University of Colorado

"This is a hands-on book that focuses on the internals of a CLI implementation on a UNIX platform"

Cool! This morning Google led me to this book.  There are several chapters online too. I only had time to glance at them this morning, but looks like good stuff. Check out chapter 3 for a nice overview of the VES.  

11:35:15 AM    

Writing Secure Code

This book provided a few new insights, but nothing earth-shattering.  It's a good read for newer programmers, but [good] seasoned programmers will have already run into a lot of the described issues and learned from their mistakes. [Paresh Suthar's Radio Weblog]

I agree that its quite basic. However, judging from the amount of buffer overruns that are seen in everyday C/C++ code, and the fact that Buffer Overrun checks had to be put into Everett C++, I don't at all agree that many programmers are writing C/C++ write code that doesn't have these problems (or even aware). Heck, to some extent Java and C#/.NET exist for large reasons because of the failure of C/C++ programmers to write good safe code.

9:30:16 AM    

Lending more crendece to the theory that only one company is making money selling Java, Pud writes:

Cloudy days ahead. Rumor has it all-hands meeting (ALL of em) at Sun Microsystems yesterday. Vacations and paid-time-off cancelled for everyone, all trips delayed........big lists being made, knives sharpened and ready. Let the massacre begin!

On closer inspection looks like Pud is making a fuss over a pretty small deal. 

2:14:15 PM    

Everett just made my day.... Sam Gentile on the new version of Visual Studio.NET: "Last, but certainly not least, there is now a Form Designer for Managed C++! You will be able to do everything you do with the C# or VB designer. You can visually design forms and work with Managed C++. This obviously opens powerful opportunities to do certain things like Direct/X without Interop penalities and much more. Its very exciting!" [Sam Gentile's Weblog] Damn straight it's exciting. Reading this paragraph just made my day. [StrangeCoding]

An important affirmation of the core strengths of C++: "Games are going to be written mostly in C++ for the next umpteen-thousand years. Even if MS comes through with their promise to make managed DirectX run at 98% performance, you won't be seeing C# games on the shelves. You're probably never gonna see any form of CLR running on a console." and now the new features of Managed C++ WinForms: "So I'm back to square one, working with the built-in Dialog Editor that has barely changed in the last 4 versions of Visual Studio -- and that means internal tools create frustration from having a poor UI. But now... a Managed C++ Form designer...

rock."

11:25:03 AM    

I've been trying to stay on top of the hype, rumours, and news being released about the 'next' version of Windows. Just when I think I am getting a handle on it all, this type of news announcement is made: Microsoft to skip Longhorn Server Release [Andrew Law's .NET Radio Weblog]

2:32:14 PM    

Traditionally, leadership is conceptualized as a special form of power relationship where leaders have substantial influence over the behaviour of followers and exercise that power for mutual benefit. [read more] [Tony Bowden: Software Engineering]

11:15:02 AM    

Joel has written a great piece on software development abstractions and complexity.

Ten years ago, we might have imagined that new programming paradigms would have made programming easier by now. Indeed, the abstractions we've created over the years do allow us to deal with new orders of complexity in software development that we didn't have to deal with ten or fifteen years ago, like GUI programming and network programming. And while these great tools, like modern OO forms-based languages, let us get a lot of work done incredibly quickly, suddenly one day we need to figure out a problem where the abstraction leaked, and it takes 2 weeks. And when you need to hire a programmer to do mostly VB programming, it's not good enough to hire a VB programmer, because they will get completely stuck in tar every time the VB abstraction leaks.

11:14:44 AM    

Radio blogger #115946

I'm finally taking a foray into Radio after my friend Peter Drayton told me about it.  Lots of my friends are using RSS aggregators these days and I decided to get with the program.  Radio seems like a good fit if for no other reason than the jaunty Saguaro logo - plenty of those around my place ;)

[Jason Whittington's Radio Weblog]  Update: New Home

Jason's here! Welcome.

11:23:25 PM    

I have just been given a go-ahead (Visual C++.NET only so I won't talk about the rest) since a lot of this has gone public already. The Everett Visual C++.NET features, I feel, are the biggest changes to VC++ since 5.0 and have made me extremely happy. The features break into 4 main areas:

• ANSI/ISO Compliance
• Forms Designer for Managed C++
• Security Features
• Optimizer Improvements particuarly in floating point

The ANSI/ISO compliance is particularly exciting as Visual C++ finally does Partial Template Specialization, Partial Ordering, Member Template Definitions, and pretty much everything in the standard. Public statements have said 98% compliant. I have not been able to throw any Standard C++ at it that it couldn't compile and handle correctly yet. Very heavy users of advanced Standard C++ features, particuarly templates like Loki, Boost and Blitz now compile 100%!

Also, in the unmanaged arena, there have been significant additions for security, paticuarly in the area of buffer overruns. The new /GS flag, when code is recompiled with 71, will catch many buffer overruns. There are also Safe Exceptions which I won't go into here. Also, in the unmanaged area, there have been some outstanding improvements made in the optimizer, particuarly for floating point. The /G7 flag builds code optimized for the P4 and there are major gains. Also the new /arch:[SSE:SSE2] flags let you generate code for the Streaming SIMD and Streaming SIMD Extensions 2 instructions.

Last, but certainly not least, there is now a Form Designer for Managed C++! You will be able to do everything you do with the C# or VB designer. You can visually design forms and work with Managed C++. This obviously opens powerful opportunities to do certain things like Direct/X without Interop penalities and much more. Its very exciting!

3:45:10 PM    

From Brian: As of today, I am finally allowed to talk publically about what I have been working on for the past six months. Here is the press release and an early article. In all fairness, I had really very little to do with this. Most of my contributions were related to getting Dotfuscator translated into all of the languages that Visual Studio ships in. We turned over our first feature complete version three weeks after I was hired, so most of my stuff won't be seen until a future version. Congratulations to everyone at PreEmptive Solutions for a job well done.[Brian Graf's Weblog]

Well, I couldn't say anything either until now (It seems like all the pieces of Everett are going public one by one!). Congrats Brian.

10:38:39 AM    

I want to step away from coding, talking about .NET altogether, and talk about abstraction, domain engineering, generic programming, and design paradigms for a bit. In 1999, I read a book by Jim Coplien, “Multi-Paradigm Design for C++”, which forever changed the way I looked at design paradigms. Lately, while reading Andrei Alexandrescu’s “Modern C++ Design: Generic Programming and Design Patterns Applied”, combined with doing a lot of “Modern C++”, I had several awakenings those shook up things for me even more.

            For years now, it seems to me, we have had many design “gurus” repeating a mantra “Object Oriented Design good, all other techniques  bad”, to the extent that for many developers and designers, that is the only paradigm that they use and even know. Abstraction is one of the key tools for managing the ever-increasing complexity of modern software. As Coplien says, “The common answer to what is abstraction usually has something to do with objects, thereby reflecting the large body of literature and tools that have emerged over the past decade to support object-oriented techniques.” Even more so, frameworks, languages and abstractions like .NET’s BCL and most of Java is only OO based (yes, I had been thinking about this for 2 weeks now, before Microsoft’s vapor announcement of future generic programming features in .NET). Java is touted, rightly or wrongly, as completely OO such that everything must be in a class. NET’s BCL is mostly only OO. Both of these, for the most part, wrap your abstraction and your way of thinking in object-oriented ways. Yes, there are exceptions (no pun intended!), but for the most part, most of the world thinks in objects. Well, that’s goodness, right? After all, it models the real world and builds abstractions much better, right? Well, yes and no. There’s no denying the vast benefits of OO but the key message in these books, and particularly Coplien’s book, is that Object Oriented Design is just one subset of the solution domain and not always appropriate for the problem at hand.  {READ MORE...}

3:03:16 AM