<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Posts on Jim&#39;s Place</title>
    <link>https://jimlawless.net/blog/posts/</link>
    <description>Recent content in Posts on Jim&#39;s Place</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <lastBuildDate>Sun, 07 Sep 2025 00:00:00 -0500</lastBuildDate><atom:link href="https://jimlawless.net/blog/posts/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Understanding TRS-80 .CMD Files</title>
      <link>https://jimlawless.net/blog/posts/trs80-cmd/</link>
      <pubDate>Sun, 07 Sep 2025 00:00:00 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/trs80-cmd/</guid>
      <description>7 Sep 2025
Nick Andrew contacted me with some Python-based utilities for manipulating CMD files. You can find them here:
https://github.com/nickandrew/nick-src-trs80/blob/main/bin/cmdfile.py
https://github.com/nickandrew/nick-src-trs80/blob/main/bin/hex2cmd.py
Nick mentions this in his interview on my Stray Pointers podcast. The link below has a few source URL&amp;rsquo;s for the Podcast on a few platforms:
https://straypointers.com/e/s3e09.htm
10 Jun 2023
I had originally published this text on Sunday, November 8, 2009. It&amp;rsquo;s seen a couple of revisions. There&amp;rsquo;s some C code in this post, but the main point of the post is to provide a way to dump TRS-80 binary CMD files.</description>
    </item>
    
    <item>
      <title>A Command-Line MP3 player for Windows (Updates - 27 Aug 2025)</title>
      <link>https://jimlawless.net/blog/posts/cmdmp3/</link>
      <pubDate>Wed, 27 Aug 2025 00:00:00 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/cmdmp3/</guid>
      <description>In 2009, I was tinkering with the Windows multimedia subsystem and I wrote a short program to play MP3 audio files from the command-line ( cmdmp3.exe ). I created a second program that was a GUI application ( cmdmp3win.exe ) for those who didn’t want the console window to show. Althought it&amp;rsquo;s technically a GUI application, no visible user interface is present unless an error occurs.
I have released a new version of the sources and executable programs tonight ( 26 Jan 2024 ).</description>
    </item>
    
    <item>
      <title>Computing with a Mac Again</title>
      <link>https://jimlawless.net/blog/posts/backtothemac/</link>
      <pubDate>Sun, 06 Jul 2025 15:38:22 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/backtothemac/</guid>
      <description>My First Mac In July of 2012, I bought my first Macbook. It was a low-end model with the minimum RAM configuration and a 13-inch screen. I had come up through the ranks of 8-bit computing and I&amp;rsquo;d had a dalliance with the 16/32-bit Commodore Amiga, but I had spent most of my time with Intel-based PC&amp;rsquo;s running Microsoft operating systems. I wanted to try a few new things including writing an iOS app, at the time.</description>
    </item>
    
    <item>
      <title>CP/M Days</title>
      <link>https://jimlawless.net/blog/posts/cpm/</link>
      <pubDate>Sat, 03 Aug 2024 11:02:26 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/cpm/</guid>
      <description>Originally published on: Wed, 07 Apr 2010 00:15:01 +0000
In my early days of computing, I used to read a lot of tech magazines. I had been reading about this &amp;ldquo;Operating System&amp;rdquo; called CP/M: Control Program for Microprocessors. The computers I had owned to date really didn&amp;rsquo;t have true operating systems, so I had a very vague idea of the significance of an OS.
I did understand that different kinds of computers seemed to be capable of running CP/M.</description>
    </item>
    
    <item>
      <title>MailSend - The Story of a Humble Command-Line Email Utility</title>
      <link>https://jimlawless.net/blog/posts/mailsend/</link>
      <pubDate>Sat, 24 Feb 2024 00:00:00 -0600</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/mailsend/</guid>
      <description>I used to sell a command-line email utility that I had written for 32-bit implementations of Microsoft Windows. The utility was named MailSend ( not to be confused with the three or four other command-line mailers which share the name. ) The domain name that I used to host MailSend and other utilities, mailsend-online.com has come up for renewal. After 23 or so years of having that domain, I think it&amp;rsquo;s time to retire it.</description>
    </item>
    
    <item>
      <title>The October 10th Bug</title>
      <link>https://jimlawless.net/blog/posts/oct10/</link>
      <pubDate>Tue, 10 Oct 2023 00:00:00 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/oct10/</guid>
      <description>Originally published on: Fri, 7 Oct 2011.

