Common Problem-Solving Patterns

Breaking Down Complex Problems

In Programming: Large applications are broken into modules, functions, and components that can be developed and tested independently.

In Art: Complex drawings start with basic shapes and proportions before adding details. Paintings are built up in layers, each serving a specific purpose.

In Photography: A successful image considers composition, lighting, exposure, and post-processing as separate but interconnected elements.

The pattern is consistent: start with the big picture, identify the main components, then refine iteratively.

Debugging and Problem-Solving

In Code: When a program doesn’t work, you isolate variables, test assumptions, and work systematically through possibilities.

In Drawing: When a portrait looks “off,” you check proportions, value relationships, and edge quality systematically.

In Photography: When an image isn’t working, you analyze exposure, composition, focus, and timing methodically.

Both disciplines require:

• Systematic analysis
• Testing hypotheses
• Patience with iterative improvement
• Comfort with failure as a learning tool

Technical Skills Enhancing Creative Work

Automation and Batch Processing

Programming concepts translate directly to creative workflows:

• Photoshop Actions: Essentially visual programming for repetitive image processing
• Lightroom Presets: Reusable “functions” for consistent photo processing
• File Organization: Database principles applied to managing thousands of images

Version Control Thinking

Git workflow concepts apply to creative projects:

• Branching: Saving multiple versions before major changes
• Commits: Documenting stages of development with notes
• Rollback: Returning to earlier versions when experiments fail
• Merging: Combining successful elements from different attempts

Documentation Habits

Technical writing skills improve creative process documentation:

• Clear project notes for future reference
• Step-by-step technique documentation
• Equipment and settings recording
• Process photography for complex projects

Creative Skills Enhancing Technical Work

Visual Design Principles

Art training improves technical communication:

• Typography: Understanding hierarchy and readability
• Layout: Applying composition principles to user interfaces
• Color Theory: Using color meaningfully in data visualization
• Visual Hierarchy: Directing attention in technical documentation

Iterative Refinement

Artistic process thinking improves code quality:

• Multiple drafts: Not settling for the first working solution
• Critique process: Regularly reviewing and improving work
• Aesthetic judgment: Recognizing when something “feels right”
• Patience with process: Understanding that good work takes time

Attention to Detail

Fine art training develops observational skills valuable in debugging:

• Seeing subtle differences: Noticing small variations that indicate problems
• Pattern recognition: Identifying recurring issues quickly
• Systematic observation: Looking at problems from multiple angles

The Creative-Technical Portfolio Website

This very website exemplifies the intersection of technical and creative skills:

Technical Requirements:

• Clean, semantic HTML structure
• Responsive CSS design system
• Performance optimization
• SEO and accessibility compliance
• Version control and deployment

Creative Considerations:

• Visual hierarchy and typography
• Color palette and brand consistency
• User experience and navigation flow
• Image presentation and gallery design
• Content organization and storytelling

The project required both technical problem-solving (Ruby dependencies, build processes) and creative decision-making (visual design, content structure).

Lessons for Integrated Practice

Embrace Both Sides

Rather than keeping technical and creative work separate, actively look for connections:

• Use technical tools to enhance creative work
• Apply creative thinking to technical challenges
• Document processes from both perspectives
• Share knowledge across domains

Process Over Tools

Both technical and creative work benefit from:

• Clear processes that can be repeated and refined
• Regular practice and skill development
• Learning from failure and iteration
• Building on fundamentals before advanced techniques

Community and Learning

Both communities value:

• Sharing knowledge and techniques
• Constructive critique and feedback
• Continuous learning and adaptation
• Recognition that mastery takes time

Future Directions

As technology and creativity continue to converge, new opportunities emerge:

• AI-assisted creative tools requiring both technical understanding and artistic judgment
• Interactive installations combining programming with visual art
• Data visualization as a fusion of analysis and aesthetic presentation
• Generative art using code as a creative medium

The boundary between technical and creative work continues to blur, making skills in both areas increasingly valuable and complementary.

What connections have you found between your technical and creative work? I’d love to hear about your experiences at the intersection of these disciplines.

This is a small compilation of images where it’s not a single bird alone, but the family together - either a couple going about their day, and at times even a full family, simply relaxing together or foraging for a meal.

The Equipment

Assorted - as all of them were not captured together. A combination of zooms and an 800mm prime. Images have seen slight adjustment mostly for exposure and a bit of a tone curve … I try to keep it simple and light handed in this department.

The Waiting Game

Not much of a single waiting game here … but the process of building a collection of images following a theme over a period of time. This page will see updates as the collection grows larger.

The Reward

Red-whiskered Bulbul (Pycnonotus jocosus)

Common Rosefinch (Carpodacus erythrinus)

Indian Peafowl (Pavo cristatus)

