I’ll be starting up a new software project soon, so I decided to do a little redesign on the ol’ software blog to get ready.  Yeah, yeah, I’m way behind on posts.  I know.  I’m not apologetic for being busy, but that’s pretty much why no one comes to this blog anymore.

I’m psyched to get started on a Rails 2.0 project now that it’s done.  And I’m starting a new project at work after delivering a solid v.2 (and maybe v.final) of my existing project.

I’ve been doing some heads-down iPhone (Safari, not SDK) development the last 2 weeks and ran into something that had me puzzled for awhile.

The Problem

I was doing a little Javascript to capture the input from a text input and use it to update part of the UI. I wanted to do this without the user clicking on a ‘Process’ or ‘Submit’ button because screen real estate is in short supply on the iPhone. So, I wanted to hook the text input’s onKeyPress event to a handler that would get the current contents of the textbox, parse it, and update the UI automatically. However, since Safari on the iPhone fires the onKeyDown, onKeyUp, and onKeyPress simultaneously when you type via the software keyboard, I couldn’t capture the input. For example, when I typed ‘99′, the first ‘9′ would fire the event and the contents of the textbox were null, and when the second ‘9′ fired the event again the contents would now be ‘9′. In effect, the textbox didn’t have the key pressed yet when the event was fired.

The (Hack) Solution

My first thought was to capture the key that was pressed, then concat it to the contents of the textbox. The ol’ Take What You Have and Add What They Pressed maneuver. Except for the whole host of further problems, it worked perfectly. For one: what if the user (remember, we’re on an iPhone) dragged the cursor to the middle of the string and input something. Or: what if the deleted a character with the backspace key. It was just one headache after another.

The Good Solution

The better solution came to me while I was in the shower. Don’t know why; it just did. In the event handler for onKeyPress, I called setTimeout(realHandler, 100); and then put the textbox-reading and value-parsing code in the realHandler() function.

It worked perfectly, and the real handler now had access to the whole textbox value, including the key that was just pressed.This whole thing may be common knowledge, and maybe I just described some oft-repeated wisdom in the AJAX developer community, but it took me a while to get it right, so I figured I’d post it.

After a long while of thinking about how best to use this blog, I’ve come up with a series of posts describing a great technique we use to generate code in order for our component at the company to be used by multiple clients. However, this post isn’t about that. This post is an endorsement of a great book I’m in the middle of right now: Beautiful Code, published by O’Reilly Media. They also have a blog about topics in the book at http://beautifulcode.oreillynet.com/, which I added to my netvibes feed (you are using Netvibes, aren’t you?)

The book is intended to showcase computer science’s great minds, and each essay/chapter details a piece of code that the contributor deems “beautiful.” Now, eye of the beholder and all that jazz, but some of the featured essays leave me wondeirng what in the hell these dudes are thinking when it comes to beauty. For example, while Charles Petzold’s (of Programming Windows fame) chapter on on-the-fly code generation features a nifty solution to a problem, the meat of it details generating .Net CLR op codes to do bit wrangling. He even states himself at the end

Now, you might regard FilterMethodIL as ugly, and I’d be willing to concede that it sure isn’t the prettiest code I’ve ever seen. But when an algorithm clocks in at a quarter of the execution time of some earlier code, then the only word that I find appropriate is beautiful.

Emphasis in the original. Well, I can certainly agree with the premise that 75% gains in performance is beautiful, but the beauty wasn’t in an elegantly coded solution. It delved deep into .Net’s Reflection.Emit namespace and writing what was essentially assembly code. That isn’t beautiful code, and its important to note the difference. I wasn’t looking for 500 pages describing obfuscated Perl contest winners that can predict the weather in 5 lines of crazy code, but I was expecting some elegant solutions that can typically be expressed in one page or less of code. Not pages, and pages, and pages (and pages, and PAGES) of one function that is cool because it does protein folding in an entirely NEW way!

Which isn’t to say I haven’t learned anything. I think there’s some genuinely great essays in there, and they’ve made me question how we can improve our own designs. In particular, the (truly) concise and beautiful solution to the regular expression matcher in Chapter 1 by Brian Kernighan really illustrates the power of clever recursion. From a design point of view, Chapter 2 (Subversion’s Delta Editor: Interface As Ontology) by Karl Fogel is also good. It describes how a different mode of thinking can lead to a better interface. Finally, the chapters on the beauty of testing were (of course) of interest to me: Chapter 6 (Framework For Integrated Test: Beauty Through Fragility) and Chapter 7 (Beautiful Tests), and to a lesser extent Chapter 3 (The Most Beautiful Code I Never Wrote).