The Y2K panic was not the first time I had encountered a date-oriented software bug. Years before Y2K problems were even a worry, I ran into a situation where an MS-DOS program written in C began to run amok on October 10th.
There had been no new releases of this particular program in months. It had behaved normally running continuously on an unattended PC in a computer room.</description>
    </item>
    
    <item>
      <title>On Pascal</title>
      <link>https://jimlawless.net/blog/posts/pascal/</link>
      <pubDate>Mon, 21 Aug 2023 18:43:56 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/pascal/</guid>
      <description>I saw a re-mention of a 2019 blog post tonight called I come here not to bury Delphi, but to praise it and the counterpart commentary at HackerNews/YCombinator &amp;hellip;
I thought that I&amp;rsquo;d reminisce a bit about my experience with Pascal and Delphi.
Padawan Pascal Like many of my generation, I started out coding in 8-bit BASIC dialects and later began to code in assembly language. What I often did when writing assembly was picture the program in BASIC.</description>
    </item>
    
    <item>
      <title>On Perl</title>
      <link>https://jimlawless.net/blog/posts/onperl/</link>
      <pubDate>Sun, 13 Aug 2023 14:21:52 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/onperl/</guid>
      <description>I believe that I first encountered details of the Perl programming language in the pages of The C Users Journal. I suspect that it was Sydney Weinstein&amp;rsquo;s article &amp;ldquo;A Perl of Great Price&amp;rdquo; in the April 1990 issue of The CUJ. At the time, I was developing software professionally using C almost exclusively. Perl&amp;rsquo;s use of various sigils and symbols were offputting for me. I didn&amp;rsquo;t give the language too much thought after that.</description>
    </item>
    
    <item>
      <title>Generate UML Sequence Diagrams from Text with PlantUML</title>
      <link>https://jimlawless.net/blog/posts/plantuml/</link>
      <pubDate>Sun, 16 Jul 2023 11:07:59 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/plantuml/</guid>
      <description>Setup I recently needed to draw a UML sequence diagram. That&amp;rsquo;s usually something I&amp;rsquo;d do in Microsoft&amp;rsquo;s Visio ™. I was aware of text-to-chart utilities such as Medusa so I assumed that similar tools would be available for generating sequence diagrams. A quick search of the web yielded an open source tool called PlantUML. PlantUML is a set of tools for converting text scripts to various kinds of UML diagrams. To use the bare-bones setup for PlantUML, you&amp;rsquo;ll need a Java Virtual Machine (JVM).</description>
    </item>
    
    <item>
      <title>Extending Commodore 64 BASIC</title>
      <link>https://jimlawless.net/blog/posts/basic-wedge/</link>
      <pubDate>Mon, 12 Jun 2023 18:16:47 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/basic-wedge/</guid>
      <description>The original version of this post was published on March 16, 2014.
Back in the day, I used to write machine-language subroutines for the Commodore 64 that I would then call from a main program written in BASIC. I found it easier to use BASIC as the higher-order controller over a set of ML functions that usually did things for which CBM BASIC 2.0 was not well-suited.
In one case, I wrote an Xmodem file-transfer protocol handler.</description>
    </item>
    
    <item>
      <title>How I Chose to Upgrade to a Commodore 64</title>
      <link>https://jimlawless.net/blog/posts/choosing64/</link>
      <pubDate>Fri, 26 May 2023 14:15:46 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/choosing64/</guid>
      <description>In the mid-1980&amp;rsquo;s, I&amp;rsquo;d owned a used TRS-80 Model I for about a year when I had a yearning for a newer system. I only had cassette-based storage which proved to be unreliable. I had a 16K machine and I had a few games and tools for the TRS-80. I learned Z-80 assembly language and I was having a lot of fun tinkering, but that particular line of computers had met its end.</description>
    </item>
    
    <item>
      <title>Capture and Convert Images (including .webp) with Pic2File for Windows</title>
      <link>https://jimlawless.net/blog/posts/pic2file/</link>
      <pubDate>Thu, 25 May 2023 17:29:01 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/pic2file/</guid>
      <description>Once Upon a Time In 2009, I created an image capture utility for Windows called Pic2File. It wasn&amp;rsquo;t like a number of capture utilities. For Pic2File to function, images needed to be copied to the Windows clipboard. Pic2File would scan the clipboard periodically for images. If image content was present on the clipboard, it would save the image to the specified file format in a sequentially-numbered file. It then clears the clipboard data.</description>
    </item>
    
    <item>
      <title>My Journey Began with BASIC</title>
      <link>https://jimlawless.net/blog/posts/basic/</link>
      <pubDate>Sun, 30 Apr 2023 00:00:01 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/basic/</guid>
      <description>&amp;ldquo;It is practically impossible to teach good programming to students that have had a prior exposure to BASIC: as potential programmers they are mentally mutilated beyond hope of regeneration&amp;rdquo; – Edsger Dijkstra
