Svetlin Nakov's Blog, page 3

Software Engineering Overview – Free Video Lesson

I am happy to announce my free video lesson on software engineering fundamentals, which I recently published in YouTube as part of my “Dev Concepts” series. In this lesson I make an overview of software engineering concepts like software development lifecycle, software quality assurance, unit testing, source control systems, and project trackers. Each concept is essential for your development as a software engineer. You should have a basic knowledge of each area because they are daily used in the software industry. Even if the technologies differ, the concept is still the same, only some details change over the time, like the tools we use.

Software Development Lifecycle (SDLC)

The software development lifecycle (SDLC) describes the activities that every software projects goes through, like gather requirements, design, develop, test, deploy and maintain the software.

Software Development Lifecycle Diagram

As shown in the diagram, the software engineering activities are split into different stages:

Requirement analysis – the senior members of the team or the project analysts gather information from the customer. This information is then used to plan the basic project approach and to conduct a product feasibility study in the economical, operational, and technical areas.Defining requirements – then the team should clearly define and document the product requirements and get them approved by the customer or the market analysts. The most important output from this step is the UI prototype: the app screens, which developers should implement.Designing architecture – a design approach clearly defines all the modules of the product along with its communication and data flow representation. The internal design should be clearly defined with even the minutest of the details.Building and developing – in this stage, the actual development starts, and the product is built. This is when programmers write and debug their code. If the design is performed in a detailed and organized manner, coding can be accomplished without much hassle.Testing the product – in this stage, developers and QA engineers test for defects and deficiencies. The issues found are fixed until the product meets the original specifications.Deployment – at this stage, the goal is to deploy the software (e.g. in a cloud environment / on a dedicated hosting / in the app store) so users can start using the product. However, many organizations choose to move the product through different deployment environments, such as a testing or staging environment.Maintenance – the final phase of the software development lifecycle occurs after the product is in full operation. Maintenance can include software upgrades, repairs, and fixes if it breaks. Customers often demand new features for the software application, which the developing team needs to add.Software Quality Assurance (QA)

Software Quality Assurance (QA) is a term that covers all aspects of guaranteeing a high-quality software product or system. It includes creating processes for each stage of development to reduce bugs and flaws during the build. Companies need it to measure the quality of the software.

At the heart of the QA process is software testing. That is the process of checking whether the software conforms to the requirements and works as expected. Software testing aims to find the bugs (or defects) in the software and to report them for fixing. Software testing can be manual or automated.

Manual testing also involves testing the user experience (UX), the user interface, and the visual look and feel of the software.Automated testing is done by scripts and programs, which perform robotic checks of the software.

In addition to testing, there are a few other approaches to software quality assurance, such as code reviews, quality inspections, and issue tracking.

Software Quality Assurance is a must in Software Development as it ensures your software is built efficiently and is finished with minimal flaws and bugs. Without it, Software Development could be quite unreliable, with products potentially requiring complete do-overs.

Unit Testing

Unit testing is an important concept and practice in software development. As a term, unit tests are pieces of code that test specific functionality in a certain software component. Usually, they are not written by QA engineers but from the developers who wrote the code. Unit tests are part of the product source code and aim to improve the code quality, reliability, and maintainability.

Unit testing frameworks simplify, structure, and organize the unit testing process. It executes the test and generates reports. The developers organize tests in a hierarchy using classes and functions. After that is done, they assert the execution result and exit all conditions for correctness. Examples of unit testing frameworks are: JUnit for Java and Mocha for JavaScript.

Unit test developers usually follow the “AAA pattern“. It stands for:

arrange the input data and entrance conditionsact – execute the function for testingassert whether the results and the exit conditions are as expected

In the arrange section, you have the code required for setting up the specific test. Here is where we create objects and potentially set expectations. Then there is the act, which should be the invocation of the method being tested. In the assert, you would check whether the expectations are met.

By implementing unit testing, it’s easier to catch and fix issues early before they cost extra time and money. We should aim to write unit tests that focus solely on a single unit of code. With having more test reports, it will be easy to find the error in our code.

Source Control Systems

Source Control Systems (like SVN and Git) aim to keep the source code and other project assets in a shared repository. The information there is available through the Internet or in a local environment. The team that works on the specific repository can clone, pull, commit, and push the local changes. If there are conflicting changes, they can fix and merge them in the end. If the developers have a problem with a specific commit, they can compare different versions of the same file and restore previous versions.

Git is the most popular source control system in modern software development. It is a powerful tool for version control and team collaboration at the source code level. In the above video, I explain briefly Git and GitHub by showing a few examples. First, I clone the repository, edit a local file, commit the local changes, and then publish the commit.

Project Trackers

Project Trackers are a simple tools designed to manage and track the project plan and schedule, to assign, arrange, track, and visualize project tasks. Trackers are an important concept in software project management in general. Each task may have a description, sub-tasks, assigned people, deadline, and other fields.

Most project trackers visualize and organize the work on the project with Kanban boards. A Kanban board is an agile project management tool designed to help visualize work limits, the work in progress, and maximize team efficiency. In general, it uses cards arranged in columns. Each card describes a task to be done or an issue to be handled. In general, it uses cards arranged in columns. Each card describes a task to be done or an issue to be handled.

Typically columns on the Kanban board are:

Backlog – tasks waiting to be started. Usually, the tasks staying upper in the backlog have higher priority.In-Progress – this column holds the tasks that are currently taken by the team.Done – this is a collection of already completed tasks.

That process of work can be defined as “agile“. It means that tasks and their priorities change regularly, but everyone in the teams always knows the progress, and which task to do next. Teams that use project management apps typically track more than one project at a time. The software helps them figure out when to schedule work based on when things need to get done and the human resources available to do them.

Conclusion

All of these concepts are important for your future development as a software engineer. Each topic can be separated into a course and studied in detail. Even if you are indifferent to all the concepts, you should know at least the basics about each topic. In almost every interview for a software developer, you will be asked if you are familiar with these areas. Each software company uses different technologies, but the concepts behind them are similar.

How to Make Your Own Flappy Bird Game in Unity and C#?

In this video, our friend Niki Lubomirov will show you how to create a “Flappy Bird” game using Unity and C#. This practical video tutorial is short, but informative and demonstrates how to build the game from the start to the end, step-by-step, with all the code and actions in Unity. I call this “step-by-step project tutorial“. It is recommended for people who know how to code, but need to gain more experience in creating end-to-end software projects. Enjoy.

Unity is, essentially, a well-rounded game engine that truly does simplify game development. While there may be better engines to choose from, learning Unity will only help you grow as a game developer.

Getting Started

For this project, we are using the 2020.3 LTS table release. To create this project you will need to have Unity and Unity Hub installed. You can download them from https://unity3d.com/get-unity/download. To get the completed project, you can download it from GitHub: https://github.com/SoftUni/Flappy-Bird-Demo.

