Is my path correct?

As i have good knowledge of HTML5 and CSS including Bootstrap, transitions, and media queries, and also basic of Javascript (variables, loops, objects, arrays, functions).
I have some previous experience with graphic design, SEO, wordpress and SQL.
Now, can somoene tell me is the path that i’ve decided to take going to lead me to get a frontend job?
What should I remove, is there anything that i miss?

  1. YDKNJS books to read (and maybe Javascript: Wierd Parts)
  2. Mean stack (MongoDB, Express, Node.js, Angular)
  3. DOM Enlightenment
  4. FCC Backend
  5. JavaScript Design Patterns
  6. jQuery + AJAX + how to use API
  7. Angular course
  8. SASS
  9. Jasmine and Gulp
    Of course during learning i would love to make some projects with the things that i’ve learned.

For a frontend job the list you posted is fine, I’d focus on React instead of Angular.

1 Like

What makes React better than Angular in your opinion?

It has been trending like crazy these years, while Angular went under a complete revamp for v2, and v4 is coming this year.

I think Eloquent Javascript > YDKJS. The former seems better to come to after some experience and in any case, skips over a lot that EJS covers

Jasmine isn’t a bad choice, but be very flexible with which testing framework you choose. There aren’t a whole lot of great tutorials out there for testing and the few there are will differ in their tech stacks. Gulp is also good, but not necessarily resume worthy.

If you complete the front end certificate and study some computer science fundamentals (algorithms and data structures), you should be ready to start applying for junior positions at companies willing to invest in employee training. These are a little harder to come across and may pay less (in my experience, no data to back this up), but you can still expect much higher than minimum wage pay to start.

@p1xt has written the guides for job preparation. These are based on many years as a professional programmer and I would take them as gospel. Following any of these guides to the letter will get you places.

By algorithms do you mean picking up a book on known algorithms, learning them etc or doing algorithm challenges? Can you go into this a bit? How are each important, if at all? Thanks

It’s really good to practice with the algorithm challenges, on Free Code Camp and elsewhere, but I’m thinking in particular about algorithm analysis. This answers a question that we (web developers) take for granted - How do we tell if one algorithm is faster than another? It’s not about how much code is written, because modern compilers are really good at optimizing human-written code. We could benchmark two different algorithms, but getting two computers set up to race each other is harder than it sounds. There are background processes to account for, hardware has to be identical, and we need to come up with mock data. We would certainly be able to get a sense of which algorithm is faster, but not why. The most usable approach to finding the “speed” of an algorithm is by getting an abstract idea of how much work is done per element of data being processed.

Most of the algorithms introduced in introductory algorithm classes are about the most efficient way to deal with arrays of information. As an example, write an algorithm that will find a particular number in an array


The easiest solution is to start from the beginning and iterate through the array until the number is found. So, if we keep adding numbers to the array, how much more work needs to be done to find a number (in the worst case)? For this array, it’s after 15 iterations. If we add another 10 numbers, the worst case would go up to 25 iterations. Add another 100, the worst case is now 125. The work increases linearly with the number of inputs. We generalize this by saying the algorithm has a linear time complexity in the worst case, or use the shorthand notation, O(n) (Big-O of N). We can do better than this, though I won’t say how. A simple algorithm can search a sorted array in O(log n). What does that mean? If we have an array with 1,000,000 elements, then a linear search could take 1,000,000 iterations. The logarithmic algorithm would take 20 (rounding up). That’s a big deal. Imagine how long it’s taken for computer hardware speeds to increase by a factor of 50,000, yet we can do that with a fundamental understanding of algorithms.

For more info, check out the algorithm lessons in the guides above. It’s a difficult, wide ranging topic, but knowing even the basics will get you far.

Preparing this let’s say “schedule” I had in mind those prepared by @p1xt paths, however i found that some of theme are just in my opinion lectures to listen or such things, things that have little value in getting to know tools and getting experience with them. I have made a decision of Jasmine and Gulp just to have some knowledge of this sort of tools that might be usefull in future work, i don’t mind learning Grunt instead of Gulp or Mocha instead of Jasmine. What i would like to focus on is to get to know javascript at decent level and start learning those major frameworks React or Angular to choose, and some tools for testing, debugging (Jasmine etc:.)
By now i have more or less half of lower-level alghoritms done (not only on FCC). I believe that book with JS patterns might be useful in this case.

function returnPosition(arrOfNums,num){
	var arr = arrOfNums.slice().sort((a,b) => a-b);
	function mid (){ return Math.round(arr.length / 2)}
	var i = 0;
	while (i < arr.length){
		if (arr.slice(mid())[0] === num) return arrOfNums.indexOf(arr.splice(mid())[0]);
		if (arr.slice(mid())[0] > num) arr.splice(mid());
		else arr.splice(0,mid());
	return num + " isn't located";

Yeah I’ve seen this kind of thing talked about a lot, where you rip the data in half. I just assumed that indexOf etc are the most optimal way to do things.

Do you have another example?

That example has the right idea, but there’s a much simpler way to do it without modifying the array. There are countless other examples, but I won’t explain them here. You can see lots of algorithms in action at VisuAlgo or some videos on YouTube.