My early days of computing began in the late 1970’s. I used to go in to the Radio Shack in the mall where they would let the patrons type stuff into their display-model TRS-80. You could tell that none of the patrons were skilled in any type of computer language as the screen was filled with a line of nonsense followed by a line indicating that a syntax-error had occurred.</description>
    </item>
    
    <item>
      <title>Text Editor Wars : Multi-Edit versus ... Pizza?</title>
      <link>https://jimlawless.net/blog/posts/multi-edit/</link>
      <pubDate>Sun, 30 Apr 2023 00:00:00 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/multi-edit/</guid>
      <description>In the late 80’s, my programming team was in search of a decent programmer’s text editor for MS-DOS. At the time, a number of editors seemed to have comparable features. Any missing features could often be added via the embedded macro language that each of these editors sported. What was it that helped to make the decision?

The advertisement from American Cybernetics above ( excerpted from the late, great Computer Language magazine ) caught our eye.</description>
    </item>
    
    <item>
      <title>Computers I Have Known</title>
      <link>https://jimlawless.net/blog/posts/known/</link>
      <pubDate>Tue, 25 Apr 2023 21:14:18 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/known/</guid>
      <description>Originally published on: Sat, 22 May 2010
The first computer in my household was a Radio Shack TRS-80 pocket computer that my dad owned. My brother got it for him as a birthday gift in 1980.

This was essentially a calculator with a pretty nifty BASIC interpreter built in. The BASIC was not without its own personality. Although it supported arrays, I found that if I DIM&amp;rsquo;ed an array &amp;ldquo;A&amp;rdquo; and placed a value in A(2) &amp;hellip; variable &amp;ldquo;B&amp;rdquo; would get clobbered.</description>
    </item>
    
    <item>
      <title>Another Squares Puzzle</title>
      <link>https://jimlawless.net/blog/posts/squares2/</link>
      <pubDate>Tue, 18 Apr 2023 06:21:16 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/squares2/</guid>
      <description>I saw another Facebook &amp;ldquo;squares&amp;rdquo; puzzle this morning. Here is the blank image:

Here are the squares that I count:

I see the first eight in the image above.

&amp;hellip;nine..

&amp;hellip;ten&amp;hellip;

&amp;hellip;eleven&amp;hellip;

&amp;hellip;twelve&amp;hellip;

&amp;hellip;thirteen&amp;hellip;

&amp;hellip;fourteen&amp;hellip;

&amp;hellip;fifteen&amp;hellip;

&amp;hellip;sixteen&amp;hellip;

&amp;hellip;seventeen&amp;hellip;

&amp;hellip;and the entire puzzle is one big square. That makes eighteen.</description>
    </item>
    
    <item>
      <title>The Squares Puzzle</title>
      <link>https://jimlawless.net/blog/posts/squares/</link>
      <pubDate>Mon, 10 Apr 2023 21:59:59 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/squares/</guid>
      <description>Originally Published on August 2, 2012
A number of my Facebook friends have been posting a puzzle based on the image below.

How many squares can you count in the above image. I count 40. I’ve included several sequences of the puzzle with squares colored in red and yellow to illustrate the ones I see.
First, let’s just count the basic squares across and down.

That gives us 16.</description>
    </item>
    
    <item>
      <title>A Quine in Forth</title>
      <link>https://jimlawless.net/blog/posts/forthquine/</link>
      <pubDate>Sat, 11 Mar 2023 13:05:46 -0600</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/forthquine/</guid>
      <description>Originally published on: Tue, 04 Aug 2009
