DEV Community: Nyasha (Nash) Nziramasanga

9 Learnings from a fast-growing startup

Nyasha (Nash) Nziramasanga — Mon, 06 Feb 2023 12:09:18 +0000

I have been at Linktree for more than a year now as a Software Engineer (React Native) in the Mobile team. Linktree is a link in bio solution for creating micro-websites for small businesses and creators. It’s been growing at an average of 80% year on year and things have changed so much from the head count going from 100 to nearly 300 in 2022 to multiple re-organisations, a new office in Melbourne, rebranding and launching the mobile app which hit 2 million unique downloads within 6 months of release.

This is what I learned working at a fast-growing startup:

👊🏾 Impact

As a software engineer, I’ve learned that the key to success in this field is to not complain, but rather to adapt and deliver. This means being flexible and open to change, and always working to find solutions to problems that have the most impact on the end user.

🙎🏾‍♂️ People First

Focus on the customers that use the product every day. This means understanding their needs and wants, and building the right features that will make their lives easier. People like to get the most done with the least amount of effort, the focus is to get a task done with a few clicks or no clicks at all.

🛣️ Product development life-cycle

A common feature request first comes from an idea, first create a hypothesis on what problem you are solving for then design a solution for it before creating building and releasing it. Using metrics to measure the impact of a change on test subjects and if it goes well role it out to everyone.

🧑🏼‍✈️ Know your manager

A manager can make or break you, it’s important to take the time to know and understand how your manager ticks and what incentives drive them. Having a manager who is supportive and willing to help you grow and develop as an engineer is super important. On the other hand, a bad manager can make your job unbearable and make you want to move teams or even leave the company. The trick is to have a healthy dose of communication at least once a week talking about life and work.

🛠 Complexity

Over-engineering is easier than it looks. Sometimes it’s tempting to add more features or functionality than is necessary, but this can lead to a bloated and confusing product. It’s important to strike a balance between adding value and keeping things simple. Using the Keep It Simple Silly (KISS) principle usually works by breaking down things into smaller more manageable tasks.

🗂️ Domain-driven development

I’ve also found that domain-driven development works well for medium-sized companies. This approach involves breaking down a monolithic codebase into smaller, more manageable chunks, and building software that is specific to a particular domain or area of the business. The trend I have seen is organisations start with a monolith (literally everything in one spot), and then as they grow they begin to breakup the monolith into smaller micro-services.

🎯 Specialise

I believe that having a niche is a strength as a software engineer. By focusing on a specific area of expertise, you can become a subject matter expert (SME) in an area you can deliver the best results. I am hyper-focused on Mobile app development specifically using React Native and have gone on to train and equip web engineers on how to build on mobile apps.

🔬 Experimentation

Making data-driven decisions through metrics and experimentation has been key to my success. This means gathering data on how users are interacting with the app and using that data to inform decisions about what features to add, remove or refine. Experimenting is key to testing out your hypothesis. This means trying out new ideas and approaches, and learning from what works and what doesn’t.

Lastly, I’ve found that ideas are cheap, but the execution is super expensive. It’s important to have a clear vision and plan for how to execute your ideas and make them a reality. Also, understanding your manager’s incentives can help you navigate company politics and help you choose to work on projects with the most impact.

React Native PressableHighlight

Nyasha (Nash) Nziramasanga — Mon, 05 Sep 2022 01:32:59 +0000

What if you want to use something similar to TouchableHighlight on both iOS and Android with a ripple effect? Using the Pressable component is not enough, so we can create a PressableHighlight component that handles both a background highlight change for iOS and a ripple effect for android.

You can find the code on this snack

Requirements:

For iOS a background highlight onPress
For Android a ripple effect

PressableHighlight Component

export default function PressableHighlight(props) {
  return (
    <Pressable
      android_ripple={{
        color: '#676B5F',
      }}
      style={({ pressed }) => [
        Platform.select({
          ios: {
            backgroundColor: pressed ? 'rgba(0,0,0,0.1)' : 'transparent',
          },
        }),
        props.style,
      ]}>
      {props.children}
    </Pressable>
  );
}

The android_ripple takes an object which accepts the ripple color, the onPress event can be used to change the backgroundColor which in this case is a black color with an opacity of 10% when pressed and transparent when inactive.

React Native Text Cycler using reanimated

Nyasha (Nash) Nziramasanga — Mon, 04 Apr 2022 13:04:54 +0000

Below is a code snippet on how to make a text looping effect in React Native with reanimated for animations.

Check out the snack example here

