“Simplicity is the soul of efficiency.”

— Austin Freeman

Just a few months ago, I dropped out of college in an effort to take a bet on myself. Though I wasn’t totally sure what my next move would be, I felt compelled to lean into my interests in the Web 3 space. About a week after disclosing my withdrawal from the remainder of the Spring 2022 semester, I was given the opportunity to attend a crypto conference within my own city — an experience that has forever shaped my path for the better.

I attended ETH Denver as a “BUIDLER”, and though I was not well versed in many programming languages at the time, I was able to encounter many remarkable individuals with communities and projects in the making that I know are changing the future as we know it.

Many developers from all backgrounds came together to collaborate with others to create applications and projects that could be selected and further funded by VCs and companies within the Web 3 space. Being able to watch the formation and development of these ideas sparked a flame within me that I haven’t been able to tame since, and I am forever grateful that somehow I took the leap towards exploring that which truly strikes a chord within me, the path of pursuing a new practice that pushes me to continue to be a lifelong learner, observing my own growth through progress, and observation.

Many conference attendees were eager to share their knowledge, and upon relaying my ambitions to be a blockchain developer, I was told about the Flatiron School, a programming school with live classes in my city.

I am now writing this as a student who has just completed the first out of five phases within the Software Engineering Bootcamp at Flatiron School in Denver, and following the last three weeks of exploring HTML, CSS and JavaScript, I have come upon some observations I’d like to at least try to express in words.

Patterns Extending to the Etheric 🧬

Though I would consider myself a spiritual person, I feel as if the meaning of that word has been convoluted by trends in recent years that perpetuate ideals of spirituality that detract from what it at least seems to me — a lifelong journey of introspection, rather than a lifestyle filled with superficial practices and ritual that may negate from the observation, learning, and growth that an organic and free-flowing spiritual path facilitates.

Etheric: of or relating to the heavens or a spiritual world or plane of existence

Within the context of programming, it’s become quite obvious to me that there are a seemingly infinite number of ways to write code, even if the intended goal is to perform the same function.

Regardless of how a developer may structure their code, there remains a consistent set of underlying structures that must remain the same for any code to work properly.

I personally believe that by observing themes and patterns on a micro level, we can better understand what might happen on a larger, more macro level. Individually, collaboratively, and systematically, many of the same underlying structures and elements remain constant, just as code does.

Ultimately, following my first week of collaboratively working on my first project for school, I have been inspired to contemplate what some of my realizations might suggest about life on a larger scale.

I’ve been reminded of some thoughts and ideas I’ve come across in other life contexts too — which only reinforces my belief that much of life stems from a very similar base, one which we shape and form to fit our individual styles and expressions as intellectuals and creatives.

In a very similar way, JavaScript, HTML, and CSS in conjunction with one another and separately, have enabled me to come to both new and familiar realizations, which I will elaborate on in the remainder of this post.

Communication is 🔑

In order to create effective communication, clear definitions of how you will express ideas and thoughts are essential.

Among the three primary programming languages I’ve been learning, there are different syntax rules that can sometimes make or break your code, meaning that **you can’t just copy and paste content **from one language to another and expect it to work.

Within the realms of programming, friendships, and partnerships, clear communication, and expression of needs, tendencies, and wishes, must be present in order to establish and create something solid, sound, and functional.

While this may sound a bit cliche, I found it worthy of touching on regardless.

Meet Me at the Function 🥳

Throughout the last few weeks, my many attempts to write and adjust JavaScript codes through trial and error have enabled me to understand the fundamentals of how functions work much more in-depth than ever before.

A JavaScript function is a block of code designed to perform a particular task.

There are A LOT of different ways to write functions in JavaScript, and two expressions that I have found particularly interesting are the arrow and anonymous functions.

In the code snippets below, I have tried to render the **same result **using these different function methods.

You can test these in Replit to verify that this is the result for the codes written below.

smile, you are awesome!

These are just a few examples of the ways you can write the same function, and I’d like to think that this further enforces the idea that a similar backbone exists behind many of the things that stem from an initial effect.

Traditional Functions

function encouragement(smile) {
    console.log(smile, "you are awesome!")
};
encouragement("smile")
//result
//smile, you are awesome!

