At the CodeMash conference this year many things stuck with me, and two have been bugging me enough to do something about them this last weekend.  One was the idea that programmers need to practice and refine their skills, which was probably best described in the ideas of “Code Katas” ala Dave Thomas in the Pragmatic Programmer.  The other was my recent concentration on all-things-Silverlight, specifically looking at the power of the platform and the emerging patters (e.g. MVVM).

So if I can find an hour or two to “practice my craft” without expecting this will ever result in production code - just for learning – what should I tackle?  It hit me - “Fractals!!!”.  It seems like every computer system and programming environment that I’ve gotten since the late 80s I have seen what I could do with some of the now-classic fractal algorithms. Inspiration for this also came from Corey Hanes great feature summary of another classic, the “Game of Life”.

This post isn’t intended to be a detailed primer on fractals, and specifically fractals resulting from an “iterated function system” or IFS, but here are the basics.  Many systems in nature exhibit features that look very similar to each other.  That is, leaves on a tree, mountains, crystal structures, cells, snowflakes, etc.  How can we try to simulate these patterns in a simple system to generate complex results.  The IFS routines in these systems are kind of like DNA in a cell.  Each element in the current generation of a system doesn’t know where it came from, but does know how to create the next generation in the system.  How about an example.

Start with a square. 

The shape you start with really doesn’t matter.  What you end up with is making a “collage” of whatever shape you start with, a square is simple and fills the space nicely (which will be important later).

Now we need to add some simple transformation rules.  We’ll do a “classic” Serpinski triangle or “gasket”.

A transformation rule generally has four parts: Scale, Rotation, Translation, and Probability.

In this case each of the three translations will scale 50% on both axes and have no rotation (0 degrees).

1. The first will not move at all (i.e. translate (0,0)).
2. The second will be a full width horizontally away (width, 0). 
3. The third will be a full width vertically away and a half-width horizontally away (width/2, width)

These then are the simple rules that this system will run by.  Each square in the system will know these rules and know how to apply them to themselves.  So when told to “iterate” each square should execute each rule by creating a clone of itself, and applying the rule to it.  After the iteration, the original square(s) should self-destruct as their short life is now over.

So what would happen with the next iteration?

And so on and so on.  What if we did this 7 times?

Starts looking far different that you might have expected.

So how might we start to tackle this in Silverlight?

Actually, this should be far easier to do in Silverlight than in previous platforms because graphics and transformations are built in to Silverlight “out-of-the-box”.

So “Iteration 0” will be easy (just a Rectangle).

 <Rectangle Fill="Red" Height="400" Width="400"/>

Now we could  create a rectangle with half the height, width, and translate it in XAML, but we want to be able to automate this, so perhaps there is a better way.

<Rectangle Fill="Blue" Height="400" Width="400">
 <Rectangle.RenderTransform>
     <TransformGroup>
         <ScaleTransform ScaleX=".5" ScaleY=".5"/>
         <RotateTransform Angle="0"/>
         <TranslateTransform X="0" Y="0"/>
     </TransformGroup>
 </Rectangle.RenderTransform>
</Rectangle>

We can take the original Rectangle and use the RenderTransform to handle all of the scaling, rotating, and translating of the Rectangle.  This works pretty well and is starting to get promising.  What would the other two “rules” look like?

<Rectangle Fill="LightBlue" Height="400" Width="400">
 <Rectangle.RenderTransform>
     <TransformGroup>
         <ScaleTransform ScaleX=".5" ScaleY=".5"/>
         <RotateTransform Angle="0"/>
         <TranslateTransform X="200" Y="0"/>
     </TransformGroup>
 </Rectangle.RenderTransform>
</Rectangle>

<Rectangle Fill="AliceBlue"  Height="400" Width="400">
 <Rectangle.RenderTransform>
     <TransformGroup>
         <ScaleTransform ScaleX=".5" ScaleY=".5"/>
         <RotateTransform Angle="0"/>
         <TranslateTransform X="100" Y="200" />
     </TransformGroup>
 </Rectangle.RenderTransform>
</Rectangle>

But now we have a problem.  This works well for Iteration 1, but not for subsequent Iterations.  We need to be able to do transformations on top of existing transformations (on top of other existing transformations, etc.).  Rectangle alone will not get us there.

What is a very simple XAML object that can contain another object? The ContentControl is just such a basic object.  Its basic job is to contain one other object (which itself could contain other objects), and it just so happens to also inherit from UIElement, which means it has RenderTransform as well.  What does this mean.

It means that we can do something like this …

<ContentControl>
 <ContentControl.RenderTransform>
     <TransformGroup>
         <ScaleTransform ScaleX=".5" ScaleY=".5"/>
         <RotateTransform Angle="0"/>
         <TranslateTransform X="0" Y="0"/>
     </TransformGroup>
 </ContentControl.RenderTransform>
 <Rectangle Fill="Green" Height="400" Width="400">
     <Rectangle.RenderTransform>
         <TransformGroup>
             <ScaleTransform ScaleX=".5" ScaleY=".5"/>
             <RotateTransform Angle="0"/>
             <TranslateTransform X="0" Y="0"/>
         </TransformGroup>
     </Rectangle.RenderTransform>
 </Rectangle>
</ContentControl>

… which, if you look at it, is the first rule in Iteration 2.  That is, apply the first rule to an object that already had the first rule already applied to it.  Now we’ll get a rectangle that is half the size of a half-sized rectangle (25%) and hasn’t rotated or moved from the origin at (0,0).

[End of Part 1]

Two more parts to this coming in the next few days:

• Part 1 – Fractals with TransformGroup and MessageBus
• Part 2 – Automating transformations by creating an IFS Content Control
• Part 3 – Wiring up the Iterations using a basic MessageBus implementation.
• Part 4 – But will it work for a fractal Fern?
• Part 5 – Lessons Learned (aka limitations of the MessageBus and recursion in Silverlight)

Ironically(?) It will end up taking 3-4 times as long to blog this as it actually took to code it, but there is learning in the blogging as well, so more coming soon.

Programming for Today’s Kids: Why NXT-G, Kodu, Scratch, Alice, Small Basic, KPL / Phrogram and others can reignite the imagination and understanding of technology for today’s kids.

As Kids growing up in the 70s and 80s, we did not have all the technical resources available to us as they do today.  Computers were rare, under-powered, and very difficult to use. Hand-held calculators weren’t even widely available, no public Internet, 3 TV channels, etc., etc.

What we did have was an accessible programming language that came with most computers: BASIC.  In fact, there wasn’t even much software that you could buy for your computer.  You had to write your own, and the language and environment was built-in to the machine.  A little later came LOGO, and even later came HyperCard for the Macintosh.  So for a kid with access to a computer, and a little interest, motivation, and summer break, you could spend hours programming and creating basic games with text, graphics and even sound.

Ironically, with all the advances in 30 years we have largely lost the entry-level development environment that kids can experiment and get started with.  Sure there are free tools for .NET, Java, PHP, etc. but they start at a much higher level and have so many commands and options that it is easy to get confused.  What kids need is a “level 0” or “level 1” type environment that is limited but easy to use (and did I mention fun?).

Not every kid needs to learn to write complex programs.  But a generation of kids growing up without even a basic knowledge of how computer programs are written make them unaware of how things work and end up victims or slaves of the very technology that is meant to help them.

So for the last 4-5 years I’ve been on an active search for current options for kids who are even mildly interested in programming.  They need to be risk-free (i.e. kids can play around with them without damaging anything), fun (no kid-assembly language primers here), and have the ability to scale to average homes.

I have made no conclusions here, but I wanted to list the environments I am using and “tracking” currently.  We started the “Bots on the Rock” robotics club in January 2008 and that has been doing well with kids 8-15.  In just the last month I started using Kodu on the XBox 360 at home, and now on the PC with the idea of using that with the club as well.  I am going to do a quick listing of what’s available, with more details to follow. 

Kodu: Game Programming Lab (XBox 360, PC (in Beta)) – 400 XBox “points”

The latest item on my list is Kodu: Game Programming Lab from Microsoft Research.  I put it first mainly because that is what I’ve been “talking” about on Twitter/Facebook which lead to this post (i.e. can’t explain all of this in 140 characters). Kodu is available today for the XBox 360 and and Academic version is in beta test for the PC for release in the near future.  As of today I have the PC version running on my laptop and I will be working with that more over the weekend.  We’ve been using the XBox 360 version for just under a month, and all of my kids really love playing with it and are making their own games – in fact they’d rather “play” Kodu than many of the other “real” games.

