Feeling unproductive as project increases in complexity...

Let me tell you what is going on.

3 years ago I started working on a startup, there where only 3 developers on the team. We only did HTML, CSS and a little bit of PHP and javascript. Things where fine back then I could jump into any part of a project and get things done. We ended up being very successful and in order to grow we had to keep doing the same things but at a faster pace so we had to create a new solution. So our boss decided to create a new project that could enables us to expand.

This new project was the same as before but it allowed us to automate a lot of things. The project was meant to test the waters before creating a real solution. React had just came out and I was introduced to react+ redux and a lot of new JS related concepts. This project ended up being successful as well.

Now we are working on the "real" project, which was supposed to be released 1 year ago, and it's still no sign if us releasing it. There are bugs everywhere, the architecture is highly complex, and I'm really struggling.

I am constantly running into situations where I just don't understand the codebase due to how fragmented and complex it is.

I think one of the reasons is that we have adopted a functional programming by using "ramda" as the unspoken standard, and there are a lot of files being used together to compose functions

Here is an example of what 1 function can look like. Now imagine someone composing this function with 3 or 4 other ones that look like this. It quickly becomes very hard to understand what is going on.

R.converge(
    R.compose(
      R.filter(R.compose(R.not, R.isNil)),
      R.zipObj(['example', 'example', 'example', 'example', 'example']),
      R.unapply(R.identity),
    ),
    [
      R.prop('example'),
      R.prop('example'),
      R.prop('example'),
      R.ifElse(
        R.propSatisfies(R.compose(R.not, R.isNil), 'example'),
        R.compose(R.map(Element.serialize), R.prop('example')),
        R.always(undefined),
      ),
      R.ifElse(
        R.propSatisfies(R.compose(R.not, R.isNil), 'example'),
        R.compose(R.map(example), R.prop('example')),
        R.always(undefined),
      ),
    ]
  ),
};

A lot of times this is what I have to work with, and I am having such a hard time backtracking these composable functions. I feel as if I'm not able to contribute as much as I used to , and it's frustrating to have to struggle with this.

I think I should let my boss know that I am not trying to be slow on purpose. That I am struggling and It's taking me longer to get things done. At the same time I'm also considering just quitting because I feel as if the codebase is beyond me and It's just going to keep getting worse.

If anyone has run into this situation please leave your comments below..