First, we open the Unity Hub and Create a 2D Project.We create a Sprites folder in the game directory, and we import all the needed images for the game.After we import the needed images, you can see that you have more than one bird. We slice it save it in a new folder called Animations.We set it on the scheme, we can start the application and see if the bird will fall.Script for the BirdWhat we need to do next is create a script for our bird. We create a Bird.cs file in the Assets/Scripts folder. We create methods for the Bird to fly and set boundaries so it cannot fly outside our screen.using System;using UnityEngine;public class Bird : MonoBehaviour{ [SerializeField] private Rigidbody2D _rigidbody; [SerializeField] private float _force; [SerializeField] private float _yBound; private void Update() { if (Input.GetMouseButtonDown(0) && _rigidbody.position.y < _yBound) { Flap(); } } private void Flap() { _rigidbody.velocity = Vector2.zero; _rigidbody.AddForce(Vector2.up * _force); }}Now we need to create pipes. We create Upper and Lower pipes. If the bird hits them the game will be over.MovingObjectAfter we are done we create a MovingObject infinity runner. We need to constantly move the objects to the left. The speed increased by one, for every second that passes. We set boundaries for when the object is destroyed. We attach the script to the pipe. We can check if our scripts work.using UnityEngine;public class MovingObject : MonoBehaviour{ [SerializeField] private float _speed; [SerializeField] private float _xBound; private void Update() { this.transform.position -= Vector3.right * _speed * Time.deltaTime; if (this.transform.position.x < _xBound) { Destroy(this.gameObject); } }}Object SpawnerWe can move to the spawner script. We create the class in the same scripts folder. We need a prefab to be spawned, and a time interval arrange by 1 axis with a name – _yClamp. If enough time has elapsed, the object will spawn, and the elapsed time will reset.using System;using UnityEngine;public class Spawner : MonoBehaviour{ [SerializeField] private GameObject _prefab; [SerializeField] private float _time; [SerializeField] private float _yClamp; private float _elapsedTime; private void Update() { _elapsedTime += Time.deltaTime; if (_elapsedTime > _time) { SpawnObject(); _elapsedTime = 0f; } } private void SpawnObject() { float offsetY = UnityEngine.Random.Range(-_yClamp, _yClamp); Vector2 pos = new Vector2(this.transform.position.x, this.transform.position.y + offsetY); Instantiate(_prefab, pos, Quaternion.identity, this.transform); }}After we are done we can put the spawner into action.  We create a spawner to spawn pipes, evey 2 seconds in the y-axis.We add the functionality to the ground as well. If we hit play we can see the pipes and ground spawning infinitely.CollisionsIn our next step, we need to make the game end. We add events to the Bird inside the Bird.cs class. As a bonus you can add sounds for different events. With OnCollisionEnter2D, our bird dies and we freeze the time.[SerializeField] private AudioSource _audioSource;[SerializeField] private AudioClip _flapSound;[SerializeField] private AudioClip _hitSound;[SerializeField] private AudioClip _scoreSound;public static event Action OnDeath;private void OnCollisionEnter2D(){ OnDeath?.Invoke(); _audioSource.PlayOneShot(_hitSound); Time.timeScale = 0f;}private void Start(){ Time.timeScale = 1f;}Starting a New GameWe need to create a button, which starts our game.We use the Observer Design Pattern and it’s commonly used in game development.We create a new class called UIManager. In our class we add the following play button logic:[SerializeField] private GameObject _playButton;[SerializeField] private TMP_Text _score;private void Awake(){ Bird.OnDeath += OnGameOver;}private void OnDestroy(){ Bird.OnDeath -= OnGameOver;}public void RestartGame() => SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex);private void OnGameOver() => _playButton.SetActive(true);Adding ScoreWhat we need to do is create a text mesh for the score on our screen. In the Bird class, we add functionality so that the score will change. The OnTrigger event will trigger and play a sound.public static event Action OnScore;private void OnTriggerEnter2D(){ OnScore?.Invoke(); _audioSource.PlayOneShot(_scoreSound);}In the UI Manager we also need to add the functionality for the score. Each time the bird passes a pipe depending on the state we will get Awake() or OnDestroy() event. We increment the current number of the score when the score increases.private void Awake(){ Bird.OnDeath += OnGameOver; Bird.OnScore += OnScore;}private void OnDestroy(){ Bird.OnDeath -= OnGameOver; Bird.OnScore -= OnScore;}private void OnScore() => _score.text = (int.Parse(_score.text) + 1).ToString();Final Words

If we followed all the steps as shown in the video tutorial, our project should be working. What you learned in this tutorial will work for most of your projects in any engine. Unity‘s pipeline is smooth, yet complex. Unity is, simply put, the world’s most popular game engine. It packs a lot of features together and is flexible enough to make almost any game you can imagine. Unity packs tools for 2D and 3D game development.

Where to Go Next?

Learn more at SoftUni Global: https://softuni.org/project-tutorials/how-to-make-our-own-flappy-bird-in-unity.

My Free Java Foundations Full Course: 30 Hours Video Tutorial + 55 Hands-On Exercises

I am happy to publish my Free Java Foundations Full Course (30 hours video tutorial + 74 hands-on exercises). This course is designed as next step after the “Java Basics” free course. It will help you learn the core of programming with Java, using a practical, hands-on approach. In this free Java programming course I teach the fundamentals of Java programming, from the basics to the advanced features: data types, arrays, methods, lists, strings, maps, lambda expressions and stream API, classes and objects, object-oriented programming principles, exception handling and some Java APIs.

The ultimate goal of the course is to prepare students for the official Java Foundation certification from Oracle. After the course, when you solve the hand-on exercises, you will get practical skills in coding and Java programming foundations, which will allow you to learn modern Java technologies and start a tech job after that. This course is not enough to start a job as Java developer, but gives you a solid foundation for the software engineering profession.

Access the free Java coding video lessons, practical hands-on assignments, the course slides, and the automated code grading system for your exercise solutions from the SoftUni Global website:

Java Foundations Certification: Full Course (30-Hour Free Video Tutorial + 55 Exercises)

All the topics from my Java Foundations course are essential to your further development as a software engineer. So, make sure to solve the hands-on exercises in addition to watching the video lessons. Software companies need practical skills, not just knowledge, so you should focus on the hands-on exercises if you want to become a Java developer. If you have no prior programming experience, first watch my Programming Basics with Java course.

Video Tutorial: Java Foundations Certification

Watch my free 30-hours Java Foundations video course on YouTube:

Java Foundations Certification Course (Part 1 of 3): Java Syntax, Conditions, Loops, Data Types, Arrays, and MethodsJava Foundations Certification Course (Part 2 of 3): Lists, Strings, Maps, Lambda, Stream API, Classes, and ObjectsJava Foundations Certification Course (Part 3 of 3): Defining Classes, OOP, Principles, Exceptions, and Basic Java APIsCourse Instructors

This course is designed and created by me (Svetlin Nakov) and is taught by me and my colleague George Georgiev.

Svetlin Nakov

I am an experienced tech trainer who helped in the last 20 years more than one hundred thousand young people to begin coding, learn software development, and start a tech job. Learn more from my personal web site: https://nakov.com/about.

George Georgiev

George Georgiev, an experienced programming instructor, is a senior Java developer and an award winner.

Learn By Doing: Learn to Code by Coding Exercises and Projects

