DEV Community: Alex Yelenevych

Expert Guide on Trends in Software Development for Beginners

Alex Yelenevych — Thu, 02 Dec 2021 17:03:57 +0000

One problem that should be familiar to the majority of programming beginners who are looking to find their own path in the tech industry is the abundance of trends. The field’s boiling development constantly gives birth to dozens of new niches, technologies, and business models, which can be truly overwhelming.

And this problem isn’t simply rhetorical in nature, as feeling overwhelmed with options and possibilities makes choosing what to focus on when learning software development and which technology stack to pick as their main career specialization incredibly difficult.

Too many tech trends

Popular tech websites and developer communities aren’t always much of a help. Specialists love to debate about popular trends, advocating for those technologies and solutions they use or believe are superior. With all this informational noise out there, digesting it all to form your own opinion would take considerable time and effort.

So, we conducted a survey of well-known software development experts and industry influencers, asking them to share their opinions on the most popular software development trends and give some tips to programming beginners who are starting their careers in tech.

After all, as we said, developers like to talk and argue about trends. And everyone loves to give others advice. So, we managed to gather a lot of interesting insights and valuable tips.

Based on the results of insights we’ve got from the tech expert survey, as well as some input from our friendly and helpful user community, we put together a guide on current trends in the software development industry and areas of knowledge beginners in the field should prioritize.

Thanks to everyone who helped with answers and participation.

Tech industry trends

The experts we interviewed specified the number of general tech industry trends they consider to be the most significant and full of long-term potential.

1. AI and Machine Learning

Unsurprisingly, AI is number one on this list. Artificial intelligence is probably the most well-known tech trend of today. Even people who are far from the tech industry should’ve noticed how AI has turned from something specialized into an everyday technology that augments our devices, services, and websites.

AI keeps getting better and better at understanding what users want, as well as influencing their choices with more relevant ads and commercial offers. And it will keep trending in 2021 and beyond. All the technologies that are parts of the AI field, such as machine learning, deep learning, image recognition, speech recognition, and others will continue to evolve, becoming even more common and omnipresent in our daily lives.

Ken Fogel, Java expert, and Computer Science Technology Professor at Dawson College in Canada agrees that AI/ML is the top tech trend today: “If I needed to define one trend, I’d have to say AI/ML. I do not know if this will result in better software. What I do see is that in the general population of software users, I call them human beings, AI/ML is the buzz phrase that many believe will solve all our problems. Of course, it will not, but customers are clamoring, from what I read, for solutions that employ this technology.”

2. Big Data

Big data is another major technology trend that isn’t going away anytime soon. In fact, the opposite is true. The market shows an overwhelming demand for big data, and it keeps growing. By 2025, businesses are projected to create about 60 percent of all global data. Companies across various industries generate almost continuous streams of information and require technology solutions that can efficiently collect, store and use large amounts of data.

The demand for big-data professionals will keep growing in the coming years, creating countless opportunities. According to the U.S. Bureau of Labor Statistics, this field will grow about 27.9 percent through 2026. Some researchers predict that the most successful and well-paying jobs in the coming decade will be data-related.

“You might have heard that ’data is the new oil.’ That’s true. In particular, I would pay attention to data engineering, because for two reasons. One, it is booming. Two, there is a massive shortage of skilled data engineers. Except for data-related jobs, another huge trend is developing in the cloud, which is an increasingly popular option for many companies,” said Karolina Sowinska, an experienced software developer, and tech industry influencer.

3. SaaS and PaaS

Many development experts consider SaaS and PaaS models, as well as microservices, to be extremely promising. Even better, these models are also open to developers specializing in different programming languages. As interaction takes place according to REST, which is a de facto standard, the specific language you use isn’t very important, whether Java or Python.

4. Cloud computing

Even though cloud computing was a hot, new trend around a decade ago, it still deserves a spot on this list. It’s become a common and important part of software functioning processes.

Today, people use cloud services all the time without even realizing it, from booking hotels online to ordering food delivery to check for new posts on social networks. Businesses all around the globe are increasingly adopting cloud computing as it allows them to reduce costs and make their products more accessible to consumers. So, cloud computing is another major niche that will see rising demand for highly qualified experts in the coming years.

5. Mobile development

Mobile development is a market that will, without a doubt, keep growing at an accelerating pace for several reasons. The upcoming deployment of Starlink, a global satellite system that should bring high-speed broadband internet access to areas where it used to be poorly accessible, is one. If the system is deployed as planned, more people will be able to access the Internet on their phones worldwide, which will accelerate the mobile development market. According to a report by IDC, Android-based smartphones had almost 85 percent of the global market in 2020. Since Java and Kotlin are the two main languages in Android development, the demand for developers coding in these languages will remain consistently high and may even rise in the coming years.

Software development and Java trends

Software development itself has no shortage of interesting trends and innovative technologies our experts suggest keeping an eye on as well.

Here are five major trends that we perceive to be the most important ones. This is true for software development in general, but we focused particularly on the Java ecosystem.

1. Functional programming

Many of the software development experts we surveyed pointed to functional programming as one of the major trends with potentially big futures ahead. Even though the concept of functional programming has been around for a while, its popularity has started to flourish again. Functional programming is also a great fit for many other accelerating fields such as global web services and parallel computing, allowing developers to deal with many current problems in software development a lot more effectively.

2. Microservices

With flexibility as one of the most important requirements today, microservices will also be a booming trend. These allow engineering teams to reduce development costs, testing complexity, and development time. Using microservices, however, increases the infrastructural complexity of systems. And the consequence of that is the growing demand for DevOps professionals, which is also a field of specialization that is worth attention for beginners.

3. GraalVM Native Image

The rise of GraalVM Native Image, which allows you to compile Java code to a standalone executable application and does not require a JVM and accompanying libraries for its work, is another interesting trend. And it serves as a great addition to the microservice architecture and serverless approach, allowing developers to create self-contained executable images that can run incredibly fast.

4. Spring framework

Even though Spring is the most popular Java framework in the world, its ever-evolving ecosystem means that it’s still a trending topic. Project Reactor and r2dbc, which were originally subprojects of Spring, are examples of how the Spring ecosystem gives birth to new technologies and approaches.

“I’d recommend paying attention to frameworks and technologies that are on the rise within that field. Try them out yourself, understand why people are switching to them, and if it makes sense for you, learn them yourself,” said Masha Zvereva, an entrepreneur and the founder of the Coding Blonde blog.

5. Java and its new features

Of course, Java itself, with all its ever-developing ecosystem, remains relevant, despite the language being almost 26 years old now. Thanks largely to the six-month new release cycle, Java is walking in step with the times and acquiring new features that make this language even more applicable for various tasks and projects across industries and suggest a bright future for Java and Java-based technologies for years to come.

Many powerful features were introduced to Java in versions 14 and 15, including sealed classes, records, text blocks, and hidden classes.

Erik Hellman, mobile programming expert and the author of Android Programming: Pushing the Limits, who was one of the experts participating in our survey, recommends that you should also take a look at asynchronous programming.

“Asynchronous programming, in general, is something everyone struggles with. Regardless of programming language, this is a concept that is crucial to understand. Other trends are functional programming, declarative UI, and basic Machine Learning. Tools every developer needs to grasp are Docker, Git, and all the keyboard shortcuts in the code editor you’re using,” he said.

Everlasting trend: never stop learning and start with basics

But we should also bring to your attention that the majority of experts that we have interviewed underlined that learning fundamentals of programming and computer science, in general, is much more crucial than trying to follow the right trend, if you’re willing to have a successful career in software development.

Here are a few notable quotes.

“Learn to manage innovation and changing requirements..”

This is advice from Markus Eisele, Java Champion and founder of JavaLand. “Our industry is constantly reinventing itself. We went from mainframes to pizza-style Intel servers to the cloud. We had bash scripts, continuous integration, and now GitHub actions. Investing time to understand the core concepts behind the technology we are using is crucial to stay relevant. Always aching to use the latest and greatest technology is not. Think about the functional and non-functional requirements that exist and map them to the technologies you think could be a good fit. Our toolbox grew massively over the last decade and it will continue to do so. Learn to manage innovation and changing requirements as part of your technology portfolio,” recommends Markus.

“In the long run, those programmers who truly understand the basics will be in higher demand..”

Lukas Eder, famous Java and SQL expert, has the same stance: “While following the latest and greatest seems tempting, I think in the long run, those programmers who truly understand the basics will be in higher demand than the ones that followed marketing. This includes learning data structures and algorithms (no need to be an expert, but understand them). Learn the relational model, normalization, SQL. Learn about programming paradigms including imperative, object-oriented, functional programming. Learn a few different programming languages to appreciate the differences and ecosystems,” recommends Lukas.

“Fear of missing out is there even when you are a senior..”

“In times when there are more JavaScript frameworks than days in a year, it might be daunting to start learning and to know what exactly you should focus on. The FOMO (fear of missing out) is there even when you are a senior. There is no way to know everything in our industry. Focus on the fundamentals first and make sure you have a solid base. These are skills like problem-solving, algorithms and data structures, etc. When you have solid fundamentals, it is going to be pretty easy to pick any new trend that there might be,” added his five cents Vadim Savin, an experienced full-stack developer and programming blogger.

