DEV Community: shoshinmas

Successful Russian attack on Polish powerplant

shoshinmas — Wed, 21 Jan 2026 08:46:20 +0000

Polish biomass-fired district heating plant in Ruciane-Nida was successfully manipulated by cyber threat actors linked to Russia. Attackers altered technical operating parameters of one of the boilers (1 000 kW), but operators quickly detected and reversed the changes before any harm occurred. The plant continued normal operation, and heat delivery to residents remained unaffected. The incident was reported to CERT Polska and local law enforcement.

more with sources: https://cybersecwaw.hashnode.dev/pro-russian-group-launches-successful-attack-on-polish-heating-plant

Review of important Java changes from version 8 till 21

shoshinmas — Thu, 06 Jul 2023 19:27:34 +0000

Java 8

Lambda Expressions* — The introduction of lambda expressions is the most important change in Java 8. They enable the creation of anonymous functions and promote a functional programming style.

List<String> names = Arrays.asList(“Jan”, “Adam”, “Ewa”);
Collections.sort(names, (a, b) -> b.compareTo(a));

Stream APIs* — A new API is used to support streaming operations on data in collections, fundamentally changing the way data is manipulated.

List<String> names = Arrays.asList(“Jan”, “Adam”, “Ewa”);
List<String> upperCaseNames = names.stream()
.map(String::toUpperCase)
.collect(Collectors.toList());

Interfaces with default methods — Java 8 introduced the ability to define default methods in interfaces, allowing new functions to be added to existing interfaces without compromising compatibility.

Java 9

Jigsaw (Project Jigsaw) — The introduction of modularity to the Java platform is a major feature of Java 9. Modules make it easier to scale applications for both small and large projects.

REPL (JShell) — JShell is an interactive command shell that allows you to quickly test code snippets without having to create a full class.

Java 10

Local type inference — Java 10 introduces type inference for local variables, which means we no longer have to declare the type of the variable — the compiler will do it itself.

var text = “Hello, Java 10”; // Type Inference
System.out.println(text);

Java 11

Running .java files — Since Java 11, it is possible to directly run .java files without first compiling them to .class.

HTTP Client API — The new HTTP client API, which was available as an “incubator feature” in Java 9 and 10, is now a full-fledged API as of Java 11.

Java 12

Switch Expressions* — The switch has been improved and now offers a more concise and secure syntax.

String day = “MONDAY”;
String result = switch (day) {
case “MONDAY”, “TUESDAY”, “WEDNESDAY”, “THURSDAY”, “FRIDAY” -> “Weekday”;
case “SATURDAY”, “SUNDAY” -> “Weekend”;
default -> throw new IllegalArgumentException(“Invalid day: “ + day);
};

Java 13

Text Blocks — The introduction of text blocks has made it easier to work with multi-line text in Java.

Java 14

Records — Records are a new type of references in Java, which are non-mutable data. They make it easier to create classes that are just data carriers.

public record Point(int x, int y) {} // Defining a record

Pattern Matching for instanceof — This feature increases code readability by eliminating unnecessary type casting.

Object obj = “Hello”;
if (obj instanceof String s) {
System.out.println(s.toLowerCase());
}

Java 15

Sealed Classes — A sealed class allows programmers to specify which other classes can inherit from it.

public sealed class Shape
permits Circle, Rectangle {}

public final class Circle extends Shape {…}

public final class Rectangle extends Shape {…}

Java 16

Records (stable version) -Records that were previously available

available in the preview version, have become full-fledged language elements in Java 16.

Pattern Matching for instanceof (Stable Version) — As with records, the pattern feature for instanceof, which was previously available in the preview version, has been officially introduced in Java 16.

Java 17

Sealed Classes (Stable Version) — In Java 17, the sealed class, which was previously available as a preview feature, has become a full-fledged part of the language.

Pattern Matching for Switch (Preview) — Java 17 introduced patterns for switch expressions as a preview feature, which has the potential to increase code readability and security.

Java 18

Project Panama (Preview) — This is one of the most anticipated projects for Java. The goal of Panama is to improve Java’s interoperability with native C/C++ code.

Java 19

Project Valhalla (Preview) — This is a long-awaited project that aims to introduce value types (value types) and specialization of generics into Java, improving performance and memory.

Java 20

Project Loom (Preview) — Project Loom aims to add lightweight threads (so-called “fibres”) to the JVM, increasing the efficiency of multithreading in Java.

Java 21 — upcoming

Although plans for Java 21 are still unclear, we can expect further development and fixes for preview features from previous versions, as well as new features that will continue the development of Java as a programming language and platform.