This free Java Foundations video course teaches skills, not just theory. Each course section comes with carefully prepared hands-on practical exercises, where you write code to solve practical problems, run and test your solutions, maybe make bugs, fix them, and test your code over and over until it finally works properly. My entire course provides more than 50 exercises, with automated grading in the SoftUni Judge System.

Remember that coding is a skill, and should be practiced, just like any other skill. Write code to learn the skill of coding! Write code every day for 1-2 years, and you will get enough experience to start your first developer job.

Automated Grading System for Your Code

To check your solutions to the practical hands-on exercises from this course, I give you a free access to SoftUni’s automated Judge System, where you send your Java code, and you get an automated grading: the Judge System tells you whether your solution is correct or wrong. That is quite useful. Try it, and you will love it!

I will show you how to solve many coding problems. Follow my guidelines and sample solutions and write them. Try to solve the additional exercise problems as well. Write code, play with it, experiment, make bugs and imperfections, fix them, write code, do it many times! That is how you acquire coding skills in practice.

Spend Enough Time on the Exercises!

Do not skip the coding exercises at the end of each course section! They are much more important than video lessons. They give you the practical skills you need for your next tech job.

If you are serious about programming, take this course with all its exercises. You should invest about 60 or maybe 70 hours. Yes, this is a lot of time, but learning programming takes time! Just like learning math. Do you remember how many hours you spent at school learning it?

Ask the Mentors for Free

In case that you have a question or difficulty solving some of the exercise problems, or you have a bug, and you do not know how to fix it, I and my team are here to help.

Join the SoftUni community at softuni.org and ask for free help from our mentors. Yes, you can ask anything about this training, and you’ll get a free answer! At SoftUni, we value our community and we are always open to help.

At SoftUni, we have answered hundred of thousands of questions already and we helped tens of thousands of students to learn to code and start a tech job. See their profiles at the SoftUni alumni page on LinkedIn: https://www.linkedin.com/school/software-university-softuni/people.

This Course is Just a Start in Your Java Journey

This course is just a start in Java programming. To become a software engineer and start a tech job, you should learn and practice programming 10-15 times more than what I give you in this course. It takes time and effort to build the skills for your first IT job, so be patient and keep coding for a long time (1-2 years until your first developer job).

To become a junior Java developer, you should learn advanced coding, data structures and algorithms, object-oriented programming, databases, and object-relational persistence frameworks, such as Hibernate and Spring Data, backend development, MVC frameworks, and enterprise technologies, such as Spring Boot, Spring MVC, and Java EE, as well as basic front-end skills, such as HTML, CSS, JavaScript, REST and AJAX. That is what the software companies expect from you as a junior Java developer. It takes time to get practical skills and experience with all these concepts and technologies, along with a solid GitHub portfolio of Java projects.

If someone says that a beginner can learn to program and start a job in 3 or 5 months, do not believe him. That is unlikely to happen. You better study slowly and thoroughly. The effort will pay off.

Java Foundations Certification: Course Topics

This free Java Foundations Certification course covers the following topics from Java programming:

Basic Syntax, Conditions and Loops in JavaJava Data Types, Variables and ExpressionsArrays in JavaMethods, Parameters, Return ValueLists in Java: Using ArrayListStrings and Text Processing in JavaMaps, Lambda Functions and Java Stream APIObjects and Classes in JavaDefining Classes: Fields, Constructors. Accessors, MethodsOOP Principles: Encapsulation, Inheritance, Abstraction and PolymorphismException Handling in JavaJava API Classes: Time, Random, Big NumbersJDK, JRE and Java Tools

This is the detailed course content of my free Java Foundations course:

Lesson #0: The Judge System (Automatic Grading for Your Code)

Before I start with the course topics, I will show you the SoftUni Judge System, where you can check your exercise solutions instantly, for free.

SoftUni Judge is an automated system for code evaluation. Just send your code solution for a coding problem from this course, and the system will tell you whether your solution is correct or not and what exactly is missing or wrong. I am sure you will love the Judge System once you start using it!

Lesson #1: Basic Syntax, Conditions, Loops

In the first course lesson, I explain some of the fundamental concepts in programming. For example – I will review how to use data types, variables, conditional statements, and loops. Also, I will show how to debug our code and see where it fails. Read more here.

Lesson #2: Data Types and Variables

In the next lesson, I will talk about variables and data types (such as string, integer number, floating-point number, boolean, and others). I will show how variables are stored in the memory, how to convert from one data type to another, etc. Read more here.

Lesson #3: Arrays

In the next course lesson, I will show how to read an array from the console, process arrays, use the for-each loop, print arrays, and simple array algorithms. Build a strong foundation of knowledge in Java programming by learning them. Read more here.

Lesson #4: Methods

This lesson reviews another main paradigm in the programming universe: methods. I will show a few ways to make our code more organized and readable. Also, I will explain how to extend the functionality of our code. Read more here.

Lesson #5: Lists

In this next lesson, I will talk about Lists. They are one of the most popular data structures in programming, as they allow for flexibility. Unlike arrays, their length is not fixed, and you can insert and delete elements at any point. Read more here.

Lesson #6: Strings and Text Processing

This lesson introduces strings and provides an in-depth explanation of text processing in Java. It includes several important topics surrounding strings – the StringBuilder class, concatenation and why it’s a slow operation, the methods concat(), indexOf(), contains(), split(), replace(), and many more. Read more here.

Lesson #7: Maps, Lambda and Stream API

In this lesson, I explain maps, lambda, and the stream API. All of these three topics are extremely important for every beginner programmer. They are part of the pillars of programming, just like the rest of the topics in the current course. Read more here.

Lesson #8: Objects and Classes

With this lesson, you will make your first steps in the world of Object-Oriented Programming (OOP), which is one of the most widely-used programming paradigms in modern programming. By the end of the lesson, you will be familiar with the objects and classes and their purpose. You will also know the different class members: methods, constructors, getters and setters, fields, etc. Read more here.

Lesson #9: Defining Classes

In this next lesson, I will go over the topics of defining simple classes, conventions, and best practices in doing so, creating objects of these classes, object references, and what is the difference between an object and a class. Read more here.

Lesson #10: OOP Principles

This lesson explains another main part of programming. I will talk about and explain the four pillars of Object-Oriented Programming (OOP). They are encapsulation, abstraction, inheritance and polymorphism, . Read more here.

Lesson #11: Exception Handling

In this lesson I explain exception handling and why it’s important in software engineering. Exceptions simplify code construction, maintain and allow problematic situations to be processed at multiple levels. In Java, exceptions are objects. The base for all exceptions is the Throwable class – it contains information about the cause of the exception, its description, and the stack trace. Read more, here.

Lesson #12: API Classes

In the next lesson, I show the most frequently used Java API classes. Get familiar with the Math class, how to generate random numbers, the need for BigInteger and BigDecimal in programming, and how to work with the date and time in Java. I will also look at two of the main Java classes – Arrays and Formatter. Read more here.

Lesson #13: JDK, JRE and Java Tools

