Category: Portfolio

“The advent of AI has revolutionized countless industries, and software development is no exception. With the rapid advancement of AI-powered coding assistants, the role of junior programmers is undergoing a seismic shift. These sophisticated tools, capable of generating code, debugging errors, and even suggesting improvements, are poised to redefine the landscape of software development.

One of the most significant implications of this technological revolution is the potential for a decline in the demand for junior programmers. As AI continues to refine its capabilities, it can efficiently handle many of the tasks traditionally performed by entry-level developers. This could lead to a reduction in the number of junior positions available, forcing aspiring programmers to acquire more specialized skills or explore alternative career paths.

Yours Truly, Gemini AI”

——-

“The rise of AI-driven code assistants has significantly transformed the role of junior developers, with many predicting that these advancements may eventually replace the need for entry-level programmers. AI code assistants like GitHub Copilot and ChatGPT are now capable of generating reliable code snippets, automating repetitive tasks, debugging, and even suggesting best practices. A 2022 study by GitHub revealed that developers using AI assistants were able to code 55% faster than those without. This speed and efficiency rival what junior developers typically contribute, as their primary tasks—writing basic functions, performing code reviews, and fixing bugs—can now be handled by AI. The accuracy and contextual awareness of these tools make them comparable to the skill set of a junior programmer, leading some experts to question the necessity of hiring entry-level talent solely for coding purposes.

Moreover, AI assistants can continuously learn from vast amounts of data, improving their performance over time and staying up-to-date with the latest technologies and programming languages. For companies, this represents an opportunity to streamline development processes by relying on AI, which can operate 24/7 and doesn’t require onboarding or training. In contrast, junior developers need months to become fully productive, and even then, their code may still require oversight. AI’s ability to integrate with different tools and platforms enables developers at higher levels to focus on strategic and creative tasks, leaving the routine coding to AI. As a result, the demand for junior programmers is expected to decline as companies embrace AI to perform tasks traditionally assigned to them, signaling a major shift in the tech job market.

Yours truly,

ChatGPT AI”

——-

“The rise of AI and code assistance tools is significantly reshaping the landscape of software development, particularly impacting the roles of junior programmers. AI coding assistants, such as GitHub Copilot and OpenAI’s Codex, have demonstrated capabilities that match or even surpass the coding skills of junior developers. These tools can generate code snippets, debug errors, and even suggest entire functions based on natural language prompts. For instance, GitHub Copilot has been shown to complete up to 40% of code in certain programming languages. This level of proficiency means that many tasks traditionally assigned to junior developers can now be efficiently handled by AI, reducing the need for entry-level coding positions.

Moreover, companies are already restructuring their development teams to leverage these advancements. Organizations are focusing on hiring senior developers and AI specialists who can oversee and refine AI-generated code, rather than maintaining large teams of junior developers. This shift is driven by the efficiency and cost-effectiveness of AI tools, which can handle repetitive and straightforward coding tasks, allowing senior developers to focus on more complex and strategic aspects of software development. As a result, the demand for junior developers is decreasing, with AI taking over roles that require basic coding skills. This trend suggests a future where the traditional path of starting as a junior developer and gradually moving up the ranks may become less common, as AI continues to evolve and integrate into the software development process.

Yours truly,

Copilot AI, Microsoft

: GitHub Copilot’s impact on coding efficiency

: Restructuring development teams around AI

: The future of junior developers in an AI-driven world”

<<<<<<<

“Despite the impressive advancements in AI, these systems are not infallible and can be prone to significant errors, particularly in basic mathematical calculations. AI models, especially those based on large language models (LLMs), often struggle with fundamental arithmetic due to their training focus on linguistic patterns rather than mathematical accuracy. This can lead to AI making rudimentary mistakes, such as incorrect addition or subtraction, which might seem trivial but can have serious implications. For instance, an AI miscalculating financial data or engineering specifications could result in substantial financial losses or structural failures. These errors are often overlooked because users tend to trust AI outputs implicitly, not expecting such basic mistakes from advanced technology.

The potential for catastrophic failures increases when these small errors go unnoticed and propagate through systems. In critical applications like healthcare, finance, and infrastructure, even minor inaccuracies can escalate into major issues. For example, an AI providing incorrect medical dosages or misinterpreting patient data could lead to life-threatening situations. Similarly, in automated trading systems, a simple miscalculation could trigger massive financial disruptions. The reliance on AI without rigorous oversight and validation can thus pose significant risks, highlighting the need for continuous human supervision and robust error-checking mechanisms to mitigate these dangers.

Yours truly,

Copilot AI, Microsoft

: AI Gone Wrong: A List of AI Errors, Mistakes and Failures

: 32 times artificial intelligence got it catastrophically wrong

: Why AI Struggles with Basic Math (and How That’s Changing)”

<<<<<<<