Red-vented Bulbul (Pycnonotus cafer)

Black Kite (Milvus migrans)

Plum-headed Parakeet (Psittacula cyanocephala)

House Crow (Corvus splendens)

Red-vented Bulbul (Pycnonotus cafer)

Common Myna (Acridotheres tristis)

Red-naped Ibis (Pseudibis papillosa)

Spotted Dove (Stigmatopelia chinensis)

Rose-ringed Parakeet (Psittacula krameri)

This is from an early morning walk, looking for birds and some birdy action.

At a local park, I spot this Common Hoopoe (Upupa epops) which seemed pretty hungry and was moving around rapidly, checking the grassy lawn for something to eat.

The Equipment

A Nikon Z-mount mirrorless body with an 800mm lens, on a shoulder strap - handheld.

The Waiting Game

As this fellow went about, I could anticipate that there were some interesting images to make.

I got down low, and started shooting a few bursts to try and capture some nice context-filled action images.

See a section of the series shot below …

A sample from the series

The Reward

Eventually, I did get a bunch of interesting images, as the hoope successfully pulled out a juicy worm and happily swallowed it up!

Here are the three I have chosen to depict the action - predator over prey … hunger satiated … nature! These have undergone just some basic adjustments, like exposure and a bit of a tone curve. Further processing should help obtain even better results … but I get lazy with this part of the work flow 😁

Where's my food?

Hmm, found some!

aaaand ... swallowed!

This is another capture from an early morning bird walk. Getting up early, getting out with the right gear and an open mind.

The Equipment

A Nikon Z-mount mirrorless body with an 800mm lens, on a shoulder strap - handheld.

The Waiting Game

After spying this little thing - Himalayan Bulbul (Pycnonotus leucogenys) - rummaging around between these bamboo sticks, I wondered what it was up to. Bulbuls aren’t exactly the types to be getting into such piles of wood, at least not in my experience. So I continued to watch it, ready with the camera up to my eyes, getting down to it’s level. Waiting to see what’s up…

The Reward

It was collecting nesting material! Here is the evidence … it delicately pulls out a fine strand of spider web, which it shall use to build it’s nest.

Himalayan Bulbul (Pycnonotus leucogenys) - pulling on a strand of spider web for nesting.

And who knew COVID was just round the corner, about to throw the world into chaos 😐…

The Setup

A good setup is important for nice results - you need to be comfortable, you need to feel inspired.

The Setup

For this study, I worked with an image captured by me in May 2018.

It started with a light pencil sketch to get everything in place,

Initial sketch

And then, the first solid lines with a pen … time to commit to the ‘bigger picture’ …

First commit

Once you have the main layout, getting into the details … some parts are precise, some are loose … trying to balance the two to keep true to the rendering in mind,

Details follow

Until it’s done, and you have something that you are satisfied with,

The finish line!

Hope you like it!

PROC COMPARE by default gives you a very detailed result which can be tedious to go thorugh, especially if you are comparing large datasets with lots of rows and columns.

It builds on PROC COMPARE to reduce columns, rows etc and summarizes changes per key item, making the output easier to analyse and work with.

In fact, I have used the reduced output to programmatically prepare proper reports for before/after changes, that can be automatically delivered at the end of specific ETL builds to stakeholders.

The code