import React, { useEffect, useState } from 'react';
import { StyleProp, TextStyle } from 'react-native';
import Animated, { FadeInDown, FadeOutUp } from 'react-native-reanimated';

const TextCycler = ({
  items,
  textStyles,
  duration = 3000,
  textColors = ['#000000'],
}) => {
  const [index, setIndex] = useState(0);
  const numberOfItems = items.length;

  useEffect(() => {
    const timeout = setInterval(() => {
      setIndex((previousIndex) => {
      // if last item in the array the index is set to 0 meaning start again (looping effect)
        if (previousIndex === numberOfItems - 1) return 0;

        // go to next index
        return previousIndex + 1;
      });
    }, duration);

    // cancels repeating timer
    return () => clearInterval(timeout);
  }, [duration, numberOfItems]);

  return (
    <Animated.Text
      key={index}
      entering={FadeInDown}
      exiting={FadeOutUp}
      style={[textStyles, { color: textColors[index] }]}>
      {items[index]}
    </Animated.Text>
  );
};

export default TextCycler

Document Store Database - MongoDB (Part 3)

Nyasha (Nash) Nziramasanga — Fri, 17 Jul 2020 06:11:41 +0000

Continuing from part 2

Document store database technology will be the primary focus after understanding how NoSQL databases work. A definition of document stores will explore the mechanisms that make it different from other NoSQL storage techniques. This will be followed by a list of characteristics and concluded by studying the most popular document database software in use MongoDB.

What is a Document Store?

Document Store, also known as a document-oriented database store, is used to retrieve and store data in NoSQL databases as documents similar to JSON (JavaScript Object Notation) objects. They have similarities with key-value stores when storing data where a document contains pairs of fields and values. Below is an example of a MongoDB stored document which is very similar to a JSON object, this semi-structured format makes it easy for developers to work with.

Example of a coding boot camp document on a MongoDB database server:

Key-Value pairs in a MongoDB document:

Collection of 3 documents:

Characteristics of Document Stores

Below are the main characteristics found on NoSQL document store databases:

JSON-like - Stores all information of an object in a single instance similar to a JSON Object in the database
CRUD Operations - Supports Create, Read, Update and Delete operations
Lookup - Extracts documents based on a unique key or identifier
Data Retrieval - Can use an API or query language to retrieve documents based on the content
Organisation – Documents can be organised in a variety of ways for instance as Collections which are a group of documents, Tags which are additional data outside document and Directory hierarchies which are groups of documents organised in a tree-like structure
Schema-less - Does not have to adhere to a predefined schema
Key-value - Uses key-value pairs in documents

MongoDB

MongoDB is a cross-platform, open-source, schema-free NoSQL database developed using C++ in 2007 by 10gen and is now known as MongoDB Inc. Prominent users of MongoDB include start-up rides hailing services Uber and Lyft.

Database Structure

MongoDB databases reside on a MongoDB Server which can have multiple database instances. A database has collections which contain one or more documents. Figure 4 below illustrates a MongoDB database structure; In the figure below, the customer database has a collection of usernames and courses documents. The “_id” field is a primary key, a unique identifier type named ObjectId which is created by the application when the document is created.

Database – Instance of a MongoDB database on a server
Collections – Group of documents
Documents – Records as JSON objects known as BSON (Binary JSON) a serialized MongoDB format

Features

Indexing - Fields in documents are indexed by primary or secondary indices.
Replication - High availability through replication sets with read and writes done on the primary replica when a primary replica fails a secondary replica is elected to be primary.
Aggregation - An operation that computes results, MongoDB offers 3 types of aggregation pipeline, the map-reduce function and single-purpose aggregation method. The example below uses the count operation as the aggregate to find all books where the author is Tom Ford

Transaction - Supports ACID transactions.
Server-Side Execution - JavaScript can be used for querying, aggregation and sent directly to the database for execution.
Sharding (Load Balancing) - MongoDB uses sharding to scale horizontally, sharding is the process of breaking up large tables into smaller chunks called shards that are spread across multiple servers (S.Choudhury, 2019).
BSON Format - BSON is a JSON like format which is binary encoded serialization used for storing documents in collections.
Ad hoc queries - MongoDB supports regular expression searches, field and range queries Example: Fetching all records from a customer table with employee name NASH.

Capped Collections - Fixed-size collections which will maintain insertion order
GridFS (File Storage) - Using MongoDB as a file storage system for storing files such as images and documents. File storage is managed by GridFS which is MongoDB’s way of storing files in a database, files are stored in binary chunks which are around 256k each.

MongoDB Management Service (MMS) - Web tool for managing and tracking databases and back-ups, this also includes performance and tracking hardware metrics.

