blog

• 2008 - September - 05 04:11 PM US/Central

  Feel, don't Think.

  - programming, feel, think

  When I write programs, I rely on feeling. If it doesn't feel right, I keep going until it does.

  What I'm working on right now is a new, very large replacement for an existing (competing) product. The existing product has been deemed (by me) as unsatisfactory. It feels kind of like Microsoft Windows in nature; I can tell its architecture isn't all that great underneath. Don't get me wrong -- it was a great product when it first came out around ten years ago -- but by now, I've begun to see their approach to certain things, and while it appears that their code base may be clean (unlike, perhaps, Windows), it is also large, and most certainly inflexible. There is too much specialization in the wrong places. I can tell they are not generalizing nearly enough.

  I can tell this intuitively, rather than logically. I just know, based upon what I see their software do, and what kinds of behaviors and little quirks it has, how it thinks of things. And intuitively, I know it is not the best approach.

  It is ironic, then, that my first instinct always seems to be to attempt to imitate them. Thankfully, my feelings usually intervene, and instead of just doing what they did, I do things completely differently, in a way I can feel is much improved.

  In this way, my approach to designing software is more artistic and design driven than logic-driven. The same feelings which tell me that a design looks right tell me when a piece of a program is designed correctly -- or, at least, as correctly as I can conceive at that time.

• 2008 - July - 24 04:45 PM US/Central

  The "Open Web"

  - programming, web, code, open web

  Here's my definition:

  The "Open Web" is a realization.
  It is a realization that it is alright to share all kinds of information.
  It is a realization that the information you create may be found by others, and then improved.
  It is a realization that the information comes even before yourself.
  
  It is a realization that The Information itself is the noble cause.

• 2007 - November - 06 09:27 AM US/Central

  Tip: Going Overboard is Generally Not a Good Idea

  - programming, overboard, school

  I learned the hard way: do NOT go overboard on programming projects. It is way too much work.

  I spent probably seven to eight hours programming my recent C++ assignment that was supposed to be a simple menu-driven command line application. I had to overcomplicate it hower. I made a menu controller, and made it allow registering of command objects. Then, I made each of the eleven (I think...) commands as separate classes, inheriting the base command class. In addition to that, I created the model for the application (a phone book of students and staff). Further, I allowed removal of items added (not a requirement), and saving of the entries to a file in a machine-readable format, and reading of that same format (again, neither one a requirement - though writing to a human readable file was). I added support for quotes to allow values to take up more than one word. I added support for backslashes within those quotes to escape quotes.

  I could have used a simple switch statement for detecting menu commands. I could have made it completely straightforward, with none of the bells and whistles I added. I didn't. It was a big mistake. Not only was the project 37 files instead of the 7 files, but it was much more complicated than it needed to be (though, much more modular and, perhaps, well-written).

• 2007 - October - 08 08:07 PM US/Central

  I Am Suppressing My Programs

  - programming, simplicity, orwell, newspeak, 1984

  I'm Big Brother... to my programs. I'm a vicious draconian ruler over them. I'm forcing them to be simpler, to lose their complexity and become all neat and organized... is this a bad thing, actually?

  I suppose making programs simpler inside is not so bad as forcing an entire civilization to begin speaking in ever-simpler words, as in Orwell's 1984. But I can't help but think - am I not being just a little bit cruel to my poor, poor programs?

  Perhaps I'm not. Perhaps the comparison isn't so valid. It isn't that my programs are simple, but that the individual parts of my programs are simple. Humans are much the same way; the concepts of how the human brain works (neurons interacting) are much simpler than the actual result.

  I think that this is the problem with many pieces of software. They are designed in complicated ways. I can tell, I can feel it when I run the programs: they feel clunky, old, abnormal. Some examples: Mac OS X Tiger's Finder, the entirety of Microsoft Windows, Adobe CS software... the list goes on.

  Why are these big pieces of software so, so complicated? Because they are still using the same codebase as they stared with, for some of them, over a decade ago.

  Rewrites (complete and total rewrites) are the best things that can happen to software. Each full version upgrade of a piece of software should be completely rewritten. Sure, programmers should be allowed to copy and paste some code here and there, but they should always redesign from the ground up the software. Only if they come up with the same design as the time before should they keep their old code base.

  On a side note, I hope Apple's Finder is rewritten for Leopard. I think it might be, since it shows some signs of being implemented in Cocoa (I couldn't care less whether it is or isn't, but it should at least be rewritten). The current Finder feels clunky and slow, and is in desperate need of an update.

• 2007 - September - 22 04:08 PM US/Central

  The Complexity of Simplicity

  - programming, simplicity, complexity

  Too many programs are complicated. The prevailing viewpoint seems to be that the programs need to be complicated to have a wide feature set. Why, however, is it not possible to have both simplicity and complexity? Or rather, why is it not possible to have simplicity and flexibility?

  The truth of the matter is that everything can be simple. A program might be terribly complicated and use tons of super-advanced formulas, but that program can always be broken down to one of the simplest (if difficult to use) languages: assembler. Assembler has a very small command set. How is it possible for such a language to allow so much flexibility?

  The key, in my opinion, is for applications to be layered. This is already true for the frameworks for most applications; high-level elements are based on lower-level ones. The higher-level elements, however, usually lack some of the flexibility of the lower-level elements.

  Thankfully, possible to expose all levels simultaneously. Use the top level, and it will be easier to accomplish the task. Use the bottom level and it will be more flexible.

  Too many GUIs don't seem to understand this. They either expose hardly any options, restricting the user greatly, or expose all features at the same time, overwhelming the user with options.

  Why not layer the features? Why not allow both high-level and low-level features? Use keyboard shortcuts to quicken the lower-level tasks for advanced users, and make the shortcuts modifiable. Expose the more complicated features through intuitive methods if possible - perhaps they aren't actually as complicated as they seem. Most things aren't.

• 2007 - September - 19 02:00 PM US/Central

  Benefits of GOTO

  - programming, goto

  Many people seem to hate "GOTO," and I can sympathize with them. The use of GOTO statements can make a program's code very messy. However, whether a programmer likes it or not, they use GOTOs in every program. They go by names such as functions, loops, if statements, and switches.

  read more
• 
  2007 - September - 18 10:59 PM US/Central

  Idea: Story Language

  - programming, idea, ideas, learning

  I came up with an idea about a programming language or environment to teach programming concepts.

  The language is meant to allow students to learn at whatever pace they want. Though it would never act quite like a real language, as it would all be managed and used through a UI rather than through typing code, it should be able to progressively express the different concepts in computer program design. The advanced features should always be present, but also transparent; this way, they will not distract students from what they are learning, but will also not hinder them if they want to learn more.

  read more
• 2007 - September - 01 05:13 PM US/Central

  C++ Problem: In Hindsight Obvious

  - programming, hindsight, C++

  Well, I was having terrible difficulties with some C++ code. I had a template class, and a template class which inherited that first template class. I named them simpleStream and arrayStream (arrayStream inherited simpleStream), and I'll explain what they were for later.

  read more