“Pick something you enjoy. Then explore all of it..”

And don’t forget to enjoy, reminds us Filip Grebowski, an experienced software engineer and the author of a popular programming tutorials channel on YouTube: “Once you learn the fundamentals, it’s important to pick something you enjoy, whether it is frontend, backend, or more specifically a tech stack that you enjoy. Then explore all of it. Dive into the latest advancements and stay on top of the game. That’s how you will become the best in what you do.”

Conclusion

Learning the fundamentals is the everlasting trend in programming and the key to achieving long-term success in this field. Even following the industry and where it’s going certainly is advisable as well, and can help you better position yourself as a specialist on the software development job market.

If we had to extract one key piece of advice that virtually all our experts have for programming beginners, it would be quite predictable, we’re afraid. It’s to never stop learning all the way throughout your career, as accumulating knowledge is the natural state of a good developer. We at CodeGym couldn’t agree with this more and hope that this information will help you to make the right choices and avoid some traps along this road.

First published at CodeX.

Common behavioral mistakes of novice programmers and how to avoid them

Alex Yelenevych — Wed, 24 Nov 2021 12:56:55 +0000

The mistakes of novice programmers, those who are just learning or just starting to work, are very similar to each other. Many of them can be called not mistakes, but behavioral features, stages all beginners go through. We as Java course creators are interested in this topic, so we interviewed opinion leaders and collected the most common, in their view, examples of such behavioral errors in order to … shorten their duration for future software developers. If you start noticing such behavioral mistakes early and try to fix them, your path to mastery will be shorter and your work will be more efficient.

Using wrong tools

The most common mistake everyone can observe among people starting programming is using the wrong tools, or not using the tools correctly. Sometimes they choose tools but ignore the task they need to solve with it. They heard something in advertising, or read reviews. Complete beginners are sometimes afraid to expand their toolbox. They can stubbornly ignore Git, the basics of which can be learned very quickly, use the first code editor they come across, an outdated IDE, the wrong framework, and so on.

“One example I’ve seen a few times is when beginners are not aware of VCS tools like Git, but instead use something like DropBox to store their code.”, Erik Hellman, Freelance Software Developer, said, “I have also seen beginners use MS Word for writing code, which can be quite funny to watch.”

Ignoring debugging

This mistake, of course, is a part of the previous point. A debugger is a tool too after all. Nevertheless, given the importance of this point and the fact that the debugging process is an important and valuable skill for any programmer, we took it out separately.

So … You work with statically typed languages like Java, C++, etc. Hence, there isn’t much to say here other than debugging your code! Try it right after writing your first programs. This is an extremely healthy habit and a must in your work. Moreover, at the time of starting your very first work, it is desirable that this skill is already confident. All modern IDEs (and, having solved the mistake of the previous paragraph, you will use modern IDE, right?) have excellent built-in debuggers with all the necessary functions. You can debug an entire program, its module, a single function, and so on. Read docs, watch youtube tutorials or ask your experienced friend to help. In any case, explore the debugger.

Copying without checking

Googling and copy-pasting someone else’s code isn’t really a crime. Quite the opposite: this process significantly speeds up the work and helps the developer in his constant learning. However, here is an important point: copy-paste should be thoughtful. Learn from it, try to get how this code works, modify it according to your task.

“Once beginners get past the challenge with all the tools, it tends to be a problem of not knowing how to find information. Copying code from the first StackOverflow answer they found or using outdated libraries is very common among new developers”, the software developer Eric Helman said.

Ignoring unit testing

Very often, newbies are not actually writing tests for their code and don’t test their code. Some novice developers check their code, but they do it in a very specific way. For example, they manually change the data in the program and output the result to the console. In fact, you need to start unlearning this method right after you have mastered the basic syntax.

“Thoroughly oftentimes people do manual tests but not of the cases. Getting comfortable with unit testing, getting comfortable with understanding all the edge cases of your code, and working through them. That’s one of the more likely snares of people are going to mess up on and then if you’re really getting your career started consistently”, Dylan Israel, software developer, and YouTube Content creator commented.

Falling in the tutorials hell trap

Newbies often get lost and don’t know exactly where to learn new information and how to learn it. Instead, they watch video after video, looking for more and more new stories. Here’s what Vadim Savin, Software engineer, and Youtube content creator, says.

“The most common mistake I see newbie programmers do is falling in the tutorials hell trap. How many udemy courses have you bought, and how many of them have you finished? The problem is not with tutorials, because you can learn a lot from them, the problem is the lack of practical experience. If you want to be the best at basketball, you wouldn’t watch tutorials all day and read books for a year, you would get on the court and start practicing. That’s the same with learning programming. Start building projects. When following a tutorial, don’t just watch, but do the same thing as the tutor is doing. Then, try again, but this time from memory. After you get the basics, start implementing the new knowledge in real projects. Start building that website/app/game that you have always wanted to build. This way, you will be motivated to practice because you will work on something you are excited about, and you want to feel the burden of learning”.

Fear and overreaction on code review

One of the obvious mistakes novice programmers make is a sharp reaction to code review. Very often, newcomers perceive the remarks of colleagues as harsh criticism, get upset, offer resistance, trying to prove that they were wrong. In fact, code review is a procedure for improving code, and not only for a newbie. For a beginner programmer, this is a great opportunity to learn on the job. Think of the process this way. Nobody wants to offend or humiliate you (well, most likely nobody, some people are strange when you are a stranger). Everyone is trying to ensure that your overall project is of the highest quality possible. Of course, the reviewer is not a saint and can also be wrong. It is important that you argue these points without emotion, try to look at your code with detachment and calmness.

Too much or not enough efforts

This problem is like a double-edged sword. On the one hand, many developers put in too little effort and abandon a difficult task that they can do, because they are not sure they can solve it. On the other hand, there are those who, on the contrary, can torment themselves for a very long time over a task that should have long been abandoned. As a result, the former does not develop fast enough, and the latter loses motivation. Here’s what our experts have to say about it.

Karolina Sowinska, a data pro and a YouTube content creator:

“I think the largest mistake that new programmers make is not trusting yourself enough to stick with a problem to solve it. That’s certainly the mistake I was making at the beginning. I thought that I don’t have enough knowledge or experience to be able to solve a difficult issue. In reality, facing unknown problems is exactly what experienced software engineers do on an everyday basis. You will not feel comfortable 70% of the time. So it’s paramount to shift your mindset from “I can’t solve it yet” to “I will solve it no matter what” regardless of how much experience in coding you have”.

Masha Zvereva, founder at Coding Blonde YouTube channel:

“One of the biggest issues I see newbie programmers struggle with is a combination of impatience, comparing themselves to others, and self-doubt. Learning how to program is hard and requires a different type of logic than what we’re used to in our day-to-day life, so it takes time to properly understand certain concepts. And different people will learn different aspects of programming quicker than others, but that doesn’t mean anything about their intelligence or future opportunities. Everyone is on their own timeline and has their unique learning style. Be patient with yourself and use additional materials if the ones in front of you don’t make sense to you”.

Saldina Nurak software engineer and YouTube channel autor:

“The main mistake that new programmers make is either self-doubt and thinking that they are not smart enough, or the complete opposite of that, thinking that they know everything, when in fact they don’t.
Looking back to my university days I can say that I was in the first category. I could understand the code during the lectures when professors explained it, but I had problems solving those same tasks alone, so I was wondering if I just wasn’t smart enough.
Now I know that it is because I didn’t spend enough time practicing. It’s the same when you are learning a new language, most people are able to understand it before they can speak it.
Some of the tips that helped me to overcome that issue and become better at programming are naming variables and functions according to their purpose, using diagrams and pseudo code when I couldn’t understand the code itself, writing comments for later reference, being consistent, and trying to learn a little bit every day, building a solid foundation and filling all the little gaps that I had in my knowledge.”

Overengineering

Ask a newbie programmer, what in their opinion the ideal code should be. The common answer would be “optimal, of course!” This usually means “optimal” in terms of performance and resource consumption. It’s a logical answer, isn’t it? Yep, this is so in an ideal world, but, alas, we don’t live in one.

Therefore, this answer is fundamentally wrong, especially when it comes to large projects that will be used and supported for many years. Experienced developers will choose the latter between optimality and readability. They know that, while optimally, Junior’s over-engineered code is so difficult to read and maintain that it will likely need to be rewritten completely soon. And if you see in front of you an even formatted code without frills, you can say it is boring, most likely it was created by an experienced programmer.

By the way, such code will most likely contain comments. And they will be exactly where they are needed. Moving on to the next error.

Where are your comments, dude?

Comments … Newbies and comments are just an ancient tragedy. Comments could be literally everywhere and explain the obvious things, or vice versa, code without comments at all. Don’t be like this, please. Explain what isn’t readable in an easy way or is referencing other modules.

“One of the common mistakes is the “We don’t need no stinkin’ comments” with apologies to The Treasure of the Sierra Madre where the original version of this line came from. Just last week while discussing this issue it was suggested that comments are worthless because when code is updated or refactored the comments are rarely updated so we might as well do away with them.” — Ken Fogel, Java Champion, CS teacher at Dawson College shares, “I once had to remove comments from submission to an open-source project. Comments represent the technical manual complex systems required. Imagine having to repair a modern automobile without the shop manual.”