Datatypes

The following data types in the table below are provided by MongoDB.

Data Type	Description
Date	Date and time
Array	List of objects E.g. [1,2,3]
Null	Missing fields
Object	BSON object
ObjectId	12 bytes long binary values as unique identifiers names “_id”
Character sequence types	Scalar types

Database Document Operations

MongoDB uses its own API to query data from a database, In the table below only the main CRUD operations will be examined namely Selection, Insert, Update and Delete.

Queries	Description	Query
Selection	Used to search for a document in a collection, the find operation is equivalent to WHERE clause in SQL.	Search for a book with the title Hello World `db.books.find({title:"Hello World"});`
Insert	Inserting a document into a collection using the insert operation, the save operation can also be used. MongoDB automatically appends a new primary key field “_id” to the new document	E.g. Save a book called DSAs `db.books.insert({title: "DSAs"});`
Updates	Updating a document in the database, the first argument specifies the selection criteria of the document to be selected and the second argument is the field to change. Uses update operation, however, there are more operations used for updating records such as updateOne, updateMany and findOneAndUpdate	E.g. Update book with id 1 to COMP3771 `db.books.update({"_id":1},{"title":"DSAs"});`
Delete	The remove operation is used to delete a document based on the selection criteria, also findOneAndDelete operation can be used to delete a document	E.g. Delete a book with id 1 `db.books.remove({"_id:1"})`

Understanding Non-Relational (NoSQL) Databases (Part 1)

Nyasha (Nash) Nziramasanga — Fri, 17 Jul 2020 06:11:03 +0000

This article is a 3 part series around NoSQL to help understand the features and different types of Non-Relational (NoSQL) databases.

History of NoSQL Databases

Relational database model the foundation of RDBMSs (Relational Database Management Systems), was invented in 1970 by Edgar Codd a Computer Scientist working at IBM (E. Codd, 1970). Relational databases arrange structured data into rows and columns associated with a specific primary key for each row, it is also known as SQL (Structured Query Language). Popular SQL databases are Microsoft SQL Server, MySQL, and Oracle Database.

The term Non-Relational databases (NoSQL) was first termed in 1998 for a relational database that didn’t use SQL (C. Strozzi, 2007), and was picked up in 2009 at conferences promoting NoSQL such as the NoSQL meetup in San Francisco organised by Jon Oskarsson a Last.FM developer. Erik Evans a blogger and Rackspace employee made the NoSQL term popular and described the ambitious movement as “The whole point of seeking alternatives is that you need to solve a problem that relational databases are a bad fit for” (E. Evans, May 2009).

Eric identified a few shortcomings with RDBMSs that needed to be addressed due to the challenges faced when handling sizeable amounts of unstructured data, which was growing exponentially because of the rise of social media platforms such as Facebook. This is where NoSQL came in to handle unstructured big data efficiently to maximise business value and bring customer satisfaction.

What are NoSQL Databases

A Non-Relational Database is a database technology that does not incorporate Relational Database Management Systems (RDBMS) strict rules of modelling structured data as tables, rows, and columns. They are also known as NoSQL databases and have risen in importance because of the rise of Big Data which refers to large, diverse sets of unstructured data that grow at an ever-increasing rate (T. Segal, July 2019).

NoSQL databases refer to a broad class of non-relational databases namely key-value, wide-column, document and graph databases which use Application Programming Interfaces (APIs) to provide Create, Read Update, and Delete (CRUD) access, unlike classical RDBMSs which uses SQL as the primary query language.

Benefits of NoSQL Databases

Below are the benefits of using NoSQL databases over RDBMSs:

High Scalability

NoSQL Databases handles partitioning (sharding) of data across several servers enabling horizontal scaling as data storage requirements grow. Compared to RDBMSs which vertically scale by upgrading to more powerful thus expensive hardware as demand grows.

Lower Cost

NoSQL Databases are designed to use cheap commodity server clusters for the management and storage of data. On the other hand, RDBMSs use expensive storage systems and patented servers.

No Complex Relationships

NoSQL databases support their own access language through APIs to interpret the data being stored which gives developers flexibility in data access, rather than using SQL to make multiple complex table joins on RDBMSs.

Unstructured Data

Unstructured data brings flexibility and rich interleaved information web which can be used for advanced searching and data analysis.

Higher Throughput

Some NoSQL databases have higher data throughput compared to traditional RDBMSs, for example, Googles Bigtable (column-store Hypertable) allows Zvents search engine to store one billion data cells per day (J. Doug April 23, 2008).

Issues of NoSQL Databases

Security Issues