Within this statement, we are introducing the function with the typed-out word “function” before the name of what we will call the function.

2. Anonymous Functions

const encouragement = function (smile) {
    console.log(smile, "you are awesome!");
};
encouragement("smile")
//result
//smile, you are awesome!

Anonymous functions allow us to call a function by simply assigning a variable, and follow the same structure as a traditional function.

3. Arrow Functions

const encouragement = (smile) => console.log(smile, "you are awesome!");
encouragement("smile")
//result
//smile, you are awesome!

Arrow functions allow us to condense the length of our function, enabling us to define it in a single line, while still computing the same result.

The variety of function expressions I have briefly discussed here are just a few of the many ways you can structure a function in JavaScript. Though the particularities of their styles vary, they still require the same core elements.

In many ways, I believe that our separate journeys as individuals within the human collective reflects this…leading us to also utilize some of the same elements or structures in the context of our lives.

Though many of us at this point have cultivated a number of different lifestyles and interests that allow us to experience vastly different life paths from one another,** we still seemingly come across the same themes, lessons, and ideals.**

Less is More 🤏

Within many other contexts within my life, I have come to realize that less really is more, and **being able to make a point that can be clearly understood, yet is still precisely to the point **is truly a skill I hope to better harness and utilize as I continue to evolve as a person, and a developer.

“Success is rarely determined by the quality of your ideas. But it is frequently determined by the quality of your execution.”

― Jeff Atwood Effective Programming: More Than Writing Code

Arrow functions provide a beautiful point of introspection for me, as they emphasize the point of how important it is to keep things meaningful and succinct.

**Further examples of how arrow functions can work are included below, **and I have included them to not only display their structure and functionality, but also hope that they can elude to the idea of embodying the vast array of ways that a function can be written.

While negating much of the extra “fluff” a function might normally contain, arrow functions may not have all the capabilities of other structures.

That being said…to any developers who may be reading this, I would advise you to avoid using the arrow function for event handlers, object methods, prototype methods, and functions that use the arguments object.

const a = 'smile'
const b = 'a shining star'
const add = (a,b) => (`${a}, you are ${b}!`)
console.log(add(a,b))

This function would return the following text in the console:

//smile, you are a shining star!

One final example of an arrow function:

phrase = “smile, you are amazing!”
phrase => expression
console.log(param) // this would return:
Resulting in the following phrase:

//smile, you are amazing!

The arrow function allows for the bulkiness of extra syntax elements to be replaced by simpler, shorter arrangements. I find this fascinating, and have found myself striving to reanalyze my coding techniques in efforts to cut down on some of the extra lines I’ve written, allowing me to more clearly establish what is going on within the function itself.

Within my life outside of coding, I have begun to also see how much more easy to understand clear and concise communication can be.

As my journey both with development and through life continues to unfold, I look forward to challenging myself to be more succinct with what the information I am trying to relay, in any medium I might be using.

Conclusion 🧠

Though I am still quite new to coding, the concepts I‘ve been able to learn have inspired me in many contexts outside its realm. Clear communication is key, and learning to express that in the most understandable and to the point way, is an effort I think would all help us to better understand one another better.

“Perfection is achieved not when there is nothing more to add, but rather when there is nothing more to take away.”

— Antoine de Saint-Exupery

There is no better time than now to exercise this, as we are in the midst of what seems like a modern renaissance, enabling us to create and share with the world ideas and visions that would only be possible given the technological and ideological advancements of the modern age.

Within the context of code and everyday life, infinite possibilities exist in terms of the various styles we might use as forms of expression.

At the core, the same fundamental elements exist and furthermore serve as cornerstones of the structure that is integral to the success of creating our desired result.

“Programming, in essence, must become the act of reducing complexity to simplicity.”

— Max Kanat-Alexander Code Simplicity: The Fundamentals of Software

I look forward to writing more content on this platform regarding more of my introspective thoughts as they surface within my journey of learning to code. I hope that in some way, this has sparked a flame within you to consider a new perspective, and I appreciate you taking the time to take a step within my mind. If you have any questions, or would like to be in touch, feel free to message me, or comment below.

ʕっ• ᴥ • ʔっ Thanks for reading!

Love,

NESSA KODO