Sure, competent commenting is a special science. However, if you master it, your colleagues will be very grateful to you. Remember the times when you had to understand someone else’s code. I think someone’s literate comments helped you, right? If you find it difficult to understand how to correctly place comments, look at the libraries of your programming language that you use, read, comments on their code … Learn from the best.

Messy code formatting and frustrating names

Sometimes novice developers don’t understand the importance of standardizing their coding. They have not yet realized how difficult it is to navigate someone else’s code, and don’t understand that they write code not only and not so much for themselves.

Each language has a set of rules that describe the correct formatting of the code. Some IDEs already know how to format the code in a standard way on a wave of hotkeys. Take the time to find out how to do it in your case. However, there are many things you still need to keep track of yourself.

Even more dramatic is the naming of variables and functions. If in the learning task int p; looked quite adequate, in a module of a large project it’s not! persentOfYearIncome looks terrible, but it is much clearer what we are talking about. By the way, don’t try to use short names and write transcripts in the comments. Better not be lazy and pick up your variables. functions, classes have friendly names. Even if they are not the most elegant.

Conclusions

“I would actually consider mistakes to be very healthy. It’s what teaches you the most as you try to solve a problem that you did not plan for. I think if I was to name an action that a programmer might do and call it a “mistake” it would be when we come across an issue in the code and we simply give up,” software developer and YouTube author Filip Grebowski said.

And I definitely agree with him. Mistakes are something that we cannot avoid as programmers. Everyone makes them, even the most proficient experts. Try not to repeat the same mistakes all the time and you become a better programmer faster.

First published at Geek Culture.

How We Entered the Chinese Red Ocean EdTech Market And Survived

Alex Yelenevych — Fri, 19 Nov 2021 14:20:46 +0000

Expanding into a new market is always a risk, especially if your niche in this market is already a red ocean and the market itself is very different from those you’ve already mastered.

The Chinese market has always been a tough nut to crack for Western and European companies. The probability of bringing a successful EdTech company here is very small since this market in China is already occupied by local players.

In addition, there are a lot of nuances in China that are not obvious to Western marketers. We have always loved to take on challenges, so we started trying to expand to a wide variety of markets including the Chinese. In this article, I’ll share with you how we did it.

New markets. First (failed!) try

Due to the success of and interest in CodeGym in the Western Europe market, it was logical to expand our local online product to other countries. However, our first attempts were unsuccessful. In 2014, we were interested in the Indian market. Since India is a country where IT outsourcing is developed, the potential audience is very large, and the salaries of software developers are significantly higher than the national average, which makes them kind of rock stars. It’s also important to note that, in India, most people can speak and understand English.

We didn’t do marketing research; instead, we decided to try an inside approach: we left for India for six months with our entire small office. It turned out to be a really smart decision, though we faced difficulties very quickly. As of 2014, India had mostly mobile internet, but it was slow and of poor quality. Only 15 of 250 million Internet users had a decent internet connection. In addition, it turned out that online payment systems were in their infancy in India, making payment difficult. As a result, we saw interest in our course, but much less than we expected. Unfortunately, there were no sales at all.

We retreated and began research, learned the US market, and launched contextual advertising. There was interest in the course, but we, unfortunately, did not take into account some local peculiarities, making the English translation of the course subpar.

New markets. Next steps

Although the first attempts were unsuccessful, we drew valuable conclusions from them and built a circuit that worked as a result. To begin with, we used an approach based on testing risk assumptions. The main idea was to get user feedback as quickly as possible and test the idea even before creating the product.

Using this approach, we checked the markets we were planning to enter, and realized that they were growing. We hired a localization team and prepared the first local English language CodeGym. After that, we ran tests to ensure our product fits into the market. We have highlighted several important metrics associated with learning(passing the beginning of the course, solving the first problems) and the convenience of registering on the website. After a while, we sent out a questionnaire to clients in which we asked how disappointed they would be if they could no longer use CodeGym. There is a generally accepted estimate for this question: if 40% or more are disappointed, then there is product-market fit. Our estimate was 63%.

The next step was to search for different distribution channels; PPC, PR, SEO specialists appeared and we found channels that work for us. Ultimately, we received a lot of positive feedback about the course from non-English-speaking countries, so we thought it would be nice to launch a localized CodeGym in these markets.

At the moment, we’ve developed a system of “accelerated testing” of the market, where, with minimal effort, we’ve been able to check whether a new market is suitable for us in one to two months.

The following are the most important criteria:

Market size
Level of competition
Demand for Java in the job market
Product market fit pre-assessment
Team expertise
Market complexity in terms of legal, financial, and bureaucratic issues

We translated the interface of the CodeGym website as well as the first two levels of the course into the language of the countries in which we planned to launch, and then checked a few more parameters:

Translation quality
User activity in the product

Launch in Europe and problems with distribution in China

We launched 12 local versions and found that the mini-versions of CodeGym are best perceived in Poland, Germany, France, and China. We also learned that China was the leader in all metrics of engagement in learning. However, the markets of European countries were relatively similar to our own, while in China, we immediately faced some difficulties.

We began our journey to Tianxia along a seemingly proven path: launch advertising, look at metrics, conduct surveys, and draw conclusions. However, even launching ads in China is not that easy.

So, what difficulties can an experienced marketer have when creating an advertising office? With Google, Facebook, Quora, or LinkedIn, there really were no problems. However, to create an advertising account in Chinese products Baidu, WeChat, Weibo, Douyin, QQ, or Tencent, oh, how difficult it is if you are out of China!

On some advertising platforms in China, foreign companies cannot create an advertising office, especially if your company is related to education. On others, this can be done, but you need to go through countless checks, confirmations, calls, prepare tons of documents that need to be signed with hieroglyphs, take a photo with completed questionnaires, and much more. In short, only a very serious company can do this.

Unsurprisingly, these features weakened our enthusiasm. Since there were other promising areas, we decided that the obstacles in China were too high and the market was difficult; we decided to postpone the work in China for now.

And yet, China!

Six months have passed since the successful launch in Europe, but we still did not lose focus on China. Within the framework of collecting information, we realized that it is Asia, in principle, that is the current market driver for Ed-Tech’s growth, mostly China and India. There are about 900 million Internet users in China. Users spend an average of 3 hours per day browsing content online and actively researching educational opportunities abroad.

According to a study by the Chinese media platform JMDedu, the majority of parents in major cities in China spend at least $ 7,000 per year on children’s education.

China’s EdTech market sector provides stable venture capital flows. China is the leader in investment in EdTech.

Also, it can be noted that online education is one of the fastest-growing industries in China. In 2015, the number of online education users in China was 110 million, with a market value of 114 billion yuan.

By 2018, the number of online students grew by 63% to 179 million, and the market value doubled to 300 billion yuan ($45.6 billion). This trend is expected to continue in the future; UBS estimates the market will grow to 714 billion yuan ($108 billion) by 2025.

The size of the online education market in 2020 was $203 billion. In 2021, it is likely to be $223 billion, and in 2025, the online education market will grow to $341 billion (average annual growth of 9.23%).

According to forecasts, due to COVID-19, these numbers may change, and in 2025, we will receive not $350 billion but $404 billion.

This market is already taken! Are you sure?

The statistics looked very promising, especially considering the positive response we received from our test course. However, as part of the Market Research of the programming market in China, it turned out that there are already a significant number of companies and products that have completed insane rounds of investments and have grown to a scale that is difficult to imagine. The main players in the online education market in China are Yuanfudao, Zuoyebang, Xue’ersi, and Baicizhan. Higher education and vocational training account for 75% of the total market share.

It would seem that we shouldn’t even think about competing with local companies. However, our research has shown that almost all Chinese EdTech is targeted at schoolchildren. Even college students had very few of these products, let alone adults who are considering a career change and considering becoming a software developer. Our product is aimed primarily at adults who want to change jobs, as well as students. At the same time, the Chinese are much more inclined to change jobs than, say, the Japanese or Koreans. For example, in a 2018 report, online recruiting company Zhaopin reported that more than half of its employees plan to change jobs in three years.

Do you speak Java, China?

Next, we began to investigate an important issue for us. At the moment, our platform is focused on learning only one programming language, Java. Therefore, we had to find out how popular this language is in China. We found that according to various estimates, 26.67% of all developers in China are Java developers and they have the highest salaries in the industry. It also turned out that the number of Java developers is growing by 20–30% annually, and demand often greatly exceeds supply, though these are not exact figures.

We haven’t found many interesting products to help adults learn Java. Among them were such services as Huke88 (it is somewhat similar to Udemy with a subscription), a free Alibaba course, and free video courses on Bilibili. According to reviews on Zhihu and Baidu Tieba (the Chinese counterparts of Quora), they are not very high quality and do not solve problems related to learning Java. The feedback on them was very weak, and requests from students for learning assistance were often unanswered.

