The Rewards and Risks of Reddit Marketing

Promoting your product on Reddit comes with significant potential rewards, but it can also be quite tricky. Many users attempt to share their products only to get banned right away. The main reason? Reddit’s algorithms are highly sensitive to spam, especially from accounts that lack “link karma.”

Link karma is essentially a score that reflects your positive contributions to the community. If you’re new to Reddit or haven’t built up enough link karma, sharing your brand link in a post or comment is almost guaranteed to lead to a ban. The platform’s algorithm assesses your link karma, which is accumulated through meaningful, non-spammy interactions across various subreddits. Without a trustworthy history, your content is likely to be flagged and removed.

How to Promote Your Product Successfully

So, how can you navigate these challenges? Here are some strategies to consider:

1. Identify Relevant Subreddits: Start by finding 2–3 subreddits where your target audience is active. Engaging with these communities is essential before mentioning your product. Focus on providing genuine value in discussions.
2. Build a Reputation: It might feel tedious, but building a reputation takes time and effort. Engage with others by answering questions, offering insights, and sharing knowledge. This groundwork is crucial for establishing credibility.
3. Mention Your Product Subtly: Once you’ve established a positive presence, you can start to mention your product in conversations. However, avoid dropping links initially. If your insights are valuable, users will naturally seek out your product.
4. Use Tools to Assist You: While it may seem self-serving, tools like Redreach can help you identify niche subreddits and relevant posts. These insights can guide you to areas where your audience is already engaging with topics related to your product.
5. Avoid Direct Links Initially: Even with a solid amount of karma, it’s wise to stay away from posting direct links to your product. This approach feels less spammy and fosters a more genuine interaction.

Reddit can be a powerful platform for promoting your product, but it requires a strategic approach. Focus on building your reputation within the community, offering value, and gradually introducing your product. By following these tips, you can successfully navigate Reddit’s landscape without falling victim to bans.

If you’re looking for further guidance on thoughtful engagement and community-building strategies, check out KarmaReach.

They specialize in helping brands connect meaningfully with their audiences, ensuring your message resonates and reaches the right people.

“I believe in the horse. The automobile is a temporary appearance” — Wilhelm II, Emperor of Germany, 1916

In the early 20th century, skepticism of this new invention grew, and it had to happen. Why wouldn’t it? Countless livelihoods hung in the balance. Many people, particularly those with vested interests in traditional modes of transportation like horse breeders and carriage makers, were doubtful about the long-term viability and practicality of automobiles. But, more than that they feared the erosion of skills honed over generations.

If this new invention proves successful, it could threaten the livelihoods of many. From those who care for, groom, and exercise horses, to specialists like farriers who tend to hooves and shoeing, and roles such as stable masters, postilions, and harness makers.

Fast forward to 100 years, We are living in probably the best time to be alive. I have covered in my another blog about how this is the best time to be alive. We are healthier, wealthier, and more educated than at any time in history.

How is it that with all the automation and expansion of innovation, we were supposed to be replaced by machines, and yet here we are still waiting for that day?

In 1960, Norbert Wiener A Computer Scientist and mathematician wrote “Why Machines Should Not Replace Men,” published in the magazine “The Atlantic Monthly”. It was a take against the widespread replacement of human workers by machines. He raised concerns about unemployment, income inequality, and the loss of human skills and creativity in a mechanized world. Yet, six decades later, there are still many times more people employed today than there were anytime before.

Andrew Yang, a candidate in the 2020 Democratic Party presidential primaries, ran his campaign with the idea of plans to give every American adult $1,000 a month in universal basic income (UBI) as a way to offset job loss from automation. His proposal gained tremendous attention and approval from young people. This was even before ChatGPT came out. The skepticism of tech taking over jobs was still prevalent, akin to a simmering pot.

But there’s something Andrew Yang needs to understand before he proposes to print money and create hyperinflation like we’ve never seen before.

The wrecking of jobs by new technology is not a new concept. About 80% of the job roles from the 18th century have either disappeared entirely or been greatly diminished, with one person now capable of performing tasks that once required the effort of hundreds.

When the desktop computer came onto the scene, Data Entry Clerks, Record Keepers, and Typists were caught off guard. Tasks like recording and searching for data, which previously took humans hours with paper-based methods, could now be completed by computers in seconds. As of now, in reality, there are more IT-related professions than those that were displaced by the PC.

During the earlier days of telephony, companies relied on manual telephone switchboards, where operators connected calls by inserting a pair of phone plugs into the corresponding jacks. Today, we have cellphones that automatically connect your calls without any intermediaries.

Throughout history, whenever new technology pops up, it leads to the creation of new industries for employment.

If you are spending time on internet then the doomers (someone extremely pessimistic) can’t get enough of how AI is going to put all of us out of job, and we will be completely run over by machines. Something, that’s been talked out for over decades now.

So, what’s it going to be? Is the LLM breakthrough going to turn fearmongering into reality?

“The last decade was about distributing data at scale. This decade is about generating data at scale,” I tweeted as I scrolled through another doom post on Reddit about AI.

So, what are the implications of AI functioning in our lives? As mentioned earlier, with the assistance of technology, we are currently living in the best times. Just consider it, traveling has become significantly easier and more affordable with the advent of Instagram, Google Maps, search aggregators like SkyScanner and Kayak, and other travel blogs.

