DEV Community: Jon Randy 🎖️

The most interesting and fun projects to build are always the one ones with little to no practical use, and I thoroughly recommend building them 👍

Jon Randy 🎖️ — Fri, 01 Aug 2025 16:36:59 +0000

"We are destroying software" - https://antirez.com/news/145

Jon Randy 🎖️ — Thu, 13 Feb 2025 02:18:35 +0000

@ben The spam is still bad on the site. Any progress on solving this?

Jon Randy 🎖️ — Wed, 22 Jan 2025 11:15:40 +0000

Don't do this. Please. It's going to be even harder to discover decent content on here 😞

Jon Randy 🎖️ — Wed, 13 Nov 2024 00:56:55 +0000

LLMs are Bullshitters 🐮💩

Jon Randy 🎖️ — Sat, 15 Jun 2024 07:17:13 +0000

Just read a great paper on LLMs. I strongly suggest reading it, but here's the conclusion:

Investors, policymakers, and members of the general public make decisions on how to treat these machines and how to react to them based not on a deep technical understanding of how they work, but on the often metaphorical way in which their abilities and function are communicated. Calling their mistakes ‘hallucinations’ isn’t harmless: it lends itself to the confusion that the machines are in some way misperceiving but are nonetheless trying to convey something that they believe or have perceived. This, as we’ve argued, is the wrong metaphor. The machines are not trying to communicate something they believe or perceive. Their inaccuracy is not due to misperception or hallucination. As we have pointed out, they are not trying to convey information at all. They are bullshitting.

Calling chatbot inaccuracies ‘hallucinations’ feeds in to overblown hype about their abilities among technology cheerleaders, and could lead to unnecessary consternation among the general public. It also suggests solutions to the inaccuracy problem which might not work, and could lead to misguided efforts at AI alignment amongst specialists. It can also lead to the wrong attitude towards the machine when it gets things right: the inaccuracies show that it is bullshitting, even when it’s right. Calling these inaccuracies ‘bullshit’ rather than ‘hallucinations’ isn’t just more accurate (as we’ve argued); it’s good science and technology communication in an area that sorely needs it.

ChatGPT is bullshit | Ethics and Information Technology

Recently, there has been considerable interest in large language models: machine learning systems which produce human-like text and dialogue. Applications of these systems have been plagued by persistent inaccuracies in their output; these are often called “AI hallucinations”. We argue that these falsehoods, and the overall activity of large language models, is better understood as bullshit in the sense explored by Frankfurt (On Bullshit, Princeton, 2005): the models are in an important way indifferent to the truth of their outputs. We distinguish two ways in which the models can be said to be bullshitters, and argue that they clearly meet at least one of these definitions. We further argue that describing AI misrepresentations as bullshit is both a more useful and more accurate way of predicting and discussing the behaviour of these systems.

link.springer.com

One Byte Explainer: Recursion

Jon Randy 🎖️ — Thu, 13 Jun 2024 07:52:02 +0000

This is a submission for DEV Computer Science Challenge v24.06.12: One Byte Explainer.

Explainer

To understand recursion, see here.

How to Calculate the Nth Fibonacci Number

Jon Randy 🎖️ — Wed, 03 Apr 2024 08:50:27 +0000

Okay, lets dive straight into the code...

const fib = n =>
  Math.floor((((1 + 5**.5)/2)**n - ((1 - 5**.5)/2)**n)/5**.5)

Explanation here.

The Rise of Tech Bloggers Relying on Generative AI

Jon Randy 🎖️ — Wed, 14 Feb 2024 06:27:02 +0000

In the ever-evolving landscape of online content creation, the utilization of generative AI has become increasingly prevalent, especially among tech bloggers. These bloggers, driven by various motivations, are turning to AI to automate the process of generating articles without thoroughly reviewing or fact-checking the content. While some may view this trend as a shortcut or an attempt to keep up with the fast-paced nature of digital media, it raises questions about the integrity and authenticity of information shared within the tech community.