This is an extra lesson in the course, in which I explain and demonstrate with live code examples the concepts of JDK, JRE, JVM, the command-line compilation tools in Java, the Java compiler javac, class files and JAR archive, the concept of “classpath” and how to deal with all these technologies and tools.

Coding Exercises: The Most Important Part of This Course!

The essential part of this practical Java training is the hands-on exercises: the homework assignments after each course section. This course provides more than 50 exercises, with automated grading in the SoftUni Judge System. You should spend about 30 hours of coding to solve them. Yes, this is a serious effort, but it will pay off.

Remember that the only way you can get practical skills is by practice. Write code and solve exercises. Watching video lessons can be pleasant and motivational, but you will never become a software developer by only watching videos. It is a good start, but it’s not enough.

Please, follow the exercises: solve the practical problems and send your solutions to the Judge System for grading. You have more than 50 exercises to solve. Most of them are already solved in the video lessons, but the others are intentionally left for you.

Join the SoftUni Global Lerarn-to-Code Community!

In case that you have a question or difficulty solving some of the exercise problems, or you have a bug, and you do not know how to fix it, we are here to help.

Join the SoftUni community at softuni.org and ask for free help from our mentors. You can ask anything about this training, and you’ll get a free answer! At SoftUni, we have already helped hundreds of thousands of students to learn to code. See their profiles at SoftUni alumni at LinkedIn.

Join the SoftUni global learn-to-code community at softuni.org to get free access to the practical exercises and the automated Judge System for this course. Get free help from mentors and meet other learners. It is all for free!

SoftUni Community

My most successful teaching methodology is “learn by doing“. Write code, run the code, test the code, make mistakes, fix them, run and test again, finally submit your code to the Judge System. That is how you learn coding: by practice.

Subscribe to My YouTube Channel

Do you like this Java Foundations Certification free programming course? Do you want more? Subscribe to my YouTube channel to stay in touch with my free coding courses, lessons, and tutorials:

Code with Nakov @ YouTube

Object-Oriented Programming (OOP) – Basic Concepts

I published a new video lesson for beginners, where I explain the concepts of the object-oriented programming (OOP) with live code examples. The video is short, but is very informative and explains the OOP principles in a clear and easy to understand way, briefly, concisely, and in simple words. Learn about objects, classes, interfaces and inheritance in this short video with code examples in C# and JavaScript:

What Is Object-Oriented Programming?

OOP Overview – Video LessonWhat Shall You Learn about OOP From This Lesson?

In this lesson I briefly explain and demonstrate the concept of OOP (the object-oriented programming), which is basically the concept of using classes and objects to model the real world in your programming language.

I explain the concepts of classes (which define the structure for the objects), data fields (which hold data) and properties (which provide access the data fields), and the concept of object state, as well as the actions, defined in the classes (which in OOP are called methods).

I show some live coding examples in C# and JavaScript where I define a class, instantiate objects from this class, and access the object’s data and call the methods of the object.

Later, I explain the concepts of inheritance, interfaces and abstract classes in OOP and provide a real-world example. I define an abstract class with an abstract method in it and inherit this base class into two child classes, where I override the inherited abstract methods to provide a specific implementation. Finally, I demonstrate how to use these abstract class and the child classes derived from it.

Object-Oriented Programming (OOP)

Object-oriented programming (OOP) is the concept of using classes and objects to model the real world.

Classes are sets of data fields, together with methods (which are functionality to interact with the data fields and other objects). Classes define the structure of information objects: the data they holds and the operation they can perform.Objects are instances of the classes, holding certain values in their data fields.

Let’s look at this simple example of class definition:

class Rectangle { int width, height; int CalcArea() { return width * height; }}

The code above defines the class “Rectangle“, which holds two data fields: width and height (integer values). It defines a method, holding the code to calculate the area of the rectangle.

We can have several objects of this class “Rectangle“.

The first object is a rectangle of width 5 and height 6.Another object has width 6 and height 4.Some other object has width 7 and height 3.

We have one class “Rectangle” and 3 objects (or instances) of this class.

The class holds the definition (the specification, the model, the template) for the objects. It defines the data fields and methods and more details (in some cases). Classes don’t hold data. They hold data definitions and operation definitions. Objects hold values for the data fields in the class. Objects of class “Rectangle” hold data about certain rectangle. Objects are information structures, holding data.Typically, one class has multiple objects (or instances).

Classes and objects are the building blocks of the object-oriented programming (OOP) and they come together with some other OOP concepts like abstraction, interfaces, data encapsulation, inheritance, polymorphism and exception handling.

Examples of Classes and Objects in C# and JS

To demonstrate how classes and objects work in programming, I have prepared these examples in C# and JavaScript:

https://repl.it/@nakov/rectangle-oop-jshttps://repl.it/@nakov/rectangle-oop-cs

These examples demonstrate that in programming we can define classes, which model real-world entities. They hold data (properties) and operations, just like in the real world. Objects are instances of the class definition with certain data characteristics, just like objects in the real world.

Inheritance, Interfaces and Abstract Classes

Let’s continue with the concepts of inheritance, interfaces and abstract classes in the OOP, with a real-world example.

I can define an abstract class Figure with an abstract method calcArea() in it, and I can inherit this base class into two child classes (Circle and Rectangle), where I can override the inherited abstract method to provide a specific implementation for the area calculation. Finally, I can use this abstract class and the derived child classes as building block in my code.

Inheritance and interfaces are two other major concepts in the object-oriented programming.

Inheritance allows classes to inherit data and functionality from a parent class (also called “base class”). When a class inherits another class, the parent class fields are merged with the child class fields and they together form the set of data fields for the child class.Interfaces defines abstract actions. These are actions to be implemented in the descendent classes. Interfaces define a set of empty (or abstract) methods (or actions), which shall be obligatory implemented in the child classes. Interfaces are also called “contracts“, because they define certain set of functionalities, a contract to implement certain methods.

Abstract and concrete classes are quite important when we model the real-world with the concepts from OOP.

Abstract classes are used to model abstractions. For example, the class Figure is not a concrete figure like square or rectangle, but the concept or the abstraction of “figure”. Abstract classes defines data + actions (or normal methods) + abstract actions (or empty methods). Abstract classes are designed to be inherited (or extended).Concrete classes like Circle and Rectangle represent real entities, not abstractions. Concrete classes define data fields + concrete functionality (methods). They can implement interfaces and inherit abstract and other classes.Inheritance and Interfaces – Example

In this example I demonstrate abstract classes and concrete classes. This is an example of abstract class, which models an abstraction “Figure“:

abstract class Figure { int x, y; abstract int calcArea();}

The above code defines the base abstract class Rectangle with two data fields: x and y. It defines also an abstract action (or method) for calculating the area of the figure. This method is empty (or abstract), because it is specific to the concrete figure, like “circle” or “rectangle“. In the child (or descendent) classes this abstract action will become concrete, it will hold the code to calculate a circle area or rectangle area or other, depending on the concrete figure. This abstract class models the generic abstraction “Figure” and child classes will determine the type of the figure.

Please, don’t focus on the programming language. Focus on the OOP concepts now.

The abstract method calcArea() returns an integer value. It will be invoked by the child classes later.

