🖥 BinDiff - это инструмент, написанный на Java для сравнения бинарных файлов с открытым исходным кодом, позволяющий быстро находить различия и сходства в дизассемблированном коде.

BinDiff содержит следующие компоненты:

• cmake - файлы сборки CMake с объявлением внешних зависимостей
fixtures - Коллекция тестовых файлов для проверки работы ядра BinDiff
• ida - Интеграция с дизассемблером IDA Pro
• java - Исходный код Java. Он содержит пользовательский интерфейс визуального диффа BinDiff и соответствующую библиотеку утилит.
• match - Алгоритмы сопоставления для ядра BinDiff
• packaging - Исходники инсталляционных пакетов
• tools - Исполняемые файлы-помощники, поставляемые вместе с продуктом

• Github
• Docs

@javatg

🖥Тестирование Java при помощи JUnit: примеры и советы по тестированию

JUnit — это открытый фреймворк для написания и запуска тестов на языке программирования Java. Он разработан с целью поддержки автоматизированных тестов, особенно модульных тестов (unit tests), и обеспечивает удобные аннотации, утверждения и утилиты, которые позволяют легко писать и запускать тесты для Java-кода.

Настройка тестовой среды JUnit
Для начала вам необходимо установить JUnit в ваш проект. Если вы используете Maven или Gradle, добавьте зависимость JUnit в ваш файл настроек. В изображениипример для Maven.


Основы и примеры написания тестов с JUnit
Структура теста
Тестовый класс создается отдельно от основного кода. Он содержит один или несколько тестовых методов, каждый из которых проверяет отдельный аспект работы кода. Тестовые методы помечаются аннотацией @Test.

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class CalculatorTest {

@Test
public void testAddition() {
Calculator calculator = new Calculator();
int result = calculator.add(2, 3);
assertEquals(5, result, "2 + 3 should equal 5");
}
}

Использование утверждений

📌 Читать

@javatg

🖥 Может ли Java быть быстрой? Сравнение производительности Helidon Níma и Spring

Основной тренд в мире IT сейчас - экономия ресурсов и легковесные решения. В облаке мы платим только за те ресурсы, которые действительно используем. И чем эффективнее мы их используем, тем меньше денег тратится впустую: уменьшая издержки, увеличиваем маржинальность.

Java долгое время была и остается фаворитом в enterprise решениях, но все чаще в высоконагруженных проектах предпочтение отдается более "производительным" языкам, таким как Go, а порой даже C++. Но вдруг Java тоже может быть быстрой?

📌 Читать дальше

@javatg

🖥 Документация Spring Boot 3 REST API с использованием SpringDoc OpenAPI

В этом руководстве подробно объясняется, как генерировать документацию REST API с помощью библиотеки SpringDoc OpenAPI в приложениях Spring Boot 3.

📌 Читать

@javatg

🖥 Принципы SOLID в Kotlin

SOLID — это аббревиатура, обозначающая пять принципов дизайна, которые позволяют создавать сопровождаемое, масштабируемое и надежное ПО. Роберт К. Мартин ввел эти принципы, чтобы помочь программистам писать высококачественный код. Изначально предназначенные для объектно-ориентированного программирования, принципы SOLID применимы и к другим языкам, например Kotlin. Они направлены на обеспечение чистоты кода и улучшение дизайна программного обеспечения.

Вот 5 принципов SOLID:

Single Responsibility Principle (SRP) — принцип единственной ответственности.
Open-Closed Principle (OCP) — принцип открытости/закрытости.
Liskov Substitution Principle (LSP) — принцип подстановки Лисков.
Interface Segregation Principle (ISP) — принцип разделения интерфейса.
Dependency Inversion Principle (DIP) — принцип инверсии зависимостей.
Теперь рассмотрим подробнее каждый из этих принципов с примерами выполнения и нарушения.

Принцип единственной ответственности
Принцип единственной ответственности является одним из принципов SOLID в объектно-ориентированном программировании. Смысл его заключается в том, что для каждого конкретного класса должно быть определено только одно назначение. Другими словами, каждый класс должен иметь только одну обязанность или одно задание.

