Software Development
As a software developer I place a very high priority on the
satisfaction of the end user of my software.
I have found that there are several key elements in achieving
this satisfaction:
- Understanding the business of the end user.
This often involves analysis of the user's business
process or work flow.
Whether it be in education, finance, manufacturing or research,
it is
only by understanding what the user is currently doing and why
it is being done that I can develop a software solution to
improve that process.
- Assisting the end user -- who may or may not have a high
degree of computer knowledge or experience -- in determining
the requirements and specifications for a given software
solution.
Users often do not know what the computer can and cannot do,
or how the computer might be able to make their work more
efficient by providing more timely, more accurate or more
complete information.
One of my jobs as a software developer is to present
design alternatives to the user that are realistic,
given the hardware and operating system environment and
the time and money constraints of the project.
I often present prototypes to help the user conceptualize
these different alternatives and to get feedback from
the user before investing additional development time.
- I place a very strong emphasis on the usability of
my software.
I have often written programs that I know will be used every day,
sometimes by one user, sometimes by many users.
Therefore, it is of critical importance that the user
interface be clean, well-organized and intuitive.
Whenever I am working on a piece of software, I always try
to place myself in the position of the end user and think,
"What would I like this program to do?
How would I like it to look?
What features would I find really useful?
What would save me time as I'm using this program?"
I often try to go beyond the minimal requirements
of the program and
incorporate additional features that the user may not
have asked for or even thought of, but which will end
up being helpful and saving the user
time in the long-run.
- I am also mindful of the functionality
of my software.
I am an absolute perfectionist, and if something has my name
attached to it, I want it to work correctly every time,
without bugs, glitches or errors.
This means using normalized database design to
ensure the integrity of the user's data.
It also means testing the software by thinking of all
the possible scenarios in which it might be misused,
presented with bad data, or encounter unexpected conditions.
I build in confirmation messages when the user is
about to perform a task that has the potential for
modifying or deleting critical data.
- Finally, I am concerned about the long-term
maintainability
of the software I write.
I approach each project with the goal that it can continue to be
managed, maintained, modified and enhanced after I am gone.
This means commenting my code and
writing documentation, both for the end-user
and for other developers who may have responsibility for
my software
in the future.
I often write some of this documentation before finishing
or even before starting to write the software,
in order to provide a roadmap
for myself of what the software should do and how it should
work.
As can be seen from the points above,
achieving the satisfaction of the end user requires
attentiveness throughout the complete
software development life-cycle.
Below are screenshots of some user interfaces I have designed,
as well as code samples to illustrate my coding style and
conventions.
User Interface
As mentioned above,
it is of critical importance that the user
interface be clean, well-organized and intuitive for
the end user.
Here are some examples of user interfaces I have designed.
The following is one of a number of dialog boxes I designed
as part of a system to track trades and open positions for
a portfolio manager.
This dialog box allows the user to enter a new position
in the portfolio by assembling each of the constituent parts
of a futures contract: the underlying instrument, the expiration
month and year, and if applicable, the strike
price on the call or put option.
The next window shows a screenshot of a simple
disk monitor program written as part of a real-time
data collection system, in which new data is constantly
being written to the disk.
In order to prevent the disk from filling up,
the user can specify the minimum free disk space desired
and a directory from which files of a certain type may be
deleted when the free disk space falls below the desired level.
Coding Style
Coding style is important because well-written code helps ensure
both the correct functionality and the
long-term maintainability of the software.
I use modular programming techniques to keep routines short
and easy to understand.
For example, here is a procedure from a Visual Basic
program I wrote recently.
Since Visual Basic is an event-driven language, this
procedure is called every time the user types a key in a
particular search field.
'============================================================================
' Code samples
' Copyright 2000 Mark Swearingen
'============================================================================
' Require explicit variable declaration
Option Explicit
'----------------------------------------------------------------------------
' Declare global variables
'----------------------------------------------------------------------------
' Database Access Objects (DAO)
Public rstContact
As DAO.Recordset
'----------------------------------------------------------------------------
' Editbox controls
'----------------------------------------------------------------------------
Private Sub txtSearch_Change()
' If Recordset object is not yet defined, then abort
search
If rstContact
Is Nothing Then
lstSelect.Clear
UpdateRecordCount 0, 0
ClearRecordDisplay
DisableRecordButtons
Exit Sub
End If
' If no records in table, then abort search
If rstContact.RecordCount = 0
Then
lstSelect.Clear
UpdateRecordCount 0, 0
ClearRecordDisplay
DisableRecordButtons
Exit Sub
End If
UpdateRecordList
UpdateRecordCount lstSelect.ListCount, rstContact.RecordCount
End Sub
|
By creating several user-defined sub-procedures which handle the
detailed record processing,
the above event procedure is kept short and easy to read.
(Note that the outcome of each of the two
If
statements above is identical.
Because Visual Basic is an object-oriented language,
these cannot be combined into one
If
statement by using an
Or
clause; if they were,
then the attempt to access the
.RecordCount
property of the
rstContact
object would cause a run-time error in the program
whenever the
rstContact
object was undefined.)
The next code sample shows the detailed processing in the
UpdateRecordList
procedure, which is called by
txtSearch_Change
above.
'============================================================================
' Code samples
' Copyright 2000 Mark Swearingen
'============================================================================
' Require explicit variable declaration
Option Explicit
'----------------------------------------------------------------------------
' Declare global contstants
'----------------------------------------------------------------------------
' Field names in Access database
Public Const
strFIELD_LAST As String
= "LastName"
Public Const
strFIELD_FIRST As String
= "FirstName"
Public Const
strFIELD_AREA As String
= "AreaCode"
Public Const
strFIELD_PHONE As String
= "Phone"
' Index names in Access database
Public Const
strINDEX_LAST_FIRST As String
= "LastFirst"
Public Const
strINDEX_LAST As String
= "Last"
Public Const
strINDEX_FIRST As String
= "First"
Public Const
strINDEX_AREA As String
= "Area"
Public Const
strINDEX_PHONE As String
= "Phone"
'----------------------------------------------------------------------------
' Declare global variables
'----------------------------------------------------------------------------
' Database Access Objects (DAO)
Public rstSearch
As DAO.Recordset
'----------------------------------------------------------------------------
' Data storage, retrieval, search and manipulation routines
'----------------------------------------------------------------------------
Private Sub UpdateRecordList()
Dim blnRemove
As Boolean
Dim intList
As Integer
Dim intName
As Integer
' Set Index for fast key searches
rstSearch.Index = strINDEX_LAST_FIRST
' Search existing list for records that should be
removed
intList = 0
Do While
intList <= lstSelect.ListCount - 1
' Search for this list item in the database
intName = lstSelect.ItemData(intList)
blnRemove = False
rstSearch.Seek "=", strLastName(intName),
strFirstName(intName)
If rstSearch.NoMatch
Then
blnRemove = True
' If record does not match new search string,
then remove it
ElseIf
Len(strLastName(intName)) > 0
And Len(txtSearch) > 0
Then
If
InStr(1, strLastName(intName), txtSearch, vbTextCompare) _
<> 1 And
InStr(1, strFirstName(intName), txtSearch, _
vbTextCompare) <> 1
And
InStr(1, strAreaCode(intName), _
txtSearch, vbTextCompare) <> 1
And InStr(1, _
strPhone(intName), txtSearch, vbTextCompare)
<> 1 Then
blnRemove = True
End If
End If
If blnRemove Then
' Remove this record from the list,
since it no longer matches
lstSelect.RemoveItem intList
' Make array element available again
strLastName(intName) = ""
Else
intList = intList + 1
End If
Loop
' Search database for records that should be added
AddSearchField strFIELD_LAST, strINDEX_LAST
AddSearchField strFIELD_FIRST, strINDEX_FIRST
AddSearchField strFIELD_AREA, strINDEX_AREA
AddSearchField strFIELD_PHONE, strINDEX_PHONE
' If list is now empty, clear display
If
lstSelect.ListCount = 0 Then
ClearRecordDisplay
DisableRecordButtons
' If no item is selected, then select first item
ElseIf
lstSelect.ListCount > 0 And
lstSelect.ListIndex < 0 Then
lstSelect.ListIndex = 0
Else
' Force update of record
lstSelect_Click
End If
End Sub
Private Sub AddSearchField(FieldName
As String,
IndexName As String)
End Sub
|
Comments are used where appropriate to explain the purpose
of a line or a block of code.
The above routine keeps a list of records up to date each time a
search string is changed by the user.
First it weeds out existing records in the list that no longer
match the search string.
Next it adds to the list any new records that now match the
search string.
(For brevity the code in the
AddSearchField
procedure above has been
omitted and only the declaration is shown.)
Note also the use of line-continuation characters
( _ )
to keep all lines within the width of a printed page.
