When it comes to JavaScript package managers, npm has been the go-to for years and for me personally. But lately, you might’ve heard whispers (or maybe loud cheers) about pnpm. Let’s break it down.

A Quick Overview

• npm (Node Package Manager) has been around since Node.js became popular. It’s reliable and easy to use, making it the default package manager for most Node projects.
• pnpm (Performant npm) is the new kid on the block, bringing a fresh perspective on package management with a focus on speed and disk efficiency.

Let’s look at why you might want to switch to pnpm, or if sticking with npm is good enough for you.

1. Speed: The Need for Speed 🏎️

npm has gotten faster with v7 and v8, but it still installs packages in a way that can feel sluggish, especially in big projects. It puts a node_modules folder in every project with full copies of your dependencies.

pnpm, on the other hand, uses a content-addressable storage system. This fancy term essentially means that it stores packages globally and uses hard links to your project. So, instead of creating a full copy, it just points to an existing package. The result? Faster installs and less disk usage.

TL;DR: If speed is a concern and you’re dealing with large projects, pnpm can be a game changer.

2. Disk Space: A Hoarder’s Nightmare 😱

If you’ve ever run out of space because of node_modules, you’re not alone. The way npm works, every project gets its own set of dependencies, even if another project already has the same ones.

With pnpm, shared packages are stored in a single place, and hard links are used for your project. This drastically reduces disk space usage.

Example: If you have five projects using React, npm will store React five times. pnpm will store it once, with pointers in each project.

Disk Space Winner: pnpm.

3. Compatibility: No Surprises, Please 🤞

You might wonder if switching to pnpm will break your project. The good news is that pnpm is largely compatible with npm and yarn. Your package.json file stays the same, and you can use almost all the same commands (pnpm install, pnpm start, etc.).