Looking at the list of chapters I liked, I realize they are all clustered in the first half dozen chapters. I think that may be an anomaly as it just so happens that I’ve read through Chapter 13 (of 33 total) and chapters 8 through 13 just haven’t struck my fancy much. I did kinda dig Chapter 9’s take on a Javascript compiler written in Javascript, but in particular I found Chapter 11 (Secure Communication: The Technology of Freedom) to be an extended wankfest with really no discussion of code or design. All I learned was that this dude is dedicated to PGP-based encryption, lived in the Himalayas for a couple of years doing development over a satphone, and has an aversion to government spying (which I agree with, but was a bit preachy in a book based on, uh, beautiful code).

So far, I think Beautiful Code was a great buy with only some shortcomings. I’ll definitely check back in with more thoughts once I complete more of it.

I just found this online training on Windows Presentation Foundation (WPF), Windows Communication Foundation (WCF), and Windows Workflow Foundation (WF):

Collection 5134: Developing Rich Experiences with Microsoft® .NET Framework 3.0 and Visual Studio® 2005

It is free and you can access it for 3 years.

Enjoy it!

Microsoft announced last week the new platform to develop rich internet applications called Silverlight. As they mention in their website, Silverlight is a cross-browser, cross-platform plug-in for delivering the next generation of Microsoft .NET–based media experiences and rich interactive applications for the Web.

Although they refer it as a cross-platform, the supported platforms are Windows and Mac OS, but not Linux.

See more information and download the beta version at:
http://www.microsoft.com/silverlight/default01.aspx

I wasn’t aware that it even existed, but apparently Microsoft started their own SourceForge-ish open source project repository.  It’s called CodePlex, and there are some intriguing things there.  If you’re looking to start a .Net-centric project, it may not be bad to look there, though that isn’t a slam against SourceForge.  Certainly, if you are looking to join on to an existing project, it’s a great place to search.

John Wooden, for those of you not familiar with college basketball, is the greatest college basketball coach of all time. His UCLA teams won 10 national championships in 12 years, after which he retired. At one point his teams won 88 straight games.
Now, the really interesting thing about John Wooden is that he had a very different way of coaching than other basketball coaches.

Basketball coaches, in general, spend a lot of time screaming, exhorting, and publicly demonstrating that they are exerting control on basketball games and basketball players.