I needed a little mental exercise tonight, so I chose to write a quine ( a program that produces its own source as its output ) in the Forth programming language?
Why Forth? Because I&amp;rsquo;m a novice Forth programmer at best. I don&amp;rsquo;t think very well in Forth, so this took some effort. Here&amp;rsquo;s the quine: ( the source for this quine is in the public domain )</description>
    </item>
    
    <item>
      <title>Scott Ballantyne: Blazin&#39; Into Forth</title>
      <link>https://jimlawless.net/blog/posts/blazin/</link>
      <pubDate>Sat, 11 Mar 2023 12:56:39 -0600</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/blazin/</guid>
      <description>Originally published in Commodore Hacking electronic magazine #15, April 1998
In the early 70&amp;rsquo;s, Charles Moore designed one of the most powerful computing languages known. This language, Forth, was very different from the traditional procedural languages.
Forth is a language which allows the programmer to change most any facet of the language they wish ( including syntax extensions ).
Forth&amp;rsquo;s rapid acceptance on 8-bit microcomputers stemmed from the fact that it took a relatively small amount of memory to properly implement the language.</description>
    </item>
    
    <item>
      <title>An Interview with Tom Zimmer: Forth System Developer</title>
      <link>https://jimlawless.net/blog/posts/zimmer/</link>
      <pubDate>Sat, 11 Mar 2023 12:46:29 -0600</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/zimmer/</guid>
      <description>This post was formerly hosted at a couple of my other blogs. I&amp;rsquo;ve moved it here. It was originally posted in 2000.
If you&amp;rsquo;ve ever used a Forth compiler, chances are you&amp;rsquo;ve heard the name Tom Zimmer. Tom&amp;rsquo;s been a staple in the Forth community for a few decades. Tom developed a number of Forth systems for popular 8-bit microcomputers that dominated the home-computer market in the 80&amp;rsquo;s.
Tom is the creator of the freeware Win32Forth system.</description>
    </item>
    
    <item>
      <title>The Video Arcade that Wasn&#39;t</title>
      <link>https://jimlawless.net/blog/posts/arcade-zero/</link>
      <pubDate>Mon, 20 Feb 2023 13:07:50 -0600</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/arcade-zero/</guid>
      <description>A friend and I used to really enjoy playing pinball. We happened upon a group of stand up video machines in the late 1970&amp;rsquo;s as we were exiting our local mall through a Sears store. We noticed Atari&amp;rsquo;s video pinball which we thought was interesting. We played it a couple of time but we didn&amp;rsquo;t really enjoy it as much as a real pinball machine.
We did, however, notice other kids our age (mid-teens), gathered around some of the other machines.</description>
    </item>
    
    <item>
      <title>Learning Z-80 Assembly Language on the TRS-80</title>
      <link>https://jimlawless.net/blog/posts/z-80/</link>
      <pubDate>Sat, 21 Jan 2023 18:01:00 -0600</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/z-80/</guid>
      <description>Originally published on: Sun, 08 Nov 2009
My first computer was a second-hand TRS-80 Model I with 16K of RAM and a cassette-recorder for auxiliary storage. I was 17 years old when I received this computer in the Fall of 1982. My goal? Like many kids my age at the time, I had intended to write a video game or two and live happily on the riches that would befall me.</description>
    </item>
    
    <item>
      <title>Testing the Amazon Time Sync NTP Service with Python</title>
      <link>https://jimlawless.net/blog/posts/amazonntp/</link>
      <pubDate>Fri, 11 Nov 2022 09:09:35 -0600</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/amazonntp/</guid>
      <description>I&amp;rsquo;d just read a new article describing Amazon&amp;rsquo;s new publicly available NTP service (Amazon Time Sync). You can read the article here:
https://aws.amazon.com/about-aws/whats-new/2022/11/amazon-time-sync-internet-public-ntp-service/
I thought I&amp;rsquo;d give it a try with a Python script.
I first needed to add ntplib to my local Python libraries:
pip install ntplib Then, I put together this short script (amazontime.py):
import ntplibfrom time import ctimentp = ntplib.NTPClient()response = ntp.request(&amp;quot;time.aws.com&amp;quot;)print(ctime(response.tx_time)) Here&amp;rsquo;s the invocation and the output:</description>
    </item>
    
    <item>
      <title>Using Python to Remove Image Backgrounds</title>
      <link>https://jimlawless.net/blog/posts/rembg/</link>
      <pubDate>Sat, 05 Nov 2022 14:50:25 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/rembg/</guid>
      <description>A couple of weeks ago, I saw a notification containing a simple Python script that would remove backgrounds from images. The sample source code was something like this:
from rembg import removefrom PIL import Imageinp = Image.open(&#39;image.jpg&#39;)output = remove(inp)output.save(&#39;image.png&#39;) I tried it. The results were pretty impressive. Without providing any parameters to speak of, a number of images that I used to test the library were transformed into images highlighting a central person or object while rendering the background transparent.</description>
    </item>
    
    <item>
      <title>Black Hat Python - Python Programming for Hackers and Pentesters - 2nd Edition</title>
      <link>https://jimlawless.net/blog/posts/blackhatpython2/</link>
      <pubDate>Sat, 08 Oct 2022 10:47:48 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/blackhatpython2/</guid>
      <description>I had read the first edition of this book in 2015-ish. That version was very intriguing, but it exclusively used Python version 2 for all examples. This was a time when the language was known to be in transition to version 3, although many were doing so somewhat cautiously, if at all.

The 2nd edition of this book covers the same material with updates that include usage of Python 3 and the appropriate counterpart libraries.</description>
    </item>
    
    <item>
      <title>Jim Butterfield : The Commodore Guru</title>
      <link>https://jimlawless.net/blog/posts/jim-butterfield/</link>
      <pubDate>Tue, 04 Oct 2022 18:27:57 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/jim-butterfield/</guid>
      <description>Originally published in the Commodore Hacking (C=Hacking) electronic magazine #14, November 1996. This post has been reprinted in Commodore Free magazine and other e-magazines. Jim Butterfield passed away on June 29th, 2007 after a long battle with cancer. I grieve with the family and the legions of techies who looked upon Jim as a mentor via his articles and ongoing contact with the Commodore community. Rest in peace, Mr. Butterfield.</description>
    </item>
    
    <item>
      <title>Speaking with Don French : The Man Behind the French Silk Assembler Tools</title>
      <link>https://jimlawless.net/blog/posts/don-french/</link>
      <pubDate>Tue, 04 Oct 2022 18:27:43 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/don-french/</guid>
      <description>Originally posted 5-21-2004. In the early days of 8-bit computing, a programmer&amp;rsquo;s most often-used tool was the assembler. Due to memory constraints, many of the early 8-bit machines could not run a full assembler. At best, one could hope for some sort of machine-language monitor that would include a mini-assembler and a disassembler.
That was &amp;hellip; until Don French came along and implemented a symbolic assembler on the unexpanded VIC-20.</description>
    </item>
    
    <item>
      <title>An Interview with Game Developer James Hague</title>
      <link>https://jimlawless.net/blog/posts/james-hague/</link>
      <pubDate>Tue, 04 Oct 2022 18:27:32 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/james-hague/</guid>
      <description>This post was originally published in 1999.
Being a bit of a video-game and classic computer enthusiast, I recently purchased the electronic book Halcyon Days - Interviews with Classic Computer and Video Game Programmers. Note: In 2002, this book was made available to read freely here: https://www.dadgum.com/halcyon
The author of the book, James Hague, is himself a game developer. Since I noticed that his complete bio was missing from the text, I asked if he&amp;rsquo;d permit me to interview him.</description>
    </item>
    
    <item>
      <title>All Things Python</title>
      <link>https://jimlawless.net/blog/posts/pystuff/</link>
      <pubDate>Sat, 24 Sep 2022 19:26:49 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/pystuff/</guid>
      <description>The original intent of this post was to focus Python-related materials to another of my sites. I have decided to just merge it into the main jimlawless.net site. Please see this link for posts about Python programming:
https://jimlawless.net/blog/tags/python/</description>
    </item>
    
    <item>
      <title>Play MP3 Files in Windows with Python</title>
      <link>https://jimlawless.net/blog/posts/playmp3/</link>
      <pubDate>Wed, 14 Sep 2022 19:34:42 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/playmp3/</guid>
      <description>Portions of this post were previously published on Sun, 26 Jun 2011.
I read the book Grey Hat Python : Python Programming for Hackers and Reverse Engineers by Justin Seitz. The book introduced the Python ctypes library to me. The ctypes library, allows a Python program to access to lower-level features of the operating environment normally reserved for C programmers.
As an early experiment, I rewrote in Python the bulk of the command-line MP3 player I had originally written in C.</description>
    </item>
    
    <item>
      <title>Yet Another Attempt at Obfuscated C</title>
      <link>https://jimlawless.net/blog/posts/obf-c2/</link>
      <pubDate>Sun, 22 Sep 2019 12:00:00 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/obf-c2/</guid>
      <description>I had discovered the International Obfuscated C Coding Contest (IOCCC) some time in the late 1980’s in the pages of a printed technical magazine. At the time, my C skills were still in their larval stage, but I was very intrigued by the handful of entries that had been presented.
In later years, I tried my hand at other obfuscated coding contests, each time usually on a whim. I managed to irritate a few people with an entry in an obfuscated Ruby coding contest and I managed to see print in The Perl Journal for one of that publication’s obfuscated Perl coding contests.</description>
    </item>
    
    <item>
      <title>Create JPEG Images from PNG&#39;s on your Mac Desktop</title>
      <link>https://jimlawless.net/blog/posts/png2jpg/</link>
      <pubDate>Tue, 04 Jul 2017 12:00:00 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/png2jpg/</guid>
      <description>I like to use the PNG format for Mac screen-captures to ensure that I don’t lose any clarity in the source images. I often convert these images to JPEG format for inclusion in email or posts. I got tired of running the conversions by hand.
tojpeg.rb is a Ruby script for OS/X and MacOS that uses the sips utility to convert the PNG files in ~/Desktop to JPEG counterparts. The PNG files are left intact.</description>
    </item>
    
    <item>
      <title>Display File, Function, and Line Number in Go (Golang)</title>
      <link>https://jimlawless.net/blog/posts/whereami/</link>
      <pubDate>Sun, 17 Apr 2016 12:00:00 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/whereami/</guid>
      <description>Years ago, I used a macro in C and C++ programs to provide information on the current line of code being executed. I used this in error handlers and exception traps in addition to other information. Displaying the file name and line number of a given exception in large projects was often helpful in the speedy remediation of issues.
I also used this technique to home brew tracing function in the code.</description>
    </item>
    
    <item>
      <title>A TCP Echo Server in Go (Golang)</title>
      <link>https://jimlawless.net/blog/posts/goecho/</link>
      <pubDate>Wed, 23 Dec 2015 12:00:00 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/goecho/</guid>
      <description>I had the need to test connectivity between a couple of servers, recently. Netcat wasn’t available so we managed to cobble something together that worked for the particular situation.
An “echo server” is a program that people often code as kind of a “kata” for practice. I decided to write an echo server in Go.
I have not tested this code on all appropriate environments, yet, so I wouldn’t say that this code is completely stable.</description>
    </item>
    
    <item>
      <title>My Tech Magazine Articles from Yesteryear</title>
      <link>https://jimlawless.net/blog/posts/magazines/</link>
      <pubDate>Fri, 03 Jul 2015 12:00:00 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/magazines/</guid>
      <description>In the early 1990’s, I began writing for a few of my favorite technical magazines. Here is a mostly-complete list.
Windows/DOS Developer’s Journal, September 1992
A Universal EXE-to-BIN Conversion Utility ( Tech Tips ) and More on Copying Large Data Chunks in C ( Tech Tips ) The second entry was co-authored by my friend Roger Samaan.

Windows/DOS Developer’s Journal, March 1993
Converting a Windows Screen-Saver into an Application ( Tech Tips )</description>
    </item>
    
    <item>
      <title>Growing Up with Radio Shack</title>
      <link>https://jimlawless.net/blog/posts/radioshack/</link>
      <pubDate>Thu, 15 Jan 2015 00:00:00 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/radioshack/</guid>
      <description>I saw in the online Wall Street Journal that Radio Shack is preparing to file for bankruptcy:
http://www.wsj.com/articles/radioshack-prepares-bankruptcy-filing-1421279360
I had read a blog post eulogizing the store from a former employee several weeks ago. I ended up on the Radio Shack Catalogs site:
http://www.radioshackcatalogs.com/
…poring over old catalogs, looking at all of the gear that I’d purchased throughout my childhood and through the early years of my adult life. Reminiscing brought back some good memories.</description>
    </item>
    
    <item>
      <title>Fare Thee Well, Dr. Dobbs Journal</title>
      <link>https://jimlawless.net/blog/posts/ddj/</link>
      <pubDate>Thu, 01 Jan 2015 12:00:00 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/ddj/</guid>
      <description>I was a little choked up when I read Andrew Binstock’s post Farewell, Dr. Dobb’s :
http://www.drdobbs.com/architecture-and-design/farewell-dr-dobbs/240169421
The articles in the magazine were a powerful influence on the quality of my technical skills.
In early 1987, I was in the final quarter of a vocational/technical programming curriculum. I would soon be out looking for gainful employment as a computer programmer. I read a fair number of computer magazines at the time, but most specialized in the Commodore 64 family of computers.</description>
    </item>
    
    <item>
      <title>An RPN Interpreter in Go (Golang)</title>
      <link>https://jimlawless.net/blog/posts/rpngo/</link>
      <pubDate>Sat, 20 Jul 2013 12:00:00 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/rpngo/</guid>
      <description>I built a non-Turing-complete interpreter in Go whose current incarnation is simply named “rpnrepl”. rpnrepl is a very tiny stack-based, postfix language whose syntax is similar to that of the Forth programming language.
rpnrepl can only perform four mathematical operations, display the topmost item on the stack, display a newline, and exit the running program.
Unlike Forth whose grammar can change dynamically, rpnrepl does have a simple grammar. Words are separated by spaces unless bound by single quotation-marks or double quotation-marks.</description>
    </item>
    
    <item>
      <title>Simulating Try-Catch in Go (Golang)</title>
      <link>https://jimlawless.net/blog/posts/trycatch/</link>
      <pubDate>Wed, 17 Jul 2013 12:00:00 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/trycatch/</guid>
      <description>In the Go code I’ve been writing to help learn the language, I’ve been using a common function to deal with error conditions. The function terminateOnErr(err error) checks to see if the err parameter is nil. If not, it displays the paramter and calls os.Exit(1).
func terminateIfError(err error) {if( err != nil ) {fmt.Fprintln(os.Stderr, err)os.Exit(1)}} Later in the code, I use the following line after every error check that I need to perform:</description>
    </item>
    
    <item>
      <title>Sending GMail with Go (Golang)</title>
      <link>https://jimlawless.net/blog/posts/gsend/</link>
      <pubDate>Fri, 05 Jul 2013 12:00:00 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/gsend/</guid>
      <description>I needed a command-line e-mail sender utility that would send e-mail via my GMail account. I wanted the solution to work on Windows and OS/X for the time being.
My solution is a utility named GSend.
GitHub repo: https://github.com/jimlawless/gsend/
The Go source is as follows:
// Copyright 2013 - by Jim Lawless// License: MIT / X11// See: http://www.mailsend-online.com/license2013.php//// Bear with me ... I&#39;m a Go noob.package mainimport (&amp;quot;log&amp;quot;&amp;quot;flag&amp;quot;&amp;quot;net/smtp&amp;quot;&amp;quot;fmt&amp;quot;)func main() {to := flag.</description>
    </item>
    
    <item>
      <title>Variant Types in Go (Golang)</title>
      <link>https://jimlawless.net/blog/posts/variant/</link>
      <pubDate>Mon, 15 Apr 2013 12:00:00 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/variant/</guid>
      <description>Here we Go again…
I had corresponded with some seasoned Go programmers about variant types some time ago. I was searching for a way to keep a slice of data where each element might be a different data-type. The approach I had been taking was in trying to define a data-structure that could act as a wrapper for some of the basic data types. I then learned through the wisdom of these developers that Go could already accommodate my needs in a much simpler fashion.</description>
    </item>
    
    <item>
      <title>Ancient Devtools</title>
      <link>https://jimlawless.net/blog/posts/8bitdev/</link>
      <pubDate>Tue, 10 Jul 2012 21:43:31 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/8bitdev/</guid>
      <description>When I first began using microcomputers in the late 1970’s, development tools for 8-bit machines were precious and mysterious commodities. Most of these sorts of tools that looked to be useful were very expensive. My usage of most of these tools was driven by budgetary constraints.
The Gateway Drug : BASIC
All it really took to pique someone’s interest in microcomputers was to show them a simple program such as:</description>
    </item>
    
    <item>
      <title>My First Android App</title>
      <link>https://jimlawless.net/blog/posts/android/</link>
      <pubDate>Tue, 12 Jun 2012 12:00:00 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/android/</guid>
      <description>Several months ago, as the “year of learning to code” was getting underway, I wondered what it would be like to have a JavaScript REPL available for my mobile device.
I figured that I could build my own mobile app using the PhoneGap framework that would simply expose a large textarea that could be eval()‘ed at the tap of a button.
I bought an older Android tablet to prove the concept.</description>
    </item>
    
    <item>
      <title>BBS Fun in the Eighties</title>
      <link>https://jimlawless.net/blog/posts/bbsfun/</link>
      <pubDate>Sat, 13 Mar 2010 12:00:00 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/bbsfun/</guid>
      <description>My introduction to the world of electronic bulletin-board systems ( BBS’s ) began in the mid-1980’s.
One evening, my friend John called to say that he’d gotten a modem for his Commodore 64. On a whim, I went to Sears and spent over $60 for the same 300 baud “dumb” VIC-1600 modem. This modem was marketed for the VIC-20, but it worked with the C64 as well. It lacked the auto-answer/auto-dial features that were present in the 1650 modem.</description>
    </item>
    
    <item>
      <title>Flirtin&#39; with Forth</title>
      <link>https://jimlawless.net/blog/posts/flirtin/</link>
      <pubDate>Mon, 15 Feb 2010 12:00:00 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/flirtin/</guid>
      <description>I was a senior in high-school in the mid-1980&amp;rsquo;s when I first encountered a dialect of the Forth programming language. I was quite familiar with BASIC and Z-80 assembly-language and was just beginning to hand-assemble some 6502 code.
One of my instructors brought in King Microware Tiny Forth for the Commodore 64 computer in her lab.

I was intrigued, at first, and tried to tinker with Forth. The booklet that came with Tiny Forth described the following line of code that I was supposed to enter at the OK prompt:</description>
    </item>
    
    <item>
      <title>FIF Isn&#39;t Forth</title>
      <link>https://jimlawless.net/blog/posts/fif/</link>
      <pubDate>Sat, 12 Dec 2009 12:00:00 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/fif/</guid>
      <description>Several years ago, I created a Forth-like programming language interpreter called FIF ( FIF Isn&amp;rsquo;t Forth ). I put FIF aside for a while as other events began to consume my time. I ultimately ended up losing all of the source code that I had built to that point.
I had pondered trying to recreate it, but the work I had done in making FIF opened my eyes to things that I&amp;rsquo;d want to do differently.</description>
    </item>
    
    <item>
      <title>Embedding Javascript in a Batch File</title>
      <link>https://jimlawless.net/blog/posts/jsbatch/</link>
      <pubDate>Fri, 07 Aug 2009 12:00:00 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/jsbatch/</guid>
      <description>The program below is both a batch file and a JavaScript WSH console file. The dual nature of the file is achieved via JavaScript block comments and the strategy by which the command interpreter searches for target labels in a batch file.
Save the file below as hybrid.bat &amp;hellip;
rem ( /*@echo offcscript /nologo /e:javascript hybrid.batgoto end*/ )// by Jim Lawless// This program sample is in the public domainfunction rem() {WScript.</description>
    </item>
    
    <item>
      <title>Obfuscated C</title>
      <link>https://jimlawless.net/blog/posts/obf-c/</link>
      <pubDate>Tue, 21 Apr 2009 12:00:00 -0500</pubDate>
      
      <guid>https://jimlawless.net/blog/posts/obf-c/</guid>
      <description>I had written a little C program a while back for the 19th annual International Obfuscated C Coding contest.
Not only did my code not win … it didn’t even warrant an entry in the honorable mentions or anything like that. If you look at the winners and look back at my code, you’ll immediately see why; the winners and the runners-up were much more creative than my effort.
Rather than get lost in obscurity, I felt that my entry needed to be published, so it has been given the honor of appearing in my first public blog post.</description>
    </item>
    
  </channel>
</rss>