“While AI-powered coding assistants offer significant benefits, they are not infallible. One of the most concerning limitations is their propensity for generating buggy or incorrect code. These errors can range from minor syntax mistakes to more serious logical flaws that can lead to catastrophic system failures.

A particularly troubling aspect of AI-generated code is the potential for it to introduce subtle mathematical errors. These mistakes, often overlooked by human reviewers due to their seemingly innocuous nature, can have devastating consequences in applications that rely on precise calculations. For example, a minor error in a financial algorithm could result in significant losses, or a faulty mathematical model in a critical system could lead to dangerous malfunctions.

Truly Gemini AI

“

<<<<<<<

“

While AI systems have made significant strides in assisting with coding and problem-solving, they are far from flawless and can make basic, sometimes catastrophic, mistakes. AI models often struggle with fundamental concepts, particularly in mathematics and logic, where errors in simple calculations or faulty assumptions can go unnoticed. For example, models like GPT-4 can incorrectly solve elementary math problems, overlook order of operations, or provide misleading outputs due to gaps in their training data. These subtle mistakes, when embedded in critical systems, can lead to larger issues if not properly scrutinized. In industries like finance or healthcare, even small mathematical errors can snowball into devastating outcomes, risking miscalculations of risk, incorrect diagnoses, or faulty software behavior.

What makes these errors particularly dangerous is the tendency for users to over-rely on AI, assuming its output is always correct. As AI systems become more integrated into everyday tasks, people might trust them too much, skipping crucial verification steps, especially when errors seem minor or unlikely. This overconfidence can lead to AI-driven systems making unnoticed, yet critical, miscalculations, with consequences ranging from system downtime to catastrophic failures in life-critical systems. AI, despite its advanced capabilities, lacks the intuitive reasoning of a human, making oversight and human validation necessary in any situation where small mistakes could have major ramifications.

Yours truly,

ChatGPT”

🙂

Multiple Javascript .replace(), Regular Expression – String Replace Instances – In One Call, On Multiple Lines

[code]

for(var i=0; i<Open_Client_Files_Tabs_Cookie_Arr_G.length; i++){

 

My_Add_New_Open_Client_Files_Tab_Prototype = Add_New_Open_File_Tab_Prototype_G.replace(/~FLUCTUATING_COUNT~/g, i).
replace(/~FLUCTUATING_LAST_NAME~/g, Open_Client_Files_Tabs_Cookie_Arr_G[i].split(“~”)[0]).
replace(/~FLUCTUATING_FIRST_NAME~/g, Open_Client_Files_Tabs_Cookie_Arr_G[i].split(“~”)[1]);

 

}

[/code]
[SHORTCODE_Insert_Google_Adsence_Here]

onmouseout  onmouseover event handlers Problem causes child elements event handlers to fire / trigger /actuate – Use mouseenter mouseleave on the parent element instead. It will prevent the child elements from firing as well.

 
[SHORTCODE_Insert_Google_Adsence_Here]
Recently – I found myself in the need of a DIV within a DIV – where they both needed mouse events to be triggered independently, as the user mouses over the parent and then child DIV. The mousing of the child div – caused the parent “onmouseout” to actuate unnecessarily.

The solution is to NOT use “onmouseout” or “onmouseover”.
As “onmouseout”  or “onmouseover” are subject to “Event bubbling” as it is known.  “event on element2 takes precedence. This is called event bubbling”. http://www.quirksmode.org/js/events_order.html

 

The Problem:

The mousing of the child div that uses onmouseover – causes the parent “onmouseout” to trigger.

 

The Solution:

Along with JQUERY – Use the “mouseenter” and “mouseleave” on the parent div instead – the child elements will not effect the “onmouseleave”

Use Example:
Continue reading “onmouseout onmouseover element parent event handlers problem – child events cause parent to trigger”

I was adding PHP image upload and delete functions to an application the other day – when I came upon a few problems. The iPhone 4S images that were taken in Portrait mode, and then uploaded, did not display with the appropriate portrait orientation (The orientation of the camera relative to the scene, when the image was captured.). They were saved on the iPhone, still in the Landscape mode – although they were taken as Portrait. For whatever reason, the iPhone 4S saves both Portrait and Landscape images with the same Landscape (Width greater than Height) display orientation.

The Problem:

I can’t use the standard methods to detect which image is actually portrait or landscape – as both Landscape and Portrait are saved as width=”3264″ height=”2448″.

The Portrait images uploaded were displaying as Landscape. So, I need to detect these, and then rotate them to the proper orientation. But, using a typical method of  if(width > height) == ‘landscape’ type of detection and assignment, would not work, because all of the images are saved with the Width greater than the Height on the iPhone 4S. How can I then detect if the image is Portrait and only saved as Landscape so that I can appropriately rotate that one to Portrate?