NoSQL database face considerable security issues such as being vulnerable to SQL Injection, Lack of encryption during client-server communication and unable to use external encryption tools like LDAP and Kerberos.

Lack of Standardisation

Database designs and query languages of NoSQL databases vary between different software vendors and services, this presents a learning curve when learning multiple NoSQL database structures and queries.

New Technology

NoSQL is new compared to traditional RDBMSs with lesser support and adoption by larger organisations such as banks.

[Part 2] Types of NoSQL Data Storages

[Part 3] Document Store Database - MongoDB

Types of NoSQL Data Storages (Part 2)

Nyasha (Nash) Nziramasanga — Thu, 16 Jul 2020 12:26:07 +0000

Continuing from part 1

Characteristics of NoSQL data storage

Often Open Source
Non-Relational (NoSQL)
Schema-less
Horizontally scalable
Uses BASE consistency

Types of NoSQL Data Storages

NoSQL uses different data stores to optimise for specific purposes based on the system requirements, below in Table 4 there are 4 categories of NoSQL data stores and examples of vendor software offerings:

1. Key-Value Store

Store data (a value) and apply a label to it (a key) and store it in either in-memory or storage system optimised for fast data retrieval. Used for caching objects in applications.

Example: Redis

2. Document Store

Designed for storage, retrieval, and managing of document-oriented information. Document stores save all information of an object as an instance in the database, instead of spreading data amongst different tables as with relations databases.

Example: MongoDB

3. Wide Column Store

Uses tables, rows and dynamic columns, different to relational databases as each row does not require the same column allowing for horizontal scaling of the database a use case is storing user profiles

Example: Cassandra

4. Graph Database

Stores data as nodes and edges. Nodes store the object data and Edges stores information on the relationship of the nodes. Used to traverse relationships and patterns in data use cases are social networks, artificial intelligence, and a recommendation engine.

Example: Neo4j

The following table below shows the types of NoSQL databases and features associated with them:

Type	Performance	Scalability	Flexibility	Complexity
Document Store	High	Variable	High	Low
Column Store	High	High	Moderate
Low Kev-value Store	High	High	High	High
Graph-based	Variable	Variable	High	High

[Part 1] Understanding Non-Relational (NoSQL) Databases (Part 1)

[Part 3] Document Store Database - MongoDB

What I learned as a Junior Software Developer at a startup

Nyasha (Nash) Nziramasanga — Sun, 22 Mar 2020 22:57:56 +0000

Hello 👋🏿, I'm a Software Developer specializing in Javascript (JS) mainly the MERN Stack (Mongo DB, Express.js, React.js, Node.js). I just hit my 1-year junior dev anniversary and thought of sharing my experience in the industry.

Here is what I learned after 1 good year junior deving at a startup:

1. 📖 Continuous learning

The startup was mainly a Javascript house, which I had very little experience with since I worked with PHP in my final year internship. However, I was up for the challenge to learn Javascript from the ground up. After a month, I slowly fell in love with the MERN Stack and with how it works and became pretty good after 3 months. It used to take me a day (6 - 8 hours) just to spin up an API with CRUD (Create, Read, Update and Delete) functionality, now it takes me less than an hour depending on the functionality.

The key takeaway was to be hungry and willing to learn a new tech stack and get obsessed with it so much that you become a beast 💪 at it.

MERN Stack - is a javascript web development framework consisting of MongoDB, ExpressJS, ReactJS, and NodeJS for building web apps.

2. 🏎️💨 High-velocity

Being in a start-up, I carried so many responsibilities. One day I could be doing customer service, the other consulting or software deving. I found this challenging at first since all I wanted to do was be a software dev. I soon realized that's the nature of startups they "pivot" a lot and your skills pivot along with it, especially to keep clients happy and engaged.

3. 🤝 Expectation management

Managing expectations was probably the hardest part for me since I thought I could code the shit out of anything. I later realized that when working on a project the easiest part is actually coding/building the feature or app service, the hardest part was accounting and managing all the unforeseen hurdles like changing business priorities, external factors, etc.

The best way we got around this as a team was through using Trello, daily stand up meetings and bi-weekly sprint planning sessions to visualize all the projects in progress and manage priorities accordingly.

4. 👨‍👨‍👦 Dev Team

The dev team was probably the best part, everyone was always willing to help and share their knowledge. I learned so much from everyone and we all had a good time pair programming which was amazing in sharing skills and hyper-productive. We also went to dev meetups and events around Melbourne mostly the Junior Dev Melbourne events.

Overall, it was a great first year as a software developer and I feel more confident in taking on larger, challenging projects and working with great devs to make better software for all.