Kodu is difficult to explain in words, and really needs to be demoed – here is one of the better YouTube videos out there.

Basically all of the programming is done with an XBox controller (even on the PC) with a very intuitive series of “sensors” and “commands” (e.g. when I see a ball go towards it).  It also controls a very robust scene generator which enables a huge variety of terrains and elements to be included in the games.

The recent update of Kodu on the XBox 360 allows for much easier sharing of games that you have created.  You can even create multiplayer (local) games, and quickly learn about the headaches that come from multiplayer games on the same screen. 

There are a whole series of posts that could be written just about this environment, but for now I’ll leave you with the links.

NXT-G: Lego Mindstorms (PC, Mac) – Included with LEGO Mindstorms Kit ($275)

NXT-G is the graphical programming environment that comes with the LEGO Mindstorms Robotics kits.  The environment is a “click and drag” programming surface where programs are created by stacking and ordering blocks on the screen (much like building LEGO buildings, hmmm).  Blocks are called “Move”, “Loop”, and have sensor blocks that correspond to the robotic sensors in the kit (e.g. touch sensor, ultrasonic (distance) sensor, sound, light, and now color in the 2.0 kit).  The NXT-G application is actually an implementation of National Instruments LabVIEW graphical programming software which is used professionally by engineers and scientists.  In fact, you can use LabVIEW to do some advanced things with the robots that NXT-G will not handle.

The Education version of the NXT-G kit is now up to version 2.0 and contains separate modules for doing data logging and support new sensors like the temperature sensors.  In addition third party sensors can be added for specific needs – for example we added Compass and IRSeeker sensors from HiTechnic when we were doing our series with the robotics club on LEGO Soccer (i.e. needed to “find the ball” (bright IR source) and know “which way” was the opponent’s goal).

Dragging and dropping controls is quite easy for most students – in fact the biggest challenge continues to be slowing kids down and having them try to think through and plan out a solution instead of just barreling right into programming.  Probably an ongoing struggle for many programmers out there.

Small Basic (PC) - Free

Small Basic came out of Microsoft’s DevLabs as a simple programming language for kids to get started with.  It is unique among many of the rest in that it allows for the direct entering of programming code, whereas most of the others have gone to a graphical programming language.  It also preserves a lot of the BASIC syntax (15 keywords) so it will be comfortable for many adults that are assisting and mentoring kids who are starting to program.  It also means that the age range probably scoots up a few to perhaps 10-16.

The power of Small Basic comes in it’s simplicity (look at the tool bar compared to Visual Studio, Eclipse, or any other professional tool set).  There is only so much you can do and experimentation is easy to get into and execute.  Another part of the power comes from the .NET Framework.  There are many libraries included (Flickr one is shown) and others are being developed.  If there is something you want your Small Basic program to do, that it doesn’t to right now, develop a Class in your favorite .NET language and Small Basic will be able to access the functionality.

Scratch (PC, Mac) - Free

Scratch has been developed by the Lifelong Kindergarten Group at the MIT Media Lab as programming language for kids 8 and up.

Like Kodu, this is better demoed than described (pardon the music and volume level, but the later content is very helpful).

Many educators using it with a lot of materials freely available and ready to go.  With the backing of the Media Lab and some key educators (and as it is free) this is a platform that is growing in general adoption and use.  It is probably also in the 10-16 year age range and has many key features.

One of the other programs, besides BASIC, that I really miss is “Storybook Weaver” which enabled students to write stories with animated and multimedia features included.  Scratch, and next Alice, offer a lot in the way of storytelling in addition to programming.

Alice (PC, Mac – Java) - Free

Alice is unique programming environment out of Carnegie Mellon in that allows creation and manipulation of custom 3D characters and objects – which is really cool.  Creating 3D objects is hard but not impossible, and better tools are coming out all the time.  There are freely available 3D models that are being created by the community for use by others in Alice.

I have not used Alice, but that is only because of a lack of time and resources and not because of any other reason.  Here’s a video promoting Alice and showing many of its features.

Like Scratch there is a nice storytelling component in Alice which is currently called “Storytelling Alice” (soon to be “Looking Glass”).  So whereas the Alice 2.0/3.0 environments themselves are better suited for a formal class in programming, a more informal and easy-to-use version for storytelling (and basic programming) is available.

Now strongly allied with Java, Alice is extensible via Java which makes many other possibilities available for more advanced porgrammers.

KPL / Phrogram (PC) - $35-$50 + more for additional libraries

Lastly, to be complete in this list I wanted to include the Kids Programming Language (KPL) which has been retired, but has resurfaced as Phrogram.  The KPL effort was intended to create a simple programming language for kids that would allow for rich graphics capabilities and be extensible using the .NET Framework.  Admittedly I have not used or tried using the product since it became Phrogram, so I can’t make any recommendations.  On the surface it appears that the communities surrounding the other products are more active and current.

In Conclusion – there are no Conclusions

I am glad that the market for kids programming environments is heating up and that there may actually be competition instead of a big giant hole.  I am actively using NXT-G on a regular basis and am really starting to like Kodu (more each time I use it).  In considering a class or even formal curriculum for “next steps” I am watching Small Basic, Scratch, and Alice and expect to be using one or more of these in 2010.

One of the other fortunate things we were able to spend some time on last week was Kodu for the XBox 360.  Kodu is one of those things that is difficult to describe in words or even screen shots, and really needs to be experienced to understand.  In a nutshell it is a programming environment and visual programming language that lets kids create fully functional games using just the XBox 360 controller.

So how complex or cool could these games really get with such a significant limitation?

In the end all three kids want to use Kodu more than play any other games or videos at the moment.  And for them to use up their limited computer/game time on a programming environment is quite amazing.

The game works by adding programming commands using the XBox controller.  They are set up in a “when-do” type format (i.e. and “if-then” or “condition-action”).  So, for example, when-kodu-sees-apple do-move-towards-it or when-kodu-bumps-apple do-eat-it.  Sounds strange, but ends up being really powerful when you get into it.  Not only can the robots/actors in the environment have programs, but all the objects (stars, coins, castles, apples, balls, trees, etc.) have their own programs which can be cloned to make an army of autonomous elements.

The kids have created a few race, shoot-em-up, and Mario-style, games – be glad to share if anyone else gets going online.  Check it out and let me know if you get going.

I applied on Microsoft Connect to try to get our Bots on the Rock robotics club into the beta for using the PC version – I’ll let you know if that works out.

Check out the Kodu Forums online for more information and community around this cool new environment.

Kidbook vs. Netbook

I wrote almost a year ago of how I’ve been looking for a netbook that would meet some basic requirements for use by kids for their daily work.  There have been a lot of netbook models which are basically all the same specs, but none have really stood out as something that was designed and intended for kids, especially younger kids, to use on a daily basis.  Enter the Dell Latitude 2100 “kidbook”.  I’m calling it a kidbook because it adds some important features.

The 2100 is designed from the ground up for daily use in schools – it is not generally intended to be a consumer netbook.  This means some important things.  First, it amazingly comes with no promo/demo/annoyware installed.  While this isn’t really a feature, it saves perhaps an hour or more of uninstalling to get up and running.

The unit feels solid, has a rubberized shell, and is somewhat ruggedized – perhaps not to warehouse/government standards, but it definitely feels sturdy.  It immediately makes me think that this is what a “Little Tikes” or “Rubbermaid” laptop would look and act like. Also, the bottom of the unit has no access points for memory or drives, etc.  In fact if you even remove the four screws on the access panel it will not come off – there are three more screw under the keyboard (see below) that need to be removed to access the hardware. This adds a nice level of security from interested eyes, but adds some complexity of adding memory, etc.  Interestingly this also means that desktop spills could avoid damage as there are no access holes or vents on the bottom surface.  The 6-cell battery option raises up the base even more for additional clearance.

The 2100 is a barebones and utility machine.  It is not a tablet (though we did get the touch screen, see below), there is no thumb scanner, or firewire ports (3 USB).  The keyboard is solid and nearly full sized, but there are no multimedia keys other than volume/mute controls.  Did I mention there is no CD/DVD drive – typical for a netbook, but still something to get used to from desktops and laptops.