We also found out that help is needed for people who have already found a job as a Java programmer. First, developers in China are a relatively young profession. The majority (56.7%) of developers in China have between 0 and 3 years of experience. Second, 71.8% of Chinese developers were trained in this profession at university, and, according to surveys, this training did not give them the appropriate skills and knowledge. Therefore, they often learn while working independently. Naturally, this category speaks English quite well, but nevertheless, a good Chinese course will not be superfluous.

First 3,000 users and registration problems

Summing up all the information received, we decided to continue our tryings for the Chinese market. However, due to the problems described above, we could not fully concentrate on it and instead decided to work with it on a leftover basis. So, we wrote several answers mentioning CodeGym on Zhihu, published a number of articles about the product on popular Chinese platforms, and sent out press releases to the Chinese media. During the first week, there were no reactions from the media and few transitions to the site, so we decided to postpone the idea of expansion for a while and think about other approaches. However, 4 months after the events described above, I looked at the metrics for various products. When I looked into the Chinese version of CodeGym, I found about 3,000 registered users there. Most of them have already passed free localized levels and solved all the problems. In the comments, there were many requests for access to the rest of the course.

We monitored local websites related to learning programming, and it turned out that CodeGym was mentioned quite often. At the same time, there were many complaints on the forums about difficulties with registration and a lot of popular “life hacking” posts about how to create an account on CodeGym. There was a problem that we had no idea about: when registering via email, we opened Google-captcha, but it was banned in China, so we had difficulty using email for registration. All social networks that can be used for login also do not work in China (sure, we knew this, but decided to leave this method just in case). In short, of all the possible ways in the country, only registration through GitHub worked.

Of course, we immediately removed the Google captcha and localized 18 more course levels. Fortunately, the process has already been debugged.

It’s alive…but really risky!

The audience’s response was impressive. Reach up to level 20 of the course, the time users spend inside the product, and other metrics were exactly two times higher than similar CodeGym metrics in any other regions of the world.

At that moment, we realized that we could try to tackle this area more seriously.

We identified a set of risky assumptions in which, with each subsequent failure, the rest of the work with China would not make any sense.

The list of risky assumptions was something like this:

We won’t be able to provide Chinese users with a really convenient way to register on the website (as a foreign company, we won’t be able to implement registration through WeChat or other convenient registration methods).
We won’t be able to pass verification and access at least one advertising network in China (for example, Baidu, WeChat, Douyin, etc.).
Metrics from other channels (such as paid ones) will show lower results than traffic from Zhihu and articles that users wrote themselves. If the metrics are significantly lower than in Poland, Germany, and the United States, but the cost of advertising is about the same, then the unit economics will not converge.
Since we are a foreign company, we won’t be able to accept payments from China (for example, we won’t have some kind of license and we simply will not be able to connect WeChat Pay, AliPay, and UnionPay).
China users won’t buy our paid product.
We won’t be able to scale our distribution channels and grow rapidly in revenue.

Results

In the end, we tested all the risky assumptions, and given that all this was done without using many resources, it was not easy. We can write an entire guide to test each one and tell many fascinating stories.

For example, just like when registering a developer account on WeChat, every day for 2 weeks at 5 am I was woken up by calls from China with new requests to send photos with documents and questionnaires. Or, there’s a story about how we added payment through Chinese payment services, turned on Paymentwall, and were surprised that there were no payments at all with excellent engagement rates.

However, the most important thing is that we coped with these difficulties, and the product began to work successfully. Well, the main thing that pleases us is that the metrics of the Chinese locale of CodeGym walkthrough are, on average, twice as high as in other locales. For example, the first level of the course is passed by approximately 52% of registered Chinese users, 24% for US users, 34% for Russian users, and 25% for the Polish CodeGym version.

Of course, the real expansion is still very far away, but the first results are already pleasing to us. We currently have 23,400 registered users in the Chinese locale on our website. This number is constantly growing; we sell subscriptions to Chinese users every day. Chinese users write great reviews about us, and we plan to develop further in this market.

First. published at Entrepreneur's Handbook.

How We Created a Mobile Tool to Write Code and What We’ve Got

Alex Yelenevych — Fri, 12 Nov 2021 16:02:14 +0000

Is it possible to write programs on a mobile phone without experiencing pain, hatred, and powerlessness? When we created CodeGym, a practice-oriented online course for learning Java programming, we doubted it. However, times are changing, and technologies are changing. In this article, we are going to talk about how we created the mobile version of CodeGym and what it’s led to.

Lack of mobility was a problem

We constantly received feedback from users. They were satisfied with the course, but somewhere in the 4–5 years of CodeGym’s existence, users started to request for the mobile application. There were not so many such requests, but enough to start the research. According to it, a lot of CodeGym students read lectures on their way to work or to study. Later at night, they log into the system from a computer, most often for coding tasks. It was our first hint but we doubted that it’s possible to code from a mobile phone with convenience. So we postponed this idea for a couple of years.

However, microlearning has become more and more part of our lives. Thus, the MarketsandMarket agency assumes that by 2024 the global microlearning market will increase by 13.2%, which will amount to $ 2.7 billion.

Microlearning is a format for presenting course information, where the course program is divided into modules according to the formula “1 module — 1 thought — 1 skill”. Each lesson is a concentrate of useful information, calculated on average for 10–15 minutes of a student’s time.

By the way, when CodeGym lectures were first created, they were quite suitable for the microlearning format and were considered brief. Now, to be honest with you, micro-lectures is understood as an even more concentrated format.

Trying to be in trends we also released a few brief videos that cover some Java topics, but that was not enough. The requests for the mobile application continued, and after a while, we began to slowly explore this market.

What’s on the market for mobile programming courses?

We knew that it’s easy to read lectures from a mobile on the web, so it’s not worth developing an application just for lectures. So the main question was: is it possible to create a really convenient mobile development environment for learning programming? One that would help not waste time, and use your free 5–10 minutes on the road to write code in a convenient way, so that the student wouldn’t want to smash the cellphone into the wall out of disappointment.

IDE or Integrated Development Environment is an application that includes a set of tools programmers need for their work. It is used to write code, compile or interpret it, run it, debug it, and automate the build. In the case of the educational mobile IDE, we were interested in writing and compiling code, launching a program, and issuing validator comments.

To begin with, we explored the solutions that other programming courses had. Basically, at that time, there were multiple-choice tests. Since we are a course about practice, we considered such tests to be purely optional. However, we found some decent mobile IDE, such as Grasshopper and several others.

There were exciting ideas for hints in this app: you don’t write letter-by-letter code, but have some pieces of puzzles with pieces of code in them, and they have to be assembled in the correct order. The idea is really interesting, since it allows you to code with one finger, but we were embarrassed that there were only suitable pieces for a specific task. This approach doesn’t help to learn programming well enough: it’s a puzzle, but not a real program creation. You know, programming is still a process of creation that demonstrates not only knowledge but also creativity and ingenuity.

Mobile IDE: what should it be?

So if we come up with a mobile IDE and it will be convenient from the UX point of view, it makes sense to develop the whole CodeGym application. It will be much easier to adapt to the rest of the course, such as lectures and tasks, and we’ve got how to do this.

We considered that code typing from the virtual keyboard letter by letter is still needed. It just shouldn’t be the main mode but complement the puzzles mode. However, the pure puzzles we described above didn’t suit our course, and we figured out how to improve this approach. First, parts of the code were split into groups (punctuation marks, operators, methods, and so on). Secondly, not all “puzzles” were suitable for the solution. Of course, if you load all possible code elements according to this principle, it will be inconvenient to search for the desired element. Hence, the set that the student sees on the mobile screen differs from task to task. The important thing is that not all the options were correct, there were more pieces of code than needed to solve a specific task, so the student needed to scratch the back of the head a little.

Well, if suddenly a student learned some new way of solving a coding task before reading about it in lectures, and the shown code elements did not cover it, they can always switch to the usual letter-by-letter input mode. So switching from one mode to another gives a user both flexibility and convenience. Thus, theoretically, students could, in 10 minutes during a trip or in a queue to the dentist, reflect on the problem and solve it using one finger.

Prototype development and testing

This approach seemed promising and we developed a clickable prototype for testing. This prototype had no design, just clickable cards with explanations of what was going to be located where. We selected a group of CodeGym students from different levels and prepared a questionnaire for them. For example “you need to open a task in the application, what will you do?”. After collecting their answers, we corrected the prototype and began to create a UI based on it, and also tested it for a month and a half.

I’ll go back a bit and say that we expected the application to be just part of the ecosystem of the course, and it will be used by people who are already familiar with the web CodeGym. So we created the first UI keeping this in mind.

Choice of technologies: Android

When development started, we still considered the mobile application to be purely an add-on, so we couldn’t afford to allocate many people to develop it. Moreover, we were in no hurry and still working on improving the idea for our mobile IDE. So we decided to develop only an Android application, and later, if successful, tackle iOS.

Why Android? It’s simple. First, we already have a ready-made team of Java developers who also know Kotlin and Android well. Secondly, according to Statista and many other analytical companies, as of 2018, when we started developing the app, the market share of Android mobile phones exceeded 80%. Thirdly, a testing ground for the app was the Eastern European Russian language version and the percentage of Android users in this version was even higher. So we hired another Android developer, brought in a UX/UE designer, and got down to work.