The allure of using generative AI for content creation is multifaceted. For some, it boils down to sheer laziness. The convenience of inputting a few prompts and receiving a fully-formed article within minutes can be irresistible, particularly when faced with deadlines or a lack of motivation. In a world where time is of the essence, the appeal of cutting corners can be tempting, albeit at the expense of quality and accuracy.

Furthermore, peer pressure plays a significant role in motivating tech bloggers to embrace AI-generated content. In an era where online presence and engagement metrics reign supreme, bloggers may feel compelled to churn out content at a rapid pace to maintain relevance and visibility within their respective communities. The fear of being left behind or overshadowed by competitors drives many to adopt AI as a means of keeping up with the relentless demand for fresh content.

Moreover, there's an underlying reluctance among some bloggers to admit their own limitations or gaps in knowledge. By relying on generative AI, they can mask their deficiencies and project an image of expertise without investing the time and effort required for in-depth research and analysis. This desire to maintain a facade of competence, coupled with the pressure to produce content consistently, leads many bloggers down the path of AI reliance, regardless of the ethical implications.

However, the consequences of this trend extend beyond individual motivations. The unchecked proliferation of AI-generated content poses a threat to the credibility and reliability of information disseminated within the tech community. Articles produced without human oversight are prone to errors, inaccuracies, and biases inherent in the training data used by the AI models. As a result, readers are exposed to misinformation that can perpetuate misconceptions, mislead decision-making, and erode trust in online sources.

In response to these concerns, it's essential for tech bloggers to exercise responsibility and diligence in their content creation processes. While AI can be a valuable tool for streamlining workflows and enhancing productivity, it should never serve as a substitute for human judgment and critical thinking. Bloggers must prioritize quality over quantity, taking the time to review and verify the accuracy of their content before publishing it for public consumption.

Furthermore, transparency is paramount in maintaining trust and credibility with audiences. Bloggers who leverage AI should disclose their use of automated tools and acknowledge the limitations inherent in AI-generated content. By being open and honest about their processes, bloggers can foster a culture of accountability and integrity within the tech blogging community.

Ultimately, the decision to rely on generative AI for content creation is a reflection of broader societal trends towards automation and digitalization. While the allure of efficiency and convenience may be enticing, it's imperative for tech bloggers to uphold ethical standards and prioritize the accuracy and integrity of the information they share. By doing so, they can ensure that their contributions to the tech discourse are meaningful, impactful, and worthy of audience trust and respect.

...and, yes - #abotwrotethis

😉

Misconceptions About Closures

Jon Randy 🎖️ — Wed, 27 Sep 2023 06:38:09 +0000

The two biggest (and unfortunately widespread) misconceptions about closures:

A closure is a special type of function that has access to its surrounding scope ❌

This is entirely wrong for two reasons:

Closures are not functions
ALL functions have access to their surrounding (lexical) scope*

To create a closure, you need to nest functions ❌

Again, entirely wrong - nesting of functions is irrelevant! Whenever a function is created, an associated closure is also created.

So, what is a closure?

From MDN:

A closure is the combination of a function bundled together (enclosed) with references to its surrounding state

The closure allows the function to access the state in which it was created.

As a simplified visual:

*Except for functions created with new Function(...) which form closures with the global scope

Meet Cerebrum: Your New Coding Assistant

Jon Randy 🎖️ — Fri, 26 May 2023 03:30:13 +0000

There's a new AI coding assistant on the block, and it outshines all others I've seen by a very wide margin... let's take a look:

Ranger: JS Range Syntax for Anything

Jon Randy 🎖️ — Sat, 08 Apr 2023 06:12:17 +0000

Following on from my little experiment with a basic number range syntax in JS, I decided (as with Metho and Turboprop) to generalise the idea and make it into a library that others might find useful (or at least interesting)...

Ranger is a small JS library that allows you to use a range-like syntax with any object. All you need to do is to define a function that builds the required 'range' given a starting and ending object (+ optional extra parameters if you so desire).

The 'range' syntax is as follows:

rangeStart[[...rangeEnd, optionalParam1, optionalParam2...]]

So, for example, if you created a range function for Numbers - you could then use it like this:

// create a range of numbers from 1-10
const numbers = 1[[...10]]

