The Lightbulb Moment

So here we are, the decision to pursue a startup.

I've been wanting to do this for a while now, always with the same lingering questions running through my mind - 

• "Do I know enough to even do it?"

• "What if someone has already taken my idea?"

• "Will this idea even work?"

• "Have I done enough analysis to test the feasibility of this idea?"

• "Will this make money?"

• "Where do I begin?"

For me, that last point has always been the biggest stumbling block, how does one even begin to build something like a startup?

Motivations -

Progressing along in your professional career, you slowly start to learn more about yourself and the driving forces that get you out of bed every day. 

Being in the technology sector, we're constantly involved in discussions about the most successful startups, Facebook, Twitter, Instagram, WhatsApp, just to name a few. It's ingrained in our minds in such a way that makes us believe that we could be sitting on the next billion dollar idea. 

I'd have to admit that the idea of being the "next big thing" is certainly one of the motivating reasons to go on this journey, but surprisingly it isn't my primary reason to do so. 

I remember watching a YC Startup School presentation from Chase Adam of Watsi (video here) that I found to be really inspiring. Watsi by the way is a non-profit that utilises crowd sourcing to fund medical treatments for those in need by using a 100% donation model. 

The inspiring part of it is that Watsi leverages the power of technology to change the game in terms of how fundraising is achieved. It's not about the fame or fortune, its about making a positive difference in the world. 

Watching the video made me want to pursue a similar goal, to do something you truly enjoy and make a difference in peoples lives.

What Now? -

I started bouncing some ideas around friends, colleagues and even my university professors and I received some really constructive feedback. Being from Melbourne, the tech scene is still not as big as Silicon Valley but in saying so it still presents an excellent opportunity to build something local, testing it then expanding it out. 

Even with the feedback, I was still stuck on what to do next. Having an idea is one thing but turning it into a product or service is a completely different thing altogether. I got a little bogged down in the details of what to do and from that I became a little deflated, it almost seemed as though I wasn't progressing with this, still stuck on the start line.

There's probably a conventional way of trying to build a startup, having an idea, a team, a business plan etc, but at some point it is a matter of just going ahead and doing it. I do can all the planning the world but it isn't going to get me to where I want to be if I don't start building it. 

What's Next? -

This is most probably the wrong way to go about it, but at the moment the aim is to build a prototype over the next two months and go from there. Currently its a one man show but I do hope that this can change over time. 

This will definitely be hard but whats life without the challenges. I'm sure there will be more failures than successes but you can neither succeed nor fail at what you do if you don't give it a shot. 

I am open to any pieces of advice, everything from here on out will be a learning process.

So here we go...

Links -

• Watsi

• Chase Adam At Startup School 2013 

• Paul Graham of YC - How to Start a Startup

Deleting from a Doubly Linked List

Note - The code examples used in this post are located at my GitHub account - Doubly Linked Lists

In the past couple of posts we've covered the process of searching and inserting items into a doubly linked list. This post will cover the last of the three basic operations on doubly linked lists, deletion.

Since there is no way to directly access items in a doubly linked list like we can with an array, deleting an item involves the following steps. 

1. Search through the list to find the node we want to remove (if it exists). 
2. Connect the predecessor of the found node to the next of found node. 

Step 2 is important as if we do not complete this step then we would have two separate lists since we would have removed the connecting node.

Inserting into a Doubly Linked List

Note - The code examples used in this post are located at my GitHub account - Doubly Linked Lists.

Previously we covered the algorithm for recursively searching through a doubly linked list. It provided a detailed insight into how to traverse through a linked structure and to find and return items within it. 

Searching is an important functionality of a doubly linked list, however without any content to search for, it doesn't really do much. In this post, we'll cover the insertion algorithm so that we can start putting items into our doubly linked list and search for them. 

Doubly Linked Lists (Searching)

Note - The code examples used in this post are located at my GitHub account - Doubly Linked Lists

A doubly linked list is another example of a linked structure. As with single linked lists, it also comprises of a group of nodes connected together in a chain to form the list. 

The nodes in a doubly linked list contain the following properties -

1. The data field(s) - each node can contain any number of data fields.
2. Pointer to next - each node contains a pointer to the successor node in the list.
3. Pointer to previous - each node contains a pointer to its predecessor node in the list. 

The doubly linked list gets its name from the number of pointers that each node has. With the two pointers, each node knows about both its successor and predecessor.

Figure 1 - Doubly Linked List Structure.

Combining Single Linked List Operations (Object Orientated Implementation)

Note - The code examples used in this post are located at my GitHub account - OO Single Linked List

Over the past few posts, we've described and shown the implementation of the three basic linked list operations. Each post covered an operation (searching, insertion and deletion) with code individually detailing how it was performed without interference from the others.

Now that we know about all three operations and how they work, the last thing to do is to combine them all so we can make a properly functioning single linked list. 

If you were following through the code examples, you would have noticed that the language chosen for the implementation was Java, so it'd be fitting that we also utilise some OO (Object Orientated) concepts when we combine the operations together.

Deleting from a Single Linked List

Note - The code examples used in this post are located at my GitHub account - Single Linked Lists

In the past couple of posts we've covered the process of searching and inserting items into a single linked list. Now we're onto the last of the three basic operations of a single linked list, deletion.

Because we cannot directly access items in a single linked list like we can with an array, deleting an item from a single linked list involves the following steps - 

1. Finding the node in the list containing the item we want to remove. (If it exists)
2. Find the predecessor of the node we want to remove such that it can be re-coupled to the successor of the node. 
3. Linking the predecessor node with the successor node of the node we wish to remove.

Step 2 is particularly important as without performing the step, we will end up with two lists. 

If we think of our linked list as a line of coupled train carriages, if we remove one, we'll need to re-couple the carriages on either side of the one we removed to connect the train together again, otherwise we'll have unconnected carriages that will go nowhere when the train departs.

An illustration of what we want to try to achieve with deletion is shown below - 

Figure 1 - Deleting the node "Dave" from our linked list. 

Note - The dotted lines represent the operation that we want to achieve, which in this instance is to connect nodes "Jerry" and "Stuart" together since we want to remove "Dave". 

From Figure 1, the general idea is to link the incoming (predecessor) arrow with the outgoing (successor) arrow for the node that we want to remove. 

Inserting into a Single Linked List

Note - The code examples used in this post are located at my GitHub account - Single Linked Lists

We have previously covered the process of performing a search on a single linked list. In that post, we used a pre-constructed list to provide the basis of our search operation.  Whilst that demonstrated how to go about searching through a single linked list, it didn't shed much light on how we could build our own lists from scratch. In this post, we'll cover the second of the three basic operations of a single linked list, insertion.