Hello there, and Happy 2020!
At RisingStack, besides working on consulting and outsourced development projects, we're actively training engineering teams as well, ranging in size from 5 to 25 ppl at a time.
You might already know that we have 2-days-long training agendas for
These training opportunities are regularly popping up in major European cities, and are also available for companies who'd like to train their engineers on-site, wherever that may be.
In December we prepared a new, 5-days-long training agenda for engineering teams who'd like to dive deep into React and Node, but have little to none experience with these technologies.
Below you can read the full training agenda for the Node training, and you can also check out the 5-days-long React Training Agenda in another blogpost.
I'll get back to you within 24 hrs.
This Node.js training is for developers who:
- Want to learn how to bootstrap and design scalable software solutions.
- Want to create and develop production ready Node.js applications.
- Want to create complex and maintainable web APIs.
The goal of the training is to
- teach how to bootstrap and design scalable software solutions with Node.
- teach how to create complex and maintainable web APIs.
- teach modern application development best-practices & methods.
- teach relevant production-ready techniques like testing, debugging, logging
and monitoring with the most efficient tools.
- Basic programming knowledge is needed, but any experience with PHP, .NET or Java is sufficient.
- This training schedule is delivered throughout 5 days.
- The training relies heavily on hands-on exercises. During the training, we're building a social networking site.
Full Node.js Training Agenda
- Node.js Basics
- Setting Up a Project
- The npm module system
- API Design
- Database Handling
- Queues and Workers
- Getting ready for production
- Performance tuning Node.js applications
- Memory profiling Node.js applications
- Async programming basics
- The advantage of promises and async-await over callbacks
- Arrow functions and their relation to
- ES6 and beyond
2. Node.js Basics
You will learn the basics of Node.js and when to use it. We will cover async programming patterns, events, streams, and the Node.js process model for concurrent programming. We will also cover the most important Node.js modules.
- The strange way Node.js handles streams, and why they are important
- Understanding the most important built-in modules:
3. Setting Up a Project
We’ll layout the standard project used in Node.js projects, and the role of index.js files discuss the role of environmental variables and how to manage them with dotenv. We’ll also discuss the 12-factor app principles to make sure everyone is on the same page regarding modern web development best practices.
- 12-factor app: commandments of modern web development
- Handling configuration with environment variables in Node.js
- Standard project structure
- The power and caveats of using index.js files
4. The npm module system
We will cover how to use npm and npm scripts and how to set up a basic project. We’ll also take a look at the npm registry and the module system’s relation to how the require function works, and what to expect from .mjs modules.
- Understanding npm:
- The difference between common.js and mjs modules
- The difference between import statements and the require function
5. API Design
You will learn how the main differences between the most used routing libraries: express, koa, fastify, and the built-in http module. Using the most relevant for the group, we’ll also learn how to design an API skeleton, which can be filled with logic later.
- API design
- Too many choices, why and how to choose between built-in http, express, koa, and restify
- Creating an API skeleton with the most relevant package
You will learn how to fetch data from other APIs using the built-in http module and the most used library simply called “request” through the OpenStreetMap project.
- Using external APIs: our first real-life asynchronous use-case
- Using built-in http and the industry-standard request package
7. Database Handling
- Handling data models in Node.js for SQL and / or MongoDB
- Using the most common modules for SQL: sequelize and knex
- Using the most common modules for MongoDB: the mongo driver and mongoose
8. Queues and Workers
We will create a worker process and learn how to connect it to the API with messaging queues. After that, we will learn how to create jobs and how to schedule them.
- Handling long-running tasks in Node.js: worker processes
- Interfacing with messaging queues
- The many ways and pitfalls of writing scheduled jobs
You will learn how to create and manage sessions with Redis and how to use JWT tokens.
- Session handling: understanding Passport.js
- Using Redis for session storage
- Getting rid of external DBs: using JWT tokens in Node.js
We will cover unit testing and mocking with mocha, chai, and sinon and compare it to jest. After that, we will write end-to-end tests.
- Understanding the two most common test frameworks: mocha and jest
- Writing proper assertions and expectations with chai and jest
- Unit testing: the art of mocking with sinon and jest
- End to end testing
- Reporters: compliance with enterprise standard tooling
11. Getting ready for production
Writing the business logic consists of the majority of a Node developer’s tasks, but debugging applications that are not prepared properly for production eat up most of their time. To evade these problems, we’ll learn the necessary best practices regarding logging, caching, application lifecycle, and health checking in Node.js apps.
- Logging with pino and winston
- Caching in Redis
- Handling application lifecycle and graceful shutdowns
- Health checking best practices
While console.log-s might be enough in many cases, knowing how to use the inspector is a necessary skill for all Node.js developers. We also might need to debug applications in a staging environment, so we’ll learn how to attach debugger sessions to remote processes.
- The difference between the debugger and inspector
- Using the inspector locally
- Debugging on staging: attaching remote sessions
13. Performance tuning Node.js applications
Our job is still not over when the application is out in production. While premature optimization is the root of all evil, measurement-based optimization tuning is necessary in many cases to reduce costs or ensure the stability of our application.
- CPU profiling and how to read them
- Common overlooked optimization opportunities
- Premature optimizations and how to avoid them
14. Memory profiling Node.js applications
Hunting memory leaks can be elusive. Heapdumps tend to be too cryptic to understand easily. To give a better understanding on how to analyze memory usage, we’ll cover some actual case studies. We’ll also learn how to use the current swiss army management of performance and memory usage analyzation: Node clinic.
- Memory heap dump analysis
- Swiss army knife of performance and memory analysis: Node clinic
- Solving real-life memory leak issues from previous projects