If you were to travel somewhere in the the 1970s, airlines had not yet reached a point where they were operating at economies of scale, meaning they hadn’t expanded to the extent where the unit cost per passenger was reduced due to increased flight frequency or capacity.

As the time goes by, carriers expanded their fleets and increased the volume of passengers they transport, they were able to spread fixed costs, such as aircraft maintenance and administrative expenses, across a larger output. This results in lower average costs per unit, allowing airlines to offer competitive ticket prices while maintaining profitability.

There were a variety of factors that played a role in making flights cheaper, specifically faster software. Software, which is the ever-powerful tool for businesses, enabled tasks like searching through billions of records, inserting, deleting, computing, and generating thousands of itineraries in seconds.

As software became scalable, thanks to cloud computing, edge computing, and other technologies, other industries were able to effectively utilize it. Airlines took it upon themselves to sell seats to prevent you from leaving your cozy couch; earlier, you were more likely to go to an agency that used IATA software to book your flights (Some people still book through agencies).

Instagram, Google Maps, and plethora of online content on travel gives even the most irrationally anxious person the confidence to take the plunge and travel, thus expanding the travel industry market.

Over the years, our technology has been working on reducing poverty, making us healthy and keeping us well informed. With that, the number of millionaires has skyrocketed. Thank you, Internet!

The next phase is about generating data. AI is nothing but generating data based on the parameters you pass on. AI algorithms are designed to analyze vast datasets, extract patterns, and produce new information, which in turn contributes to the ever-expanding reservoir of digital data.

This means that different areas use AI to create new data. For example, there are programs that make up fake data to train other programs, systems that write text when given a topic, and algorithms that draw pictures based on certain features.

Go over to ChatGPT, and write a prompt to “write about Ottoman Empire seige of Constantinople as a rap song.” You will find ChatGPT spitting out verses with as close to historically correct data as possible. You might as well bob your head while you’re rapping to it.

“He who is adaptable is the one who survives” — Charles Darwin

I recently come across Devin — an AI software that writes and debugs code for you. Over the years, we would come across posts about upskilling and learning to code from big media, especially when we complain about not being able to find well-paying jobs.

This time around, it looks like even jobs like Software Engineers are at risk with promises like Devin, who wants to convince companies that we may not need that many Software Engineers to create that big new app.

Still, ChatGPT and other similar AI systems lack the inherent ability to definitively discern whether their output is a genuine product, complete garbage, or something in between.

That is not surprising, cause it doesn’t have the awareness to do so.

At least, for another 5–10 years. I think people who do technical stuff are safe cause ChatGPT is not yet at a level where it can autonomously generate fully functional software solutions that meet all requirements and quality standards. Human creativity, critical thinking, and domain knowledge are still indispensable in the field of technical work.

“I destroy jobs and create better ones” — Vitalik Buterin

Should you be concerned about losing your job to AI?

Historically, technology has always created more jobs than it has eliminated

I don’t want to claim that this is some ironclad rule of nature, but it is at least a clear historical trend. I don’t see any particular reason why modern AI and robotics should turn out to be the the first exception.

I don’t have a crystal ball to predict how AI will affect industries, but one thing is certain based on historical data: it will create new opportunities and industries. With AI, we will be generating a lot of data, from text to audio to videos. Those who are able to capitalize on generating data, and use it to their advantage will be the ones who thrive.

Changing times require changing minds.

Don’t worry about automation. Humans will always find something to do.

P.S I used ChatGPT to proofread this entire article to ensure it didn’t have any grammatical mistakes.

