That's it, Noteman is now open source - a tool for taking notes, sorting them by categories; designed for quick and easy access to the collected information.

This is a program I wrote some years ago; before any kind of formal education in programming - see the details in the sections that will follow.

At its time it was pretty successful, I relied on it, and a couple of my friends still use it (it has been more than 7 years). I promised I would release updates, but somehow I never had the time to actually do that.

Here is the program itself - download Noteman 4.0, there is a readme in the archive, with a detailed description of what it does, what the features are, and how they are used.

Some stuff about the feature set (from the fine manual):

NoteMan v4 (tLPT) The Lazy Ppl's Tool (tm), features

• As many note-windows as you wish
• Custom colors for each tab in the window
• Customizing Hotkeys
• Beep @ sharp hour
• Auto-add to registry (if neccessary)
• Configuration in ini-file
• Auto-Calculate form size and position and write the values in the ini (also automatically)
• Auto-Save the notes
• Icon in the systray that offers control of the program
• 15 TimeReminders (see Reminders in pop-up)
• Custom actions for TimeReminders, Shutdown PC added. works in 2k as well
• unlimited number of DayReminders (via ini)
• Install/Uninstall using command line params

Disable/Enable

• hotkey usage
• dayreminders
• wordwrapping
• tabs
• text centering

Changing

• Font type
• Font size
• Color of the text (in RGB)
• Color of the background (in RGB)
• Form Size
• Form Location
• Primary and secondary hotkeys
• TimeFormat mask

It also comes with a nifty feature that allowed me to use free dial up internet from Relsoft (and other providers); they had a free login/name that you could use for 15 minutes if you dialed precisely at a sharp hour. If you call and someone else made it ahead of you - tough luck. With Noteman's help I was able to log in almost all the time - the program renders the exact system time in the top left corner (above all other windows), and I had a prototype version that would tell my dialing program to start dialing at SharpHour-delta (delta is how long it took my modem to wait for tone, dial, connect, and perform authentication). Ah, the memories... My dad once removed the modem from the computer because the phone-bill exceeded the boundaries of common sense :-)

Programmers, read on to find out why this is an example of "how not to write software", how to get hold of the source code, how to compile it, and so on.

Now I've graduated a university and have gone through a series of courses on programming; I told myself that if there will be any updates, that would only happen in the case if Noteman is rewritten from scratch. If you take a look at the source-code, you will see that it is a sample of "how not to write code", and anti-Borland activists can use this as a good example in a "Borland can be dangerous for the industry" discussion point. But.. that might not be relevant now, because Borland is not what it used to be (and not only because it is not called Borland anymore, or is it? :-)

Why there were no updates:

• I don't use Delphi anymore
• There was no time (and not much will) to continue
• The current version did its job pretty well
• There were other, more important projects
• There are alternative programs that I switched to, namely Microsoft's OneNote

Noteman is written in Delphi, you can download Noteman's source code.

• I don't have the Delphi IDE installed, so I am not sure the code compiles; you might get a few warnings and errors that will require some tweaking;
• The program uses a component to provide the tray icon functionality, it is not a standard component; I (hope) I included it in the source as trayicon.dcu (Delphi Compiled Unit); if it still doesn't work, just remove all the references to it and change the logic - show the main window immediately. You can try to find this component yourself if you can't install the included .dcu;
• The code is not pretty (not properly indented, the names of the variables are not well-chosen, etc);
• Some of the functionality is duplicated in different units;
• The assembly code is obviously not mine :-)

Programmers beware - separate the GUI from the core (and everything else)

One thing I know today and I didn't know then, is that the GUI should be separated from the program's logic. Noteman is an example of not following this rule - everything is tightly tied to Borland's GUI widgets. For example, when the state of a reminder is verified - I read the caption of a label (a string), convert it to an integer, compare that with what I need, then make a decision. When I make an update - the information is only stored in the meta-data associated with the state of that particular widget.

An example: in one of the earliest versions of Noteman, the "beep at sharp hour" feature (uses the system speaker to generate a beep sound when it is a sharp hour, ex: 15:00 or 16:00) worked this way:

1. There was a hidden label somewhere on the window
2. Each second the caption of the label was set to "now", with: TimeToStr(now)
3. I would then parse the string and verify if the minutes part was equal to "00"
4. If so, a beep would be made

You can see how horribly inefficient this is - these operations happen each second! Not to mention that different people use different separators for time/date notation - so such an approach is bound not to work on some systems. The current implementation is better:

1. When the program starts, get the current time
2. See how many seconds are left until the next sharp hour
3. Create a timer and set its interval to the value obtained at the previous step
4. When the timer is triggered
5. 1. Beep
   2. Set the timer to 60*60*1000 milliseconds

Back to separating the GUI from the core. My current vision is to avoid that by storing everything in my own data-structures, and applying that information to the graphical widgets when necessary. This allows me to easily switch to another set of graphical widgets (handy when porting to another platform), or create command-line equivalents (since having a window with some widgets in it is not required). This makes it possible to let a qualified designer develop the interface, and the programmer implement it (instead of letting the programmer do everything on their own - usually not a good idea).

The drawback, of course, is that some of the information is doubled (ex: some data are stored in the form of a variable, as well as in the form of "the caption of a label"); but it's not a problem as serious as the one that the GUI *is* practically the program's core...

Programmers beware - always read the documentation and avoid reinventing the wheel

Much of Noteman's date/time manipulation features work by parsing strings; it all happened before I knew about the DateUtils unit, which provided all that functionality out of the box. Morale of the story - know your instruments well.

What I am asking you, if you decide to play with the code:

• Let me know if you plan to work on it (perhaps we could cooperate);
• Please leave a reference to the original program (a link to this page will do);

Update: the license question is tricky; choosing the right license means that I must first study the options, we all know how long the story is. This guide made it easier: