Category: Development

AI is Transforming Programming: Enabling Everyone to Have ‘Superpowers’

GitHub Copilot, VS Code, and WSL2 can provide any Windows user with the ability to be a developer, Novice and Pro

Pictured: VS Code Insiders, GitHub Copilot, and WSL2 Ubuntu

Building a web app can feel daunting, especially when you’re not a professional software engineer. But today, thanks to advancements in AI and modern tools, even someone like me—an OK sysadmin or mechanic or handyperson on my best days!—can take on ambitious projects with confidence…

Take my current project: I’m building a web app for a neighbor who runs a dog-sitting business. At first, the idea seemed simple—a functional application tailored to their businesses’ simple needs. But the more I thought about it, the more I realized this concept could apply to many other industry verticals and be the start of something to meet the broader market in the future!

The app would allow users to:

  • Schedule and store records for dog owners and their pets.
  • Provide real-time service booking via a front-end calendar.
  • Send pet owners SMS updates during their pets’ stay.
  • (Eventually) accept payments directly through the app.

I decided to start building it with a PHP backend, a Vue.js frontend, and a MySQL database, all running in a Dockerized environment. Ten years ago, this would have felt overwhelming. Today, however, tools like GitHub Copilot, VS Code Insiders, and WSL2 make it not just possible but achievable.

Here’s where the magic happens: AI-powered tools like GitHub Copilot provide what I jokingly call “programming superpowers.” They won’t make you a coding wizard overnight, but they can bridge the gap between where you are and where you want to be.

For instance, Copilot can explain code snippets, suggest syntax, or even help scaffold out an entire feature. It’s like having a mentor on demand, drastically reducing the time it takes to figure things out. Is it perfect? No. Sometimes it stumbles or provides suboptimal recommendations. But the progress AI has made in the past year alone is staggering, and it’s only getting better.

That’s the real game-changer: there are fewer excuses now for not diving into programming projects. With the combination of modern tools and AI assistance, the barriers to entry have never been lower.

Sure, you still need foundational knowledge—how to configure environments, wire systems together, and debug when things go sideways. But AI tools don’t replace expertise; they amplify it. They let you stretch your capabilities and take on challenges that might have felt totally out of reach 10 years ago.

  • VS Code ( I enjoy using Insiders )
  • Windows subsystem for linux ( Ubuntu is good, other distros available! )
  • GitHub Copilot ( Now free for any user account! )

These three tools combine on Windows to create a development environment in a snap that you can use to perform AI-driven development in. For pros, it offers a way to accelerate their development. For novices, it can educate you and help you along your learning journey.

Explore My Gaggiuino Project Photos: DIY Espresso Machine Mod

I’m excited to share my latest open-source project, Gaggiuino—a fun DIY mod for the Gaggia Classic espresso machine. I’m currently putting together the internal electronics, using Arduino to control temperature, pressure, and shot timing. The goal is to give coffee lovers more control over their brew while keeping the process hands-on. It’s all about blending old-school espresso making with modern tech, and I can’t wait to see where it goes!

Update August 2024: I’ve been running the machine successfully for about six months now and it is fantastic! It has become a very powerful entry-pro espresso machine worth much more $$$ than the original sticker price.

My completed machine with the 3d printed LCD display from Ali Express:


My complete setup with a custom built coffee bar cabinet:

https://gaggiuino.github.io/#/guides-stm32/lego-component-build-guide

Initial build of 3d printed enclosure. Was messy and difficult to get these wires so tightly packed into the case. Trick is to run some between the expansion board and the blackpill.

3d printed enclosure for the build. My friend Tony helped me with packing this thing tightly.

You do not have to disconnect as much as you think! Really just the brew switches. Leave the boiler wires attached!

After tidying the cables up a bit and realizing I only needed to move the boiler a small bit, not remove it, I proceeded:

Here it is booted!

Dealing with PATH, Bash Profiles, Git config in Windows

This post serves as a convenience for me and possibly others (probably not because nobody develops on windows) on how to manage working within Git Bash and Command Line in general within Windows 10. It can be a real pain in the neck to develop on Windows. (Updated for 11 in 2023!)

I primarily use Windows because my life is between software and business.

XKCD #763

Git Bash Notes

Windows PATH Tips/Instructions:

  • Control Panel > System > Advanced > Environment Variables
  • Edit Path to add a folder or System Variable
    • Add a folder: Point the resource you need by adding a folder path without the .exe
    • Add a System Variable: First point the directory and assign a variable name by adding to the System Variables. Next append the name of the variable to the Path ( ex. %JAVA%; ).
  • Windows Environment Variable added without restarting (ha): https://serverfault.com/questions/8855/how-do-you-add-a-windows-environment-variable-without-rebooting
    Or you know, just fucking reboot
  • Add things for convenience like c:/eclipse/ and then simply type eclipse to open the IDE

.bash_profile Examples:

https://www.tldp.org/LDP/abs/html/sample-bashrc.html

# If not running interactively, don't do anything
[ -z "$PS1" ] && return
# Suppress message about using zsh
export BASH_SILENCE_DEPRECATION_WARNING=1
# ————————————
# MOTD (Message of the Day)
# What you see when Terminal opens
# ————————————
echo "—————————-"
echo "Loaded ~/.bash_profile"
echo ""
echo "To edit run: configedit"
echo "To refresh run: configrefresh"
echo "All aliases: alias"
echo "—————————-"
# ————————————
# Configure prompt
# Includes special handling for git repos
# ————————————
# Regular Colors
Black='\[\033[0;30m\]'
Red='\[\033[0;31m\]'
Green='\[\033[0;32m\]'
Yellow='\[\033[0;33m\]'
Blue='\[\033[0;34m\]'
Purple='\[\033[0;35m\]'
Cyan='\[\033[0;36m\]'
White='\[\033[0;37m\]'
Light_Gray='\[\033[0;37m\]'
# Reset colors
NONE='\[\033[0;0m\]'
# When in a git repo, this method is used to determine the current branch
function parse_git_branch {
git branch 2>/dev/null | grep '^*' | sed 's_^..__' | sed 's_\(.*\)_(\1)_'
}
# When in a git repo, this method is used to determine if there are changes
# Changes will be indicated in the prompt by a *
function git_dirty {
if [[ -n $(git status -s –ignore-submodules=dirty 2> /dev/null) ]]; then
echo "*"
else
echo ""
fi
}
# Design the prompt
export PS1="$Purple\w$NONE \$(parse_git_branch)$Red \$(git_dirty) $NONE\$ "
# \w shows the current path
# List of other placeholders you can use:
# http://www.gnu.org/software/bash/manual/bash.html#Controlling-the-Prompt
# ————————————
# ALIASES
# ————————————
# Edit .bash_profile
alias configedit='code ~/.bash_profile'
# Force terminal to recognize changes to .bash_profile
alias configrefresh='source ~/.bash_profile'
# Ideal directory listing
alias ll="ls -laFG"
# Ask before removing files
alias rm='rm -i'
# Add your own aliases here…
view raw .bash_profile hosted with ❤ by GitHub

My .bash_profile:

# go to the root directory of my development environment on startup
cd 'C:\dev'

# set aliases for commonly used applications
alias np='start notepad++'
alias c='code .'
alias dock='docker-compose up'
alias dockb='docker-compose.exe run app --entrypoint run build:dev'
alias histg='history | grep'
alias g='git'

# save history and persist across multiple bash windows
export HISTCONTROL=ignoredups:erasedups
shopt -s histappend
export PROMPT_COMMAND="${PROMPT_COMMAND:+$PROMPT_COMMAND$'\n'}history -a; history -c; history -r"

SSH – I no longer use this (2023) as I now run the service via Windows:


# ssh things
env=~/.ssh/agent.env

agent_load_env () { test -f "$env" && . "$env" >| /dev/null ; }

agent_start () {
(umask 077; ssh-agent >| "$env")
. "$env" >| /dev/null ; }

agent_load_env

# optional SSH key handling
# agent_run_state: 0=agent running w/ key; 1=agent w/o key; 2= agent not running
# agent_run_state=$(ssh-add -l >| /dev/null 2>&1; echo $?)

if [ ! "$SSH_AUTH_SOCK" ] || [ $agent_run_state = 2 ]; then
agent_start
ssh-add
elif [ "$SSH_AUTH_SOCK" ] && [ $agent_run_state = 1 ]; then
ssh-add
fi

unset env

My .gitconfig

[color "diff"]
meta = yellow bold
[alias]
st = status
ch = checkout
co = commit
s = status
p = pull
d = diff

Plan, Develop, & Deploy Applications using Azure DevOps

I am not affiliated with Microsoft, with any of their offerings, or employees. This post is my perspective.

Developing an application is more than just code. It involves organizational process, division of labor, and the careful implementation of requirements. To manage this, some teams use multiple suites of tools, frameworks, rules, methodologies, the list goes on…

Azure DevOps gives you a suite of tools, they call “dev services”. Let’s go through them:

  1. Dashboards – View metrics about your developed applications
  2. Boards / Items / Backlog / Sprints – A place for you and your team to plan and assign work
  3. Repos – Store your application code repositories (Git driven)
  4. Pipelines – Automated build and deployments from your repositories to cloud platforms / infrastructure
  5. Test Plans – Paid test manager extension…
  6. Artifacts – Fully integrated package management (private libraries of software)

Assign work items to others on your team, track State (Started) and Reason (Work started), Assign priority, effort/actual hours, assign a Work Branch from a Repo, and Relate it to other issues. Using BitBucket daily for work, I found it to be a relatively painless switch to the overall UI.

I cannot seem to find a way to view all issues. You also cannot update issues in a large table grid view. You can batch update, which requires you to enter a separate view (BitBucket is no better!).

Users can take their issue branches and make pull requests, offering teams with the ability to peer review code before merging to the baseline (master branch). One can manage version of the software via Tags.

To deploy your applications, you can use a suite of ready made templates. There are a wealth of choices. Docker, Node, Yaml, .Net, Android, and so many more. You can even create your own pipeline by following these instructions.

Let’s hope their feature request system is improved and receives backing from Microsoft. Because, I think this could be an awesome extension to Azure.

Featured image: https://azure.microsoft.com/en-us/services/devops/

Linux Shell history Output, Ch. 01 of Ruby on Rails Tutorial


The following is output after running history command in a C9 Console (c9.io) where I am attempting my first Ruby on Rails application (Tutorial: railstutorial.org) using the Cloud 9 web IDE. Impressive amount of functionality after limited configuration. Going from zero to running application in ~50 commands is a rare feat today with how complicated the web stack world can be. Even have two environments running: prod and dev by using Heroku to deploy prod.

Project Console History Output (console 1)
Get Ruby Version
1 ruby -v
Setup Git/Bitbucket
2 git config --global user.name "your name"
3 git config --global user.email email@gmail.com
Quick aside: Server Daemon Console history output (console 2)
Install rails
1 gem install rails -v 5.1.2
Make rails app on c9
2 rails _5.1.2_ new hello_app
Goto app dir
4 cd hello_app/
Quickly read README
6 cat README.md
Quickly read Rakefile
8 cat Rakefile
9 ls
Troubleshoot bundle (dependency mgmt)
10 bundle install
11 bundle update listen
Update bundle of Gems after modifying Gemfile due to version differences
12 bundle update
13 bundle install
Spin up local rails server without params
14 rails server
Spin up rails server with params
15 rails server -b $IP -p $PORT
Create a new Git repo
7 git init
Add files to Git repo using gitignore
8 git add -A
Check status of working tree in Git
9 git status
Make a commit to repo with added files
10 git commit -m "Init repo"
Take a look at SSH for BitBucket setup
11 cat ~/.ssh/id_rsa.pub
Returning to Project Console (console 1) History Output
Add SSH key for use with BitBucket
16 git remote add origin ssh://git@bitbucket.org/username/project
Push to origin current repo, failed because of bad syntax
17 git push -u origin all
Check status of repo
18 git status
Check log of repo
19 git log
Create a master branch to troubleshoot failed push
20 git checkout -b master
Realized my username was wrong for use with BitBucket
21 git config --global user.name "username"
Pushed again, correct syntax this time
25 git push -u origin --all
Checkout to newly created modify branch for Readme work
26 git checkout -b modify-README
See branches for heck of it
27 git branch
Commit changes to repo
29 git commit -a -m "Update readme"
Go back to Master branch
30 git checkout master
Merge branches
31 git merge modify-README
Remove modify branch
32 git branch -d modify-README
Push changes
33 git push
Check status again
34 git status
Modify Gemfile to include :development and :production
35 bundle install
38 bundle install --without production
39 git commit -a -m "Update Gemfile for Heroku"
Check Heroku version for deployment to production
40 heroku version
Setup Heroku
41 heroku login
42 heroku keys:add
Create Heroku Virtual App Instance
44 heroku create
45 git push heroku master
46 git commit -a -m "Update Gemfile for Heroku"
Check on Heroku Virtual App Instance
49 heroku help
50 heroku status
51 heroku sessions
52 heroku webhooks
See progress of issued commands in the Console Window
53 history

This concludes Chapter 1 output. I will post subsequent chapters as I complete them. My goal is to revisit the process I go through to reinforce learning and identify where I made mistakes for future avoidance and for more understanding.

Java AOP

AspectJ Notes: Aspect Oriented Programming allows you to achieve an extra level of separation of concerns ontop of OOP methodology.

Key terms:
– Pointcut defines wherein the code a joinpoint (injection is what they should’ve called it) will occur.
– Advice defines what happens at the specific joinpoint.
– Weaving is the process of injecting the advice into the joinpoints.

Example code:

public aspect LicenseFee {

// playing with this to see if I can get this to work
// eclipse constantly checks to see if you actually are implementing the method before weaving occurs
// almost like it actively weaves before runtime, no wonder my computer is so slow running this thing
// so that means that when I go to run tests, some errors may occur but it should be okay/runnable despite the fact

pointcut test(): target(Main) &&
(call(void testSaveAccount()));

after(): test(){
System.out.println("TestSaveAccount called");
}

pointcut test2(): target(Main) &&
(call(void testOpenAccount()));

before(): test2(){
System.out.println("Derp");
}

}

Eclipse Semantics for Advice

DigitalOcean Ubuntu 14.04 User SSH Setup

ssh root@ip
adduser username
gpasswd -a username sudo
ssh-keygen
cat keyfilename.pub
Copy Public Key to Clipboard
su username
mkdir .ssh
sudo chmod 700 .ssh
nano /.ssh/authorized_keys/
Paste Public Key from Clipboard
chmod 600 /.ssh/authorized_keys/
exit
Return to Root User
nano /etc/ssh/sshd_config/
PermitRootLogin no
service ssh restart
exit
ssh username@ip

 

Virtualization of Development Environments Useful Links

Recently I reformatted my computer after being fed up with a “dirty” Windows install. What I found was that because I was trying out so many different development environments, I was having trouble maintaining a clean foundation for future work. It occurred to me that a possible solution for this would be to virtualize operating systems with Ubuntu/Linux, which of course would be license “free”. By using VirtualBox, I could run a couple VM’s with installed IDEs like IntelliJ or NetBeans, WAMP stack, or Visual Studio on a Windows License so that my localhost would be independent and freed up from walking all over each other. I remember last year working on something called Vagrant. Vagrant takes this idea a step much further by creating ready made boxes, hosted here, for use by anybody. So if you want to quickly jump into a development environment, you can!

Git, Java, and Netbeans Useful Links

In preparation for my new job, I’ve started to explore Java and Netbeans. In the process, I figured I would revisit using Git to cross reference some example code on Java.net while trying to learn about CRUD operations. Below is a list of links I found quite helpful.

platform.netbeans.org/tutorials/nbm-crud.html

java.net/projects/nb-api-samples/sources/api-samples/show/versions/8.0/tutorials/DBManager

youtube.com/watch?v=Kp5BSBoOw8k

java.net/projects/help/pages/SourceControl