Podcasting

I have been listening to Podcasts for while. It has been a rather cool experience. I really like the idea of subscribing to audio files and listening to them in my spare time. We live in an on-demand society and there is something cool about subscribing to data, getting it when it is available, and then listening to it when you have a chance. I wish TV was like this (it is moving in this direction with Comcast's video on demand and TIVO). Imagine being able to go home, sit in from of your TV, and watch the latest episode of Stargate (I like Stargate); without having to record it or without having to wait for the episode to air. Just be able to subscribe to Stargate and then see if a new episode is available and watch it.

Podcasts do have one down side, they are not regulated and so you have to be careful about all the locker room humor and other offensive material. Free speech is good but at the same time is this the kind of thing we want our children listening too. Well, it is not all bad and as time goes on it seems to be getting better. Now that .Net Rocks has cleaned up its act, I would recommend it.

If you would like to get started Podcasting, download iPodder. iPodder is a tool that allows you to easily subscribe to different Podcasts and will download them to your computer. It works with iTunes and will work on Windows or Mac. Even though it is called iPodder you don't have to have an iPod, as long as you have iTunes you will be find. Most of the files are MP3. This makes it possible to download them to your Pocket PC, Palm or other portable devices.

Avalon 3D

Microsoft is working on some really cool stuff. If you don’t know what Avalon is, it is a code name for a project at Microsoft that has to do with creating displays on Windows forms using an XML language called XAML. With “Avalon 3D” they have added light sources, camera angles, textures, brushes, and mesh support.

This stuff looks really cool and will raise the bar on application development. This has the potential to change the way we interact with computers. It could make the user interaction with computers a much richer and pleasurable experience.

I really think this is cool stuff. Watch the MSDN Video to see the demo of Avalon 3D.

John von Neuman

I am currently taking a Java course at Harvard University (taught by Charlie Sawyer) and in a discussion about threads we happened to run across John von Neumann. John von Neuman is the one credited for coming up with a lot of ideas about computers that exists in modern day computing architectures. There is also the "von Neumann bottleneck" which is a limitation on the idea that data must travel between memory and CPU a word/instruction at a time.

See Also:
http://www.csupomona.edu/~hnriley/www/VonN.html
http://en.wikipedia.org/wiki/John_von_Neumann

SetGlobal

Now available for download! (It's free man)

SetGlobal is a command line application that I wrote a while ago. It is a useful application that allows you to manage environment variables. Ever since I discovered that you can create an environment variable and then launch it from your address bar in windows, I have found this to be a useful way of creating shortcuts to launch applications, websites, and directories. I like the idea of attaching a short friendly name to a long URL or directory. Then from my address bar on my desktop I can type %myvar% to launch a URL or directory. I suppose you can do the same thing with Windows shortcuts, but then you need to find the shortcut and click on it. For things that I use often, I find this faster and less cluttered. (See the tutorial for example on how to do this.)

SetGlobal is a way for me to create a list of variables in a batch file so that I can manage variables across different machines. You could just use control panel/system but I like this better. I like to have a separate file containing all my variables.
SetGlobal does the same thing as the set command in DOS except that it persists the environment variable.

It is your own personal Shrinkster for your desktop.

There are other uses of environment variables and by all means SetGlobal is a useful way of managing any environment variable. (Note, currently only user variables can be created. I thought this would be less dangerous).

Disclaimer: Setting environment variables can overwrite variables that other applications rely on causing those applications to not work properly. It is always a good idea to check to see if a variable is in use before creating a new one. SetGlobal will not let you overwrite standard Windows variables.

%cool%

Four-Wheeled Segway

I must get one. For no reason other then it looks so cool.

http://news.com.com/Segway+may+go+off-road/2100-1041-5407205.html?part=dht&tag=ntop&tag=nl.e433

:-( I will probably never be able to afford it.

Another Windows XP SP2 Problem

After installing SP2 I was getting popup errors on my Tablet PC. (An error has occurred in the script URL is res://C:\WINNT\help\tpc_oobe.dll/tabsplash.hta.) The errors where coming from a "Tablet PC getting started" dialog that displays when you log into windows. If I had clicked the “don’t show again” check box on the dialog, before installing SP2, I would not have had this problem. However for some reason I liked the dialog and never checked the check box. Well, after I install SP2 and got the error messages every time I logged into windows. I was looking for a way to kill the dialog. With some greatly appreciated help from Microsoft I learned that the splshwrp.exe was the EXE that was running the dialog and that it was being launched from HKEY_LOCAL_MACHINE\SOFTWARE\ Microsoft\Windows\CurrentVersion\Run.

Windows XP SP2 and Firewalls

I recently installed Windows XP SP2. After I installed it I noticed that I couldn’t connect to my Wireless network any more. After spending a couple of hours searching the web and trying different settings on my AP, I discovered that it was my firewall that was blocking some call to or from my AP. I am running McAfee Firewall and ZoneAlarm. After I shutdown my firewalls I was able to connect. I also think that MAC address filtering doesn’t work the same as it did before (However I didn’t really look into it and just switched over to WEP security). So now I need to figure out how to configure my firewalls to work with my wireless network.

4GL?

The software industry is about to change. There have been a lot of changes as of late, however with all of the change we are still building software that is error prone, expensive, and unreliable. This however is about to change. There is a push in the software industry to build better software more efficiently and effectively. The answer is with things like code generation, application blocks and software factories. I am excited to think what this will turn into. Will 4GL finally bcome the main stream or will we have to redefine 4GL. Perhapes it will just be 3.5GL. Anyway the future will be interesting.

• Code Generation
• Application Block (Logging Application Block)
• Software Factories

Great Hackers

Great Hackers is a really great essay. (Thanks to Nick for blogging about is and allowing me to find it.) I think Paul really nailed what makes GREAT programmers GREAT. Being a good hacker (I wouldn’t call myself a great hacker. I think I my even be pushing it with good hacker) I could really relate to a lot of things Paul was talking about. I also realized why I am so frustrated with my current job. We are in maintenance mode which is not feeding my natural curiosity to learn new things. It is also not allowing me to work on anything cool. Having to look at the same code day in and day out and having little power to change the way things are done is not cool. We have a very strict change control process in place and if you want to make a major change you have to first get approval. And getting approval is not easy considering there are tons of request from clients that must be done first. Making more money is a priority. So I am stuck having to deal with the code as is, even though it has grown into a mountain of next to impossible to maintain code. All we can do is try to maintain this next to impossible code and try to build on top of it adding to the problem. I wish management would read Great Hackers an realize that in order to make things cool and exciting all they need to do is allow the developers to fix the problems by redefining the problem. As the essay points out back in the early Mac days when a lot of companies were building computers Steve Jobs came along and said “build me one beautiful”. And that, as the essay puts it “probably drove the developers harder than any carrot or stick could”. All management needs to do is give developers a vision or goal and most developers, well the great hackers, will run with it. But in our company those days seem to be gone. There was a time when developers spend a lot of time and money developing something that nobody wanted, so management decided that it is better to work on customer requests then to allow developers to go crazy. This makes me think that there must be reasons why some software is successful while others fail. But in my opinion if you are afraid of failure then you will probably never find a way to succeed.

I would also like to say that I disagree with ideas that great hackers only use Linux, Open Source software and Perl. I do agree with the idea that great hackers like control and with Open Source you have more control you can go in and change things because you have the source code. However, if you have well documented and well thought out software that is mature then that software may be wiser to use then open source. If it is easier to use and less buggy and will result in getting the end result up and running quicker then it is better. Also when it comes to operating systems and languages it is the one that allows you to do the most things that makes it better. And with that in mind it may just be the one that the hacker has the most knowledge about that makes it the better choice.

Desktops

I was reading a post from FTPOnline. There is a reference to Google’s Zeitgiest showing that Linux is only on 1% of the computers that accessed Google while Windows XP was at 51%. But the thing that I find most interesting is that 5% is given to the category of “Other”. Does that mean that Google could not identify 5% of the computers? Is there some browser that doesn't send OS information? Is it some application that is accessing Google in a way that Google cannot identify it? What is going on? 5% is quite a bit, it is a lot bigger then Linux and Mac combine.

Postmortem Document

The following is from the book "Coder to Developer" by Mike Gunderloy.  I found if very interesting because I am currently working in an environment where projects often get handed off from one group to another with little documentation from the people that actually wrote it.  I think this type of document would be very useful. (Although I am not sure that I could be disciplined enough to write it for every project.)

The purpose of the postmortem is to record the lessons that the teamor the manager learned in the course of building the software (or thethings that they wish they has known before they started).  A typicalpostmortem might include these sections:

• Overall description of the project
• Who was involved on the team
• How the projects' scope and features changed from initial design to final ship
• A list of things that were done well during the project
• A list of things that could have been done better
• A list of the tools used, along with en evaluation of their quality
• A list of tools that team members wish they had had available
• A list of important project documents with their location
• Recommendations for the next project: How can things be done better?

Coder to Developer

I have just finished reading "Coder to Developer". I found it to be a very enjoyable book. It is a book about all of the different tools and skills that a good developer needs to take a software project from beginning to end. I liked it because although the author uses a .NET sample project throughout the book, a lot of tools and skills could apply to any project. The author did a lot of research on this book (or acquired it from real world experiences) and lists many alternative tools ranging from open source to big expensive commercial tools. He also lists many invaluable web sites that are excellent resources for developers.

Reorganizing

“We trained hard…but it seemed that every time we were beginning to form up into teams we would be reorganized. I was to learn later in life that we tend to meet any new situation by reorganizing; and a wonderful method it can be for creating the illusion of progress while producing confusion, inefficiency, and demoralization.”

- Falsely attributed to Petronius Arbiter; more likely Robert Townsend

Project Task Scheduling

I just read Joel Spolshy’s page on software project task scheduling. He has some really good ideas. I like the idea of scheduling time for vacations, debugging, integration time, and scheduling some buffer time for tasks that took longer or for the tasks you didn’t know you had to do. I also like what he has to say about never letting managers tell programmers to reduce an estimate. In this article Joel also has some very convincing arguments of why you should actually create and manage a task schedule.

Bye Bye to Mr CIO Guy

Bye Bye to Mr CIO Guy is cool. I laughed then cried (literally). We are living in a changing IT world. I believe that the tech industry is changing to the next level. We are moving away from building applications that manage data on the network to building applications that access data in a wide variety of ways (Example: web, blackberries, application, via web services). We are moving to a more real-time world with instant access from anywhere. We are moving to model that is more diverse. And unfortunately, as the song says, industry is trying to cut cost, outsourcing to cheaper countries. The issue is the bottom line. Companies are tired of software taking too long and paying for features that don’t quite meet acceptations. I believe that this will separate the software developing men from the software developing boys. We are emerging into an era where software must be built cheaper and easier. I believe that technologies like code generation tools (see Code Generation and CodeSmith) and testing frameworks (NUnit) will help in creating software faster and more reliable. We still have a long way to go before we have the software we want at the cost we want. But there is a lot of advancement taking shape.

If only someone would come up with a Rapid Application MAINTENANCE tool.

Pocket PC and Movie Viewing

I have a Pocket PC and the other night decided that I would try saving an episode of Futurama onto my SD card so that I could watch it on my Pocket PC. I have a TV tuner card on my computer that records and saves it as mpeg-2 files. The Futurama episode that I saved was about 550mb. I downloaded TMpegEnc and converted the file down to about 100mb (mpeg-1). I was then able to load the file into Movie Maker and edit out the commercials, and save it to a Pocket PC compatible file. And then finally save that file to my SD card. So all this sounds cool right, well not really. It took me 4 hours to convert the 550mb file down to 100mb. Then it took me another 20 minutes just to load the file into Movie Maker, which split the file into 150 different clips. That took me about another 1/2 hour to build the storyboard, drag all the clips down and in order while editing out the commercials. Then it took me another 15 minutes to create the movie from Movie Maker. So in less then 6 hours I was watching a 1/2 hour episode of Futurama.
I have two thoughts on this. One, computers need to get faster. When we can edit a 2GB file easily then we will have a good video-editing machine. Second, why doesn't the manufacture of my TV tuner card have the ability to save to a version that I could then view on my Pocket PC. They have the ability to save me a lot of time.
Well I did, in fact, find that I could save from my TV tuner directly to an mpeg-1 file. It was not the same as the 100mb file that I mentioned above, it was about 300mb. But it is easier to deal with, and saves me the 4-hour conversion.

The Rule of 3

I think Dan has some good ideas. I like this blog because software is an iterative process. You cannot expect to build the perfect software package on the first try. I disagree that it takes three iterations as a rule. It may take more iterations or less iterations depending on the complexity and the client feed back/input. If you get good help from clients when building your application you may get it right on the first try. However, this is a rare case because clients usually only want things that fit into their own personal workflow and that may not be what other clients want. Leaving your software to be a custom solution when you wanted a commercial application.

Google's IPO

From Wired: If you take a close look at the form Google filed with the Securities and Exchange Commission, the exact value of its planned offering is $2,718,281,828 dollars, which some would immediately recognize as the mathematical constant e.

BASIC computer language turns 40

Tomorrow is the big day.

Channel 9

I checked out channel 9 from Microsoft. If you have not seen it you should check it out. Leave it to Microsoft to take bloging to the next level. We are living in a more interactive more media rich world. Computers are changing the way we think and the way we interact with those around us. The possibilities are only limited by our imagination.

Adventures of Seinfield & Superman

My brother told me about this site. I thought it was funny. A good use of technology.

Security is great until it breaks something

I have running on my machine, Norton AntiVirus, McAfee AnitVirus, McAfee Firewall, and Zone Alarm. (I am not paranoid.) I recently installed Visual Studio. And when I tried to create a new project I got presented with a can not load class error. After searching on Google I discovered that both McAfee and Norton AntiVirus try to register their own version of Scripting.FilesystemObject. In the posting that I read, it told me to go to the registry and change the file back to the Microsoft one. That fixed the problem, however my system is now less secure because my Virus software is not managing scripts that use the FilesystemObject. Security is a great thing until it causes problems. The most secure computer is the one that is turned off. However, this doesn’t help me.

Computers Suck

Well, I don’t know if I agree that computers suck. However, I do think that technology is only just beginning. What we will create tomorrow will be better, cheaper, reliable, and far more useful.

Building Better Applications

I see a lot of good ideas and a lot of software that could be written better. In most cases the software that I like and would actually pay money for are the applications that integrate well with windows or other commonly used applications. I use NewsGator not because there is a lack of free blog aggregators, but because NewsGator is easier to use. It adds a popup menu in IE so that I can easily subscript to new blogs. It is an Outlook plug-in so I don’t have to learn a new tool. It also has a website to check my blogs when I am away from my computer. It integrates well into the tools that I use everyday. This is what separates good software from great software.

Good job NewsGator.

Microsoft to remove the Calculator from Windows

I thought this was good.

Why is code maintenance so difficult?

The more complicated your code base is the less likely other people will be able to understand it. So how do you make it simpler? Well, there is no easy answer to this, even when you try to write understandable code different people with different ideas may find it incomprehensible. That said here are some things to think about when writing code.

Stay away from form inheritance. Languages like Delphi have the concept of form inheritance (creating a base window and then inheriting off it). Although this can be great in the initial creation of applications, allowing you to create many forms quickly, it is hard to maintain. What if there is a button that is no longer needed, and that button lives on the base form. You can not delete the button because that would delete it on every descendant form. So you end up hiding it. Now you have controls that in design time clutter your designing window. The problem gets worse when you need to radically change your window’s visual appearance. Now what do you do? Hide more controls or start over? Well in this case the two options are not ideal. You will end up with more confusing un-maintainable code or you will waist time rewriting the window. I think rewriting it to the way to go. Rewrite it to the way it should have been in the first place, with out inheritance.

Try not to inherit more then three levels deep. Unless your objects are created perfectly and no one will need to maintain it, inheritance is not your friend. When it comes time to extend functionality it becomes very confusing to figure out where the code belongs. Does it belong in the base or at what level? Fixing bugs can also be difficult; trying to follow the call stack as it jumps from one level to the next can be tricky. There are times that each level is very straight forward however most times the lines get blurred and functionality ends up existing at levels it shouldn’t.

Minimize the amount of code files. If you have inherited objects that exist in multiple files think about putting them into one file. If someone need to make changes it is easier because everything is in one place. Organization can go a long way. Another solution is to create a directory that holds common files.

Try not to wrap objects for the sake of making things simpler. Of course there are times that you need to wrap DLL’s or COM objects. However, if you are trying to create easier access to code by writing more code this is probably not a good thing. The less code the better. Unless you have a really good reason to do it, don’t do it.

If you have a frame-work, document it well or better yet buy one. If in your project you try to make thinks easier by writing a frame-work that you can just plug-in objects, this may seem like a good idea, just make sure that you document it well. Everyone must understand it and be able to maintain it. If you can buy a framework you are probably better off. Developers are more likely to adopt a third-party solution then one created in house.

Diagram your software. A picture is worth a thousand words and a code picture is worth a thousand lines of code. Diagrams can make things easier to understand they can show relationships very well, and can go along way in helping others to understand what your code does.

Try to teach others your coding ideas. If no one understands what you are trying to do then know one will be able to maintain your code. Also in the process of documenting or teaching others you may find code that could have been written better. This is a great opportunity to make your code more understandable.

Top Down VS. Bottom Up

There are two approaches when it comes to designing software, top down approach and the bottom up approach. The top down approach is when the developer is given a list of requirements and thinks about how the UI will look and how the user will use the UI. The developer will then just start writing code. With RAD development tools like Delphi, VB, etc it is very easy to create a window, start dropping controls on it and start writing code to respond to buttons, menu items, etc. The bottom up approach is when the developer gets a list of requirements and starts thinking about what objects are required to perform the tasks. Thought must be given to what the UI will do and how the UI will interact with the objects, but the UI is only a means to communicate with the core objects. After the initial design the developer will start coding the implementation of the objects and then build the UI to communicate with the objects.

The top down approach is faster. Most prototypes and simple applications are written this way. You can develop it quickly, get feed back and get it to market in a relatively short amount of time. And if the code is not very complicated it is easy to maintain. The problem is when things become more complicated. As time goes on and requirements grow and the amount of code written reaches a level that makes the code difficult to comprehend, maintenance becomes difficult. And if you are working in a team environment probably only the initial developer will be able to maintain the code in a decent manner. Also bug can start appearing because of the complexity of code. Because decisions are based on how the user uses the UI chances are that not all users will agree, some users will want to do things one way while others will want to do things another. This leads to switches and settings in your code that over time can result in spaghetti code, because things are not thought out the end result is very difficult to maintain and error prone. There is also the problem of adopting newer technologies. Because the code base is all tied together chances are that any changes to components will be significant, you will probably have to test everything before you redeploy because you may not know what the impact of the change will be.

The bottom up approach may be slower at the start but more maintainable in the long run. You have to think about what you are doing. If you happen to be wrong you run the risk of wasting valuable time. You also must be careful not to over think things. However, your code will be more maintainable. If you create UML diagrams, this can act as a blue print of your software. Much like database administrators use ERDs (Entity Relationship Diagrams) to view their relationships in their databases, a UML class diagram can show the object relationships of your software. UML can also be used to show the flows of messages through different objects or give a high level overview of how the different sections relate to one another. Further more, as new requirements come in developers are forced to think about how this will affect the core application. Most of the bugs that I see are caused because developers are not thorough when adding new functionality. There are also many benefits to having your UI separate from your object model.
- You can build test scripts to test your object model. This can test the core functionality of your application. Although it can not test everything it can catch some bugs early on and help the developer maintain a reliable code base.
- You can migrate your code. Because you have a separation of UI and objects you have a place to start migrating code. If the UI must change you know that this will not impact the core. Perhaps you are trying to move your application to the web, or perhaps you would like a fancier UI. Furthermore if you would like to move your application to Linux or .NET moving the objects first is easier. Most portability problems are in the UI controls. You may have to rewrite parts of the UI but this is far better then having to rewrite your business logic.
- You can turn your object model into a stand alone API. Perhaps some users would like the ability to create their own UI or may want to integrate your functionality into one of there own applications. This can make your code more valuable and more useful.

I would suggest only using the top down approach in cases when you want to get your software to market quickly and don’t care about long term maintenance. For more serious projects I would suggest the bottom up approach. It may require more time up front however the time saved in maintenance will be well worth the effort.

Why is TDD so boring?

This is an interesting read on Test Driven Development (TDD).
http://www.ftponline.com/weblogger/forum.aspx?id=9&Date=3/22/2004