Finally the 2100 is very budget conscious – starting under $400, about $450 with the additional memory, touch screen, and webcam on these units.  I remember in 1991 when I was teaching computers and we got some Apple PowerBook 100s to pilot with some teachers and students.  These were $2,500 each in 1991 money.  Even the Newton-PDA inspired eMate 300 device was $799 in 1997 and didn’t even run “real” software.  The netbooks are finally a device that has enough power at a reasonable price for 1:1 student use.

Screen

Let’s get right to my biggest concern about the units the screen resolution - 1024 x 574?  Huh?  Computer monitors have traditionally been in a 4:3 ratio (e.g. 640x480, 800x600) and more recently 16:9 (1280x720) but netbooks have commonly chosen WSVGA resolution of 1024x600.  This is trouble enough as it doesn’t match any typical resolutions of monitors, but by the 2100 dropping a mysterious 26 pixels off of this causes additional problems.

Many web sites are expecting at least 700 pixel vertical resolution, so you end up having to scroll down to get to the active parts of many web sites.  But this is true of all netbooks and web sites are adapting to the netbook trend.

However, software installers can check minimum resolution before installing or setting themselves up.  Some software will see a vertical resolution of under 600 and set up for 640x480 which makes an awkward little box in the middle of the relatively big screen.  Others will not install without at least 800x600 resolution.  To get around this you can temporarily change your screen resolution to 1024x768.  This means you end up scrolling the screen up and down to see the full screen by moving the mouse up and down.  This will allow the software to install.  Then you can change the resolution back and the software will typically run (may clip the bottom a little).

But, 1024x576 is not one of the choices in the typical “Display Properties” dialog box – so how do you switch back.  It turns out it is not that straightforward, but here is the scoop.

In “Display Properties” Settings, choose the Advanced Button.  One of the Tabs will now be called “Intel Graphics Media Accelerator Driver for Mobile”.  Here there are two things: 1) the button that takes you to the actual screen you need, and 2) a “Show Tray Icon” checkbox that will enable access to this panel directly from the System Tray.  If you find yourself needing to switch resolutions to support certain software, having easy access to his panel will be helpful.

On this screen, finally, you can find the “native” resolution of the 2100 (1024x576).

An additional tip, the new Chrome web browser from Google has a unique functionality (that I hope gets picked up by IE, Firefox, etc.) that allows you to find a page on the web and then “Create Application Shortcuts”. This does two important things: 1) Drops an icon on the desktop, start menu, quick-launch bar, etc. for that web site (and picks up the favicon as an icon for the shortcut) and 2) removes all the UI chrome at the top (i.e. no address bar, tabs, menus, just the window title).  This enables kids to get to pre-selected sites very quickly and maximizes the vertical “real estate” on the screen for maximum use.

Touch Screen

I opted for the touch screen because I am developing some software that uses it, but I was surprised at how the kids started using this feature right away in many of the applications.  The kids must not have the hang-ups I have about touching a screen to get it to do things because they use it all the time.  In fact in some software like Rosetta Stone (foreign language – nice) it is much more instinctive and natural to use the touch screen than maneuver with the touchpad.  Not much more to say about this yet – I am eager to get some software going that will use it even more.

CPU

The 2100 uses the common combination of the Intel Atom N2170 CPU and Intel 950 GMA (graphics media accelerator).  This combination does a very respectable job of running most software very well.

The notable exception is software that requires significant graphics memory and 3D acceleration.  Two failures in this regard were Age of Empires III and Civilization IV.  A general rule, if you considered buying a new video card to run a game or program, then it will probably have issues on a netbook

The 2100 plays video well (avi, mov, mp4, and even DVDs, see below), but don't expect to record or edit videos on the machine itself.  The performance was very respectable with photos (even large ones) consider the higher-end (2Gb) of memory if editing and manipulating images will be important..

Integrated Camera / Microphone

We also opted for the integrated webcam and digital microphone.  I was very pleased when installing Skype (video conferencing) at how well it worked with the hardware with the standard install.  The device comes with software for basic webcam recording and still picture capture.

The one trick we found was actually enabling the integrated digital microphone in applications like Skype and Audacity (audio/podcasting).  There is only one microphone driver/input in the software but there is an external jack for microphones and an internal digital microphone.  I only found one place to switch between the two.  If you open the control panels there will be one called the “Realtek HD Sound Effect Manager”.

Opening this up you will find a tab called “Mixer”.  Once selected you will have the option to select the radio button for either the external or integrated/digital mic.

Memory

There are really four configurations of memory in the 2100: 512Mb, 1Gb, 1.5Gb, and 2Gb.  The interesting thing is that the initial memory configuration is very important.  The first 512Mb or 1Gb of memory is actually permanent on the motherboard of the laptop – that is, it can’t be removed or upgraded.  There is one slot for memory that can take an additional 1Gb of memory.  So starting with 1Gb maximizes your memory potential.  This is how I ordered the units because additional memory was $29 for 2 1Gb DIMMs online (and I was over budget because of the touch screen and webcam already).

Adding the second sticks of memory turns out to be more involved than any laptop I have ever used or owned, and this is saying a lot.  It turns out that you first need to remove the keyboard (2 screws) to get to the internal screws attaching the bottom cover (3 screws) and then you need to remove the bottom access cover (4 screws).  One note here is to be careful with the keyboard cable clip.

This clip opens upwards (see above) and stays attached – or should stay attached.  One one of the units I had this clip (the white part) completely detach which lead to 20 minutes or so of anxiety before my wife (with better eyes and smaller fingers) got the clip to click back on (thanks Laura). 

The second 2100 memory upgrade went fine with the keyboard clip but the memory did not “seat” correctly so I had to re-remove the 9 screws, keyboard, panel, etc. and do it all over again – good experience, but, again, not as “friendly” as many other laptops.  Perhaps having Dell install the 1Gb when building the machine is worth saving $10 on memory.