This is truly an exciting time for Java developers, as the language continues to evolve with new features and enhancements designed to make developers’ daily work easier. We look forward to the next versions of Java!

Understanding Object-Oriented Programming (OOP): A guide for bootcamp graduates

shoshinmas — Fri, 24 Mar 2023 08:47:24 +0000

Bootcamps can be a great way to kickstart your programming career, but they may not always provide a comprehensive understanding of Object-Oriented Programming (OOP) concepts in Java. As a bootcamp graduate myself, I know firsthand how important it is to supplement your education with additional learning resources to succeed as a software developer.

My background is in digital marketing, where I spent more than 15 years working as a liaison between clients and tech teams. While I enjoyed implementing tracking pixels and solving problems with tag management, I decided that I wanted to take my skills to the next level and learn how to create programs myself. At the age of 35, I enrolled in an offline bootcamp that was supposed to cover the basics to intermediate levels of programming in Java.

However, I soon realized that the knowledge I gained from the bootcamp was only suitable for beginners. The same amount of knowledge could be obtained from online courses on Udemy and other platforms. When I landed my first job as a developer - not in Java, but in PHP - I realized that what was really important for success in the field was an understanding of OOP principles and the ability to work effectively in a team.

So, what are the principles of OOP? In OOP, everything is represented as an object, which has properties and methods. The four main principles of OOP are:

Encapsulation: This principle is about grouping related data and functions together into a single unit called a class. Encapsulation helps to hide the implementation details of a class from other classes, which makes it easier to modify the code in the future without affecting the other parts of the program.
Inheritance: This principle allows you to create a new class by inheriting the properties and methods of an existing class. Inheritance is useful for creating new classes that are similar to existing ones, but with some additional or modified functionality.
Polymorphism: This principle refers to the ability of objects to take on multiple forms. Polymorphism allows you to use a single interface to represent multiple types of objects.
Abstraction: This principle is about focusing on the essential features of an object and ignoring the non-essential ones. Abstraction allows you to create simpler and more manageable code by hiding the complexity of the underlying implementation.

There are also some essential sets of rules that you should know before you even try to apply for a position. They have elegant abbreviations that help you memorize them: KISS, DRY and SOLID.

SOLID: SOLID is an acronym that stands for Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. These five principles are considered fundamental to building robust, maintainable software.

Single Responsibility Principle: This principle states that a class should have only one reason to change. Each class should do one thing, and do it well.
Open-Closed Principle: This principle states that classes should be open for extension, but closed for modification. In other words, you should be able to add new functionality without having to change existing code.
Liskov Substitution Principle: This principle states that subclasses should be substitutable for their base classes. In other words, you should be able to use a subclass wherever you can use its parent class.
Interface Segregation Principle: This principle states that clients should not be forced to depend on interfaces they do not use. Interfaces should be tailored to specific use cases.
Dependency Inversion Principle: This principle states that high-level modules should not depend on low-level modules. Instead, they should both depend on abstractions.

KISS: KISS stands for "Keep it simple, stupid." This principle states that software should be designed as simply as possible, without unnecessary complexity. Simple code is easier to read, test, and maintain.

DRY: stands for Don't Repeat Yourself. I won't repeat myself, it's self-explanatory. This applies to both one class/module that you create as for the whole application. Especially when you work with frameworks.

Frameworks... Frameworks are also something that the cheap bootcamps mostly ommit. Basically, the whole bootcamp that you pay the $1-2k for should be an introduction to handling a framework and understanding what part of application would you like to engineer: back-end, front-end, or do you want to go for the whole stuff from the beginning.

In addition to OOP principles and frameworks, it's also important for developers to know how to work effectively in a team. This includes skills such as documentation, task estimation, and version control. Some of the essential tools for team collaboration include:

Documentation: Good documentation is essential for ensuring that other team members can understand your code and use it effectively. This includes comments in the code, README files, and technical specifications.
Task estimation: Being able to estimate the time needed for a task is essential for effective project planning. This involves breaking down tasks into smaller sub-tasks, estimating the time required for each sub-task, and keeping track of progress.
Version control: Version control tools such as Git allow team members to collaborate on a codebase without overwriting each other's work. Version control also enables developers to revert to earlier versions of the code if necessary.

Finally, it's worth noting that one year of coding on platforms such as Hyperskill by JetBrains is a great way to gain a deeper understanding of your chosen language and prepare for your first job as a developer. While bootcamps can provide a good starting point, it's important to continue learning and practicing on your own to build your skills and become a successful software developer.