(Scroll right for longer lines of code)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
/* builds on PROC COMPARE to reduce columns, rows etc and summarise changes per key item */
%macro SmartCompare(libref1=,dsn1=,libref2=,dsn2=,keyname=,excl_cols=);
       /*%SmartCompare(
              libref1=work, 
              dsn1=temp_test_1_old, 
              libref2=work, 
              dsn2=temp_test_1_lat, 
              keyname = COMP_TIMESTAMP, 
              excl_cols=('_OBS_' '_TYPE_' 'COMP_TIMESTAMP' 'OLD_LATEST_NEW_TERMIN')
       );
       */
       /* Rohan Kumar Thakur, https://github.com/rohankthakur */
       *;%macro a;%mend a;
       %let rc1=%sysfunc(open(&libref1..&dsn1,i));
       %let nobs1=%sysfunc(attrn(&rc1,NOBS));
       %let close1=%sysfunc(CLOSE(&rc1));
       %let is_there1=%sysfunc(Exist(&libref1..&dsn1));
 
       %let rc2=%sysfunc(open(&libref2..&dsn2,i));
       %let nobs2=%sysfunc(attrn(&rc2,NOBS));
       %let close2=%sysfunc(CLOSE(&rc2));
       %let is_there2=%sysfunc(Exist(&libref2..&dsn2));
 
       %if (&nobs1 ne 0 and %sysfunc(Exist(&libref1..&dsn1))) and  (&nobs2 ne 0 and %sysfunc(Exist(&libref2..&dsn2))) %then %do;
       %let syscc = 0;
       /* print when exists with non-zero row count */
              proc sort data=&libref1..&dsn1; by &keyname; run;
              proc sort data=&libref2..&dsn2; by &keyname; run;
              proc compare base=&libref1..&dsn1 compare=&libref2..&dsn2 OUT=work.diff_b OUTNOEQUAL /*OUTBASE OUTCOMP*/ OUTDIF NOPRINT; id &keyname; run;
              /* select CHAR columns */
                     proc sql;
                     create table work.contents as
                     select monotonic() as start, NAME from dictionary.columns where libname=%upcase("work") and memname=%upcase("DIFF_B") and (format like '$%' or type = 'char');
                     quit;
              /* make macro var with a list of columns */
                     proc sql noprint;
                     select name into :varlist separated by ' ' from work.contents where name not in &excl_cols order by start;
                     quit;
              /* make macro var with a list of corresponding counter columns */
                     proc sql noprint;
                     select trim(name) || '_2' into :varlist2 separated by ' ' from work.contents where name not in &excl_cols order by start;
                     quit;
              /* create a format for column names */
                     proc sql;
                     create table work.contents_format as
                     select monotonic() as start, 'get_col_name' as fmtname, NAME as label, 'n' as type from work.contents where name not in &excl_cols order by start;
                     quit;
                     proc format library=work.formats cntlin=work.contents_format; run;
                     proc format library=work.formats fmtlib; select get_col_name; run;
                     /* Get number of changes per keyname and all changed columns per keyname */
                           data work.count_changes_pre ;
                             set work.diff_b;
                             length changes $ 8000;
                             array vi{*} &varlist ;
                             changes = '';
                             num_changes = 0;
                                    do i = 1 to dim(vi) ;
                                      if index(vi{i}, 'X') ge 1 then 
                                                do;
                                                       if changes = '' then do; changes = put(i,$get_col_name.); num_changes = num_changes + 1; end;
                                                       else do; changes = catx(', ',changes,put(i,$get_col_name.)); num_changes = num_changes + 1; end;
                                                end;
                                    end ;
                             output work.count_changes_pre;
                             drop i;
                           run;
                           /**/
                           %let counts = %eval(%sysfunc(count(%cmpres(&keyname),%str( )))+1);
                           %global new_keyname;
                           data _null_;
                                  length full_piece $ 200;
                                  full_piece = '';     
                                  do i = 1 to &counts;
                                         full_piece = catx(', ',full_piece, scan("&keyname",i,' ')); 
                                  end;
                                  drop i;
                                  call symput('new_keyname',full_piece);
                           run;
                           /**/
                           proc sql;
                           create table work.sc_count_changes as
                           select &new_keyname, trim(put(num_changes,4.) || ' changes, ' || changes) as Description
                           from work.count_changes_pre;
                           quit;
                     /* Check columns that have changes and keep only those columns in result view */
                           data work.limited_output_pre_a;
                             set work.diff_b end=eof ;
                             array vi{*} &varlist ; /* incoming values */
                             array vc{*} &varlist2 ; /* counters */
                             retain vc . ;
                                    do i = 1 to dim(vi) ;
                                      if index(vi{i}, 'X') ge 1 then vc{i} + 1 ;
                                    end ;
                             if eof then output ;
                             keep &varlist2 ;
                           run;
                            proc transpose data=work.limited_output_pre_a out=work.limited_output_pre_b (Rename= (_NAME_ = NAME COL1=COUNT)); run;
                           proc sql noprint;
                           select substr(name,1,length(name)-2)into :shortlist separated by ' '
                           from work.limited_output_pre_b where count > 0;
                           quit;
                           data work.sc_limited_output (keep= &keyname &shortlist);
                           informat &keyname &shortlist;
                           set work.diff_b ;
                           run;
                           /* check for errors and delete temp datasets etc */
                           %if &syscc < 10 %then %do;
                                  proc datasets library=work memtype=data;
                                         delete diff_b;
                                         delete contents;
                                         delete contents_format;
                                         delete count_changes_pre;
                                         delete limited_output_pre_a;
                                         delete limited_output_pre_b;
                                  run;
                                  proc catalog catalog=work.formats;
                                  delete get_col_name.format;
                                  quit;
                           %end;
                           %else %if  &syscc > 10 %then %do;
                                  %put Warning! Temp files not deleted as there were errors detected.;
                           %end;
       %end;
       %else %if %sysfunc(Exist(&libref1..&dsn1)) = 0 %then %do;
              /* print when dataset does not exist */
       %end;
       %else %if &nobs1 = 0 and %sysfunc(Exist(&libref1..&dsn1)) %then %do;
              /* print when dataset exists with zero row count */
       %end;
%mend SmartCompare;

Project repository and documentation available on GitHub.