On the plus side, this really keeps curious kids from getting into the device (it’d be nice if you could get a replacement set of outer screws that were Torx or at least not Phillips-head screws to slow them down even more.  On the down side this makes a typically easy memory upgrade a much more involved task.

Operating System

Ubuntu Linux, Windows XP SP3, or Windows 7 – not considering Vista as a practical option right now.

This is actually a pretty easy decision for us. Linux won't run most of the educational software (out of emulation). Likewise Windows 7 won't run much of the software and “Virtual XP” mode is not supported on Atom processors.

Macintosh OSX not available on non-Apple equipment - will Apple release a netbook / kidbook?

So Windows XP SP3 is probably the most stable and understood Windows operating system in use (since Windows 98SE) and runs the important software we use.  Microsoft has stated that the XP downgrade option will be available for 18 months after the release of Windows 7, after that a CPU and memory upgrade will probably be necessary to achieve similar results.

Networking

Unsurprisingly the 2100 supports Wi-Fi and wired connections (no 3G or WiMax, but not needed).  But surprisingly it supports 802.11n high-speed Wi-Fi and 1000 Gigabit Ethernet wired connections which are not common on typical netbooks.  They also have the ability to “wake on LAN” which enables solutions like the upcoming “Managed Mobile Computing Station”.

This unit enables 24 of the 2100s to be docked for charging, storage/security, and remote updates (even includes it’s own wireless router so you can plug in one Ethernet cable and wirelessly power a room).  But at close to $4,000 this kind of kills the whole “on budget” theme for a classroom – hmm, 10 more 2100s or a fancy cart.

Bluetooth 2.1 is available as an added option (we didn’t opt-in).  This was tempting for use with the LEGO Mindstorms NXT robotics kits, or wireless mouse, but I can imagine the pairing and management of a classroom full of Bluetooth devices could get challenging.

One other thing is the somewhat hyped feature of the Network Activity Light.

This is included on the cover of the netbook and shows if any network interface is being used (i.e. light on if activity, light off if no activity).  I’ll stop short of calling this a “gimmick” but in our experience the light is always on because the network is always on.  If there were an easier way for kids to turn the network on and off, or some software uses this for other purposes (a promised API from Dell for educational software programmers may be coming soon), then this may have a larger use and impact.

Battery

Dell offers a 3-cell and 6-cell battery for the 2100.  The 6-cell adds a little bit of height but is barely noticeable.  One unique feature is that there is a clear plastic “window” on the battery where you can slide in a strip of paper with a particular student’s name (or other identifier) on the unit.  This gives a clear way to identify different machines in what may be a crowded classroom situation.

Keyboard

The keyboard is nearly full-sized and I had no time with my huge hands typing e-mail and other tests.  Another unique option here is an antimicrobial protected keyboard option. In a shared environment could be a real plus with the flu and colds going around.  For 1:1 use this may not be as much of a benefit (did not opt for this either).

CD-DVD Options / Issues

Sometimes there is no getting away from using external media.  Ironically all the backup and recovery software for the 2100 comes on CD, which you can’t ever access from the 2100 directly.  Also, some curriculums include physical DVDs (e.g. One Year Adventure Novel) and others have a lot of media that needs to be accessed from the disc (e.g. Rosetta Stone language software).  In these cases you have two options.

The first is an external CD/DVD drive.  The best of these will require no external power and can be powered directly from the USB port.  Dell has an option for this when building the machines for $90 which includes PowerDVD (playing DVDs) and Roxio Creator software (burning discs).  I was watching for deals and found a Samsung drive on sale at NewEgg for $49 which included Nero 8 (playing and burning).  This has worked well for installing software, running CDs, and playing DVDs – I was impressed that the laptop played the DVDs so well with the limited power.  I am sure when you are running off of battery power that this would significantly reduce battery run time.

The other option is to use disc images on the hard drive.  Utilities such as PowerISO will allow you to create an image of most CDs/DVDs and store them on the hard drive, and later mount these images as virtual disks.  This essentially mirrors the content of the CD/DVD to the hard drive.  This image can then be run using just the hard drive.  This raises all kinds of copyright issues and licensing headaches.  This is a topic for another post, but make sure your licensing allows for this type of use and that you are covered for the number of simultaneous installs and users that you have. Some discs have copy protection on them and will not work with this method of mounting – this clearly shows the intent of the publisher – contact them directly as I am sure this will be a common issue going forward.

Ideally software will move away from distribution by disc, and even installing locally on the netbook at all (more below on this).  But until then there are still options for curriculum that is distributed and/or must run with a disc.

Pros

Marketing material is one thing, but a well designed “kidbook” is worth lauding.  If I haven’t mentioned it before I am in no way associated with Dell and don’t get any compensation from them.  That being said, I really do like the 2100s.  They are solid and do what they claim to do, and don’t do what they don’t claim to do.  The price point is quite reasonable considering the power and functionality provided.  Unique options like the touch screen, anti-swine flu keyboard, rubberized and secured exterior, etc. are very nice to see.  The touch screen and web cam enable more “natural user interface” options that enable use of the 2100 beyond the keyboard and mouse/touchpad.

Cons

The biggest “con” is the screen resolution (1024x576).  I would predict that this gets a remedy fairly quickly because of the non-trivial impact that it can and will have on software installs and execution.  Unfortunately early adopters will be somewhat left behind by this – but that is one of the risks of being early to any technology.

Recommendations

When I was young and foolish I leased a 1995 Dodge Cirrus based on a popular consumer's magazine "Car of the Year" award (because I had finished my Masters degree, and had a full time school administrator's job, and "deserved" a new car).  I only mention this because it was the worst car I have ever owned, recalled twice, in the shop for mechanical failures 5 times, and all in the 24 months of the lease.  This is/was the last new car I ever bought and I learned an expensive lesson about cost and value (and how leasing is 95% of the time a terrible option).  I also learned not to give or trust recommendations without a significant amount of hands-on time for new models.  Interestingly the said consumer magazine has also adopted a similar policy for new models.

And you probably realize where this is going - I am going to hold off on recommendations concerning the Dell 2100 until we've spent some real-world time using it.  Unfortunately models change so fast with computers that waiting a year to make a recommendation will probably find the Dell 2115 in production with the first or second round of enhancements.  But I am in no way sending them back, and am cautiously optimistic that these will really be helpful going forward. I am also realistic that there will be improvements (1024x576) and tweaks and being on the cutting edge is exciting but sometimes you get a little cut up in the process.

Overall I’d give the 2100 “4 of 5 stars” or a solid B+, which means there is a little room for improvement but it is a solid offering and unique today in the marketplace.

Products Installed / Mentioned Here

• Rosetta Stone (Language Learning) http://www.rosettastone.com/
• Skype (Audio/Video Calls/Conference) http://www.skype.com/
• Lego Mindstorms NXT (Robotics) http://mindstorms.lego.com/eng/Egypt_dest/Default.aspx AND http://www.legoeducation.com
• Teaching Textbooks (Math, 4th-Pre-Calc) http://www.teachingtextbooks.com/
• PowerISO (create/mount disc images) http://www.poweriso.com/
• One Year Adventure Novel (Writing 8th+) http://www.oneyearnovel.com/
• Wikipedia http://www.wikipedia.org
• Google Chrome (web browser) http://www.google.com/chrome 

Implications

This is already 2 or 3 times the size of a good blog post, but I plan to add another post at some point about the implications of netbooks in the marketplace.  Some technology analysts predict that in 5 years 50% of internet connected computers will be netbooks. Software and services targeting (or at least supporting) netbooks will be an important market.  Software distributed via the network, or better yet delivered in real-time over the network, will be in demand.  Also, software that can adapt to the screen size of the user (from 10” netbook to 30” desktop monitor) will be popular to enable use and features based on the power and size of the particular install.  Some examples of recent posts on products of this type are below.  I’ll have to also post some samples of what we are doing with Silverlight and dock panels and view boxes to show some of the latest technology to help enable functionality in installations on different screen resolutions.

http://eeepc.net/netbook-office-suite-launched-by-corel/

http://eeepc.net/thinkfree-office-suite-available-for-purchase/

UPDATE: Had to fix the URL "slug" it was messing things up (never include a quote in a slug).

I get regularly chided by some friends on Twitter and Facebook when my updates and messages seem to include things that are quite foreign to many people – and in reviewing a few of the more egregious posts, they are absolutely correct.  So, to head off what will be a small barrage of posts the rest of the week, I wanted to put a quick post together on the CodeMash conference that I’ll be attending Wednesday through Friday.

What is CodeMash?  It is a regional/local conference (Sandusky, Ohio) for software developers (i.e. the “Code” in CodeMash).  But is is quite different in that it offers, allows, and even encourages programmers of all different “flavors” (e.g. Microsoft (.NET), Java, Ruby, PHP, iPhone, etc.) to present – this is the “Mash” or mashup.  A “mashup” is typically an application that takes functionality from different sources and puts them together in new and exciting ways – even if the different pieces were never really designed to work together.  So this, in my opinion, is the genius of this conference – you can have a main focus on one set of technologies (and my “bread and butter” is Microsoft) but still get a great taste and experience of what the rest of the industry has to offer, and come out better because of it.

January has many different conferences and meet-ups like the Consumer Electronics Show (CES) with all the new gadgets for the year, MacWorld with typically new computers, iPods, software, and even the Detroit Auto Show with all the new cars (we need some real excitement there).  But if I could be at any of them in January I would pick something like CodeMash because is the one that really only works well when attended in person.  I can read the press releases from CES and MacWorld and get 90+% of the information that I need. CodeMash is about learning from others, interacting with others, and really following the personal flow of what is important and interesting to an individual. 

There is also the opportunity to attend and even present in the Open Spaces area of the conference.  This is where impromptu presentations and discussions happen around topics that are of interest to the people that are there at the moment, and the content and timing of these sessions can not be predicted in advance.  It is a weird idea if someone is used to just being a “consumer” at a conference, but when you start to see the conference as “collaboration” and “community” then you really start to be fully a part of the group.

Finally, there is the whole “Twitter Tribe” and “Facebook Folks” aspect of the conference.  That is, there are some people that I’ve met only briefly (or never met in person at all) but follow and lightly interact with online. CodeMash is a chance to really put faces together with people and have the richer personal interaction that builds relationships with other people who share the same “craft” and many of the same interests.

So if I stray into “geek speak” over the next few days oblige me a little bit and I can explain more when I get back and see you face to face.

 I’ve been hoping and watching for a great portable computer that would be ideal for students (and others) for many years – at least since we tested some PowerBook 100s with teachers in 1991 (only to have some returned to us as almost “unusable” – imagine giving back technology to someone, it was a pretty “underwhelming”).  The PowerBook 170 was much better but cost $5,000 each (in 1991 money) and only lasted a year in production as well.