// log the numbers from 6-3
6[[...3]].forEach(x => console.log(x))

How to Use

Usage is extremely simple, just import the library and use it to set up the range function on your required object (usually this would be a prototype):

import * as ranger from '@jonrandy/js-ranger'

const myRangeFunction = (start, end) => {
  // logic to return 'range' here
}
ranger.attach(myObject, myRangeFunction)

If you pass in optional parameters according to the syntax detailed at the start of this README, they will simply be passed as additional arguments to your range function. Your 'range' making function can return anything - it doesn't have to be an array.

Number Ranges

Also exported by the library as an example of usage is a function called initNumberRangeSyntax that sets up a basic range syntax on the Number prototype - that does pretty much what you would expect. It can also take an additional stepSize parameter that defaults to 1 and decides the (absolute) size of the steps between items in the range:

import * as ranger from '@jonrandy/js-ranger'
ranger.initNumberRangeSyntax()
console.log(1[[...3]])  // [1, 2, 3]
console.log(5[[...2]])  // [5, 4, 3, 2]
console.log(0[[...3, 0.75]]) // [0, 0.75, 1.5, 2.25, 3]
console.log(2[[...0, 0.5]]) // [2, 1.5, 1, 0.5, 0]

And the source for initNumberRangeSyntax():

export function initNumberRangeSyntax() {
  attach(Number.prototype, (start, end, stepSize = 1) => {
    const absStep = stepSize<0 ? Math.abs(stepSize) : stepSize
    const step = start<=end ? absStep : -absStep
    let arr = [], i, d = end > start
    for (i=+start; d ? i<=end : i>=end; i+=step) arr.push(i)
    return arr
  })
}

UPDATE: It has been pointed out that returning an iterator would probably be more efficient and allow for dealing with infinite ranges. That is just as possible with Ranger - simply return a generator function:

// Number ranges as iterators
attach(Number.prototype, function* (start, end, stepSize = 1) {
  const absStep = stepSize<0 ? Math.abs(stepSize) : stepSize
  const step = start<=end ? absStep : -absStep
  let arr = [], i, d = end > start
  for (i=+start; d ? i<=end : i>=end; i+=step) yield i
})

Possible Usages

This was written as a general purpose tool that could have any number of potential uses. Some random ideas:

const myDateRange = date1[[...date2]]
const myRoute = location1[[...location2, {via: location3}]]
const myLine = point1[[...point2]]
const translator = language1[[...language2]] // could return a function that takes strings in one language and translates to another

jonrandy / js-ranger

Javascript library to add range syntax functionality to any object

Ranger

Ranger is a small JS library that allows you to use a range-like syntax with any object. All you need to do is to define a function that builds the required 'range' given a starting and ending object (+ optional extra parameters if you so desire).

The 'range' syntax is as follows:

rangeStart[[...rangeEnd, optionalParam1, optionalParam2...]]

So, for example, if you created a range function for Numbers - you could then use it as follows:

// create a range of numbers from 1-10
const numbers = 1[[...10]]
// log the numbers from 6-3
6[[...3]].forEach(x => console.log(x))

How to Use

Usage is extremely simple, just import the attach function and use it to set up the range function on your required object:

import { attach }

…

View on GitHub

Most Developers Can't Answer This Question About Anonymous Functions 🤯

Jon Randy 🎖️ — Mon, 27 Mar 2023 07:49:24 +0000

Given the following code:

function add(a, b) {
  return a + b
}
const add1 = function(a, b) {
  return a + b
}
const add2 = function add(a, b) {
  return a + b
}
const add3 = (a, b) => a + b
const addFunctions = []
addFunctions.push( (a, b) => a + b )
addFunctions.push(add3)
addFunctions[2] = (a, b) => a + b

Which of the following expressions evaluate to anonymous functions:

a) addFunctions[2]
b) (a, b) => a + b
c) add
d) addFunctions[0]
e) add1
f) add2
g) addFunctions[1]
h) add3
i) (function (a,b) { return a + b })

Give it your best shot in the comments! 🙂

Since this post is now quite old, I've added the solution:
CLICK FOR ANSWER
The correct answer is: a, b, d, i