public static void main(String[] args) {// Your code goes here}

Imagine the Java Runtime Environment (JRE) as the stage manager, and your program is the star of the show. For the curtain to rise and the performance to begin, the JRE needs to call the main method of your program. It's like the stage manager shouting, "Places, everyone! Let's get this show on the road!"

To illustrate this, let’s consider a class called MainMethodExplanation. The JRE will essentially call the main method like this:

MainMethodExplanation.main(arguments);

Now, let’s break down the components of this method signature to understand their roles in the grand performance.

The Keyword Players

public

The public keyword is like your method waving its arms, trying to get the JRE's attention. If the method were private or protected, the JRE wouldn't have the necessary access to call it. It's like your method being stuck backstage, unable to take the spotlight.

static

“No need for an instance, JRE. Just call me directly!”

A static method can be called without creating an instance of the class. The JRE doesn't have to go through the trouble of creating an object of MainMethodExplanation and then calling the main method on that instance. It can just cut to the chase and run the main method directly on the class.

MainMethonExplanation callMe = new MainMethodExplanation(); 
// JRE doesn't need to create an object of MainMethoExplanation class

void

The void keyword indicates that the main method doesn’t need to return any value. It’s like your program taking a grand bow at the end of the performance — no need for an encore or an autograph session.

main

The JRE is hardwired to look for a method named main. You can't call it anything else, or the JRE will be scratching its head, wondering where the star of the show is.

This part is like giving your program a little extra flair or direction. The args parameter is an array of strings that can be passed as arguments when you run your program. It's like giving your program a script or a set of instructions to follow.

Let’s say you want your program to print a message that you provide as an argument. You can access that message using args[0]. Here's an example:

public static void main(String[] args) {System.out.println(args[0]);}

To run this program with the argument “Hello, World!”, you can use the command line or an IDE’s run configuration to pass in the arguments.

“Whoa, hold up! What if I don’t pass in any arguments?”

Good catch! If you don’t provide any arguments and try to access args[0], you'll get an ArrayIndexOutOfBoundsException. It's like your program trying to read a script that doesn't exist, resulting in a messy on-stage blunder.

The mystery of public static void main(String[] args) has been unveiled, and you're now equipped to take on Java programming with confidence. Whether you're writing a simple console application or a mind-bending, multi-threaded masterpiece, you'll always know where the show starts and how to give your program a standing ovation.

Now, if you are still not clear, feel free to leave a comment on this post. I’ll be more than happy to respond and provide further clarification to ensure that you have a solid understanding of all the stuff discussed.

String name = "Ali";
name = "Zayn";

Yes, you can do that, but that’s not what string immutability means. In this article, we’ll talk about what strings being immutable actually does mean, all the reasons why they were made to be immutable, and what it means to your programs.

All right, so we know that string objects are immutable and they can’t be changed. But you know that you can declare some string and set it to some initial value. And if you want, you know, you can set it to some other value, right? So what’s the deal there? To answer that question, it’s important to know what actually happens when you create a string object.

So in our example, we create this name variable and assign it to value Ali. What Java does is create that string variable called name. But that name variable isn’t the string object itself. What it is, is a reference to a string object in memory that it creates with the value of Ali.

When you take this name variable and assign it a new value in our case “Zayn”, java doesn’t actually modify this string object in memory.

What it does is create a brand new string object in memory with the value “Zayn” and change the name variable to point to that string object instead.
And, it no longer points to that “Ali” string.

So when we say that string objects are immutable, we’re talking about the string object in memory. The string variables themselves can be changed to point to whatever string we want. It’s the string objects themselves that are not changeable, they are immutable.

Why does it matter? Why do we not want to be able to change these string objects? There’s actually a few great reasons. The first reason is that it enables Java to save a ton of memory space.

The Coding Cards

Let’s say we had this string name equals Ali. Then we also had string, anotherName, and it also equals Ali. These are of course, the exact same string literals, right?

String name = "Ali";
anotherName = "Ali";

When you create multiple string variables and set them all to the same literal string values, java does something pretty smart. Here is what happens under the hood.

Java creates another variable and you might think that Java is going to go ahead and create a whole new object with the value of Ali, and it’s just going to point to that, right? Well, it actually doesn’t do that. When Java creates a string object from a literal, it actually puts that string object in something called the String Pool. And then every time another string literal is created, java will check that string pool to see if that value is already anywhere in there.

So over here, when we say anotherName equals the literal string value Ali. Java asks do I have that Ali anywhere in the pool already?

Yes, I do. And it takes that anotherName string variable and points it to the exact same string object that had already created before.

That’s pretty cool, right? It’s using half the memory that it would if it were to just create a brand new string object each time. But what does that have to do with strings being immutable?

Well, if the string objects weren’t immutable. This wouldn’t work at all! If you had both of these string variables pointing to the exact same string object in memory. If the name variable was able to change the string object in memory, like instead of saying Ali, it said Marcus. That would also change the value of the string being referenced by our anotherName variable. So this whole memory saving scheme using the string pool wouldn’t even be possible if strings were changeable.

But because strings are immutable, we don’t have to worry about any of that. We can have a million different variables all with the exact same string value and pointing to the same string object in memory. And we know that none of them are going to be disrupted because that string object and memory can never be changed. There is something to keep in mind there though. So Java will do that automatically with string literals like this

String name = "Ali;
anotherName = "Ali";

It’ll automatically use that string pool.

But if instead you go ahead and create another string variable, a third name, and instead of just assigning it to a string literal, you use the new keyword.

String name = "Ali;
anotherName = "Ali";

String thirdName = new String("Ali");

Java will go ahead and create that third name variable. But because we use the new keyword, it won’t use the shared object in the string pool. Instead, it will go ahead and create a brand new object outside of the string pool with the value of Ali. Even though it has the exact same value in it, java will go and create a whole separate object for it.

And there’s a way we can prove that too.

System.out.println(name == anotherName) // prints out true.

If we print out the value of name double equals anotherName, Java’s double equals will always return true if both of these variables are referring to the exact same object in memory. And of course we know that our name and anotherName variables should both be pointing to the exact same Ali string in the stream pool. And if we go ahead and run this, it will print out “true”.

But if instead we compared name with a third name it prints out false.

System.out.println(name == thirdName) // prints out false.

And that’s because the name and third name variables are pointing to separate strings in memory, they’re not pointing to the same objects.

In Java, Strings are also completely thread safe. So in your Java program, you could have dozens or hundreds or thousands of threads all pointing to the exact same string object in memory. And all of them can be reading that value from memory whenever they want. Even though all those threads are using it, none of them are able to change it.

If you didn’t know how Strings operate in Java language, I hope reading through this helped you gets some clarity.

Companies are not willing to hire people with no experience or people who they’ve to train.

Your first job in tech is the toughest, you’re competing with virtually every new college grad and anyone who completed a boot camp. I know it can be hard to even land an interview, for someone to give you a chance to talk and demonstrate you could be valuable employee.

Now, the chance of you getting an interview totally depends on how your resume compares to the job description. The more relevant it is to the skills required, the better your chances of getting an interview.

To build your resume, I’d recommend https://thetechresume.com. It’s a nice read to follow the principles when it comes to building a tech resume.

Over the past few months, I’ve been collecting resources like videos, websites, and taking notes to prepare for coding interviews.

In that process, I made a 8 weeks study guide curated of important data structure resources to prepare for tech interviews and honestly this study guide was helpful to me to know what to study every day and in following a routine for my job search.

The Coding Cards

Why 8 weeks ?

If you’re serious about preparing for a tech interview then 8 weeks is the minimum to be given to prepare thoroughly for a tech interview. I know there are few who would cram up pools of content in a week or two. But, I believe that is not a realistic or sensible approach.

Tech interviews can be intense and most companies expect you to solve problems or go through a data structure topic in detail.

Now, My study guide with resources will eat up the entire blog space. So, Instead of straight up dumping down the content all together, I racked my brains on how to deliver the content in the most effective way possible to ensure the habit of consistency and dedication stays intact during the interview preparation process.

In this blog post, I would give you what to cover each week. If you’re interested to know what resources to refer when covering each topic then I’d recommend subscribing to the newsletter https://thedailycoding.com in which you’ll receive daily one email about the concept and the resources to practice.

If you believe you can find resources to relevant topic on your own then here’s how you should plan to cover each topic every week.

WEEK 1 — Data Structures & Big O notation

Get a hang of what are data structures and how do we measure time complexity. What are the drawbacks and when is it better to trade time with space.

WEEK 2 — Arrays & String Manipulation

What are arrays? How do we access them? Practice implementing them and analyze time and space complexity. Practice problems on string manipulation. Usually big companies who mass hire and pay relatively low ask a lot of questions on string manipulation.

WEEK 3— Hash Tables & Linked Lists

How can we link our data together and what could be the most efficient way to access the data. Hash tables are important data structures when it comes to cutting down access time. Learn about how we can chain the data set to access and map them with each other.

WEEK 4— Stacks and Queues

Understand the principles of Stacks and Queues. How can they be implemented? What are the differences? Where should each of these be applied to? Practice problems on stacks and queues.

WEEK 5 — Recursion & Sorting

Start from the anatomy of recursion to how can it be implemented to sort elements. Recursion is an important topic and it usually applies when implementing a sorting algorithm. Go over the popular sorting algorithm and learn how are they traversed and sorted.

WEEK 6— Trees

If you’re interviewing for Amazon then Trees are the must-know concept. Amazon interviewers are usually very interested to know your knowledge and problem solving skills in relation to Trees. Make sure to cover it broadly and implement it on your own. By the end of the week, you should be able to reverse a binary tree.

WEEK 7 — Graph

Graphs are another hot topic that is usually asked by high rewarding companies and FAANG. If you’re a new grad then you most likely will not receive a question on graphs but it’s nice if you know it and can practice to make yourself confident and ready to take up the challenge. Get familiar with some of the famous graph algorithms.

WEEK 8 — Patterns

The last week should be all about detecting patterns. As you solve questions on various topics, you’ll see that some of these question have patterns. There are few famous patterns like sliding window, two-pointers, cyclic sort and many more. Try to see what coding question resembles what pattern.

Now, of course there are many study guides out there. But, this one helped me in landing my first tech job and I hope it also helps you. If you’re interested about where to pick up resources to learn all these then as stated above, you can subscribe to the newsletter.

I hope you fight these hard times and don’t let the market condition dictate your self-worth. The job market right now is a hot mess and I mean it.

Let’s put our energy on things we can control and make sure we are ready when the opportunity comes our way.

When developers talk about testing in the software development context, they mostly are not talking about manually testing the software, where we perform some operations in our application and use our eyes to see if we are getting the correct result.

They are talking about setting up an automated test suite, where we write a little bit of code that performs a few operations in our app and then we add a little more code that asserts we got back the result we were expecting. This helps out developers tremendously especially as our application grows.

The great thing about the automated test suite is we write our test case a single time and we run it as many times as we want. This gives us a lot of confidence that we are not shipping a broken or buggy code in production.

The Coding Cards

Why do we want to write test cases for our project?

• Saves Time
• Create reliable software
• Helps with Refactoring, Collaborating, and Profiling.
• Peace of mind that our software is functional

It vastly helps in collaborating, if the new developer changes some area of the project. The test suite ensures the changes made in the project have not changed the result.

Creating your first test case with Jest JS

Let’s go ahead and dive right in to learn about testing by installing one tool we would need to enable automation in testing. There are dozens of testing libraries in node js and for the purpose of this article, we will be using the most popular one and my favorite, Jest.

Please make sure you’ve node installed.

Let’s setup Jest by opening up the terminal and run the following command

npm i jest --save-dev

The. — save -dev flag is used to install jest as a development dependency.

Add a new script in package.json file under scripts key:value pair; “test”: “jest”

In order to create our very first test file, we must adhere to the naming standard of the file for jest to pick up it as a testing file.

.test extension tells jest that it contains the test cases we want to run.

Now, let’s create our very first test file with the name math.test.js (Yes, it’s a JavaScript file)

Jest framework comes up with the method test() which basically runs the test. The test() takes two arguments, the name of the test and the test to run.

test('My first Test', () => {

}

Let’s save the file and run the following command to run the test case.

npm test

In the output, it is indeed looking through our file math.test.js, and even though our newly created function doesn’t do anything, it is still being considered a passing test case.

Why is it? Well, When we register a test, we write a function providing two arguments. When we run the test, it basically runs that file and checks if all the functions in that file are executing, if the function throws an error then it considers it as the test case failed.

To demonstrate what I mean by it, let’s create a function that we want to fail on purpose. In the same file, add the following code.

test('My failed test', () => {
     throw new Error('Failed to execute!')
})

When we execute again by running the command npm test, we get the following output

I’ve two total tests, One passed and One failed.

When we are running math.test.js, all we’re doing is running functions and checking which function passed and which one failed.

Now, the above test case doesn’t add any value to our understanding of how test cases can be useful.

Let’s create a js file with the name math.js

In that file, write a simple function to multiply two numbers.

const multiplyNumber = (num1, num2) =>{
      const total = num1 * num2
return total
 }

Let’s export this function to our test file by including the export line in our file

module.exports = {
       multiplyNumber
}

Now, load lets the function in our math.test.js

const math = require('// Enter Destination of math.js file')

Let’s create a test case for our newly created function. The first argument takes the name of the test case and the second argument computes. Let's compute by passing two numbers and telling what to expect when this function is run. 10 x 3 = 30. If it’s not computing to that then we throw an error.

test('Should get me the right result', () => {

const total = math.multiplyNumber(10,3)

        if(total!=30){

throw new Error('Total number should be 30! Got ' + total)

         }

})

Comment out all the previous code and run npm test.

Great! Our test case has passed.

What if our multiplyNumber() was broken? Let’s say a new developers steps in and edits the function not realizing that he has made a mistake. Let’s quickly mess up our multiplyNumber() to see what would happen.

const multiplyNumber = (num1, num2) =>{
      const total = num1 * num2 - num1. //Subtracting num1 again
return total
 }

Let’s run again the test suite. What do you see? If you messed up your code like the above then you may be prompted with that the test case has failed. And, indeed it has. The value to return is supposed to be 30 and we will get 20 for the above messed up function.

Jest provides us with another function similar to test() that we can access in our test cases. Let’s replace the line of checking if the value equals to 30 or not with the in-built Jest function.

test('Should get me the right result', () => {

const total = math.multiplyNumber(10,3)

expect(total).toBe(30) //Single line to check 

})

With jest, we delegate the task of checking the output by calling expect(), and in that, we provide the value we are expecting something about, In our case, we are expecting total so we pass that in. Now, Jest library ships with dozen or so methods. In our case, we are using toBe() where we are passing the value we expect to get.

I hope you enjoy reading this and for more such article follow me on medium and check out my website Sharjeel Sidd for the things I’ve worked on.

Why do we need testing in software and how to get started with Jest? was originally published in The Startup on Medium, where people are continuing the conversation by highlighting and responding to this story.

What does that means?

Javascript engine runs on a V8 engine that has a memory heap and a call stack.

JS is a single threaded which means only one statement is executed at a time.

Before we dive into what it means by it runs on single thread. I would want to first go over the terminology that will help you in understanding.

My attempt will be to explain in the simplest manner possible. To understand this better you need to know a Data Structure known as Stack (Last In, First Out).

Synchronous (or sync) execution usually refers to code executing in sequence. In sync programming, the program is executed line by line, one line at a time. Each time a function is called, the program execution waits until that function returns before continuing to the next line of code.

To put it in example, you are calling someone and you’re waiting for them to pick up so that you can talk to them. You’re not doing any other thing until they pick up the phone.

You fulfill the request sequentially.

const one() => {
     const two() => {
       console.log('5');
 }
    two();
}

So, what happens under the call stack?

The call stack job is to fill in the instructions and pop an instruction as it gets executed.

Javascript is a single threaded language that can be non-blocking. Single threaded means it has only one call stack. Whatever is on the top of the call stack is run first.

In the above program, functions are run sequentially.

What if we have a function that is require to do heavy lifting. Should we let the user wait till that process is over?

const one() {
      console.log("Hello");
}
const two () {
    for(i=0; i<= 100000000000000000000000; i++){
}
const three(){
       console.log("World");
}
one();
two();
three();

Consider the above example, what if our second function has to loop through huge numbers. Does this means three() has to wait till two() is executed. Technically, Yes!

In our small example it may not mean much but if we have to implement in a real project then the users may not be able to do anything until the first process is finished.

Asynchronous (or async) execution refers to execution that doesn’t run in the sequence it appears in the code. In async programming the program doesn’t wait for the task to complete and can move on to the next task.

To put it in example: You call someone and while you’re waiting for them pick up the phone, you’re also running errands.

Different languages have different ways to implement asynchronous. The most popular is through Multi-threading.

In brief, Java implements multi-threading by creating a child thread which does it’s own separate execution and then merges back with the parent thread.

This however can run into a problem known as Deadlock, which can be dealt with various deadlock prevention mechanism.

Since, we are concerned about implementing asynchronous in Javascript. Let’s see how we can do it.

Try running this in console and see what happens.

console.log('1');
setTimeout(()=> {
console.log('2')

}, 3000);
console.log('3');

You may see 1 3 and with a brief delay 2 shows up. Why is this happening?

In a nutshell, the asynchronous implementation in Javascript is done through a call stack, call back queue and Web API and event loop.

Call stack job as we seen earlier is to check what instruction is at the top of the stack and execute it. If there is an instruction like setTimeout() that requires extra time to execute then call stack will pop that out and send it to Web API.

The job of event loop is to continuously check if an event occurred, like mouse click or keyboard stroke so that it can send that to call stack. Of course, your mouse click will be given higher priority for execution than an image load.

The Coding Cards

In Javascript, All instructions are put on a call stack. When the stack arrives at setTimeout, the engine sees it as a Web API instruction and pops it out and sends it to Web API. Once the Web API is done with the execution, it will arrive at the call back queue.

The engine checks if the call stack is empty. If it is empty, then we check callback queue which has the instruction setTimeout in it. The callback queue sends it to call back stack and the instruction is executed.

The other way to think about this is when you make an API request. Say for example your website needs to fetch an image from a server. Should your website refuse to load other parts till the image arrives? That would be a bad user experience.

When call stack sees it needs to fetch an image, it pops and send it to Web API and continues executing the remaining functions.

The response of image request is stored in call stack queue.

When the call stack is empty, the event loop which is continuously running looks over the Call stack queue if it has anything. If it does, in our case the response of image request. It puts over the call stack and execute the instruction.

The benefit of this procedure is JavaScript need not worry about how many cores or nodes a CPU is running on. There is only single call stack for this implementation.

What does it mean by Javascript is single threaded language was originally published in The Startup on Medium, where people are continuing the conversation by highlighting and responding to this story.

To keep our professional network on top of our game, it is imperative that we maintain a solid presence on LinkedIn, The professional social networking platform. Just like companies build their brands, we must have a professional brand.

Having a presence on LinkedIn helps in professional settings and boost tap into its sturdy job board.

Before I walk you through how I was able to get a massive increase in my views and engagement on LinkedIn, I want to point out my motivation behind it.

I created an account on LinkedIn long back, and I have had been using it to post content related to startups and programming to help my small networks get exposed to knowledge. My posts were indeed gaining a decent amount of views and engagement. I realize all those views and engagement were not much of a help to me as they were coming from people I already know or college students.

I wanted to expand my circle and reach out to other people and diversify my network. I was coming closer to graduating with Computer Science Master’s degree. I knew I have to find a job soon and sooner I start the better it will be.

My research led me to believe the best way to get a job was by getting a referral from someone inside the company. I have had tried a few ways to get interviews. From applying on a company website to reaching out to technical recruiters and the most successful I’ve had luck with was someone inside the company vouching for me.

And, the only way to make that happen is to reach out to various people on LinkedIn. People usually suggest buying Linkedin Premium to increase the chances of getting hired. While that may seem an ideal thing to do for many but in my case, I didn’t want to spend money or at least spend less money and yield the most output out of it.

Phantombuster — is a tool used by businesses to generate leads. There are lots of use cases for phantombuster but the one I’m keen to talk about is the one that can help in growing your LinkedIn presence.

Now, my trick wasn’t to use it as a way to get ineffective attention. It was to translate into a meaningful connection. I discovered phantom buster while scouting for tools to generate leads for a startup I was running a few years back. I didn’t give much thought on how I can make it useful for building connections and in turn hunt jobs.

But, before I start talking to about what to do. I’ll like to first show how my standings changed completely. I went from receiving 20–30 views to 200+ views per day in just a week. That’s 10x!

This wouldn’t be possible without Phantombuster and a little bit of my creative effort.

What is PhantomBuster?

Phantombuster gives you the tool to generate business leads, marketing audiences, and overall growth. Consider it as a bot that acts on your behalf to do actions.

How would you go about growing your network if it had been left for you to do? The ideal approach would be to search for a job title or a company name and then add them on LinkedIn. You would typically go on their profile, click on the Connect button and then probably send a message introducing yourself to better your chances of getting accepted.

Well, that’s how most people make connections on Linkedin. But, Imagine if you want to do this thing for like 100 people every day? If each connection to add takes you 2 mins then 2mins x 100people = 200 mins which is more than 3 hours to spend on LinkedIn and given how we humans are not so persistent, our quitting rate can be a lot higher in a few days.

A lot of people know Phantombuster but a lot of them don’t know how to capitalize on it. Let me walk you down the road of enlightenment.

First, Sign up on Phantombuster by going on to https://phantombuster.com. They offer 14 days free trial, you will have to enter your credit card details but don’t worry they won’t charge you.

Once you’re in, you’re going to see a menu on your navbar shown below.

Head over to the store section. You will see tons of cards but in this section, I’m particularly interested in talking about a specific Workflow that I want you to use to grow LinkedIn followers.

Our objective is to grow our network from industries that are relevant to us. We are going to pick cards that can help us achieve that.

Choose Linkedin Search Export by clicking on Use this Phantom. You will see a settings page asking for a few details. The very first will be a LinkedIn session cookie. You need to give Phantombuster permission to act on your behalf on LinkedIn. The safest and most efficient way for Phantombuster to authenticate as yourself is by using your session cookies. To make that process as easy as possible you can download Phantombuster’s browser extension. After installing chrome extension you would be able to automatically fill your session cookie.

Enter the search term, for example, Software developer. This is basically the search you are making on LinkedIn to find people who hold software developers as their jobs. Name the CSV file you will be saving.

Anyway, most of the form fields are self-explanatory. After you’re done filling the necessary information, click on Save.

Launch your automation and download the CSV file generated by the bot. The CSV file will contain the search scrapped by the bot. Depending on the limit set by you, it could put out 100 profiles or 1000 profiles.

Open the CSV file on Google Docs and set it to public. Select another phantombuster card. This time LinkedIn Network Booster card. This card is used to automatically send invitations and connects to a list of LinkedIn users with a personalized message.

Go through the same process. In the Spreadsheet URL field, put the Google docs link. Enter the message you want to send out to the person you will be adding (All the LinkedIn profiles collected from our previous automation.)

Since I was looking for getting an internship. I searched for all the people who already had one so that I can take tips from them and if they are working in a company of my interest then eventually ask for a referral.

On the next page of settings, Choose to launch your automation with the ability to run it 8 times per day. This is like the bot doing your work while you’re sleeping. The automation is going to run for 8 times per day regardless of your computer running or not cause the bot runs on the phantombuster server.

Launch the Phantom and wait for it to do the automation. I sent 80 connections per day with getting 3 or 4 replies back, which isn’t bad.

The idea is to send out mass messages to people personalizing their first name (Phantombuster allows you to do that) and engaging with those that reply back. For example, I initiated conversation when I got a reply back.

This is one of many instances in which I automated to get plenty of referrals. If you ask me then I’d prefer spending $30/month on phantombuster than LinkedIn Premium.

Linkedin Premium doesn’t provide much value besides the ability to send 5 InMail message which I think doesn’t do anything great for people searching for jobs.

The coronavirus has taken a big toll on the job market and I would like to help in any way possible for people to get a job. This was my loose attempt at helping people. I’m sorry if this post confuses you. Please shoot me an email at sharjeel at gmail dot com and I will be happy to assist further.

You might not know this but computer science gives us a way to understand our world and what’s going on behind the scenes in much of our cases. You might have come across the frequent question when dealing with writing code. What is it’s time complexity? How can you represent it in terms of Big O notation?

I will attempt to try to explain like your five the purpose and significance of Big O notation.

When we try to understand Big O notation we came to realize it’s not restricted to the study of computer science but also something we do with people.

The Coding Cards

“To lower costs per unit of output, people usually increase the size of their operations,” wrote J.C Hosken in 1955, in the first scientific article published on sorting. This is what economies of scale look like to anyone coming from a business background. But, with sorting, size is a recipe for disaster: perversely, as a sort grows larger, “The unit cost of sorting, instead of falling, rises.” Sorting indulges into steep diseconomies of scale, violating our normal intuitions about the virtues of doing things in bulk. Cooking for two is typically no harder than cooking for one, and it’s certainly easier for one person twice. But, as a shelf of a hundred books will take you longer than sorting two bookshelves of fifty apiece: you have twice as many things to organize, and there are twice as many places each of them could go. The more you take on, the worse it gets.

This is the first and most fundamental insight of sorting theory. Scale hurts!

Computers, though, must routinely sort millions of items in a single go.

We are surrounded by people who only care about best-case performance. All records in sport reflect the single best performance. In Boxing, all it matters who won the match. Computer Science, however, almost never cares about the best case. Instead, computer scientists might want to know the average sort time. Moreover, a computer scientist would want to know the worst sort time. Worst-case analysis lets us make hard guarantees: that a critical process will finish in time, that deadlines won’t be blown.

CS has developed a shorthand specifically for measuring algorithmic worst-case scenarios: it’s called “Big-O” notation. Rather than expressing an algorithm by minutes and seconds. Big-O notation provides a way to talk about the kind of relationship that holds between the size of the problem and the programs running time.

O(1)

Imagine you’re hosting a dinner party with n guests. The time required to clean the house for their arrival doesn’t depend on the number of guests at all. This is called Big-O of one problem O(1) It’s called constant time. Doesn’t matter if 100 showed up or 50. The time to clean the house before their arrival will remain the same. Totally invariant of the guest list.

O(n)

So, what’s O(n)? Well, first n is the number of guests. These guests are all sitting on the dining table. Now, the time required to pass the dish around the table will be “Big-O of n”, written O(n), also known as “linear time” — with twice the guests, you’ll wait twice as long for the dish to come around. The time is dependent on the n value.

Simply put, as n increases so do the time. If you want to have the feast early just make sure not too many guests show up.

O(n²)

What if, as the guest arrived, each one hugged the others in greetings? Your first guest hugs you; your second guest has two hugs to give; your third guest, three. How many hugs will there be in total? This turns out to be “Big-O of n squared”, written O(n²) and also known as the “quadratic time.” One interesting algorithm that has become a punching bag for computer science students is Bubble sort. It’s simple, it’s intuitive, and it’s extremely inefficient. And it lands us in quadratic time.

It’s natural to wonder what can be a faster sorting possible.

The question sounds like it’s about productivity. But talk to a computer scientist and it turns out to be closer to metaphysics — akin to thinking about the speed of light, time travel, superconductors, or thermodynamic entropy. What are the universe’s fundamental rules and limits? What is possible? What is allowed? In this way, computer scientists are glimpsing God’s blueprint every bit as much as the particle physicists and cosmologists. What is the minimum effort required to make an order?

Could we find a constant-time sort O(1)? Well, even just confirming n books can’t be done in constant time since it requires checking all n of them.

O(log n)

In 1936, IBM began producing a line of machines called “collators” that could merge two separately ordered stacks of cards into one. As long as the two stacks were themselves sorted, the procedure of merging them into a single sorted stack was incredibly straightforward and took linear time. Simply compare the two top cards to each other, move the smaller of them to the new stack you’re creating, and repeat until finished.

Sorting two cards is simple: just put the smaller one on top. And given a pair of two-card stacks, both of them sorted, you can easily collate them into an ordered stack of four. Repeating this trick a few times, you’d build bigger and bigger stacks, each one of them already sorted. Soon enough, you could collate yourself a perfectly sorted full deck — with a final climactic merge, producing the desired result.

This approach is known as Merge sort. Each pass through the card doubles the size of the sorted stacks, so to completely sort n cards you’ll need to make as many passes as it takes to for the number 2, multiplied by itself, to equal n: the base-two logarithm, in other words. You can sort up to four cards in two collation passes, up to eight cards with a third pass, and up to sixteen cards with a fourth.

If you’re still strategizing about that bookshelf, Mergesort’s solution would be to order a pizza and invite over a few friends. Divide the books evenly, and have each person sort their stacks. Then pair people up and have them merge their stacks. Repeat the process until there are just two stacks left, and merge them one last time onto the shelf.

If you have a giant stack of census documents, and the documents are sorted by age of the person, and you want to find any 38 years old, you can look at the middle document. If the person is 38, you are done. If they are 39 or older, you discard all documents after this. If they are 37 or younger, you discard all documents before this.

You then take the remaining stack and do this whole thing again. This is more efficient, and it is called a log(n) solution, in this case, because the number of forms you need to look at relates to the logarithm (base 2 in this case) of the number of forms.

I hope this was helpful to learn about Big-O Notation.

Sorting something that you will never search is a complete waste, searching something you never sorted is merely inefficient.

Time is a fundamental component that is required to build a significant connection between the doctor and the patient. Doctors have so much on their plates already, and then on top of everything else they have the EHR, which doctors are mandated to use in most developed countries to maintain patient records.

To allow efficiency in a doctor’s practice, many tools have been developed on top of the existing EHR’s to introduce efficiency and save time for doctors.

One such is the Speech to text software. With the advent of Dragon Speech. Doctors have reported saving lots of time.

Speech-recognition is software that any size health care association can use as a component to improve the charting experience.

A lot of doctors have signed up after seeing their colleagues using speech-to-text software and noticing the difference it has made in their work and wants to start using the technology.

Doctors on average, have reported saving 5 minutes on each patient. The slider from https://voiceboxmd.com/ is helpful to know how much time you can save using a speech to text software.

If you have been in the medical industry for quite some time, you probably already know the importance of Dictation and its advantages.

Because of doctors, little experience in using technology, a large portion of them have reported having difficulties in using the software. This can also be attributed to lack of resource and help available online to teach how to use a speech to text software.

In this article, regardless of which Speech to text software you use, whether it is Dragon or VoiceboxMD. I will go through some standard best practices to use to achieve better result in dictation.

Keep background noise to a reasonable minimum: When dictating, it is vitally important that you are in an area where there is no interference of background noise. Ensure the windows are closed to block out street noise or turn down the volume of anything that can be considered as background noise.

Position your microphone properly: Place the microphone head close and directly in front of your mouth. Keep in mind to not place it too close to your mouth this can cause the audio to be too loud and can result in audio distortion.

Figure out which position is best for you: Hold the microphone the same way each time you use it. Identify which position you are getting the best result and try to maintain that position every time you are charting.

Do not dictate into the side of the microphone: Make sure that you have not placed your microphone on side. Speaking into the microphone side reduces the quality and sound of the dictation.

Use punctuation: You can add punctuation by saying what you want. Punctuation helps in formatting and can be very useful in charting overall.

For example, saying “I have prescribed Patient Mark comma the necessary drug exclamation mark” becomes “I have prescriber Patient Mark, the necessary drug!”

Speak slowly and steadily: Make sure that while speaking, you are speaking clearly and slowly. You may end up losing productivity if you speak fast. Your time will be spent going back and correcting all the errors…so avoid it.

Spell that: There may be instances where the word you are trying to speak is complicated or has a unique spelling. In that case, It is always a good idea to speak out each letter of the word. For example, The speech to text software has a good chance of picking up the word phlebolithic wrong. It is advised to spell the letters in such scenarios. P-H-L-E-B-O-L-I-T-H-I-C

Use Good Microphone: Without a good microphone, there is nothing to say. Hardware is an important element that affects the quality of your dictation. Invest in a good microphone!

Let it get used to you: The more you work with the speech engine, the better it gets. You need to give it time. And you need to correct so that it can recognize your accent. Give it some time and you will see a gradual improvement in your dictation.

Medical Dictation has been on the rise and it is imperative that user of it get comfortable cause they would spending a lot of time on it to save lots of time taking care of patients.