Come forward 16 years and there is the ambitious “One Laptop per Child” vision of Nicholas Negroponte that brings some of the best minds together to figure out how to build a cheap and rugged laptop to enable students world-wide to gain access to a wealth of information and functionality.  But this vision misses on several important points, but creates a wonderful market for smaller form factor and lesser functionality devices for students and really anybody that is mobile and wants to stay connected and productive.

In 2009 I would really like to buy 3 Netbooks (one for each of my children) to use daily as part of their educational (and other) pursuits.  This is a non-trivial purchase so I am considering it very carefully.  The market for Netbooks is coming together quickly, though there is even a new challenge this week over whether the term “netbook” is trademarked.  But the issue for this post is a recap of what I would really like to see in a Netbook, and why.

The first few things would be related to the “Net” part of “Netbook”

• The device should be able to operate when not connected to the Internet, but should achieve full potential and functionality when connected to a network.  There should be options for achieving this connectivity including network cable, Wi-Fi, and mobile networks (3G, EDGE, WiMAX, etc.).  For the later, the ability to integrate the connectivity within the main case is ideal (don’t want a “dongle” for each type of connectivity).
• Bluetooth – not required.  If it is “on the chip” with the other wireless features, then go for it.  But if it adds even $20 to the cost (and/or measurably reduces battery life) then leave it out.
• Needs to run OS-independent software from “the cloud”.  I don’t care if the Netbook itself runs XP, OSX, Vista, Ubuntu, Android, etc. as its base OS, as long as there is a platform that software can be developed on to run across devices.  This could be Flash/Flex, Silverlight, JavaFX, AIR, etc.  The ability to develop, market, and sell/distribute apps to the different Netbooks is really important.
• An optical drive should not be required, but could be connected as an external USB/eSATA device.  Installing “full-blown” applications from a CD/DVD should be possible, but limited.  Limiting local storage should be a goal to enable apps running from the “cloud” and saving data back to the network as well.
• Basic CPU – no quad-core x64 3D gaming rig here.  A nice low-power CPU, optimized for wireless applications would be nice.  Atom processors are the rage right now but VIA and AMD have processors that would work too.

The next few things would be related to the “Book” part of “Netbook”

• First, it should be roughly the size of a book – could be a hardcover, paperback or in between.  This puts it somewhere between an iPhone and a traditional laptop computer.  A target would be 8-10” screen size.  It seems that some are now at the WSVGA screen size (1024x600), better than SVGA (800x600) but full XGA would be nicer (1024x768) (see cost discussion later).
• It should provide many of the same functions of a book (reading, reference, easy access to information).
• It should be “dockable” to use a larger display (keyboard, mouse, etc.) if available at a desk or lab.
• Fairly ruggedized and should not weigh very much (think carry in backpacks) – 2 pounds would be ideal.  This device will share backpack space with other books, be banged around a bit, and will inevitably be dropped or otherwise abused. Netbooks that are engineered well in this area (e.g. rubber, plastics, where appropriate, SSD drives instead of spinning media, etc.) will have a definite upper-hand.

Finally things that really have nothing to do with “Net” or “Book” but are things I think of being part of this device.

• Webcam and microphone input – I really think that multi-media and multi-modal input for so many things is really important that I hesitate to leave this for just those that add external devices.
• Basic speakers – nothing special.  Headphone jack.
• Touch/Tablet screen – torn on this one.  There is a lot going on with multi-touch on the iPhone and Windows 7, but nothing really “proven” yet.  I think the expense that this would add would not be worth the money
• Battery life – probably the biggest hurdle Netbooks face.  Ideally it would last a full work/school day, say 6 hours of use.  Ideally the device could “sleep/hibernate” easily and have it easy to swap in a fully charged battery.  Kind of like batteries for cordless drills and other tools – yes the Netbook is a tool.
• Now that we are talking money.  The device should be $400 +/-$100.  Under $300 would probably be made so cheaply that it would violate the “ruggedness” need or some of the features.  More than $500 and it is getting too expensive.  I know this is a tight margin for prices.

I’ll update this post if/when I decide to commit on which ones to buy.  I’d appreciate any feedback or ideas that others have in this area as well.

Update 1: Added some details, fixed some weird formatting

Sure the AutoCompleteBox, Expander, TreeView, Charts, etc. from the new Silverlight Toolkit (http://www.codeplex.com/Silverlight ) are cool – and will make some Silverlight apps look even better.  But the ImplicitStyleManager (and related Theme classes) will now allow designers to encapsulate their design work into an assembly and xaml resource dictionary, and easily apply the theme to an entire page (or part of a page).

On the surface this is “duh” you could do that before – but not so.  You had to “touch” every control and add a Style and/or Template to it and have that StaticResource appear in a generic.xaml or App.xaml somewhere in your app.  Now you should be able to “style-up” and entire Page/App in a few declarative steps.

This means that there could be a market for professional looking themes for Silverlight apps that developers could apply for a really polished look in their applications.  It also means that custom themes can be created for a company or project that can be easily and consistently applied to many different controls and/or applications.

I am eager to try this out on a larger scale in the next week or so – will report back.

Check it out (with some nifty pre-packaged themes for your use) at http://www.codeplex.com/Silverlight/Wiki/View.aspx?title=Silverlight%20Toolkit%20Overview%20Part%203&referringTitle=Home&ANCHOR#ImplicitStyleManager

Another “geek post”, sorry.

We’ve been updating some of our MVC apps to the beta and were relying on the non-GAC implementation of MVC (i.e. we didn’t want to have to physically install the MVC .dlls on the shared dev and live servers – we’ll do this for RTW but not the betas).

However, even when we copied the DLLs locally and referenced those .dlls we were still getting a “yellow screen” error that the assemblies could not be found.

It turns out that there is a little-known property on the References themselves that is needed to accomplish the task of copying and referencing these .DLLs.  Select one of the References to the .dlls (say System.Web.Routing) and look at the properties.  You must set the “Copy Local” property to “True” in order to reference the local copy.

Took a little while to find this – hope to save others a little time.

After a really busy summer I am making an effort to get back into a routine which includes posting about some interesting things going on personally, professionally, and otherwise.

I thought a “soft-launch” back into it would be sharing one of my pet-peeves of the day.

The “insult to injury” here is the “Did you find what you wanted?” phrase – because apparently the little doggy did find a lot of things I probably wanted to see, but refused to show them to me.

From a Test-Driven Development perspective wouldn’t you do a simple count of the items on the right and match to the “found” number on the left?

I am getting a chance to do something I’ve wanted to do for a while – that is, get paid to do some Silverlight development.

That being said there is a lot to prove to our customer and ourselves that Silverlight is the right choice, and is at the right level of development, to be used as the platform for running day-to-day operations for a multi-million dollar business.  So we are undertaking a process to evaluate Silverlight and prove out some of the “unknowns” of Silverlight.

Other options are out there for the User Interface for this application:

(1) A “fat” installed app (WPF or WinForm) – the current app is a fat Windows 3.11/95-looking application with decent performance (especially when it was designed on PC’s with 1/10 the power of today’s applications).  But this app will be widely deployed (50+ sites) and tech support is limited and costly to overhead.  Web applications, or at least web-deployed applications, are preferred.

(2) An Ajax-enabled Web Site.  There is a lot of “magic” you can do with a little Ajax and some custom Javascript coding.  But, having done several of these sites, you end up feeling that you are making a web page do something “unnatural” (i.e. something it wasn’t designed to do).  And supporting and debugging these applications can be complicated.  Plus there is an inherent performance issue with even the best designed web application.  This is especially true when coming from a very performant Windows application to a new browser-based application.

(3) Flash/Flex. In addition to this Silverlight POC, at CQL we are working on a Flash and a Flex-based application from two other companies.  We’re updating a Flash-based application that gets a lot of XML-based data from simple web services, and we’re writing the services to support a modern site-wide Flex-based application.  There are other RIA options out there, and the two different design firms have much more experience with the Adobe products than Silverlight.  To their credit they have heard of and have used the basic Silverlight tools already, but never anything “production.”  So we need to prove to our clients and our design partners that this is a good idea.

So, what needs to be proven and how are we going to go about proving it out.

Here is the start of the list – this will build over the next few weeks.

1) Automated testing – how to test the front-end Silverlight controls using automated testing tools