Development and testing of the first version

It took a little less than a year to develop an app from the rendered layouts to the launch of the test version on Google Play. The first mobile CodeGym contained neither lectures nor other sections of the website. There was the only access to coding tasks and a mobile IDE. For closed testing, we selected about 2,000 CodeGym students, created a special group on our website, and posted a list of questions about UX, UI, convenience, etc. They actively used the application and answered questions, communicated with each other and the developers. Two weeks later we collected all the questionnaires, aggregated them into a table, and talked with the most active participants in person. We also collected crash data across devices using Firebase Crashlytics, a lightweight crash reporter from Google.

In addition, we tracked the percentage of people who opened a task, solved it, and sent the solution for review. According to our internal metrics, this number turned out to be higher than we expected, and this process took place quickly enough, which is undoubtedly a good indicator. We had a fear that using a mobile application would be too tedious and significantly slow down future programmers in achieving their goals. Fortunately, we were wrong.

After collecting all this data, comments on UI, UX, bugs, we categorized and prioritized it, and started working on improvements and bug fixes. After that, we launched an official release of CodeGym Mobile.

Other aspects of the mobile app

The second most important task after Mobile IDE was the adaptation of the Help section. We needed to make it convenient for the user to ask a question from the phone in one click. That is, just like on the CodeGym website, if users can’t solve a task, they could click on the Help button. This action leads to the creation of a topic with their code and task condition attached. So the user should only write a heading question and press the Send button.

After solving this task, we gradually transferred the entire course to a mobile format.

Our mistakes

In fact, there were not so many serious mistakes at the strategy level, since we acted deliberately and were in no hurry. We did not have a task to quickly release the application, to occupy some niche, or something like that.

However, at first, we were clearly too clever with statistics. In order to understand whether the interface is effective, we did a number of UX tests, but since we had a very small sample, we decided to use analytical tools for all possible user scenarios, literally for every click on a button, every scroll. We sent everything into the database and stored it there. The mistake was that we made all this data very complicated, collected a bunch of statistics, and didn’t quite understand how to use it. We didn’t think beforehand about how to summarize the information received.

Of course, there were a lot of technical bugs. It would be weird if they were not there :).

Well, a pleasant mistake was that we somewhat underestimated the capabilities of the mobile application: it turned out that not only those who already know our website but also new users who find it through Google Play are trying to use it.

Recent improvements

We thought that an app without a website had no value in its own right, that it was an add-on to an ecosystem. However, it turned out that there are users who liked our approach and they learn ONLY in the application. Since the interface was tailored for people who know CodeGym, we began to research what might be incomprehensible to newcomers.

There were quite a few people who figured out everything and used CodeGym for free (for a long time in the application it was possible to study for free). As it turned out, some users didn’t even know that there was such a website.

Nevertheless, we slightly changed the interface and developed an onboarding tour: a user enters the application, a pop-up window appears with explanations of locations and how the course should be taken, and tested different versions of it. In a word, we tried to improve the product itself to make it easier for a person at the very beginning.

One of the most recent and most ambitious changes is the introduction of a user-responsive course. This feature appeared on the “big” CodeGym a little bit earlier. When users enter the application for the first time, they are asked what language they want to study in, what is the goal of the learning (to become an android developer, Java developer, etc.). Now, the user is proposed to take a small theory test, which can be skipped if they have never studied Java before. After this procedure, the user clicks on the “Get a course” button and a conditionally personal version of the course is generated.

Also, we recently introduced an “app-only” subscription that costs less than a website subscription (website subscription, of course, includes access to a mobile app). As it turned out, many students are ready to study in mobile format only.

Results and plans for the future

The trends in mobile learning and microlearning are inextricably linked. Mobile learning is the fastest growing trend in EdTech (growing 23% annually), so we made the right choice when we listened to our users and started developing the CodeGym app.

We managed to develop a really convenient mobile application for learning Java by doing. Considering that programming is a sea of code, we think this is just a great result. Mobile CodeGym has really accelerated students and increased product satisfaction. It is very important that the mobile application has led to the fact that there are fewer long (at least two weeks) breaks in learning. As we’ve researched, long breaks are one of the biggest enemies of online learning and the root cause of most potential programmers’ failure.

We constantly support the Android application, listen to users, fix bugs, and think about improvements. We are currently developing a version of CodeGym for iOS, now it is at the prototyping stage. Perhaps in the future, we will develop a short video format and think about organizing effective voice input in the IDE.

First published at Geek Culture.

Every Java Junior does it: Common Java mistakes made by newcomers

Alex Yelenevych — Tue, 15 Jun 2021 16:11:24 +0000

Everyone makes mistakes, not just beginners, but even professionals. This article goes over a dozen common mistakes that Java newbies and newcomers make and how to avoid them. Have you or your colleagues made any of these common Java mistakes early in your career?

Everyone makes mistakes, not only learners or beginners, but professionals. As a programming course, CodeGym team often collects mistakes of newbies to improve our auto validator. This time we decided to interview experienced programmers about mistakes in Java they made closer to their careers start or noticed them among their young colleagues.

We collected their answers and compiled this list of dozen popular mistakes Java beginners make. The order of errors is random and does not carry any special meaning.

#1. OOP: Incorrect construction of the object hierarchy. In particular, a misunderstanding of where to apply an interface, and where an abstract class.

An abstract class lets you create functionality that subclasses can implement or override. In an interface, you just define functionality, but not implement it. Although a class can only extend one abstract class, it can use multiple interfaces.

The choice between interface and abstract class depends on many factors.

Java does not support multiple inheritance, so each class can inherit only one superclass. However, any class can implement multiple interfaces.
If you decide to write many methods, then an abstract class is the best solution for you, because you can provide default implementations for some of the methods that are common to all subclasses.
If you need to add or remove a method from the interface, it could be a problem, because you can’t declare additional methods in an interface without changing all classes that implement this interface.

Let’s look at the example below. Here we have incorrect construction of the object hierarchy. In particular, a misunderstanding of when to apply the interface, and when should be an abstract class.

&nbsp;
public interface BaseEntity {
    long getId();
    void setId(long id);
}

public interface NamedEntity extends BaseEntity {
    String getName();
    void setName(String name);
}
public class User implements NamedEntity {

    private long id;
    private String name;
    private String avatarUrl;

    @Override
    public long getId() {
        return id;
    }
    @Override
    public void setId(long id) {
        this.id = id;
    }
    @Override
    public String getName() {
        return name;
    }

    @Override
    public void setName(String name) {
        this.name = name;
    }

    public String getAvatarUrl() {
        return avatarUrl;
    }

    public void setAvatarUrl(String avatarUrl) {
        this.avatarUrl = avatarUrl;
    }
}

public class Group implements NamedEntity {

    private long id;
    private String name;
    private String description;

    @Override
    public long getId() {
        return id;
    }