SRP полезен для поддержания классов и функций, поскольку позволяет сохранить их организованность и легкость их восприятия. Определяя классу несколько обязанностей, вы непреднамеренно можете повлиять на решение этим классом других задач, что приведет к неожиданному поведению, ошибкам и увеличению затрат на сопровождение.

Теперь рассмотрим ситуации нарушения и выполнения этого принципа.

Нарушение:

// Нарушение принципа единственной ответственности
// В данном примере класс System пытается одновременно обрабатывать множество различных ситуаций.
// Такой подход может привести к серьезным проблемам в будущем.
class SystemManager {
fun addUser(user: User) { }
fun deleteUser(user: User) { }
fun sendNotification(notification:String) {}
fun sendEmail(user: User, email: String) {}
}
В данном примере класс System пытается обработать множество различных ситуаций в одном и том же месте. Такой подход может привести к серьезным проблемам в будущем.

Выполнение:

// Выполнение принципа единственной отвественности.
// Как видно из этого примера, мы разделили класс System на определенные части
// и поместили функции в соответствующие классы.

class MailManager() {
fun sendEmail(user: User, email: String) {}
}

class NotificationManager() {
fun sendNotification(notification: String) {}
}

class UserManager {
fun addUser(user: User) {}
fun deleteUser(user: User) {}
}
Как видно из этого примера, класс System разделен на определенные части и функции помещены в соответствующие классы.

Принцип открытости/закрытости
Принцип “открытости/закрытости” — это правило объектно-ориентированного программирования, согласно которому классы, модули, функции и другие программные объекты должны быть открыты для расширения, но закрыты для изменений. Это означает, что вы можете добавлять новые элементы в класс, не модифицируя его исходный код. Таким образом, вместо изменения самого класса для добавления новых возможностей можно написать новый код, использующий существующий класс. Вследствие этого, код становится более удобным для сопровождения и повторного использования.

Теперь рассмотрим ситуации нарушения и корректного выполнения этого принципа.

📌 Читать дальше

@javatg

💼 Лучшие способы тестирования функциональности системы.

Тестирование функциональности системы является одним из важнейших этапов разработки программного обеспечения и инженерных процессов.

Оно гарантирует, что система или программное приложение работает так, как ожидается, соответствует требованиям пользователей и надежно функционирует.

Здесь мы рассмотрим лучшие способы:

1. Юнит-тестирование: Обеспечивает корректную работу отдельных компонентов кода в изоляции.

2. Интеграционное тестирование: Проверяет, что различные части системы работают без сбоев.

3. Системное тестирование: Оценивает соответствие всей системы требованиям пользователя и ее производительность.

4. Нагрузочное тестирование: Проверяет способность системы справляться с высокими нагрузками и выявляет проблемы с производительностью.

5. Тестирование на ошибки: Оценивается, как программное обеспечение обрабатывает недействительные входные данные и условия ошибок.

6. Автоматизация тестирования: Автоматизирует выполнение тестовых примеров для повышения эффективности, повторяемости и уменьшения количества ошибок.

Как вы подходите к тестированию функциональности системы в своих проектах по разработке программного обеспечения, пишите в комментариях.

@javatg

🖥 ​Чистая архитектура на Android

Полезный репозиторий, в котором представлены все основные принципы чистой архитектуры: разделение ответственности, слоев, представления и данных.

Проект написан на Kotlin с применением Jetpack Compose и Coroutines. В нём есть юнит-тесты, интеграционные и анализ качества кода.

• Github

@javatg

🖥 Learn Dynamic Programming Techniques in Java

Динамическое программирование - это подход, позволяющий разбивать задачи на более мелкие подзадачи.

Это полезный навык для решения задач min change, max path sum и других вопросов на собеседовании по кодингу.

В этом бесплатном курсе вы изучите методы динамического программирования на языке Java.

📌 Video

@javatg