2) Web Service calls / Databinding – using secure web service calls for data routines.  Pull-type calls for common actions/methods.  Also Publish/Subscribe type services that could push important data to subscribed controls.  How to handle disconnected concurrency issues?

3) Security / Roles – encrypted traffic.  Working in the same security context as the containing web application (i.e. login, roles, etc.)

4) Dynamic Control Loading – app needs to perform very well and should only load the components that are needed at any one time.

5) Keyboard/Keystroke/Hot-Keys – many of the current functions of the system have assigned key shortcuts than enable staff members to quickly access common features.  Can this be reproduced in Silverlight?

6) Stress/Load Testing – How does the load of an application that is mainly web service based differ from that of a get/post HTML web application?  Many small messages vs. less frequent bigger messages.

7) Real-world ability to work with designers – We’ve all seen the PowerPoint slides showing how easy it is to work with XAML between developers and designers.  Is it true?  Does it work in real life?

8) Uploading a file – can it be done in Silverlight or will we need some Ajax/Web Page interaction?

9) Drag-and-Drop – part of the app is a scheduling calendar – can appointments be rescheduled via drag-and-drop?

10) Controls – are there enough now for what we need in beta 2?  Are any third-party controls worth using/buying?  Can we do common data-entry validation (e.g. masked-edit textbox)?

If you ask most of the world about Steve Job’s keynote this week, they will basically tell you that it was the iPhone 3G announcement (new cheaper, faster, stronger, iPhone for the world) – which is true, but it was more than that.  This was at the WWDC (world-wide developers conference) for Apple Computer. 

iPhone as a Primary Platform

There were 5200 (sold out) developers at the WWDC for 147 different sessions (85 on Mac, 62 on iPhone). 62 on iPhone – 42% of the developer sessions were on the iPhone and new iPhone SDK 2.0.  You see, Apple doesn’t sell that many Macs, as their competitors will tell you.  Macs are only 5-10% of the total number of personal computers out there.  When Apple came out with the iPod and iTunes, they found a market they could dominate.  One of the other slides in this part of the keynote said there were “Three parts to Apple now Mac, Music, and iPhone”.  Apple makes as much, or more, on their iPods and Music as they do their Macintosh computers. 

Now they are looking to dominate the cell phone market as well – specifically the Internet-enabled “smart-phone” market.  And much of the rest of the keynote showed how seriously they are taking this market.  There has been talk of this trend away from personal computers and toward “intra-personal communicators”.  People don’t want to be “tethered” to a desktop PC, but mobile with their laptops and cell phones.

Mobile devices are a first-class development platform for 2008+

Partnership and Perception

So what does Apple need to dominate the phone business that they don’t already have? (1) the Enterprise user (i.e. the Blackberry crowd), (2) the College / GenX crowd, and (3) the Techy crowd (i.e. the ones who timed every download on the “old” EDGE network), (4) Loyal Mac/iPhone fans, (5) Education users (very loyal to Apple) and (6) everyone else.

When announcing all their new features, Apple did some important things.  For the Enterprise announcements they teamed up with top Fortune 500 companies to add credibility.  They dropped key technology names like Exchange and Cisco to gain points with the corporate IT crowd. SEGA was first off with a motion-sensitive Super Monkey Ball application to appeal to fun/gamers with an app done in “2 weeks” that beats all/most N-Gage games 3 or more years into development.  Then for “everyone else” there is eBay, TypePad, AP, MLB.com, etc.  For the Techys/Mac folks there are demos of “Cow Music” and games from Pangea Software.  For Education there are Medical content/training demonstrations.

In short it shows that Apple understands the market and their customers and has something to say to all of them.

Microsoft is doing a similar thing with Silverlight and the Olympics, MLB, NetFlix, and others.

It doesn’t matter how cool your technology is, if key players are not developing for it, then users won’t have any reason to move to it.

Leveraging the “2.0” Trend

Everything “cool” right now is “2.0” – whether it is Web 2.0, Learning 2.0, etc.  Now there is the iPhone SDK 2.0.  Most developers who wanted apps on the iPhone had to create Safari/Web based apps that fit well on the iPhone browser (and this will continue). But now what is touted as an “entirely new platform” enables full APIs (down to 3D graphics, and “presence”) for developing applications.

“2.0” isn’t coming, it is here – BTW, stop calling everything “2.0”

Internationalization

It has been largely possible to develop good web sites, and have them be very successful, using only American English.  Some/few sites have worked to become multi-lingual in other primary languages. Apple made it clear that the iPhone will have support world-wide with versions and cell phone carriers in 70 different countries. 

Developers need to think about multi-language support from the very beginning of applications.

There have been two interesting keynote speeches in recent memory: Bill Gates at TechEd, and Steve Jobs at WWDC.  They both reflected on the current state of technology, made predictions, and made announcements.  So what of lasting value came out of what they had to say, and how might this impact choices being made for the future?  I’ll give you my $.02 worth on both of them, and see what you think as well (and I’ll try to fix the Blog comments to get some feedback too).

Let’s start with Bill Gates (transcript).  Perhaps the most notable thing coming out of Bill’s keynote is that it will be his last as chairman of Microsoft.  I’m sure he’ll be talking in the future, but not in the same capacity.  What effect might this have on the future of Microsoft?  How much impact has he had in the last few years as chairman, and in what areas of the company?

Continued Increases in Performance

The new trend for increased performance is no longer increases in chip speed (i.e. number of instructions per second).  Now the increases will largely come from having many different cores and processors doing work together in a single machine or on a single chip.  Also, there are systems working together across different machines, even out across the Internet.  Today’s programs aren’t written to take advantage of this Parallel processing and Cloud computing.  New techniques, tools and frameworks will need to be built in order to take advantage of these new resources, or else fall behind.  Sun’s John Gage quote, and Sun’s motto, “The Network is the Computer” is turning into “The Network is the CPU”.  Programmers who don’t learn how to segment and separate their code for distributed processing will soon find themselves at the same disadvantage as those that couldn’t move from procedural programming to event-based and object-oriented techniques.

Changes in Interaction

A big theme in this talk was the future of human-computer interaction.  Now our input devices are basically keyboard and mouse and to a certain extent pen.  The future is all about “natural interfaces” like touch (and multi-touch), voice, and vision. Star Trek, especially The Next Generation, seemed to me to have a nice balance in their technology user interfaces.  There was voice interaction, tactile/touch LCARS screens, and pen-based PADDs.  The Microsoft Surface touch technology, now being demoed for Microsoft Windows 7, could easily implement LCARS.  iPhones have done PADDs even one better by including the communicator.  Really the only illusive technology is the voice-recognition, which is still very hit-or-miss with today’s technology.  The vision systems have a lot to offer.  The Wii implements vision and 3D motion in their controller to great success.  The main lesson here is that developers who do not spend some time looking beyond simple point-and-click and keyboard input may also find themselves falling behind.

Robotics

The last thing that struck me was a seemingly larger commitment to robotics than I have seen from Microsoft before. In a sense robotics is extending the range and type of outputs in much the way the “natural interfaces” were extending the inputs.  They made the interesting comparison between the robotics development environments today and the computer programming environments 30 years ago.  Developing for robots means developing for a mobile system.  It means being able to process a wide variety of sensors and inputs and make decisions quickly.  It also means programming routines that are constantly running (e.g. keeping the robot balanced, monitoring the environment, etc.) and that run independent from one another.  On interesting component in the Microsoft Robotics Studio is the very sophisticated simulation environment.  What it means is that people can create programs for very expensive or dangerous robots and run a variety of tests and actions without ever needing to test on the actual hardware.  In fact Microsoft has started a Robochamp competition to see how well people can do at programming robots in large-scale scenarios (e.g. DARPA urban challenge, Mars rover, etc.) without needing the hardware (or getting to Mars).  In a sense this is disappointing because you don’t get to do the engineering and inventing of the robot (which LEGO Robotics folks will tell you is more than half the battle).  But in another sense it means the people with a simple download can get a flavor of what this type of programming is like without a huge investment.

Creating programs that talk to a wide variety of peripherals and take input from many sensors is an important trend here.  And learning to program and test in a simulated or virtual environment is also a good thing to learn.  All-in-all I think this was a very good breakdown of some of the challenges facing developers today.