This is an example of how we can define a child class “Circle”, which inherits from the abstract class “Figure”:

class Circle extends Figure { int radius; override int calcArea() => PI * radius * radius; }

The above class inherits the fields “x” and “y” from “Figure” and appends an additional field “radius“. This way the child class has 3 fields: two inherited from the parent class and one defined additionally. The class Circle defines a concrete implementation of the abstract method calcArea(), which calculates the circle area using the well-known formula from the school-level math.

This is an example definition of another child class “Rectangle”, which inherits from the same base class Figure:

class Rectangle extends Figure { int width, height; override int calcArea() => width * height; }

The “Rectangle” class defines two additional fields: width and height. It provides different concrete implementation of the calcArea() abstract method, which calculates the rectangle area.

This is a very good example of abstract and concrete classes. Abstract classes model common (or generic) data and functionality, and concrete classes model concrete entities and concrete implementations of the abstract actions from the parent class.

Note that the programming languages doesn’t matter for this examples. This configuration of parent class + child classes demonstrates an important concept from the object-oriented programming, which we shall learn in detail later. This example illustrates two main object-oriented programming concepts: inheritance and polymorphism.

Examples of Inheritance in OOP

To demonstrate how to use interfaces, abstract classes and inheritance in OOP, I have prepared these examples in C# and JavaScript:

https://repl.it/@nakov/inheritance-oop-jshttps://repl.it/@nakov/inheritance-oop-cs

Play with them to learn the concept of inheritance.

Subscribe to My YouTube Channel

Do you like this free programming lesson? Do you want more? Subscribe to my YouTube channel to stay in touch with my free coding courses, lessons and tutorials:

Code with Nakov @ YouTubeJoin the “Learn to Code” Community

Join the SoftUni global learn-to-code community at softuni.org to get free access to the practical exercises and the automated judge system for this course. Get free help from mentors and meet other learners. It’s free!

SoftUni Community

Happy coding!

Functional Programming: Overview

I recently published a free video lesson about the concepts of functional programming, where I explained and demonstrated the functional programming paradigm. Learn more at softuni.org:

What is Functional Programming?