However, there are some edge cases, especially if your project relies heavily on nested node_modules (which pnpm doesn't create by default). Most modern projects won’t face issues, but it’s something to watch out for.

4. Workspace Support: Monorepo Magic 🧙‍♂️

If you’re working with monorepos, pnpm shines even brighter. It natively supports workspaces, making it easy to manage multiple packages within a single repo. While npm has also introduced workspace support, pnpm’s implementation tends to be faster and more efficient because of its linking system.

For Monorepo Fans: pnpm is a clear win.

5. Ecosystem & Adoption: Who’s Using What? 🤔

Despite being the default, npm isn’t the only game in town. Many popular projects have already switched to pnpm because of its performance benefits. It’s still newer and may not have the same ecosystem maturity as npm, but it’s catching up fast.

If you’re starting a new project and want to optimize from the get-go, pnpm is a solid choice. If you’re dealing with legacy code or don’t want to rock the boat, sticking with npm is perfectly fine.

Final Verdict: Should You Switch?

Choose npm if:

• You want a straightforward, time-tested package manager.
• Compatibility and stability are your top priorities.

Choose pnpm if:

• You care about performance and saving disk space.
• You’re working with monorepos or large projects.
• You’re willing to adapt to some minor changes for the speed benefits.

In the end, both npm and pnpm get the job done. It’s about picking the right tool for your needs. Personally, I’ve found pnpm to be a breath of fresh air, especially when juggling multiple projects on limited storage.

Give it a try, and see if it fits your workflow. You might just be surprised at how much faster your projects install.

Proper documentation is an important part of any open-source project. It helps users understand how to use the project, and it can also help other developers contribute to the project. Without proper documentation, it can be difficult for users and developers to get the most out of an open-source project.

One of the key benefits of open-source software is that it allows anyone to use, modify, and distribute the code. This means that open-source projects can be built on and improved by a large community of developers. But in order for this to happen, it’s important that the project’s documentation is clear and comprehensive.

The checklist

Great documentation for open-source projects should be:

• Clear and straightforward: Written in a way that is easy for anyone, even those new to the project, to understand.
• Thorough: Covering all aspects of the project, including its code, architecture, and usage instructions.
• Up-to-date: Keeping pace with the project’s evolution and reflecting any changes or new features.
• Easy to find and navigate: Conveniently available and organized for users.
• Supportive: Providing guidance and support for users and contributors, and including information about available resources.
• Compliant with the project’s license: Clearly outlining the license’s requirements and restrictions on use and distribution.

Other notes and thoughts

Encouraging first-time open source contributors is an important part of building and maintaining a successful open-source project. Proper documentation can play a crucial role in this by making it easier for new contributors to understand the project and get started.

Having clear and detailed documentation makes it easier for users to get started with the project, and it also helps other developers understand how the project works and how they can contribute to it. This is especially important for open-source projects, where collaboration and community involvement are key to their success.

In addition to making the project more accessible and user-friendly, proper documentation can also help to establish trust and credibility for the project. When users and developers can easily find the information they need, it helps to build confidence in the project and its capabilities.

The wrap up

Proper documentation is an essential part of any open-source project. It helps users and developers get the most out of the project and can also help build trust and credibility for the project. As a result, it’s important to invest time and effort in creating comprehensive and well-written documentation for your open-source project.

References

https://blackgirlbytes.dev/conquering-the-fear-of-contributing-to-open-sourceissue/PR for photos

Special shoutout to Program Equity

What Makes Good Documentation for Open-Source? was originally published in Modules&Methods on Medium, where people are continuing the conversation by highlighting and responding to this story.

git add .

git -m commit "insert commit message here"

git push

What if you wanted to view a listing of changes you or one of your collaborators made. You can do so by going to your terminal and executing

git log

Let’s say you wanted to filter changes made by a time or author. Using --pretty=oneline is the best bet. In order to select an author or time the following must be added

git log --pretty=oneline --since='10 minutes ago'

git log --pretty=oneline --author=<insert author name>

Thank you for reading my blog, if anyone wants to connect please do so at LinkedIn or Github

Hey there! So, Big O notation had me totally baffled when I first stumbled across it. But after spending some solid hours doing a deep dive (okay, maybe not years, but it sure felt like it), I’m now feeling pretty pumped to share what I’ve learned with you.

You might ask, what’s the Big O notation all about? Well, it’s basically a way for us coders to figure out how fast (or slow) our code is gonna run.

Here’s a quick scenario for you: Imagine you need to write a function. It’s got to take a string input and spit out an array. You’ve got three solutions to pick from — which one do you reckon will get you the quickest result?

1. O(n)
2. O(n²)
3. O(1)

If you put your money on the third one, then give yourself a pat on the back — you nailed it! This guy runs at O(1) complexity, or as we call it, “Big O of 1”. What’s cool about it is that no matter how big your input gets, your algorithm won’t slow down. It’s like the Usain Bolt of algorithms — lightning fast!

Now, to break it down even more, Big O notation is like a measuring tape for your code’s performance. It shows you how much the runtime of your code will increase as your input gets bigger. Here are some examples:

1. Linear: f(n) = n
2. Quadratic: f(n) = n²
3. Constant: f(n) = 1

The first equation, f(n) = n, represents a linear time complexity or O(n). Think of a single loop going through your data — the bigger your data, the longer it’ll take.

Second up, f(n) = n², or O(n²), is quadratic time complexity. This is like having loops within loops — it’s going to take longer as your input size grows. It’s like trying to find your lost keys in a mansion!

Lastly, f(n) = 1, or O(1), shows us constant time complexity. It’s like basic arithmetic — no matter how complicated your input gets, this guy won’t slow down.

Big O notation is like your speedometer in coding. It helps you figure out how your code will perform under different conditions. It’s your key to writing efficient, high-performance code. Trust me, your future self (and your users) will thank you for taking the time to get to grips with it!

Back in late April, I decided to join a Hackathon, hosted by TH.0. They have themes for Hackathons and this one was Fintech. We had 48 hours to collaborate on a product that will change the industry with a full business pitch. The entire hackathon was hosted on Discord. TH.0 had channels for each role within a team. The roles consisted of , data-scientist, security & QA, UX-UI, and sales-and-marketing. Naturally I went into the developer channel, listed my skills, background of experience, location and LinkedIn. From there on it was every man/women for themselves. I decided to reach out to a team who already appeared to be active and just like that I had a team. In the end we were 7, Sales and Marketing, UX Designer Backend, Frontend and 3 other Web Developers with mobile and applied informatic skills.

We all jumped in a call on Discord and broke bread. I learned that most of my teammates lived in Europe and I was easily able to make a connection with them through what most of the world calls Football. After a few minutes of conversation we had to whip up our product, which turned out to be pretty cool and a first in the Fintech space.

In the end we built an application that offers users a convenient and simple method to access various currencies across the globe at a vastly affordable price point. We had an entire presentation that identified a problem in FinTech. How our application can solve that problem and then how we can theoretically do so with our demo, figma, and code. During that fun 48 hours there was an event that made me realize that I am flexible and have the potential to one day step into a leadership role. Midway through we were told that the most important part is our demo of the application and our presentation. So I dropped my role as a frontend developer and transitioned into a product manager. We already had demo of our application and as team, we felt there was no longer a need for front end code. I learned about how to work with a team in a Software Engineering position to create a product as well as rediscovering my ability to step into a leadership position. We ended up coming in second.

Once again shoutout to the team.

Here is our presentation:

If anyone would like to participate in a Hackathon in the future

https://thpoint0.io/hackathon/

Personally I thought there was no way running a silly command such as spring stop will solve the issue at hand. Leading us to be on zoom for hours because, of all the developers/engineers on this planet, I was convinced we invented a new error no one had ever seen before.

My teammate then ran a rails g model with some random strings, and wouldn’t you know it, we have a responsive terminal. I bowed down to the big brain of my instructor just like the spectators of the Camp Nou when Messi scores a beautiful goal.

At that moment I had to do some research as to why that worked, here are my findings.

Spring is a Rails application preloader. It speeds up development by keeping your application running in the background, so you don’t need to boot it every time you run a test, rake task or migration.

In the event you’re coming from ruby or no backend experience at all, the spring will essentially spare you from constantly re-running your application post tests or migrations. Spring by the way is a rails gem that comes with creating a rails application.

tl;dr If you’re using Ruby on Rails and attempting to generate anything with the rails g command and getting an unresponsive terminal as a result, give spring stop a shot.

Happy coding nerds 😁

References

GitHub - rails/spring: Rails application preloader

LinkedIn

https://www.linkedin.com/in/kennethjordan2/

We’ll be talking about the wonders of using the private method.

Using a private method to encapsulate the permissible parameters
 is just a good pattern since you'll be able to reuse the same
 permit list between create and update. Also, you can specialize
 this method with per-user checking of permissible attributes.

We’ll be refactoring some params into strong params. Lets say we wanted to return the rest of our CRUD(Create Read Update Destroy) actions. We could do all of that and have a decent amount of reusable code. Thankfully with the private method we no longer have to do such a thing!!!

We can store all our reusable code below the private method which is only viable to us, the coders by the way.

Thankfully we there are more uses to our wonderful private method. What if we wanted to return status codes when a user gets invalid data or a data that cannot be found. Fear not. Lets say we wanted to return a status code of :not_found if information we’re seeking is not in the database. Normally we could do so by adding some conditional logic inside our show or update actions as show below. However, rather than repeating some simple logic we could add

rescue_fromActiveRecord::RecordNotFound,with: :render_not_found_response

on line 2 of our file. rescue_from receives a series of exception classes or class names, and an exception handler specified by a trailing :with option containing the name of a method or a Proc object. Alternatively, a block can be given as the handler. If any of our controller actions throw an ActiveRecord::RecordNotFound exception , our render_not_found_response method will return the appropriate JSON response.

Would you rather have this block of code or a more refactored code?

def show
  bird = find_bird
  if bird
    render json: bird
  else
    render_not_found_response
  end
end

def update
  bird = find_bird
  bird.update(bird_params)
  render json: bird
rescue ActiveRecord::RecordNotFound
  render_not_found_response
end

class BirdsController < ApplicationController
  rescue_from ActiveRecord::RecordNotFound, with: :render_not_found_response

  # GET /birds
  def index
    birds = Bird.all
    render json: birds
  end

  # POST /birds
  def create
    bird = Bird.create(bird_params)
    render json: bird, status: :created
  end

  # GET /birds/:id
  def show
    bird = find_bird
    render json: bird
  end

  # PATCH /birds/:id
  def update
    bird = find_bird
    bird.update(bird_params)
    render json: bird
  end

  # PATCH /birds/:id/like
  def increment_likes
    bird = find_bird
    bird.update(likes: bird.likes + 1)
    render json: bird
  end

  # DELETE /birds/:id
  def destroy
    bird = find_bird
    bird.destroy
    head :no_content
  end

  private

  def find_bird
    Bird.find(params[:id])
  end

  def bird_params
    params.permit(:name, :species, :likes)
  end

  def render_not_found_response
    render json: { error: "Bird not found" }, status: :not_found
  end

end

tl;dr writting private methods allows your code be become more readable and you save time writing less repeatable code. Personally I'd rather write clear code with exception handling techniques(rescue_from) and strong params.

References

ActiveSupport::Rescuable::ClassMethods

https://guides.rubyonrails.org/action_controller_overview.html#strong-parameters

What Are Class Methods?

Class methods, in Ruby, are methods associated with a class. They’re defined by using self. in the method name within the class definition. Here's an example:

rubyCopy codeclass Dog
  def self.bark
    puts "Woof!"
  end
end

Dog.bark # => "Woof!"

In this example, bark is a class method that we can call directly on the Dog class.

What Are Instance Methods?

Contrarily, instance methods are methods that belong to instances of a class, often called objects. Here’s how you define and call an instance method:

rubyCopy codeclass Dog
  def bark
    puts "Woof!"
  end
end

fido = Dog.new
fido.bark # => "Woof!"

Here, bark is an instance method. We first instantiate a Dog object with Dog.new, and then call the bark method on it.

Bonus: Private Methods

As a bonus, let’s take a quick look at private methods in Ruby. Private methods are instance methods that can only be called from within the same class. They cannot be called directly from outside the class or from subclasses. You can define a private method by using the private keyword:

class Dog
  def bark
    puts "Woof!"
    secret_message
  end
  
  private
  
  def secret_message
    puts "I'm a secret dog!"
  end
end

fido = Dog.new
fido.bark
# Output:
# Woof!
# I'm a secret dog!

fido.secret_message # => NoMethodError: private method `secret_message' called for #<Dog:0x00007f8e1c8d7e18>

In this example, secret_message is a private method. It can be called within the Dog class, but attempting to call it directly on a Dog instance like fido.secret_message results in a NoMethodError.

Private methods are a great way to encapsulate behavior and keep your code clean and organized.

Imperative Code

More like the struggle and peril of JavaScript. Another term that you may have heard is lower level coding. Where you have to write code in detail. You see the computer isn’t very smart and you have to tell it exactly what to do, especially when it comes to Vanilla JavaScript. When creating DOM elements using vanilla JS it would look like :

const div = document.createElement(“div”);

div.id =’card1';

div.className = ‘card’;

div.textContent = ‘hello world’;

document.body.appendChild(div);

Declarative Code

Many people find React more malleable because of declarative programming. Declarative programming enables you to write your code and tell it what you what generally like it to do. For Example

const div = (

<div id = ‘card1’ className = ‘card’>

hello world!

</div>

);

ReactDOM.render(div,document.body);

I’m not talking about Spanish. Beuno pues… podemos hablar en Espanol si prefieres. Still with me? Well, in any case. Let’s get started on why you’re really here. It’s probably because you’re struggling to navigate the terminal for Mac or Windows.

Have no fear because Kenny is here!

Let’s start with some beginner stuff. By the time you’re done reading this blog post you’ll be typing into your terminal faster than Instagram bots in the comment section.

Lets start with my favorite:

cd

Stands for ‘Change Directory’ , you can use this command to move left or right inside of the directory. In order to get where you’re going type in cd directory name . You can also use cd to return to you the home directory and cd.. to go back one.

ls
Good old ls is a command list which lists' computer files, more specifically, files in the current directory. Lets say you've got some files you want to access, but you don’t know for sure if it’s in your directory ls will show you what goodies are in your directory.

mkdir

Make Directory creates a directory although we have to name it right after typing mkdir. Bonus!! Right after creating a directory use the touch command to create files inside of that directory some staple names for files are main.css, index.js or .html .

pwd

Shows you the full path name of your current directory.

References

https://www.digitalcitizen.life/command-prompt-how-use-basic-commands/

https://www.ibm.com/docs/en/aix/7.1?topic=p-pwd-command