Next we’ll look at Steve Job’s perspective …..

Continuing the How I Got Started Meme… cool idea, get to know the TwitterTribe better (and others)

How old were you when you started programming?

Wrote first program at 11 - BASIC 1.0 on Commodore PET

How did you get started in programming?

In grade school I was most likely ADD, so when I got done with my school work early I was a bit "high-maintenance".  The teacher's solution was to send me to the library and let me be someone else's problem.  Fortunately the librarian was great and always had stuff to do, books, filmstrips, etc.  Then one day the Commodore PET arrived and I lost 2-3 hours a day for the rest of 6th grade.  The sample apps were fun to play, but I wanted to see how they worked.  Some apps were "protected" but many others you could see the BASIC code.  A few books and a text-editor later, we were on our way.  Wrote several semi-complex apps, but they were pretty juvenile.

What was your first language?

BASIC 1.0

What was the first real program you wrote?

First of any length was a "Lord of the Rings Adventure" game, modeled loosely on some of the Scott Adams Adventures that were poplular at the time (e.g. Adventureland, Pirate Adventure, etc.).  It was text-only (i.e. a "console app" for younglings) even had a basic parser (bunch of nested if/thens) - AppleSoft Basic.  Even made up some disks of it to sell as "shareware".  Never sold any - gave a couple away.