    @Override
    public void setId(long id) {
        this.id = id;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public void setName(String name) {
        this.name = name;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}

public class Comment implements BaseEntity {

    private long id;
    private String content;

    @Override
    public long getId() {
        return id;
    }

    @Override
    public void setId(long id) {
        this.id = id;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
}

Here the beginner uses an interface, in spite of the fact that class is much more appropriate for this task. The reason is that you can keep duplicated code into a class. If it is necessary, you can add Interfaces on top of parent classes. So here is the right decision (using abstract classes instead of interfaces):

&nbsp;public abstract class BaseEntity {

    private long id;

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }
}

public abstract class NamedEntity extends BaseEntity {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
public class User extends NamedEntity {

    private String avatarUrl;

    public String getAvatarUrl() {
        return avatarUrl;
    }

    public void setAvatarUrl(String avatarUrl) {
        this.avatarUrl = avatarUrl;
    }
}

public class Group extends NamedEntity {

    private String description;

    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
}
public class Comment extends BaseEntity {
    private String content;

    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
}

#2. OOP: mess with order of calling constructors

Newbies often forget about the order that constructors are called when objects are created. The rule is simple: constructors are called in inheritance order. When you think about the logic, it becomes clear that executing constructors in order of inheritance makes some sense.

The superclass knows nothing about its subclasses. Thus, any initialization must be done in the superclass completely independently of any initialization performed by the subclass. Therefore, this should be done first.

&nbsp;
public class Animal {
   public Animal() {
       System.out.println("Animal constructor has worked off");
   }
}

public class Cat extends Animal {
   public Cat() {
       System.out.println("Cat constructor has worked off!");
   }
   public static void main(String[] args) {
       Cat cat = new Cat();
   }
}

The Output is: 
Animal constructor has worked off
Cat constructor has worked off!

As you can see, when creating child elements, the base class constructors are implicitly called first.

In addition, it is important to remember to call the correct parent constructor, otherwise the parent default constructor will be called, as in the following example:

public abstract class AbstractToken {


    private final Collection<Object> authorities;


    public AbstractToken(Collection<Object> authorities) {

        if (authorities == null) {

            this.authorities = Collections.emptyList();

            return;

        }

        for (Object a : authorities) {

            if (a == null) {

                throw new IllegalArgumentException("Authorities collection cannot contain any null elements");

            }

        }

        ArrayList<Object> temp = new ArrayList<>(authorities.size());

        temp.addAll(authorities);

        this.authorities = Collections.unmodifiableList(temp);

    }

    public AbstractToken() {

        this.authorities = Collections.emptyList();

    }

}

public class MyToken extends AbstractToken {



    private int userId;



    public MyToken(User user, Object... authority) {

        this.userId = user.getId();

    }

}

public class User {

    private int id;

    public int getId() {
        return id;
    }

The constructor of the parent class is not explicitly called in the constructor of MyToken. So the constructor of AbstractToken with no parameters will be called. This constructor is missing the required object initialization part. Don’t forget to call a particular constructor you really need:

public class MyToken extends AbstractToken {


    private int userId;


    public MyToken(User user, Object... authority) {

        super(Arrays.asList(authority));

        this.userId = user.getId();

    }

}

#3. OOP: Mess with overriding and overloading

Overriding and Overloading are two very important concepts in Java. They could be really confusing for Java novice programmers.

Simply put, overriding allows you to take a method of the parent class and write its own implementation of this method in each inherited class. The new implementation will “replace” the parent in the child class.

Here is an example. We have Animal class with voice() method.

public class Animal {

   public void voice() {

    System.out.println("Speak!");
   }
}

Let’s say we need to override the behavior of the method in the derived classes. For example, we will implement 4 inheritor classes, which will have their own implementation of the voice method.

public class Bear extends Animal {
   @Override
   public void voice() {
       System.out.println("Grrr!");
   }
}
public class Cat extends Animal {

   @Override
   public void voice() {
       System.out.println("Meow!");
   }
}

public class Dog extends Animal {

   @Override
   public void voice() {
       System.out.println("Bow-wow!");
   }
}


public class Snake extends Animal {

   @Override
   public void voice() {
       System.out.println("Hiss-hiss!");
   }
}

Now let’s check how it works.

public class Main {

   public static void main(String[] args) {

       Animal animal1 = new Dog();
       Animal animal2 = new Cat();
       Animal animal3 = new Bear();
       Animal animal4 = new Snake();

       animal1.voice();
       animal2.voice();
       animal3.voice();
       animal4.voice();
   }
}

The output is: 
Bow-wow!
Meow!
Grrr! 
Hiss-hiss!

In addition to overriding, in the program we can use methods with the same name, but with different types and/or number of parameters. This mechanism is called method overloading.

public class Program{

    public static void main(String[] args) {

        System.out.println(sum(2, 3));          // 5
        System.out.println(sum(4.5, 3.2));      // 7.7
        System.out.println(sum(4, 3, 7));       // 14
    }
    static int sum(int x, int y){

        return x + y;
    }
    static double sum(double x, double y){

        return x + y;
    }
    static int sum(int x, int y, int z){

        return ukx + y + z;
    }
}

Three options or three overloads of the sum() method are defined here, but when it is called, depending on the type and number of parameters passed, the system will choose the version that is most suitable.

There is another option where a newbie can make a mistake when overriding. You can simply remember in which case which method is called:

public class MyParent {
    public void testPrint() {
        System.out.println("parent");
    }
}

public class MyChild extends MyParent {

    @Override

    public void testPrint() {

        System.out.println("child");

    }


    public static void main(String[] args) {

        MyParent o1 = new MyParent();

        MyParent o2 = new MyChild();

    MyChild o3 = new MyChild();

//      MyChild o4 = (MyChild) new MyParent(); // ClassCastException



        o1.testPrint();

        o2.testPrint();

        o3.testPrint();

    }

} 
The output is:
parent
child
child

#4. Wrong work with exceptions

Very often novice programmers don’t know how to work with exceptions correctly. To begin with, they simply ignore them, especially those that have moved from other programming languages. However, exceptions are thrown for some reason, so don’t ignore them.

There are also cases of careless handling of exceptions. For example, a newbie writes code, and their IDE starts underlining it in red and explains that certain exceptions may be thrown during its execution. In this case, an inexperienced programmer often prefers to wrap all the code in a try-catch and do nothing in catch block:

public static void main(String[] args) {
    try {
        String urlString = new Scanner(System.in).nextLine();
        URL url = new URL(urlString);
        String content = new Scanner(url.openStream(), StandardCharsets.UTF_8).useDelimiter("\\A").next();
        System.out.println(content);
    } catch (IOException ignored) {
    }
}

The problem is that in this case, we will not know what kind of exception happened, for what reason, and whether it happened at all.

There are different options for how to fix the situation. For example:

display the stack trace:

public static void main(String[] args) {

    try {

        String urlString = new Scanner(System.in).nextLine();

        URL url = new URL(urlString);

        String content = new Scanner(url.openStream(), StandardCharsets.UTF_8).useDelimiter("\\A").next();

        System.out.println(content);

    } catch (IOException e) {

        e.printStackTrace();

    }

}

throw the exceptions above:

public static void main(String[] args) throws IOException {

    String urlString = new Scanner(System.in).nextLine();

    URL url = new URL(urlString);

    String content = new Scanner(url.openStream(), StandardCharsets.UTF_8).useDelimiter("\\A").next();

    System.out.println(content);

}

handle each exception separately:

public static void main(String[] args) {

    URL url = getUrl();

    String content = getContent(url, 3);

    System.out.println(content);

}

private static String getContent(URL url, int attempts) {

    while (true) {

        try {

            return new Scanner(url.openStream(), StandardCharsets.UTF_8).useDelimiter("\\A").next();

        } catch (IOException e) {

            if (attempts == 0) {

                throw new RuntimeException(e);

            }

            attempts--;

        }

    }

}

private static URL getUrl() {

    while (true) {

        String urlString = new Scanner(System.in).nextLine();

        try {

            return new URL(urlString);

        } catch (MalformedURLException e) {

            System.out.println("URL is incorrect. Please try again.");

        }

    }

}

#5. Problems with choosing the right Collections

Beginners are often confused about choosing the right collection. Sometimes they choose this or that collection by mistake, because they do not deeply understand data structure. The wrong choice can affect the effectiveness of your program. On the other hand, if the collection is selected correctly, your program will look simpler and more logical, and the solution will be more efficient.

To find out which type of collection is right for your task, find out the characteristics and behavior of each one, as well as the differences between them. You need to be clear about the pros and cons of each specific implementation (ArrayList vs LinkedList, treeMap vs HashMap and so on).

I recommend for the first steps:

Explore not just Сollections framework, but theoretical data structures.
Create a table with all the collections. Give a brief definition of what data structure is at its core, what are its features.
Ask yourself some basic questions. Should your collection allow access to items by index? Is null accepted in it? Is it allowed to duplicate elements? Do quick elements addition and quick removal important for your solution? Should it support concurrency?

#6. Ignorance of Java libraries, reinvention of wheels

A huge number of libraries have been written for Java, but beginners often do not notice all these gems. Don’t try to reinvent the wheel, first learn the existing developments on the issue of interest. Many libraries have been perfected by developers over the years, and you can use them for free. For example, Google Guava, or Log4j.

Let’s have an example. This is what the code looks like without using libraries:

private static Map<String, Integer> getFrequencyMap(Set<String> words, List<String> wordsList) {
    Map<String, Integer> result = new HashMap<>();
    for (String word : words) {
        int count = 0;
        for (String s : wordsList) {
            if (word.equals(s)) {
                count++;
            }
        }
        result.put(word, count);
    }
    return result;
}

Here we use Collections.frequency() library:

private static Map<String, Integer> getFrequencyMap(Set<String> words, List<String> wordsList) {

    Map<String, Integer> result = new HashMap<>();

    for (String word : words) {

        result.put(word, Collections.frequency(wordsList, word));

    }

    return result;

}

Of course, here we’ve got just a short example, so the complexity of the code has changed only slightly. However, the readability of the code has significantly increased. In large projects with many classes, using built-in and third-party libraries can significantly speed up development, improve readability, and testability. So don’t forget to explore Java libraries.

#7. Ignoring JUnit and wrong testing of your own code

Very often, novice programmers “test” their code incorrectly. For example, using System.out.println(), substituting and printing different values to the console. Seriously, from the very first steps, you should learn how to use the excellent JUnit library and write tests for your programs. Moreover, you will definitely need it in your work. Unit testing your own code is a good practice for developers.

#8. Forgetting to free resources

Every time your program opens a file or sets a network connection, you need to free up the resources it uses. It is also true for cases of exceptions when working with resources. Of course, FileInputStream has a finalizer that calls the close() method to collect garbage. However, you can’t be sure about the beginning of the build cycle. Thus, there is a risk that the input stream may consume resources indefinitely.

The problem for beginners is that not freeing resources does not lead to compile-time or run-time errors. So it’s easy to forget about it. Let’s give an example.

private void populateConfigs(Path propertiesPath) throws IOException {
    assert propertiesPath != null;
    DirectoryStream<Path> directoryStream = Files.newDirectoryStream(propertiesPath, "*.properties");
    for (Path entry : directoryStream) {
        Properties properties = new Properties();
        properties.load(Files.newBufferedReader(entry));
        validateAndSave(properties);
    }
}

The program works, but we’ll better do it the right way. Let’s close the resource as follows:

private void populateConfigs(Path propertiesPath) throws IOException {

    assert propertiesPath != null;

    try (DirectoryStream<Path> directoryStream = Files.newDirectoryStream(propertiesPath, "*.properties")) {

        for (Path entry : directoryStream) {

            Properties properties = new Properties();

            properties.load(Files.newBufferedReader(entry));

            validateAndSave(properties);

        }

    }

}

#9. Equals and hashcode problems

The Object class is the parent class for all Java objects. This class has methods equal() and hashCode (). The equals () method, as its name suggests, is used to simply check if two objects are equal. hashCode() method that allows you to get a unique integer number for a given object.

Often newbies don’t feel like these methods need to be overridden for their objects.

The default implementation of equals() method simply checks the two objects by reference to see if they are equivalent.

For example, you need to compare two points on the coordinate plane, let’s try to override the equals method:

public class Point {
    private int x;
    private int y;
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

Now, without overriding the equals() method for the Point class, let’s try to compare the points. To do this, let’s create a PointDemo class and in it there are three points, two according to the logic of Cartesian coordinates — equal (with the same abscissa and ordinate) and the third, which differs from them.

public class PointDemo {
   public static void main(String[] args) {
       Point point1 = new Point(2, 3);
       Point point2 = new Point(2, 3);
       Point point3 = new Point(2, 5);

       if (point1.equals(point2))
           System.out.println("1 and 2 are equal");
       else
           System.out.println("1 and 2 are not equal");

       if (point1.equals(point3)) System.out.println("1 and 3 are equal");
       else System.out.println("1 and 3 are not equal");
   }
}
The output is: 
1 and 2 are not equal
1 and 3 are not equal

More often, a practicing beginner forgets not to override equals(), but to override it correctly. For example, they forget that the object can be null or that it needs to be checked for equivalence to itself. Let’s write the correct equals() method to compare two points on the plane:

public boolean equals(Object obj) {
        if (obj == null)   return false; // checking if the passed object is null
        if (obj == this)   return true; //checking if the passed object is equal to itself 
        if (obj.getClass() == this.getClass()) { // checking if the passed object has the same result of the getClass () method as the current one, on which the equals method was called
            Point point = (Point) obj;  // now we can definitely convert the passed object to type Point
            if (point.x == this.x && point.y == this.y) // if the coordinates match, then return true, otherwise false
                return true;
        }
        return false;
    }
}

Now if we run the main() method of the PointDemo() class we get the following result:

1 and 2 are equal
1 and 3 are not equal

#10. Working with uninitialized objects

This newbie mistake leads to a NullPointerEception that is thrown when they try to use an uninitialized object. Don’t be confused about declaring an object variable, this does not mean that it is initialized.

So if you write something like:

private static String name;
    public static void main(String[] args) {
        System.out.println(name.length());
    }

you’ll get an exception when you try to call the length method because the name field is null. You should always initialize them before working with variables.

#11. Wrong work with Wrappers

You need to be careful to remember that Wrapper classes such as Integer or Boolean are reference data types and the type of variable can be null. In this case, it is better to avoid operations in which null doesn’t work well.

Often newbies work with uninitialized variables of type Integer or Boolean somewhere as with int or bool, which can cause NullPointerException errors. For example, if we have any Boolean s, which is Null by default, and they try to call it in some if (s), we will get an error.

Also, autoboxing of variables of primitive types requires an exact match of the type of the original primitive — the type of the “wrapper class”. Attempting to autopack a variable of type byte into Short without first explicitly casting byte-> short will cause a compilation error.

Here is an example:

public static class Man {
        private String name;
        private Integer age;

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }
   public void setAge(Integer age) {
            this.age = age;
        } 
        public static void main(String[] args) {
            Man man = new Man();
            System.out.println(man.getAge());
        }
    }

In this example, when we run the main method, we will receive a NullPointerException error. This happens because we return int instead of Integer in the getAge getter. As we said before, int can’t be null and auto-unboxing occurs, in such cases you need to be careful and pay attention that the field is not null or the getAge method returns Integer.

#12. Work with asynchronous code

Experts said that the most common mistakes among developers in general is dealing with asynchronous code (concurrency, threads, etc.).

If in a real project it becomes necessary to work with code asynchronously, you don’t need to use low-level multithreaded programming. It could be beneficial for learning issues or some kind of experimentation. However in a real project this leads to unnecessary complexity and many potential errors. Therefore, when working with multithreading, it is better to use classes from the java.util.concurrent package or other ready-made third-party libraries (Guava, etc.)

Here is an example of the code:

public class MyTask implements Runnable {

    private int monitoringPeriod;
    private boolean active;

    @Override
    public void run() {
        // do work
    }

    public int getMonitoringPeriod() {
        return monitoringPeriod;
    }

    public void setMonitoringPeriod(int monitoringPeriod) {
        this.monitoringPeriod = monitoringPeriod;
    }

    public boolean isActive() {
        return active;
    }

    public void setActive(boolean active) {
        this.active = active;
    }
}

public class Solution {

    public static void main(String[] args) {

        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(8);

        Collection<MyTask> tasks = generateTasks();

        for (MyTask task : tasks) {

            if (task.isActive()) {

               scheduler.scheduleWithFixedDelay(task, 0, task.getMonitoringPeriod(), TimeUnit.SECONDS);

            }

        }

    }

    private static Collection<MyTask> generateTasks() {

        Collection<MyTask> result = new HashSet<>();

        // tasks generation

        return result;

    }

}

If you try to do the same, but manually start the threads, you might end up with hard-to-read and difficult-to-maintain code. It’s also about the invention of the wheel.

Conclusion

We tried to describe the most popular mistakes made by Java newbies, according to experts, experienced programmers. Many examples are intended in the article so that it is convenient for beginners to get rid of these errors as soon as possible.

In fact, these are not really errors. These are certain stages of the practical use of the language, through which most of the beginning Java programmers go. Errors of the very first stage (for example, incorrect placement of curly braces or semicolons we will omit) and start with those that Java Trainee and Java Junior often do. Sure, it is advisable not to prolong this stage of “popular mistakes” for a long time. This is exactly what we wish you for in your Java developer way.

First published on (JaxEnter)[https://jaxenter.com/java-mistakes-174395.html].

15 Tips from Pro Developers for Programming Beginners

Alex Yelenevych — Mon, 31 May 2021 15:05:08 +0000

The global technology industry keeps growing at an incredible pace, seemingly unstoppable and immune to road bumps other economic sectors are suffering from. Even the mighty COVID-19 crisis didn’t manage to stop the soaring tech industry as it managed to grow in 2020 and is now on a path to reach $5 trillion by the end of 2021, which would indicate a 4.2% per year growth trend.

As the tech market keeps expanding, its appetite for talent is growing as well. Tech businesses worldwide are hungry for qualified software engineers, and this increasing demand stimulates more and more people to learn to program and join the profession. It is estimated that today there are around 24 million software developers around the world, and this number will grow to 28.7 million by 2024.

Demand for software developers is accelerating

People all around the world are choosing software development as their profession. In terms of growth in the number of software developers, the Asia Pacific region shows the strongest development, which is mainly attributed to countries like China and India. China is the top nation for annual developer population growth, while India’s pool of programmers is expected to overtake the United States by 2023.

But even this will not be enough, as the number of jobs in the tech industry is growing faster than the developer population. The U.S. Bureau of Labor Statistics projected that the number of jobs in computer and information technology occupations in the U.S. would grow 11 percent from 2019 to 2029, much faster than the average for all occupations.

When rising demand outstrips the growth of the developer population, it makes a great employee market. So it’s no wonder so many people today are already learning how to code or just considering this career path for the future. But as much as can be done to make this knowledge easy and accessible, software development is a demanding discipline. It is typical for beginners to hit multiple road bumps on the way to becoming professional software developers.

15 programming tips that you might benefit from

Recently we at CodeGym.cc conducted a survey of well-known software development experts and industry influencers, asking them to share the most valuable advice and guidance they can give to programming beginners. I compiled this list of the most essential and valuable recommendations for coding beginners based on what they have told me.

1. Practice is the key

It should come as no surprise that number one advice from most of the experts I surveyed was to practice as much as possible. All the best and proven online programming courses are practice-focused, as this is the way to teach people how to code with utmost effectiveness.

“Practice writing code as much as possible. Do all codelabs and tutorials you can find,” recommends Erik Hellman, mobile programming expert and the author of ‘Android Programming: Pushing the Limits.’

Javin Paul, a renowned Java blogger, has pretty much the same recommendation to give: “Code daily, read blogs and books, and do projects.”

2. Don’t get trapped in theory-learning

Learning theory is the second crucially important component of learning how to code after practicing. And even though the theory is important, beginners often make the mistake of devoting too much time and effort to reading tutorials without enough practice.

“Try to avoid the tutorial trap. Doing structured courses and tutorials is obviously very useful at the beginning, but eventually, you must start building the real thing,” recommends Karolina Sowinska, an experienced software developer, and tech industry influencer.

3. Join a community of developers

Social communication is also an important factor in learning how to code. This is why it is highly recommended to find yourself a community of developers that you can join to ask questions, discuss programming-related topics and support each other. These communities can be both offline, which is always better for establishing personal relationships and contact with others, and online. Codegym, for instance, has a Java developers community, where our users can discuss everything about Java software development.

“Programmers love to debate methodologies and trends. Is OOP dead? Are scripting languages the future? Is functional programming just cycling back to structured programming? A beginner should immerse themselves in the community associated with the language or environment they are working in. They should join user groups. A beginner needs to know the pulse of the industry. This year it’s functional programming and, much to my regret, untyped languages. Trends come and go, so the responsibility of every developer is to follow current trends and those on the horizon. They need to find an environment or group where they can be discussed,” explains Ken Fogel, Java expert and Computer Science Technology Professor at Dawson College, Canada.

“Find a community of developers where you feel comfortable asking questions. Don’t worry if you feel your question might be too simple. You’ll get past that quite soon,” adds Erik Hellman.

4. Learn to search for and find the solutions

Being able to search and find solutions to your programming problems and ways to solve coding challenges is almost half the success when it comes to software development. Even if you are lacking technical knowledge or skills, searching can be that meta-skill that will get you through the difficulties of professional programming.

“Many like to say that programmers are just professional googlers. I would take that as a compliment. How you use what you learn is what defines you as a professional rather than a duffer,” said Ken Fogel.

Erik Hellman also thinks searching is the key: “Learn how to search for solutions. Even if you know the answer to something, google it and see what else comes up to compare.”

5. Take the time to stop and celebrate a new milestone

Even though to become a professional programmer, you will most likely have to push yourself pretty hard. You should also know when to let it go, relax and celebrate a new milestone in this journey, even if it isn’t a big one.

At least, this is what Dylan Israel, a senior frontend engineer, coding mentor, and YouTube blogger, recommends to programming beginners. “The first piece of advice I would have is: celebrate your mini-milestones. When you learn something new, appreciate that you spent the time to learn something new; when you build something, appreciate that you built something and challenge yourself. Often we are so afraid that we want to be a hundred percent ready, and that’s a really poor attitude to have in our field because you are never going to know everything. You are never going to be a hundred percent ready. So be afraid and do it anyhow,” he told me.

6. Start applying for jobs and doing interviews early

When it comes to applying for actual programming jobs and having job interviews, it makes sense to start doing that as early as possible, even if you don’t feel ready for it yet. The fact is, jobs for software developers always have a lot of requirements, and feeling a bit under-qualified when you are reading them is quite normal for beginners. But that shouldn’t stop you from actively trying to get them.

“When you’re applying for a job, and you only meet about 50 percent of requirements, apply, see it start interviewing way earlier, get out of your comfort zone, be afraid and do it anyhow. This is something I want you to remember because that is the thing that will propel you faster. That’s the thing that will make you grow. More growth is challenging. It’s difficult, it’s stressful, but like anything else, when you grow, you get better, and you’ll be a better programmer in the long term,” said Dylan Israel.

7. Follow your passion more

Another good piece of advice when it comes to applying for jobs in software development is to follow your interests and intuition instead of making choices based on current trends or a potential salary size. Being genuinely interested and passionate about what you do will be extremely helpful along the way, keeping your motivation high and giving you the strength to go on.

“The most frequent advice I hear from experienced software developers is to follow your passion when it comes to choosing the direction in which you want to take your career. You’re going to spend a large proportion of your life working, so you want to make sure that this activity still lights you up and motivates you when things get tough. And you want to enjoy your day-to-day life in general, so take your time to identify the best pathway forward for you right now – don’t just follow the path that pays the best, for example. Follow your passions right now, don’t think of it as the final decision for the rest of your career though. The beauty of tech is that you can grow in different directions later and switch fields pretty easily as you gain experience,” recommends Masha Zvereva, an entrepreneur and the founder of Coding Blonde blog.

8. Take time to learn fundamentals

Even though the practice-first approach is highly advisable when it comes to learning how to code, you shouldn’t neglect fundamental knowledge and underestimate its importance. Knowing basic CS skills and disciplines, such as algorithms, computational thinking, data structures, and more will prove itself useful and help you advance faster.

“Our industry is constantly reinventing itself. We went from mainframes to pizza-style Intel servers to the cloud. We had bash scripts, continuous integration, and now GitHub actions. Investing time to understand the core concepts behind the technology we are using is crucial to stay relevant. Always aching to use the latest and greatest technology is not,” said Markus Eisele, a reputable Java expert and founder of JavaLand.

Vadim Savin, an experienced full-stack developer, and programming blogger has similar advice to give: “In times when there are more JavaScript frameworks than days in a year, it might be daunting to start learning and to know what exactly you should focus on. The FOMO (fear of missing out) is there even when you are a senior. There is no way to know everything in our industry. Focus on the fundamentals first and make sure you have a solid base. These are skills like problem-solving, algorithms and data structures, etc. When you have solid fundamentals, it is going to be pretty easy to pick any new trend that there might be.”

9. Learn several programming languages

Besides learning the basics of computer science and other fundamental disciplines, it would be a good idea to invest time into learning several programming languages, as it will help you understand how they are different from each other.

“While following the latest and greatest seems tempting, I think in the long run, those programmers who truly understand the basics will be in higher demand than the ones that followed marketing. This includes learning data structures and algorithms. No need to be an expert but also understanding them. Learn the relational model, normalization, SQL. Learn about programming paradigms, including imperative, object-oriented, functional programming. Learn a few different programming languages to appreciate the differences and ecosystems,” recommends Lukas Eder, renowned Java and SQL expert.

10. Embrace communication

Professional programming is almost always a team effort, so developing your communication skills and practicing them is also a part of the road to success.

This is what Markus Eisele has to share with us on the matter: “The number one lesson I learned when I became a developer was to embrace a different communication style. I met many new people, some of them very senior and experienced, and as you might expect, I wasn’t exactly seen as a productive part of the team because I was still learning. Don’t let yourself down over experiences like this. Read a little about the four-sides model and always remember that the most important part of being a programmer is to create valuable business solutions and put them into source code. This is a team effort.”

11. Learn to manage innovations and to change requirements

And here is another valuable insight from Markus Eisele, advising beginners to get used to ever-changing trends and requirements in the software industry as they are unavoidable, focusing on key skills and fundamental knowledge instead.

“Think about the functional and non-functional requirements that exist and map them to the technologies you think could be a good fit. Our toolbox grew massively over the last decade, and it will continue to do so. Learn to manage innovation and to change requirements as part of your technology portfolio,” he said.

12. Learn to plan your work

Being able to think strategically and plan your work ahead is another important skill for a software developer. Experimenting and looking for new ways to solve existing problems is also a part of it.

“I tell anyone who asks about being a programmer that this profession is akin to experimental science. If you enjoy learning how something works and if you like to run experiments to further your understanding, then you should consider becoming a programmer. You should also be an organizer of whatever work you do now. You need to be able to plan out your work before you start,” said Ken Fogel.

13. Prepare to learn all the time

Another trait that makes a really good and successful software engineer is learning all the time throughout the career. So if you want to be one, better prepare yourself that learning will never stop.

As Ken Fogel has put it, “Being a programmer means a lifelong commitment to learning. It is likely that every project you work on will require you to learn a new skill or technique.”

14. Stay consistent and don’t give up

And of course, it is always good advice to view programming as a long journey because it is and it will take many steps, with all sorts of trouble and challenges along the way. And if you want to make it, you better stay consistent and don’t let road bumps stop you.

“This is a very broad industry, and it is very easy to get lost in the ocean of information and possibilities, so my advice is to look for something that you really like. That will help you to stay motivated and enjoy what you’re doing. You can make applications for medicine, music, art, science, sports, games, fitness, anything you can think of. You can change and affect other people’s lives with your work. You can earn a lot of money and become famous as a programmer, but you’ll have to be consistent because learning programming is a marathon, not a sprint. You didn’t learn to walk when you made your first step, and you didn’t learn to talk when you said your first word. The same applies to learning programming – stay consistent and don’t give up because of many – and there will be many – obstacles that you come across.” said Saldina Nurak, a software engineer and YouTube blogger.

15. Try to have fun along the way

But even if it is difficult sometimes, no one said that software development should be a somber journey. There are many opportunities to enjoy it and have fun along the way, and you are strongly advised to do exactly that.

“Stay smart. Be proactive about the way you learn, and always try and make it fun. Keeping it fun will keep you motivated, and motivation builds success. Once you learn the fundamentals, it’s important to pick something you enjoy, whether it is frontend, backend, or, more specifically, a tech stack that you enjoy. Then explore all of it,” recommends Filip Grebowski, an experienced software engineer and the creator of popular programming tutorials on YouTube.

Conclusion

These are fifteen fundamental recommendations that multiple experts found to be the most essential and valuable for programming beginners. You can use them as a set of strategic guidelines to becoming a professional software developer. And I hope that these tips will help you to avoid hurtful mistakes and unexpected traps along the way, making this journey easier and increasingly filled with excitement rather than struggle.

Previously published at TechCute.