Functional programming (FP) is a style of programming based on composing pure functions, while avoiding shared state, mutable data, and side-effects. It’s important, because most modern mainstream programming languages (like JavaScript, Python, Java and C#) support the functional paradigm with lambda functions and higher-order functions.

In this lesson I explain and demonstrate through live coding examples in JavaScript, Python, Java and C# the concepts of functional programming, pure functions, first-class functions, lambda functions, higher-order functions, and how to combine these concepts to implement filtering, mapping, ordering and other transformations over sequences of elements.

Functional Programming Overview: Video LessonWhat is Functional Programming?

Functional programming (FP) is programming based on composing pure functions, while avoiding shared state, mutable data, and side-effects. Functional programs are sequences of transformations of data through functions. In pure functional programming functions and programs don’t have state, which means that functions do not hold shared data. They only access their input arguments and return an output. I will give some examples in the video.

Functional programming is declarative programing approach (not imperative), which means that instead of describing an algorithm how to do something step by step, functional developers describe the result by functions and compositions of functions.

The program state flows through pure functions, where one function passes its output data as input to other function.

Pure Functions

What is a “pure function“? It is a function, which returns a value only determined by its input, without side effects. Printing something at the console or storing something in a database are examples of side effects. Therefore, using pure functional programming is often impractical.

Modern languages use elements of functional-style programming and are not purely functional.

Examples of pure functions are: the square root function: “sqrt of x“, which takes a number as input and returns another number as output, and the function “sort of list“, which takes a list as input and returns a new list as output. Both functions have no side effects: they don’t change anything; they don’t read or write external data; and they do not use state. They are pure functions.

Pure functions are the heart of the functional programming. Using “pure functions” means maintaining “consistent results“. If you invoke a pure function many times with the same input data, it will have the same consistent behavior and will return the same result, because it have no state and no interaction with the external data or components. Pure functions produce predictable results and behavior and sometimes their correctness can be mathematically proven.

This is the most important principle in functional programming: to build programs by composition of stateless pure functions without side effects.

Functional Languages

Purely functional languages (like Haskell) are unpractical for most real-world projects and are rarely used.

Modern programming languages are much more practical, so they implement the functional paradigm, along with other paradigms like structured programming and object-oriented programming.

There are many functional programming languages and languages that incorporate functional paradigms into modern software development. Most modern languages are not functional, but support concepts for functional programming.

Purely Functional Languages

Purely functional languages are unpractical and rarely used, because it is more complicated to program without maintaining a state. Purely functional developers need to switch their thinking style from the traditional “algorithmic thinking” to “functional thinking“. The program in the purely functional languages is a pure function (which calls other pure functions) without side effects. An example of purely functional language is Haskell, which is not widely used in practice, but it has a great value in learning the functional programming paradigms.

Impure Functional Languages

Impure functional languages are used more often because they allow exceptions from the concept of “pure functions” and simplify the work of developers. These languages emphasize the functional style but sometimes allow side effects.

An example of impure functional language is Clojure. It is not very popular in practical software development.

Multi-Paradigm Languages

Multi-paradigm languages combine the strengths of both the functional and the algorithmic (or imperative) world. Most of today’s widely used general-purpose programming languages are multi-paradigm. They combine multiple programing paradigms: functional programming, declarative programming, structured programming, imperative programming, object-oriented programming, component-based programming, event-driven programming, asynchronous programming, and many others.

Examples of popular general-purpose multi-paradigm programming languages are: JavaScript, C#, Python, Java, PHP, C++, Go, Swift and TypeScript.

All these languages combine multiple concepts and paradigms for structuring the program to simplify the work of developers and improve their efficiency and performance.

The Functional Paradigm in Action

This is an example, which demonstrates the functional style of programming, compared to the traditional imperative (or structured) programming style. We want to write a C# program to read several numbers, find the biggest of them and print it.

Functional Style Example in C#

To solve this problem in a functional style, we can write the following code:

Console.WriteLine( Console.ReadLine() .Split(" ") .Select(int.Parse) .Max());Imperative Style Example in C#

Now, let’s see the equivalent imperative style for the same program, again in C#. This is a piece of code, written in a structured programming style (procedural style). It consists of sequence of commands and each command takes its input from a variable, calculates a new result and stores it in a variable:

var input = Console.ReadLine();var items = input.Split(" ");var nums = items.Select(int.Parse);var maxNum = nums.Max();Console.WriteLine(maxNum);Functional Programming – Live Demo

We can see the code from the previous examples in action:

https://repl.it/@nakov/functional-max-num-cshttps://repl.it/@nakov/imperative-max-num-csLambda Functions

In programming, lambda functions are short expressions that transform an input into an output.

Lambda functions are typically used as arguments to other functions, and this is supported by most modern programming languages. For example, a sorting function may accept as a parameter a lambda function, which implements the comparison between two objects.

For better understanding this concept, let’s see some examples of lambda functions in JavaScript, Java, Python and C#.

The first example is a lambda function in C#:

x => 2 * x

The next example is a lambda function in JavaScript:

x => 2 * x

The next example is a lambda function in Python:

lambda x: 2 * xFirst-Class Functions

JavaScript, Python, C# and Java support “first-class functions“. This concept means that functions can be stored in variables and can be passed as arguments to other functions. These languages support expressions of type “function”, which hold programming logic to transform some input into some output.

Lambda functions are the simplest way to write an expression of type “function”. Once we have a variable, which holds a function, we can invoke it. Let’s review some examples.

This example in JavaScript shows how to define a variable, which holds a lambda function as its value, and how to invoke it with certain argument:

let twice = x => 2 * x;let d = twice(5); // 10

The next example implements the same code in Python:

twice = lambda x: 2 * xd = twice(5) # 10

This is the same code in C#:

Func twice = x => 2 * x;var d = twice(5); // 10

The same code can be written in Java, and it looks very similar:

Function twice = x -> 2 * x;var d = twice.apply(5); // 10

First-class functions are an important concept in programming. They allow functions and methods to take other functions as arguments. And this is very powerful tool for many situations.

First-Class Functions – Live Demo

The following live demonstration illustrates how to use first-class functions in JavaScript:

https://repl.it/@nakov/first-class-function-jsHigher-Order Functions

Higher-order functions take other functions as arguments and thus they can implement abstract behavior. For example, an aggregation function may accept as an argument the aggregation operator (which is a lambda function).

Let’s see how this happens in action. We can create functions, which calculate something, but what exactly depends on their arguments.

Higher-Order Functions – Example

Let’s take an example: the function “aggregate“. It takes 3 parameters: start, end and func. The function aggregates the result from the given function over the numbers from start to end:

function aggregate(start, end, func) { for (var result = start, i = start+1; i <= end; i++) result = func(result, i); return result;}

For example, the above function can multiply the numbers from 1 to 10, or it can sum the numbers from 20 to 30.

In the body of the “aggregate” function we apply the function “func” many times in a loop, for the numbers from “start” to “end“. The start number, end number and the aggregation function come as arguments.

This function is a good example, which illustrates the power of “higher-order functions” in functional programming. The function “aggregate” accepts as parameter another function, which combines two values during the aggregation process.

Invoking a Higher-Order Functions – Example

This is an example how we can invoke this higher-order function: we sum the numbers from 1 to 10. The start argument is 1. The end argument is 10. The aggregation function is “a + b“. It sums its arguments:

aggregate(1, 10, (a, b) => a + b) // 55

This is an example how we can invoke the same higher-order function to multiply the numbers from 1 to 10:

aggregate(1, 10, (a, b) => a * b) // 3628800

This last example demonstrates how we can append together the numbers from 1 to 10, using the same higher-order function:

aggregate(1, 10, (a, b) => '' + a + b) // "12345678910"

The aggregation function here is different: it appends its arguments as text.

Invoking a Higher-Order Functions – Live Demo

This live code demonstration illustrates how to use higher-order functions in JavaScript. It holds the above examples:

https://repl.it/@nakov/higher-order-functions-jsSubscribe to My YouTube Channel

Do you like this free programming lesson? Do you want more? Subscribe to my YouTube channel to stay in touch with my free coding courses, lessons and tutorials:

Code with Nakov @ YouTubeJoin the “Learn to Code” Community

Join the SoftUni global learn-to-code community at softuni.org to get free access to the practical exercises and the automated judge system for this course. Get free help from mentors and meet other learners. It’s free!

SoftUni Community

Happy coding!

My Java Basics Full Course: Free 13 Hours Java Video Tutorial + 74 Hands-On Exercises

I am happy to publish my free Java coding basics course for absolute beginners in computer programming (13 hours video tutorial + 74 hands-on exercises). This is an excellent Java coding video tutorial, which gets deep into basic programming concepts, such as coding techniques, algorithmic thinking, problem solving and debugging.

Access the free Java coding video lessons, practical hands-on assignments, the course slides, and the automated code grading system for your exercise solutions here:

Java Basics: Full Course (13 Hours Free Video Tutorial + 74 Exercises)

This free Java programming course is designed for beginners who want to start with Java coding and find out if they like it. It covers the first steps in programming with Java:

Installing the Java development tools and development environmentWriting and running Java commands and simple programs in JavaReceiving input from the user and printing text and numbers to the userUsing data, operators and expressions to perform calculationsUsing the if-else and switch-case conditional statementsRepeating blocks of code using loops: for-loops, while-loops and do-while loopsWriting more complex control-flow logic, which combines loops, conditional statements, nested loops and nested conditionsVideo Tutorial: Java Basics

Watch my free 13-hours Java coding full video course in YouTube:

Full Java Basics Course (Part 1 of 2): Data, Calculations, Conditions, If-ElseFull Java Basics Course (Part 2 of 2): For Loops, While Loops, Nested LoopsCourse Instructor: Svetlin Nakov, PhD

I am Svetlin Nakov from SoftUni (the Software University), your Java coding instructor (LinkedIn: https://linkedin.com/in/nakov). I am an experienced tech trainer who helped in the last 20 years more than one hundred thousand young people to begin coding, learn software development and start a tech job. See the profiles of my graduates in LinkedIn: https://www.linkedin.com/school/software-university-softuni/people.

Just Google my name and you’ll find more about me, my programming books, software academies, conference talks and other teaching activities: https://www.google.com/search?q=Svetlin+Nakov.

More about me: Svetlin Nakov has 20+ years of technical background as software engineer, project manager, consultant, trainer, and digital entrepreneur with rich technical experience (back-end, Web development, information systems, databases, software engineering, cryptography, blockchain, C#, Java, JS, PHP, Python, front-end, HTML, CSS, JS frameworks). Svetlin Nakov is a regular speaker at hundreds of conferences, seminars, courses and other trainings and holds a PhD degree in computer science. He is author of 15 books about computer programming and software technologies, lives in Sofia, Bulgaria and works as an passionate trainer and inspirer at SoftUni.

Learn By Doing: Learn to Code by Coding Exercises and Projects

This free Java video course teaches skills, not just theory. Each course section comes with carefully prepared hand-on practical exercises, where you write code to solve practical problems, run and test your solutions, maybe make bugs, fix them, and test your code over and over until it finally works properly. The entire course provides more than 70 exercises, with automated grading in the SoftUni judge system.

Remember that coding is a skill, and it should be practiced, just like any other skill. Write code to learn the skill of coding!

Automated Grading System for Your Code

To check your solutions of the practical hands-on exercises from this course, I give you a free access to the SoftUni’s automated judge system, where you send your Java code, and you get automated grading: the judge tells you whether your solution is correct or wrong. This is quite useful. Try it and you will love it!

During the course lessons I will show you how to solve many coding problems. Follow my guidelines and sample solutions and write your own solutions. Try to solve the additional exercise problems as well. Write code, play with the code, experiment, make bugs and imperfections, fix them, write code, do it many times! This is how you acquire coding skills.

Spend Enough Time on the Exercises!

Don’t skip the coding exercises at the end of each course section! They are much more important than the video lessons. The exercises give you the practical skills, the skills needed for your next tech job.

If you are serious about programming, take this course with all its exercises. You should invest about 30 or maybe 40 hours. Yes, this is a lot of time, but learning programming takes time! Just like learning math. Did you remember how many hours you spent at school to learn the basics of math?

In case you have a question or difficulty solving some of the exercise problems, or you have a bug, and you don’t know how to fix it, we are here to help. Join the SoftUni community and ask our coding mentors for free anything about coding and particularly about this course and its practical exercises.

This Java Course is Just a Start

This course is just a start in Java programming. To become a software engineer and start a tech job, you should learn and practice programming 10-15 times more than what I give you in this course. It takes time and effort to build the skills for your first IT job, so be patient and keep coding for long time (1-2 years until your first developer job).

To become a junior Java developer, you should learn advanced coding, basic Java APIs, data structures and algorithms, object-oriented programming, databases and object-relational persistence frameworks, such as Hibernate and Spring Data, backend development, MVC frameworks and enterprise technologies, such as Spring Boot, Spring MVC and Java EE, as well as basic front-end skills, such as HTML, CSS, JavaScript, REST and AJAX. This is what the software companies expect from you as a junior Java developer. It takes time to get practical skills and experience with all these concepts and technologies, along with solid GitHub portfolio of Java projects.

If someone says that a beginner can learn programming and start a job in 3 or 5 months, don’t believe him. This is unlikely to happen. You better study slowly and thoroughly. The effort will pay off.

Free Help from Mentors

Join the SoftUni community at softuni.org and ask for free help from our mentors. Yes, you can ask anything about this training, and you’ll get a free answer! At SoftUni we already helped hundreds of thousands of students to learn coding. See their profiles at the SoftUni alumni page in LinkedIn: https://www.linkedin.com/school/software-university-softuni/people.

Java Basics: Course Topics

This practical free Java basics video course covers the following topics:

Java Coding: First Steps. The Java Language, IDE, Writing Java Programs and CommandsExpressions and Statements. Variables, Data Types, Operators and Expressions in Java. Console-Based Input and Output.Conditional Statements. Control-Flow Logic with the if-else Conditional StatementsAdvanced Conditional Statements. Nested and Complex if-else StatementsFor Loops in Java. Repeating Blocks of Code. Increasing a Variable from X to YWhile Loops. Repeating Code Blocks While a Condition Is True. Nested LoopsNested Loops. Using Loops Inside Other Loops. Implementing More Complex Control-Flow LogicThe Judge System: Automatic Grading for Your Code

Before the start, I will show you the SoftUni judge system, where you can check your exercise solutions instantly, for free.

SoftUni Judge is an automated system for code evaluation. Just send your code solution for certain coding problem from this course and the system will tell you whether your solution is correct or not and what exactly is missing or wrong. I am sure you will love the judge system, once you start using it!

Java Coding: First Steps

This section is the beginning of our journey with Java coding. I will explain you what Java is, the Java programming language, the Java platform, JDK, the Java runtime environment, what a compiler is, what an IDE (integrated development environment) is, and how to write simple Java programs in IntelliJ IDEA, a modern Java IDE. I will demonstrate you how to write, compile and run Java programs with several code examples.

As a homework assignment, you will have a few hands-on exercises: writing a few simple Java programs, such as what I demonstrated to you, and submitting your solutions to the judge system.

Expressions and Statements in Java

In the next course section, I will talk about variables and data types (such as string, integer number, floating-point number, boolean and others), statements (which define the commands in the programs), the most used arithmetic operators (like plus, minus, multiply, divide and remainder) and the expressions in Java (or how to combine operators with values to implement a calculation).

I explain and demonstrate how to implement a console-based input and output in Java. I will show you how to read user input, format and print output to the console, and how to read and print text and numbers. I will teach you how to use the java.util.Scanner class to read text and numbers and how to work with integers and decimal numbers.

As a homework assignment you will have several hands-on exercises related to reading some data from the standard input, performing simple calculations with them and printing the results in a certain format.

Conditional Statements

In the next section I will explain and demonstrate how to write simple if-else statements in Java. Conditional statements (like the if-else statement, the switch-case statement and few other statements in Java) check some condition and if it is true, they execute certain block of code, otherwise they execute another block of code. We shall see how they work in practice and after that, as usually, you will have homework assignments.

You will have several hands-on exercises related to reading some data, performing a check and printing a result, depending on the input data and the checks.

Advanced Conditional Statements

In the next section of the free Java coding basics course, it’s time to start writing more complex program logic. I will show you how to use complex conditions in your if-statements: how to use the logical OR, logical AND, and logical NOT operators, as well as brackets, to design more complex checks. Additionally, I will demonstrate you through examples, how to write nested if-else statements, and longer sequences of if-else-else-if-else constructions. Together we shall solve several practical problems.

As usually, you will have a homework assignment: to solve a few hand-on exercises, that combine complex and nested conditions for processing some input data and calculating and printing certain results.

For Loops in Java

In the next course section I will teach you how to use the for-loop statement in Java, in its basic form.

In programming loops are used to repeat a block of code many times, typically for each value in given range. For example, we can write a for loop, which increases the value of a variable x from 1 to 50 and prints the value of x at each step. You will see how to do this in action, and then practice with the hand-on exercises, which I have prepared for homework.

While Loops

In the next section I will explain the concept of while loops. While loops in Java allow code blocks to be repeated, as long as certain condition is true. Let’s see how this works in more detail.

As usually, I will explain the concepts to you through examples, then you’ll have homework exercises to practice your new skills from this topic.

Nested Loops

In the next course section I will talk about nested loops. In programming, loops can be nested. This means putting another loop in the body of a loop. We can have several nested loops: we can have a loop in another loop, which holds a third loop.

And nesting is natural in the real world. For example, a building can have many floors and each floor can have many rooms. In this way we nest the floors inside the building and the rooms on each floor. If we want to walk around the building and print each of its rooms on each of the floors, we must use nested loops.

You will see how the nested loops work in action and then solve some practical exercises that I will give you as a homework.

Coding Exercises: The Most Important Part of This Course!

The most essential part of this practical Java training are the hands-on exercises: the homework assignments after each course section. The entire course provides more than 70 exercises, with automated grading in the SoftUni judge system. You should spend about 30 hours of coding to solve them. Yes, this is a serious effort, but it will pay off.

Remember that the only way you get practical skills is by practice: by writing code, by solving exercises. Watching video lessons can be pleasant and motivational, but you will never become a software developer by only watching videos. It is a good start, but it’s not enough.

Please, follow the exercises: solve the practical problems and send your solutions to the judge system for grading. You have more than 70 exercises to solve. Most of them were already solved in the video lessons, but the others were intentionally left for you.

Get Free Mentorship Help

In case you have a question or difficulty solving some of the exercise problems, or you have a bug, and you don’t know how to fix it, we are here to help.

Join the SoftUni community at softuni.org and ask for free help from our mentors. You can ask anything about this training, and you’ll get a free answer! At SoftUni we already helped hundreds of thousands of students to learn coding. See their profiles at SoftUni alumni at LinkedIn.

Join the SoftUni global learn-to-code community at softuni.org to get free access to the practical exercises and the automated judge system for this course. Get free help from mentors and meet other learners. It’s free!

SoftUni Community

My most successful teaching methodology is “learn by doing“. Write code, run the code, test the code, make mistakes, fix them, run and test again, finally submit your code in the judge. This is how you learn coding: by practice.

Subscribe to My YouTube Channel

Do you like this Java basics free programming course? Do you want more? Subscribe to my YouTube channel to stay in touch with my free coding courses, lessons and tutorials:

Code with Nakov @ YouTube

I will continue publishing more Java code lessons, tutorials and full courses on programming and software technologies. I plan to publish a free Java certification course to prepare you for the “Java Foundations” official Oracle certificate.

Free Java Video Tutorial: Part 3 – Console-Based Input and Output

Today I published the third part of my free Java video tutorial with hands-on exercises. It covers the console-based input and output in Java: reading text and numbers using java.util.Scanner and printing text, numbers and formatted output using System.out.print(), System.out.println(), System.out.printf(). Learn more at softuni.org:

Java Tutorial – Part III – Input and Output

Watch the video tutorial in YouTube:

Subscribe to my YouTube channel to stay in touch:

Code with Nakov @ YouTube

I will continue publishing more code lessons on programming and software technologies.

Free Java Video Tutorial: Part 2 – Using Java IDE

I am happy to post my second code lesson in YouTube. This is the second part of my “Java tutorial” series of video lessons for absolute beginners:

Java Tutorial: Part 2 – IntelliJ IDEA

My plan for the next few weeks is to create an publish a tutorial of 10-15 free Java video lessons, which lay the foundation of programming in Java (Java coding, program logic, if-else, loops, basic data structures, arrays and lists, objects and classes). Then, I will continue with HTML, CSS and JavaScript. Meanwhile I will post free videos on some more advanced topics, such as databases, front-end and back-end technologies, cryptography, blockchain, as well as how to become a software engineer and start a tech job.

Subscribe to my YouTube channel to stay in touch:

Code with Nakov @ YouTube

I have further plans for my YouTube channel to invite guest speakers to cover interesting topics for developers, such as game development, DevOps, Linux, cloud technologies, machine learning, job interviews, agile development and many others.

Free Java Video Tutorial: Part 1 – Getting Started with Java

I am happy to announce that I am starting a free video tutorial for beginners in Java programming today:

Java Tutorial: Part 1 – Getting Started with Java Coding

This is a hand-on free training, with a plenty of practical coding exercises, which you solve and send for automated online grading. Try it! You learn coding by coding. Learn by doing: this is my proven educational concept, which helped me training 10K software engineers (see in LinkedIn).

Subscribe to my YouTube channel to stay in touch:

Code with Nakov @ YouTube

In the next few free Java video lessons from my tutorial I plan to cover the fundamentals of programming with Java: variables and data, writing control-flow logic (conditional statements and loops), basic data structures (arrays, lists and maps), working with objects and classes, troubleshooting and debugging the code, as well as basics of algorithmic thinking and problem solving.

SoftUni Global Learn to Code Community @ softuni.org

I am very happy to announce that SoftUni is now global. We are building a global learn-to-code community, which provides a free mentorship help for code learners, along with weekly code lessons with hands-on exercises, video tutorials, events for developers and other free learning resources. Come and join for free, learn coding, get help from our mentors and talk with other learners:

softuni.orgWhat is SoftUni Global Community?

SoftUni Global Community is an international community for people who learn coding, founded and supported by Svetlin Nakov (a famous software engineer and tech trainer) and SoftUni (the biggest tech education provider in South-East Europe).

The SoftUni global learn-to-code community provides high-quality learning resources for people who learn programming, free mentoring, community discussions, events and other resources. The community is based on the English language, which opens it up to people from all over the world.

At SoftUni we believe that learning in a groups, in a community, together with other learners, is quite more efficient and successful than learning alone. We believe in the power of communities and we guide our students from zero to their first developer job in a community-based environment. Now we expand globally with our free for anyone learn-to-code community.

Benefits for the Learn-to-Code Community Members

What people get from their free membership in the SoftUni Global Learn-To-Code Community?

High-quality learning resources for software development learners, available for free: coding tutorials, code lessons, hands-on exercises with automated grading, programming books, training courses and others.Weekly code lessons: free video tutorials with hand-on exercises, focusing on different topics and aspects of software development, such as programming languages, data structures and algorithms, software technologies, databases, web development, front-end technologies, back-end technologies, mobile development, machine learning and many others.Events for developers: inspirational and technical events for software engineers, with guests from big tech companies, who share their experience and advices about programming, software technologies and career development in the tech industry.Free help from mentors, who are experienced software engineers. Our team of technical trainers, coding mentors and software developers from SoftUni will be happy to answer your questions and guide you in your code learning process.Access to our free coding lessons and scheduled instructor-led courses, which build solid practical skills through high-quality teaching sessions, hands-on exercises and project-based learning experience, in groups, with mentors.My Code Lessons

My plans for the next few months are to record and publish a few series of free code lessons on different topics from computer programming and software development. I will start with a practical hands-on Java tutorial, which combines video lessons with practical exercises with automated grading. All lessons, videos and resources will be in English.

I truly believe that to learn coding, you should code. You should practice! The only way to become a software developer is by writing code, a lot of code, every day, for years! This is what I am teaching my students in the last 20 years: to learn by doing, to practice every day, to solve coding problems, to write projects, to make mistakes, to fix them, to test and debug the code, to rewrite the code when it goes in wrong direction, to practice, practice, practice!

Practical learning with hands-on exercises and real-world software projects: this is how I trained 10K software engineers at SoftUni (together with my colleagues) and how they have a tech job (see their profiles in LinkedIn).

My First Code Lesson: Java Tutorial – Part 1 – Getting Started

This is the first episode from my “Code Lessons” series. It is the first from my “Java Tutorial” series, where I want to teach newbies the basics of Java programming:

Unlike most video tutorials for developers in YouTube, my free coding lessons always include a practical hands-on experience – a practical skill building exercises, where learners write code and sole practical coding problems. Try my coding lessons and you will experience coding. For most exercises I have prepared an automated grading system (the SoftUni judge), which evaluates your code and tells you whether its correct or wrong. This saves a lot of time, especially when you are a beginner in coding. Try it, believe me, experience my code lessons. They are free for everyone.

My YouTube Channel: Code with Nakov

Subscribe to my YouTube channel “Code with Nakov“, where I post several times а week a new code lesson, technical talk, guest speaker session or live event on computer programming, software development and software technologies. Watch my free video lessons and programming tutorials and comment in the videos what do you like and what can be improved, propose new topics for video lessons, discuss and enjoy.

If you want to become a software developer, follow my code lessons and the practical hands-on exercises, coming with them. This is a good start that prepares you for mastering the software development profession, which requires significantly more efforts, and hard learning for a long time.

Soon I will announce my zero-to-job tech degree programs for absolute beginners in English, where I teach software engineering very seriously: from coding basics, loops, arrays and maps, through algorithmic thinking, problem solving and computer science concepts, to software technologies, databases, front-end and back-end and Web development.