First program I ever got anything for was a simulation of a beam of light bouncing off a parabolic mirror for the Cranbrook Institute of Science.  They had a huge (4-5 foot diameter) parabolic mirror in one of the exhibits and wanted to simulate how the beams of light went into the mirror and back out.  The program used Apple ][ "hi-res" graphics and a game paddle (PEEK/POKE) so you could move the beams of light around and watch how they moved across the screen, off the mirror, and all went through the focal point.  Hardest part was drawing the parabola.  All I got for it was free admission and access to some of the "backroom" areas of the museum - it was worth it.  Funny thing was when I went back years later the mirror was gone but the Apple ][ was still there (as an exhibit - sigh).

What languages have you used since you started programming?

I'll define "used" as writing 2 or more programs, over 1000 lines of code.
BASIC (many variants), 6502/68000 Assembly, Pascal (several), PAL, Fortran 77, Modula-2, C, Objective C, RPL, AppleScript, HyperTalk, Mathematica, Javascript, LOGO, Iptscrae, Perl, SQL, Java, ActionScript, VBScript, VB.NET, C#, NXT-G

In the "hello world, up and coming" list are: F#, VPL, PHP

What was your first professional programming gig?

The first full-time (summer) job where I got a paycheck was at the Masonry Institute of Michigan.  They needed a Novell 2.11 server installed, Baseband wiring for a network, and mostly a shared database server application.  This was a Paradox database, which meant I spent a few months learning and programming some pretty complex apps in "PAL".  There are still some nice things you could do with PAL that are much more complex to do today.

The next summer I got paid as a research assistant programming quantum-mechanical wave functions in Fortran 77 on a Cray YMP Supercomputer.  The Cray was in California and we connected first via 300 baud modems, and later over this new "Internet" thing.

First full-time professional web programming job was using SuiteSpot with LiveWire Pro from Netscape Communications Corp to code in server-side Javascript.  You got to use Navigator Gold to edit source files which it actually compiled up to the server.  There were objects to maintain state and the suite included Informix to contain application data.  We used Oracle for some data from customers as well.  We used both Solaris and Windows NT 3.51 (with Netscape's HTTPD server, not IIS 1.0).

If you knew then what you know now, would you have started programming?

Yes. No regrets.  I might have taken computer programming "seriously" a bit sooner (I guess implying I take it seriously now).  It was always more of a hobby.

If there is one thing you learned along the way that you would tell new developers, what would it be?

Code a little every day, and use a new language or framework whenever you get a chance.  But, take a day off a week and unplug and go off the grid for a while with real live people, friends, family, nature, etc. and do things.  If it needs batteries or a plug, let it go for 24 hours.  Even just in practical terms, completely letting go of tech regularly tends to "free up your local cache" and "defrag your life".  You might need to drag some others with you, kicking and screaming from their wired "life support", but they will thank you for it, in the end (you know I don't mean literal "life support" right - a metaphor).

What's the most fun you've ever had ... programming?

It's all fun, really, just different kinds of fun.

There is "Puzzle Solving" fun, learning something new, rendering a 3D Fractal for the first time, creating something that wasn't there before.

There is "I have Power" fun, typing in a command and having the computer "obey" you for the first time.  Even now programming a LEGO robot to "do my bidding" is oddly fun.

There is "Gaming" fun, writing a basic game that someone actually has fun/laughs using, playing games (Wii Mario Kart, is fun).

There is "Helping Others" fun, seeing a start-up or inventor/entrepreneur get their site up and running and start bringing in customers, fixing a family computer (again) so they can get back to whatever they were doing (fun for the first few times)

There is "Hacking Fun" taking things apart, putting them back together (sometimes), tracking a Wii controller via Bluetooth, making a touch screen, etc.

Any and all of these could justify an "all-nighter", and be a lot of fun.  There is a lot of "un-fun" things in our business, but most of the actual coding is really fun.

I've been committing to get back to occasional blogging, in addition to following Twitter, so I wanted to see if I really could get out a 10 minute idea-to-blog post.

Here it goes.

I found this really handy utility on the "Office Labs" site called "Community Clips".  On the surface it is "just another screen capture utility" but I found it really handy.

Once installed it will capture the screen (or specified window) and record the input on the microphone.  So you can start recording, do a task you want to help someone with, and save the screen capture and audio down to disk.  The nice thing then is you can just upload that video and you are basically done.  The software will even automatically upload your video to the Community Clips site if you are demonstrating some Microsoft software.  Then your tips will join many others for the same product.  Since I didn't have a real worthy example, I just uploaded mine to Silverlight Streaming and YouTube.

This seems like a great way to do basic tech support or short instructional videos.  There are certainly much higher-end software for longer sessions, special features, editing, etc. - but for the quick one-off videos of this type I think a simple tool like this is ideal.

Below should be the samples - you'll need Silverlight for the top one and Flash for the bottom one.

And yes, this post, plus the video and uploads, fit in the 10 minute post goal!

p.s. The video is really boring - don't have a microphone set up right now.  Just me loading the Community Clips web page.  Just a technical test - but it works.

p.s.s. It is an interesting comparison of Silverlight Streaming vs. YouTube.  If you double-click the Silverlight version it will go full screen - at which point it is quite usable.

Community Clips

Over the next week or so I plan to have individual blog posts about my "favorite" demos in this presentation, but I wanted to get the PowerPoint stack and code samples out there ASAP.  I will definitely blog in detail about the SEOHelper, Blueprint CSS additions, jQuery Ajax (3 ways), and the MasterPage/BaseController/BaseViewData pieces. 

• Powerpoint Deck
• Code Samples

Where to get the current MVC builds

• The sample code uses the 0416 Interim Source Code Release bits

Blog posts, forums, etc. where many of these ideas/solutions came from

• PagedList<T> routes for LINQ to SQL data - Rob Conery
• Model-based Client-side Validation for ASP.NET MVC - Steve Sanderson
• Password Generator - Chris @ SloppyCode
• MasterPageBugFix - Michael Jenkinson's solution - for BaseViewData inheritance
• Scott Gu's Blog
• Scott Hanselman

Projects, resources, etc. where many of the libraries came from

• Blueprint CSS
• jQuery
• jQuery UI
• tablesorter
• clueTip
• LiveValidation (js framework for client-side validator)
• Castle Project - Validation libraries (and much more, we used the validation)
• Asirra - "cat" CAPTCHA from Microsoft Research
• FCKEditor - HTML editor for textareas
• log4net - for the ActiveFilter for logging
• MVCContrib

Another tool I use almost daily for documentation and presentations is Window Clippings, by Kenny Kerr.  There have been screen capture utilities out there since ... well ... since there have been screens, so why is this one different?  There are several reasons.

First, as with other really useful tools, Window Clippings integrates seamlessly into your system and just seems to become part of the operating system.  I hit "PrtScrn" and get Window Clippings.

Second, it does the most common things I need with a simple click of the mouse.  Most often when doing a screen capture you are selecting an entire window - Window Clippings knows this and lets you select a window directly.  Also, it is "Vista Friendly" - what I mean by this is that Vista introduced all kinds of transparency and "Aero" features which can lead to other windows (or your desktop) bleeding through transparent areas on windows that end up in your screen capture.  Window clippings isolates the window clears whatever is behind the window from the screen capture.  Nice clean window capture.  After selecting a single window, the most common thing I need is to capture a section of a window (or the entire screen).  Window Clippings lets you crop or expand the capture area before you capture the image so you only get what you want.

Third, Window Clippings gives you options of what to do with the captured image.

You can copy the image to the clipboard, save the image to a file (even pick the file type - PNG, JPEG, TIFF, BMP), and even add a "post-save event" to post-process the image once you have taken the picture (never done that - sounds interesting).

The last thing I really like about Window Clippings is the ability to set a time delay before the picture is taken (kind of like the timer on a camera).  This lets you set up things like opening menus initiating pop-up windows or other "strange behavior" on the computer that you couldn't capture with a keypress (i.e. the keypress would either not get through or would take focus away from what you were trying to capture).

There is a free version that implements many of the functions and may be enough for some people's needs.  I dropped the whopping $10 for the full version (adds cropping and time-delay, and more).  I can easily recommend this tool to others.

I occasionally run into some cool software tools that I end up using a lot, and wanted to blog about them.

I have a few that I want to post soon - here is the first.

ZoomIt is a simple free utility developed by Mark Russinovich at Sysinternals and distributed by Microsoft.  It basically does three things, and only three things, but it does them very well.

I use ZoomIt primarily when doing presentations (on a projector or working with several people on a single computer).  When you press a pre-determined key sequence (Ctrl + 1 as a default). The screen will zoom in 2x centered on your current mouse location.  It is a nice animated zoom that clearly shows what is being magnified.  If you want to increase (or decrease) the level of zoom you can use the mouse-wheel or up/down arrow keys.  Hitting the ESC key or right-mouse button returns you to normal operation.  This enables you to quickly zoom up on some text or controls that may be too small to see (or see well) on the screen.  This is allI use ZoomIt for 95% of the time.

But for completeness there are two other functions that exist.  The next is "Draw" mode.  This is kind of a "John Madden" draw-over markup of the current screen.  If you want to highlight, circle, point to, or even type on the screen (in 5 fabulous colors) you can with this function.  It will remind you of working with a very limited paint program, but can be very effective at drawing attention where you want peoples attention (bad example below).

You can also type "w" or "k" to wipe out the screen and turn it in to a temporary whiteboard or blackboard.

The final thing that ZoomIt will do for you is pop-up a timer in the middle of the screen.  It is a no-nonsense block of red text on a white background that will count down the seconds for the amount of time that you set.  It defaults to 10 minutes and you can use the mouse-wheel or up/down arrows to adjust up or down the number of minutes.  This is useful if you want to start a presentation on time (i.e. a count-down timer to start), or take a 10/15 minute break in the middle of a presentation, or give your audience a specific amount of time to complete a particular task.  Again, a very simple no-nonsense approach, but well implemented if this is something you need.

ZoomIt v1.8

Interesting.

Imagine a web "page" where it was just as easy to embed audio or video as it is now to insert an image.

Pages are more structured with "sections", "articles", "headers", and "footers".  They can include a "nav" section.

Embedded data is possible with native "datagrids" and "datalists" andRSS feeds embedded right in web pages.

More interactive elements with server-side "events", "progress", and "output".

Elements like <center>, <font>, and even <tt> will finally be removed (instead of just depreciated) - even <frame>s finally meet their worthy demise.

All kinds of new APIs, including persistence/database, audio/video, drawing, and more.

There is a high-level document describing the differences at the W3C site - still just a draft but quite a look at what might be to come.

Draft of HTML 5 Hints at a Brave New Web | Compiler from Wired.com

Before I forget this with all that is going on, I came across a new resource in town when I was talking my certification test last week (or was it the week before?).  I was looking online for a place to take my test when the "PC ProSchools" link came up as a possible test site.  It turns out it is really close to me (I-96 and East Beltline) and is pretty new (too new for Google Maps - about a year old).

I thought I knew of most of the Microsoft training facilities in town and had never heard of them.  I got to my test about 15 minutes early and they were fully booked so I started asking about their programs and reading some of their material.  I ended up getting a tour of the facilities and programs by a guy named Richard Fera (who was really helpful).

They had a great training lab (room for 50 at brand new machines, dual projectors, dual stations in the back of the room for more trainers (3 trainers available in a full class)).  They had an open lab and what looked like a server room / wiring closet (which turned out to be an "advanced lab" area).  Their focus is on the infrastructure side (i.e. the MCSE route) on getting the servers up and running and all kinds of troubleshooting.  They do not offer programs for software development (i.e. the MCPD route).  So they had never heard of the test I was taking but it was pretty clear that their testing lab got quite a bit of use.

They are a Microsoft Platinum Partner provider for training (which says a lot about volume, graduation rate, certification rate, and placement rate (>70%)).  It is an interesting model because they run it kind of like something between a technical trainer (i.e. offering one class at a time) and a college (full-blown multi-year program).  They offer an intense one-year program which is open to any high-school graduate who meets some basic criteria.  The classes are either M/W or T/Th (with a few Fridays thrown in for test-prep and labs) from 5:30-10:30, which is quite a bit of work.  But in the end you should have your MCSE.

Add to this that they also do placement and have jobs looking for people - placed 48 of the lass class of 50.

Reading this post it sounds kind of like an advertisement, but it really isn't.  I'd write about any new resource class, school, book, etc. that could be helpful to people doing what I do (or supported the servers I need to run on) and do that fairly often.  If I knew someone who was interested in servers and hardware, and looking for a job without committing 2-4 years to school, this seems like the kind of thing you'd need to keep you on track and get it done quickly.  It's an option worth checking out at least.

www.pcproschools.com

I posted a review of this book to Amazon, but also wanted to share it here.  It really is the best single book on the topic now.  I met both of the authors many years ago in Boston at a WinDev/DevelopMentor conference and they are both really talented programmers and communicators ...

Programming WPF is probably the first book on WPF I ever read (the 1^st Edition) and the last one (2^nd Edition) I’ll be buying (which is a good thing, since I have 7 WPF-related books now). The first edition was a real treat because there was nothing else available a the time and Chris and Ian really hit some topics (like Databinding) very well - so well that they set the standard for books to come. As each pre-release of WPF came out they dutifully updated the XAML and Framework calls of all the examples from the book. But with the production version of the .NET 3.0 Framework there was so much more that programmers needed to know. Ian took the WPF show on the road and Chris listened to a lot of feedback from the developer community – the results of which really come out in this new edition.

The 2^nd Edition of Programming WPF comes in strong as the most complete text available on WPF. The authors’ diverse background lead to a great blend of clear and concise writing for a wide variety of topics. The introductory chapters are great for beginners just getting into the topic, but there is also a great deal of detail in the advanced chapters to get you well into topics such as: handling graphics, bitmaps, databinding (templates and stying), animations, 3D, text and flow documents, and more.

I like the way they take typically hard topics (e.g. Control Templates) and go deep with concrete examples and helpful code/apps like “Show Me The Template!” from Chapter 9. They also show that they understand “real programming” environments when they don’t just gloss over issues such as the interoperability of WPF and Windows Forms (which isn’t a stretch because they’ve written on Windows Forms as well).

A “taste of Silverlight” left me wanting more – maybe they’ll come together for a Silverlight book once 2.0 ships? The color section in the middle was helpful but awkward as you read through it when you get to the center of the book and see color versions of pictures you are already past and glimpse pictures of what is to come. I applaud the inclusion of only 32 pages of basic XAML syntax – enough to give you an understanding of the language but not so much as to take over the book (some books can end up being 1/3 to 1/2 syntax and framework references, which is why you install the MSDN Library and Intellisense). I wanted to see something about Expression Blend or even Design as these tools become important when doing good UI design, but at 800+ pages already there really isn’t room (and I don’t know what I would have cut to make room).

While several of the other WPF books have been good to read through and learn from, I can see the Programming WPF book being one that will become a reference book to return to when you have need for a certain feature of WPF.

Amazon.com: Programming WPF: Books: Chris Sells,Ian Griffiths