John Wooden focused almost all of his energy on teaching rather than winning. Time with his players was spent not criticizing, not encouraging…but actually conveying information. Focused, specific points on how to play basketball better. He became so famous as a teacher that researchers studied his practices, and still publish papers on his methods (http://newsroom.ucla.edu/page.asp?RelNum=5219).

He didn’t stand up during games, and hated to call timeouts. In his entire career as a player and coach he was called for two technical fouls, and one of them he still claims was a case of mistaken identity. He reached a point where the best players in the country wanted to play for him, and then were taught how to play by the best teacher in the country, so his teams would always win.
One would think that this would lead to a vast number of imitators, but it didn’t.

On the face of it, this is rather stunning. John Wooden’s success leads to the rather obvious conclusion that running around on the sideline, calling excessive timeouts, screaming at players and refs…all that doesn’t mean a hill of beans when it comes to winning basketball games.

Winning basketball games comes down to:

1. talent.
2. training.

So why are coaches doing counterproductive things like screaming at their own players?

They have to.

I mean, they have to make it look like they are doing something to influence the outcome of the game.

When people care about anything that they can’t control, they put someone in charge who provides the illusion of control.

This is the problem for our Agile Project Manager. They’re in charge of a project, and they aren’t doing anything to control it. TSP/PSP, MS Project, etc. may be snake oil, but at least it’s clear what the project managers do for their job.

Let’s face it, if your job title says “Project Manager”, it doesn’t cut it to say that the requirements change too fast and the estimates are too crappy to do “project management”. If you attract a great team and enable them to succeed, you might get away with not providing the illusion of control to the big bosses. But if you fail once, you can bet that “negligent” will be one of the nicer words the big bosses will have for your oversight of the project.

Bottom line, I suspect there will be one or two project managers who succeed well beyond their peers by cutting out the snake oil, but I am afraid that a bunch of them (unfortunately, the sincere ones) are signing up for suicide missions. And all the engineers out there who think the project managers job is to take bullets for them…well, just keep in mind that it’s not an easy thing to do. A project manager has a lot of reasons to keep the pointy hat on.

Software development projects have an alarming tendency to get software project managers fired. 

Imagine you are a software project manager…I’m not, but I can kind of imagine how it must feel.  You probably wrote software a long, long time ago, but since then you’ve been managing projects.  You know a few things: you definitely don’t want to get fired, which means that you want the project to succeed.  You’re not allowed to push the project ahead by actually coding, so all you’ve got is project management and people skills to rely on.

People skills we’ll save for another day.  Free sushi seems to work pretty well, but again, we can’t get into that now.

Now there is a whole pseudo-science of project management out there for you to use, with wonderful (software!) tools like MS Project that can be used to manage your software projects.  Unfortunately you’ve observed that the MS Project masters still get fired with alarming regularity.  And rumor has it that the project manager for MS Project uses it for her home remodeling projects, but not the MS Project development team schedule.

Hmmm.  What’s the problem?

Well, there are a lot of problems.  If there was just one problem, then we might find a silver bullet to really solve the problem.  But, hey, I don’t need to outrun the bear, just outperform the guy down the hall so that the bear fires him.  Since I can’t really write code, I’ll focus on some of the things that are relevant to the project management side of the business:

• The estimates I get from my engineers suck. 
• The requirements keep changing, faster than I can cascade the corresponding staircase into MS Project.
• My team depends on other teams delivering successfully.  They don’t, therefore I’m screwed.  Or my team screws someone else’s team…you see where this is going, I imagine.
• The cost of fixing bugs is very very high. 

Now, I’ve lasted at this project management game for a while, and the dependency problem is a big one, but usually I can get the other guy fired for that. 

We’ll circle back to the quality problem later.  For now, let’s just assume that I’ll encourage the team not to do stupid things like pretend to bring in the schedule by skipping testing.  That hasn’t turned out very well the last three times we tried it, anyhow. 

So let’s see, we’ve got terrible estimates and the requirements change all the time.  My mom used to have the same problem chasing after three kids, each of whom thought their homework was almost done and kept forgetting to tell mom that they needed a ride after school to something or other.

How did mom solve this problem? 

Time to take a break from surfing the web…er, I mean “working”, and give mom a call.

“Son,” she said, “you have to take it one day at a time.”

Come again?

“You realize that a bunch of things aren’t that important.  If the garage doesn’t get cleaned today it’s not the end of the world.”

So you always work on the most important thing?

“You always work on the most important thing.”

And what if that isn’t working?

“Then you try something else.”

Hmmm.  That almost sounds crazy enough to work.

This in a nutshell is Agile Project Management.  You always work on the most important thing, and you make sure that every month or so you’ve made some progress.  Real progress, that is, as in working code.  And then you hope the dependency problem doesn’t get you fired.

I should mention that there is another way to attack the problem.  You work very hard to get better at estimating, and you lock down the requirements.  Locking down the requirements is very hard, but if you are say the military and you can shoot anyone who tries to change the requirements, you can freeze the requirements.  Unfortunately even shooting engineers won’t get them to estimate better, since they really don’t know how to do it.

Well, if you let them solve the same problem over and over they would get good at estimating that problem, but it doesn’t help those of us who have to solve new problems.  Since all of the money in software development is in solving new problems, again you are out of luck.

But this approach, in a nutshell, is TSP/PSP Project Management.  If you don’t know what that is, consider yourself lucky…but don’t fear, we’ll come back to kick that cow in triplicate later.  For now I’ll just say that at least the MS Project team knows how to write software that works. 

Mom (who by the way could sling some mean IBM OS/360 assembler code back in the day, and tells me that Fred Brooks is a very nice man) told me to always work on the most important thing, which right now means writing a rather boring proposal on the best way to do a very boring code port, so I can keep my job.  Sigh.  We see that Dilbert and the pointy headed boss really do have a lot in common after all.

So it’s time to go, next time we’ll dive more deeply into the quality problem, and what it means to you as an Agile Project Manager.  And maybe even get into the John Wooden problem with Agile Project Management.

First: apologies to the non-existant readers of this blog. I’ve been out of town on business (and sometimes leisure) for the past three weeks, with little time to actually get work done on various projects. A sad malaise had set in, but I’m trying to get re-energized. The 10 day forecasts includes temperatures above 40°, so that’ll definitely help.

Second, and what prompted this post, is that I had to note the breathtaking hubris taking place in some technological circles in which every mainstream technology is dismissed as ‘attempting a vendor lock-in.’ The result: the group in question invents an entirely new technology to insulate themselves from 3rd party technology changes/evolution. In the meantime, your rivals are actually building products that will make them money using real, proven technology. RE: vendor lock-in, duh. Of course Adobe wants to sell you Flex as your environment. But if it’s the correct tool for the job, just use it.

I understand the theoretical argument for building on your own stack, but especially in the web world I believe that it wildly lacks any sort of pragmatism… unless you have a large team of brilliant people who can roll out a deep framework in world record time.

I’m sorry to lean on clichés, but building online applications is different than the desktop. The medium is too new to chain yourself to any one toolset, including the ones you invent. Because by the time you deliver your custom environment, the real world has moved onto Web 3.0, and then it’s on you to ‘upgrade’ your framework to deliver the next gen features requested or required by your users. Perhaps once we get to the absolute limit of what kinds of user interaction and data exchange the TCP protocol will support, things will simmer down and you won’t see one new web framework every month or year, but there’s a lot of innovation in the RIA space right now and you’d be a fool to believe your corporate peers aren’t investigating every one of them to see where they can score quick inroads against your market share.

Your thoughts?

Man, I had to do some serious (serious) wranglin’ to get my dev laptop to just create an IIS dev server to deploy a test web site to for ASP.NET.  I’m used to being up and running in seconds when using RoR.  I had a previous test server for a DotNetNuke install I was playing with and I had to do scorched earth to get a new test site up.  Next: do hand-to-hand combat with SQL Server Express 2005 and ADO.NET to try and understand those technologies.

While I consider myself a good software designer in the middle tier (and even the UI layer) I’m woefully underknowledgable when it comes to databases.  When I was working on a database-touching web site for the company, I was writing what I know now to be some of the worst code imaginable.  That needs to change, and I’d rather learn ADO.NET on the web and get some experience with ASP.NET while I’m at it.  There aren’t a terrible amount of desktop applications that touch SQL Server.

Man, things have been terribly busy here in the last part of January.  I had a couple of co-workers out here from the company to do recruiting at the college.  I’ve been on the college recruiting team for Madison for three plus years now and it never gets any easier.  I always take a chance on a few students with not-so-great resumes, and sometimes I get surprised but mostly I get what I thought I was gonna get.

Anyhoo, my current plans include getting up-to-speed on ASP.NET 2.0 and ADO.NET 2.0 for a project I may or may not be working on.  I picked up a few books on the subject today.  I have apost I’m working on about why ASP.NET confuses me.  One thing I’d really like to do is be up-front about why it confuses me so much, and then once I learn the ins-n-outs I can explain how I figured it out.  Maybe it’ll be helpful to others, or not.

I’ve found out about a cool event happening here in Madison the first week of March.  Unfortunately, I’ll be Vegas that week but I wanted to link to it here for anyone that might be interested.  It’s called BarCampMadison and it’s right out of the Silicon Valley playbook.  It tries to hook up entrepeneurs with engineers in order to  make cool things happen.  Yes, it is that vague.  I hope it is a regular thing in Madison, I definitely wish I could attend.

Finally, registration for RailsConf is now open.  My girlfriend and I had taken that week off to go camping in northern Wisconsin.  I’m going to see if I can swing a trip to Portland instead.   Ben told me he’s going, and it would be great to hang out and see the cool stuff they’re doing with Rails.

My brilliant colleague Luis alerted me to an online refactoring course by Industrial Logic. It costs $150 and you can follow C# or Java exercises (though you have to choose which one upon purchase). I work with patterns every day; the components we developed last year at the company are chock full of the simpler patterns such as Filter, Abstract Factory, Strategy, and a modified Chain of Responsibility. However, I’m taking the course for several reasons:

1. It uses real code, not contrived toy-code, and each exercise begins with an effort to identify where in the code a refactoring makes sense. They don’t simply say, “Here’s a function, make it into this other thing.” While I do work on existing patterns (and have refactored some major code to patterns myself) I welcome the opportunity to improve my Code Smelling ability.
2. While I understand what a resulting pattern should look like (for instance, if I built it that way to begin with), refactoring using mechanics is a different beast. I’m excited that I’m gaining the discipline to apply simpler refactorings one at a time while all unit tests continue to pass.
3. Finally, doing the mechanical work efficiently and gaining the discipline are integral aspects of becoming better at test driven development. At the company we are planning on attempting to do TDD for next year’s release. I know the doctrine, but I don’t have the discipline; hence taking this course.

So far I have completed Factory Method and Strategy (two patterns that I’d already implemented, but never refactored to). I’m looking forward to the rest and I’ll update the site if I come across anything particularly insightful.

Okay, after a few days of attempting to write a .Net client to a RESTful Ruby on Rails resource, I’m officially pissed off at REST (for the moment).  Here’s why: the recent history of programming languages and frameworks has moved in one direction only.  That direction was away from software developers having the onus to write all of the plumbing for common tasks.  The nice thing about interopting with a SOAP web service from .Net is that all of the plumbing is generated for you.  You can tweak things from there, but it’s enough to get started without writing the code to send and receive data over the wire.

Well, with REST that’s all out the window.  If you want to interop with a RESTful web service, get ready to write a bunch of raw HttpWebRequest code.  Get ready to go write some Xml serialization code to get your objects in and out of the transport XML that the RESTful service generates and requires.  None of these things are partuclarly difficult, but they’re time-consuming and they run counter to the current attempts to remove plumbing concerns.

Of course, if you’re working from within the framework that generates the RESTful resource (Rails, in this case) there are all sorts of helpers that are auto-generated to help with the raw URLs you need to interact with the resource.  Other frameworks don’t have these helpers or libraries yet, due to REST’s recent surge in popularity.  I’m sure they will come, eventually, but this is one case where being on the bleeding edge cuts deep.

After a few days of frustration and an IM chat with Ben last evening, I’m still no closer to figuring out why I can’t get a very simple test SOAP web service running on RoR 1.2 RC1.  I’m almost sure the problem lies in the new routing spec in config/routes.rb, but I can’t figure out the solution. Ben suggested that Rails is moving away from SOAP and towards RESTful services anyways, which is all well and good, but I’m unsure how to write a (say, .Net) client to a RESTful web service.  It may be the Model of Simplicity, but it eludes me still.

My thought of the day references my previous post where I mentioned i’m part of a team that’s relatively new to agile development practices. I’ve worked enough with agile methods now to have witnessed the benefits first hand and I understand the struggle involved with adopting the mindset. However, for me it was more of a moderate foot hill compared to the mount everest I see some traditional and seasoned programmers struggling with.

This brings me to the topic of my post. The concept of YagNi, or “You Aren’t gonna Need It”, and my curiousity as to why it is so difficult for some to grasp. Secondly, in order to address the problem on a particular project, what’s the best way to go about mentoring developers who have difficulty narrowing their scope?

I’ll be the first to admit that I fall victim to over-developing solutions from time to time. Although, When I try and keep my development tasks as simple as possible I find that my coding time is shorter overall and my code is considerably cleaner. Besides, I don’t think you can learn to improve without making mistakes.

In code reviews recently I’ve been seeing a lot of check-ins that include extra classes, variables, or properties that are inflating the scope of the particular task, not to mention the code base. If I bring up the issue in the code review it sparks a lengthy discussion over the future need of said classes, variables, and properties.

How do you mentor others on the benefits of the YagNi concept and keeping tasks simple? I’m probably just jumping the gun here, my guess is over time the code reviews will begin to show the benefits of limiting the scope of tasks. I guess we’ll just have to wait and see.

I’ve been doing considerable extensions to an in-house test tool we have at the company, and in doing so I’ve learned a lot about HelpProvider and ToolTip.  In fact, the idea of extenders that allow customization of the Properties window in Visual Studio has taken a hold of me and I want to use it to do some documentation-focused UI tool-tipping in the tool.  I’ll report back once I’ve got something working, but for now I can say my idea revolves around a simple XML file providing two-way mapping of the tool data fields (back to the real client and also to the eventual SOAP payload data model) that get s mapped to the tooltip for each field.  Sounds simple enough; I’ll let you know if I succeed.  Note that I’m constrained to .Net 1.1 here.  Fooferaw.

Thanks to Whazz, I now have a forum on which to spill my techno-guts. What better way to start than to briefly discuss a pretty good book I just finished? Actually there are probably better ways to kick off a first post, but this is what you get.
Practices of an Agile Developer is another addition to the Pragmatic Programmer bookshelf. I think one of the key things I walked away with from the book was it’s straight-forward, simplistic nature and flow. The authors, Andy Hunt and Venkat Subramaniam, present a series of 45 “best practices” that they consider the traits of successful agile developers. Each tip is introduced by the devil himself, tempting you to do your worst to the project by taking a particular shortcut or other such non-agile action. It’s then followed up by the guardian angel of agile development, describing which agile practices can improve on your methods.

Seem retarded? Well, I guess in sense it is somewhat silly, but honestly I think it works. While it may be one of those “Duh!” books — i.e. a book you read then completely agree with everything the author’s have laid out while pretending you practice everything they’ve preached — I think it’s still a great read even for those who think they score a perfect 45 out of 45 with Andy and Venkat, if not just for the reassurance alone.

Part of the reason I’ve found this book beneficial is that my current group has just begun adopting agile methods, scrum in particular. Not many of the developers in our group have any experience with agile development, and I think this book can serve as a great introduction. While the traditional Schwaber, Beedle, and Martin books are still necessary as references, the content in them is extremely dry as an introduction for someone new to agile software development. Either way, I went ahead and order books for everyone, maybe I’ll do a repost in a month to see if my hunch is right?

Well, that’s my frist post anyway. More techno-guts to come.

Things on my mind in no coherent format and/or order

TDD, Whitebox Testing, scrum, agile, web 2.0, .NET, NUnit, interop, components, versioning, build integration

 Thanks to Moneypenny for hooking me up.  Better thoughts to come in the near distant future.

Well, my girlfriend had to work last night so I stayed up late and got a working version of a ClickOnce-deployed application.  Not that it was terribly difficult, but I did run into some snags that Google cleared up nicely.  One was a Visual Studio bug(?) that was acknowledged by Microsoft where development machines with the .Net 3.0 framework installed failed publishing ClickOnce apps to the file server because of the specific partial trust security requirements that were selected.  In the end I had to do two things to get it working:

1. Ensure that MediaPermission and WebBrowserPermission were not selected in the list of permissions of the partial trust application.
2. Download the .Net 3.0 Redistributable (x86 and x64 versions) and copy them to the correct base folder in order for VS2005 to use them in case they were prerequisites for install.  This was due to the fact that VS2005 didn’t natively know how to direct the end-user to the vendor site in case they needed the prerequisite, so you had to have the installable packages locally.

You can find all the goodies at this MSDN Forums page.

New Books

I had some gift cards burning a hole in my pocket so I stopped by oreilly.com to see if they had any new .Net 3.0, Ruby on Rails, or Flex books out.  I was initially surprised to see Juval Löwy’s Programming WCF Services available under their Rough Cuts service, but then I remembered that it was quite a while ago that I attended his intro to it as part of a BayNET User Group Education Day.  I love his book, Programming .Net Components, Second Edition, and was anxious to see the new one.  Juval is a great speaker and writer, and I highly recommend taking one of his classes or getting his books (whichever you can afford).

While I was at the online store, I also picked up the new Programming Windows Presentation Foundation book.  I’m interested in the Flash-alternative XBAP stuff, though I’m sure the general community will have to wait a bit for more penetration of the .Net 3.0 runtime before any widespread use can be made.  In any case, I’d love to see some of the things it can do.

Finally, I got a few of the smaller O’Reilly Short Cuts PDFs for around $10 apiece.  I got one on ClickOnce deployment, which didn’t tell me much more than I gleaned from the web and the Windows Forms 2.0 Programming book.  I also got a Short Cut on Mongrel (Rails web server) and Capistrano (multiple machine deployment of Rails applications).  More on those when I get time to sit down and read them.

2007 is here and one of The Resolutions is to become more adept at the .Net Framework 2.0. Specifically, I’d like to get a project up and running with a .Net 2.0/3.0 smart client interacting with a Ruby on Rails web service backend. The only problem: I have no ideas on what to work on. I mean, I have ideas, but I haven’t settled on any real direction yet.

In the meantime, I got some books at Borders kick-ass Buy 2, Get 1 Free sale last week. Windows Forms 2.0 Programming, Working with Legacy Code (a good suggestion by a co-worker), and Essential C#. Since I am restricted to using the 1.1 .Net Framework at the company, I’m poring over the Forms 2.0 book. In particular, ClickOnce looks interesting enough that I’m developing some prototypes with it. With luck, I’ll gain some insight into how we can improve the design of our codebase once we get the OK from the architecture community to port our code over to 2.0 (not necessarily with ClickOnce, but just using 2.0 features in general.)

I’ve also brought my personal development lappy up-to-date with software patches and new applications. I got the .Net 3.0 runtime and SDK installed, and I put on the available Windows Workflow extensions for Visual Studio 2005. There was also some extensions for WPF and WCF. I’m still interested in getting a WCF application running, but I’d rather interop with a RoR backend for the moment. Perchance I could get an old computer running as an IIS server, but I’d rather not throw away hardware I don’t have for that. That would be down the road when I finally get the computer of my dreams and could turn my existing mega-tower into a full-on file and application server.

Another one of the computer-related Resolutions is to get those meetups started. I’m supposed to get in contact with some of the student groups here at Madison, and once that happens we can start to work on a schedule and place for that stuff… hopefully.

Hope your new year is a great one.

Lately I’ve been desperately trying to carve some time out of my schedule to get back to the grindstone on some projects.  I was happily humming along on a Ruby on Rails project this spring and summer before the company crunch time began.  I always end up dropping personal projects in the late summer/early fall because after working such long hours programming and debugging at work I have little patience for doing the same at home.  It’s roundabouts this time of year, however, that I get interested again and start looking at all of the new stuff coming out of the bleeding edge tech community.

I’m downloading and installing Rails 1.2 Release Candidate 1 as we speak.  I’d like to try my hand at some RESTful web services, to be used in conjunction with my nascent attempts at using Adobe Flex 2 as the client tier.  I spent a chunk of my evening last night downloading the free Flex 2 SDK, eclipse, and the Web Standards eclipse plugin so that I don’t have to drop $600 on a Flex Builder 2 license.  The thing I don’t like about Adobe is their extravagant developer license costs.  But, if I can create the same stuff without the Builder IDE then I suppose it’s moot.

In conjunction with the Flex 2 SDK, I also headed over to oreilly.com and bought the Rough Cuts version of the Programming Flex 2 book.  And holy shit, that thing is really rough.  I don’t have an opinion on it yet as I’m only on the first chapter, but once I get through it I’ll post a little something on its utility as it relates to cost ($59.99 for the online+book bundle).

For those that aren’t familiar with Ruby on Rails, I’ll probably devote a future post to some bare bones explanation, but hit rubyonrails.org to get a clear picture.  It’s a vibrant community that is still a bit off the radar (if you’re not in Silicon Valley).

One of the great joys I get from my job is doing mentoring. I’ve been the Answer Man for several new college grads and interns in my time at the company, and it’s a role that I take pride in. I remember when I first moved from academia to industry and how confused I was about things as elementary as bug tracking, Visual Studio debugging, source control, working with quality engineers, etc.  For someone who has mastered writing the Towers of Hanoi in assembler, it’s simple enough if there’s only someone around to patiently explain. And I’m a patient explainer as long as it doesn’t involve explaining the Benefits of Social Security; I get exasperated at that point.
The company does a fair amount of recruiting at the University of Wisconsin-Madison and I was excited at the possibility of being a point person with the computer science department. One of my co-workers worked on a project with his alma mater, Cal Poly, and I had hopes that we could work out the same sort of arrangement with Wisconsin.

I was somewhat disheartened, then, by a meeting with the chair of the Industrial Affiliates the other week. The department feels that working with the industry in that capacity (such as a class project run jointly with a company) is not part of its mission as a world class center of learning. The department has no intent for its students to be used as a cut-rate development shop, and I admire that sentiment. I do wish, however, that students who desire to use their degree to enter the consumer/enterprise software development field had options during college (and supported by the school).

I believe that I got spoiled living in Silicon Valley for five years. There were always highly motivated, young techies around to learn from, bounce ideas off of, and create a startup with. I hear good things about Madison’s emerging tech community, but I find little about it searching the usual suspects such as .Net User groups and Meetups (see my last post).

So, we come to my next idea: start Meetups in conjunction with university student organizations to informally meet with students with a drive to graduate and enter the software industry. My other idea involves talking to the business school about their Information Systems programs and whether a partnership would work with them.  I’ll be tracking these efforts on this blog (as well as advertising for them once they get off the ground).
Long story short: I’d love to engage students to learn from them, to teach them whatever I can, and to give them an idea about what is involved with working in the software industry, post-graduation. Ideas of your own? Please share with the class.

For anyone that hasn’t been to meetup.com to see what they offer, it’s pretty great from a “I want to learn new things” point-of-view. If you don’t immediately find a relevant meetup in your city or area, you can either start your own or signup to be alerted if someone else starts one.

When I lived in the Bay Area I frequently attended the Silicon Valley Ruby on Rails Meetup. It was fantastic, because it was a mix of entrepeneurs, techies, and recruiters. Madison doesn’t have a Ruby or RoR Meetup yet, so I was thinking of starting one. The only problem: nowhere to host it at the moment. I suppose i could do it at my apartment, but you can imagine the wrinkles involved therein. It would be better if a company could host it like they do in California, but I don’t know enough tech people in the Madison area to be able to work something like that out.

So, if anyone has any ideas please pipe up in the comments. Library? Union? Coffee shop?

The last two years I’ve been involved in a terrible amount of C# development Version 1.1 of the .Net Framework.  Sadly, due to market conditions we were unable to develop in and ship our assemblies on the 2.0 Framework (with all of it’s improvements) but for the functionality we absolutely required it wasn’t an issue.  As far as writing the unit tests, however… well, suffice to say we’ll be talking about the [InternalsVisibleTo()] attribute in time.

Most of my development last year was creating interface-based components to do date calculation based on XML-encoded rules, and also to handle e-filing and e-payment transmission of tax forms and tax payments.  So it’s been a great year from a learning perpspective.  More web services, more XML, and all using patterns and extensive unit testing.

The year prior I was also using C#, but it was mostly in the UI layer of the Payroll Setup subsystem.  It was also a great year for learning.

On the side over the last year I’ve been trying to pour my extra time into Ruby on Rails development, but without a solid project to work on it’s been tough.  I’d like to evaluate Flex 2.0 soon (if the company would pay for a studio license) as well.  Since I’ve done a lot of C#, doing some ASP.NET work would also be interesting.  Essentially, on these newer or non-desktop technologies I’d like to get involved with a real project to cut my teeth on.

I’d also like to do more with client-side data access layers.  The stuff we were doing this year with the XML resource retrieval and use in calcs included a great data layer, but it was read-only.  I’d be interested in doing more with transactions and such, since that concept will also be important once the industry starts doing serious Windows Communication Foundation development.

Finally, our work group has been using highly modified Scrum to do our project management last year.  I would really like to use more of the straight-out Scrum techniques and guidelines rather than rolling our own; I believe important aspects get too muddied by saying, “We’ll do things the Scrum way for X, but our own way for Y.”  If X is major and Y is minor, fine, but if Y is major then you have a disconnect.

It’s taken awhile to get my second, more software-focused weblog up and running (see the about page) but my recent experiences at work have necessitated it.  I’ve grown disillusioned with the Not Invented Here form of software design and implementation. I’ve longed for a world of actually programming against a known API rather than a swirling, un- or poorly-documented abyss of internal “components”.  I’ve become frustrated with the “You can’t use that technology! It’s only 5 years old! It’s not mature enough!” argument.  Most of all, I feel that I can’t talk about COM-.Net interop or RubyOnRails development at work these days without soundly dangerously, insubordinately insurgent.

So here we are.

I’m a developer who loves interface-based architecture and components, and who wished to god he knew more about web services, J2EE, Flex 2.0, RoR 1.2, and all those other things that– oh god if I only had the time.  So here’s my stick in the sand: I’m gonna learn about it and try to post my results on the blog.  I see no real audience for this, but maybe you got to the fifteen hundredth page of Google search results and now here you are.  In that case, oh god I’m sorry.