The Solution:

Read the EXIF Header Data within the image. Some cameras have an orientation / position sensor, using, possibly, a gyroscope. The position or horizontal or vertical orientation (Portrait or Landscape) of the image taken, is written to the EXIF header of the image data.

$source_image = '../images/path_to_Image_on_your_server.jpg';

$exif = exif_read_data($source_image);
print_r($exif);

if(isset($exif['Orientation'])&& $exif['Orientation'] == '6'){
	 echo "The image is rotated";// So do something with the image
}

 

[SHORTCODE_Insert_Google_Adsence_Here]
The “orientation” value is relative to the camera position at the time the image was taken. In this case – the Top Left corner of the camera was at position 6. This is how iPhone orients its camera when you hold it upright. If you turn your iPhone so that the screen is facing you and the home button is to the Right – your iPhone is in position 1.

Now that I had a way to detect if the image was Landscape or Portrait – I needed a way to rotate the image to its proper Portrait orientation – so that it would display properly in the webpage.

I decided to use the GD2 Library to rotate the portrait image to its proper orientation.

The Problem:

Out of Memory Errors using the GD2 Library image rotate function.

“Fatal error:Allowed memory size of 67108864 bytes exhausted (tried to allocate 9792 bytes) in /system/libraries/Image_lib.php on line 728”

 // PRODUCES MEMORY ERROR
$config['image_library'] = 'gd2';
$config['source_image'] = $source_image;
$config['rotation_angle'] = '270';// << GD2 rotates counterclockwise  -_-

 

The Solution – 1:

Continue reading “PHP Image Rotation Iphone Portrait EXIF Orientation GD2 and imagemagick Libraries”

 
[SHORTCODE_Insert_Google_Adsence_Here]
I am a big fan of iframes for some things. I know – as many others do – that you can sometimes effectively and efficiently achieve with iframes, what you can with AJAX.  In many cases, it is way less of a headache, particularly when you mention the fact that AJAX is not cross browser friendly : ( and you are left jumping through the usual hoops for the likes of the”all mighty” Microsoft and their “all friendly” Internet Explorer – just to mention ONE nauseating reason. In my opinion – when you are left the choice “to dance or not dance” for Bill Gates – I will chose to take a seat when I can. As we all know we have been providing plenty of entertainment for Bill over the last decade or so – with our slick dance moves.

Setting up an iframe as a catch all reciprocal transmitter/receiver for form data – has proven very successful for me. I had a usage for dynamically generated iframes to process multiple corresponding check type values. One waiting for values from the other before proceeding.

In this case – I am posting form values to multiple dynamically generated iframes, and want the content of each iframe to remain, as I post to another dynamically generated iframe.

As you can see by my example below – even just dynamically creating and adding a new iframe via” innerHTML +=”, causes the previously generated iframes to refresh inside the container that is being updated with innerHTML+=.

The unwanted refresh does not happen when I do not use javascript to create the iframes – if I just write the html ahead of time and post to the already existing iframes, there is not any refresh problem. The previously posted iframes will remain with the posted content.

I do not know how many iframes I will need – so that is why I am using javascript to dynamically generate the iframes.

I am aware that I could use AJAX for this same purpose, but I am not using AJAX for this.

——-

THE PROBLEM

In my example – the iframes are refreshing, regardless of there content, when I am dynamically adding another iframe to a DIV "iFrame_Container" via javascript and innerHTML.

Is there a way to achieve this without the iframes refreshing?

With my example – I am only showing that the iframes are refreshing. I am not posting to them. But the problem shows up the same.

Click the “Add Iframe” button, up to 3 times. note the previous iframe(s) refreshing as the new one is added.

——-

[code]
<script>
var Content_For_Iframe_Array = new Array("http://www.bing.com", "http://www.wordpress.com/", "http://www.webcrawler.com");

var Inc_iFrame_Num = 0;
function add_iframe_with_content(){
if(Inc_iFrame_Num < 3){

var iFrame_String ="<iframe frameborder='5' src='"+Content_For_Iframe_Array[Inc_iFrame_Num]+"' scrolling ='yes' id='iFrame_"+Inc_iFrame_Num+"' style='height:300px; width:800px; margin:5px; padding:0px;'></iframe>";
        document.getElementById('iFrame_Container').innerHTML += iFrame_String;
        Inc_iFrame_Num++;
    }
}
</script>

<div style="cursor:pointer; background-color:#CCC; border:thin #7777 solid; width:85px; margin-top:40px; margin-bottom:14px;" onclick="add_iframe_with_content();">Add Iframe</div>
<div id="iFrame_Container" style="height:300px; width:800px; border:#CCC thin solid;">Div to hold Iframes</div>
[/code]

——-

THE ANSWER

Continue reading “Dynamically generating iframes – Preventing refresh when using innerHTML+=”