Appjar is an affordable suite of apps for startups to leverage in order to compete with the bigger guys in their space, but for way less money

Appjar

appjar

Hi, there! Occasionally, there arises a need for swift load testing, whether it be in a local environment or on a testing platform. Typically, such tasks are tackled using specialized tools that demand thorough prior comprehension. However, within enterprises and startups where rapid time-to-market and prompt hypothesis validation are paramount, excessive tool familiarization becomes a luxury. This article aims to spotlight developer-centric solutions that obviate the necessity for profound engagement, allowing for rudimentary testing without delving into pages of documentation. local running You should install:: Docker — all services and tools are required for it. Java 19+ — for kotlin service. Also, you can try to use the Java 8 version; it should work, but you have to change the Gradle settings. Golang — one of the services is golang service =) Python 3+ — for the Yandex tank. Tech Requirements Prior to embarking on our journey, it is advisable to generate a couple of services that can serve as illustrative examples for testing purposes. Kotlin + webflux. r2dbc + postgres. Stack: Our service has: – get all stocks (limit 10) GET – get stock by name GET__ /api/v1/stocks /api/v1/stock ?name=appl – save stock POST / api/v1/stock It should be an easy service because we have to focus on load testing =) Kotlin and the HTTP Service Let's start by creating a small service with some basic logic inside. We'll prepare a model for this purpose: @Table("stocks")
data class Stock(
    @field:Id val id: Long?,
    val name: String,
    val price: BigDecimal,
    val description: String
) Simple router: @Configuration
@EnableConfigurationProperties(ServerProperties::class)
class StockRouter(
    private val properties: ServerProperties,
    private val stockHandler: StockHandler
) {

    @Bean
    fun router() = coRouter {
        with(properties) {
            main.nest {
                contentType(APPLICATION_JSON).nest {
                    POST(save, stockHandler::save)
                }
                GET(find, stockHandler::find)
                GET(findAll, stockHandler::findAll)
            }
        }
    }
} and handler: @Service
class StockHandlerImpl(
    private val stockService: StockService
) : StockHandler {

    private val logger = KotlinLogging.logger {}

    private companion object {
        const val DEFAULT_SIZE = 10
        const val NAME_PARAM = "name"
    }

    override suspend fun findAll(req: ServerRequest): ServerResponse {
        logger.debug { "Processing find all request: $req" }

        val stocks = stockService.getAll(DEFAULT_SIZE)
        return ServerResponse.ok()
            .contentType(MediaType.APPLICATION_JSON)
            .body(stocks, StockDto::class.java)
            .awaitSingle()
    }

    override suspend fun find(req: ServerRequest): ServerResponse {
        logger.debug { "Processing find all request: $req" }

        val name = req.queryParam(NAME_PARAM)

        return if (name.isEmpty) {
            ServerResponse.badRequest().buildAndAwait()
        } else {
            val stocks = stockService.find(name.get())

            ServerResponse.ok()
                .contentType(MediaType.APPLICATION_JSON)
                .body(stocks, StockDto::class.java)
                .awaitSingle()

        }
    }

    override suspend fun save(req: ServerRequest): ServerResponse {
        logger.debug { "Processing save request: $req" }

        val stockDto = req.awaitBodyOrNull(StockDto::class)
        return stockDto?.let { dto ->
            stockService.save(dto)

            ServerResponse
                .ok()
                .contentType(MediaType.APPLICATION_JSON)
                .bodyValue(dto)
                .awaitSingle()
        } ?: ServerResponse.badRequest().buildAndAwait()
    }

} Full code here: GitHub Create a docker file: FROM openjdk:20-jdk-slim
VOLUME /tmp
COPY build/libs/*.jar app.jar
ENTRYPOINT ["java", "-Dspring.profiles.active=stg", "-jar", "/app.jar"] Then, build a docker image and tune it 🤤 docker build -t ere/stock-service .
docker run -p 8085:8085 ere/stock-service But for now, it's better to stick with the idea of running everything through Docker containers and migrate our service into a Docker Compose setup. version: '3.1'

services:

  db:
    image: postgres
    container_name: postgres-stocks
    ports:
      - "5432:5432"
    environment:
      POSTGRES_PASSWORD: postgres

  adminer:
    image: adminer
    ports:
      - "8080:8080"

  stock-service:
    image: ere/stock-service
    container_name: stock-service
    ports:
      - "8085:8085"
    depends_on:
      - db Moving forward: how can we proceed with testing? Specifically, how can we initiate a modest load test for our recently developed service? It’s imperative that the testing solution is both straightforward to install and user-friendly. Given our time constraints, delving into extensive documentation and articles isn’t a viable option. Fortunately, there’s a viable alternative — enter Yandex Tank. The tank is a powerful instrument for testing and has important integrations with , but in the article, we will use it as a simple tool. JMeter https://github.com/yandex/yandex-tank?embedable=true Docs: https://yandextank.readthedocs.org/en/latest/ Let's kick off by creating a folder for our tests. Once we've placed the configs and other essential files—fortunately, just a couple of them—we'll be all set. For our service, we need to test methods “get-all” and “save.” The first config for find method. phantom:
  address: localhost
  port: "8085"
  load_profile:
    load_type: rps
    schedule: line(100, 250, 30s)
  writelog: all
  ssl: false
  connection_test: true
  uris:
    - /api/v1/stocks
overload:
  enabled: false
telegraf:
  enabled: false  
autostop:
  autostop:
    - time(1s,10s) # if request average > 1s
    - http(5xx,100%,1s) # if 500 errors > 1s
    - http(4xx,25%,10s) # if 400 > 25%
    - net(xx,25,10) # if amount of non-zero net-codes in every second of last 10s period is more than 25 Key settings for configuration: Address and port: Same as our application. Load test profile (load_profile): We'll use the 'lined' type, ranging from 100 requests per second to 250 with a 30-second limit. URIs: A list of URLs to be tested. Autostop pattern: No need to stress-test if our service has already gone down! =) Copy and paste the bash script (tank sh): docker run \
    -v $(pwd):/var/loadtest \
    --net="host" \
    -it yandex/yandex-tank And run! What will we see as a result? Yandex Tank will log everything it deems worthy during the test. We can observe metrics such as the 99th percentile and requests per second (rps). So, are we stuck with the terminal now? I want a GUI! Don't worry, Yandex Tank has a solution for that too. We can utilize one of the overload plugins. Here's an example of how to add it: overload:
  enabled: true
  package: yandextank.plugins.DataUploader
  job_name: "save docs"
  token_file: "env/token.txt" We should add our token; just go here and logic by GitHub: https://overload.yandex.net Okay, dealing with a GET request is straightforward, but what about POST? How do we structure the request? The thing is, you can't just throw the request into the tank; you need to create patterns for it! What are these patterns? It's simple — you need to write a small script, which you can again fetch from the documentation and tweak a bit to suit our needs. https://yandextank.readthedocs.io/en/latest/ammo_generators.html?source=post_page-----77157bf4a779--------------------------------&embedable=true And we should add our own body and headers: #!/usr/bin/env python3
# -*- coding: utf-8 -*-

import sys
import json

# http request with entity body template
req_template_w_entity_body = (
        "%s %s HTTP/1.1\r\n"
        "%s\r\n"
        "Content-Length: %d\r\n"
        "\r\n"
        "%s\r\n"
    )

# phantom ammo template
ammo_template = (
        "%d %s\n"
        "%s"
    )

method = "POST"
case = ""
headers = "Host: test.com\r\n" + \
          "User-Agent: tank\r\n" + \
          "Accept: */*\r\n" + \
          "Connection: Close\r\n" 


def make_ammo(method, url, headers, case, body):
    """ makes phantom ammo """
    req = req_template_w_entity_body % (method, url, headers, len(body), body)
    return ammo_template % (len(req), case, req)


def generate_json():
    body = {
        "name": "content",
        "price": 1,
        "description": "description"
    }
    url = "/api/v1/stock"
    h = headers + "Content-type: application/json"
    s1 = json.dumps(body)
    ammo = make_ammo(method, url, h, case, s1)
    sys.stdout.write(ammo)
    f2 = open("ammo/ammo-json.txt", "w")
    f2.write(ammo)


if __name__ == "__main__":
    generate_json() Result: 212 
POST /api/v1/stock HTTP/1.1
Host: test.com
User-Agent: tank
Accept: */*
Connection: Close
Content-type: application/json
Content-Length: 61

{"name": "content", "price": 1, "description": "description"} That’s it! Just run the script, and we will have ammo-json.txt. Just set new params to config, and delete the URLs: phantom:
  address: localhost:9001
  ammo_type: phantom
  ammofile: ammo-json.txt And run it one more time! It’s Time to Test the GRPC! Having acquainted ourselves with loading HTTP methods, it’s natural to consider the scenario for GRPC. Are we fortunate enough to have an equally accessible tool for GRPC, akin to the simplicity of a tank? The answer is affirmative. Allow me to introduce you to ‘ghz’. Just take a look: https://ghz.sh/?source=post_page-----77157bf4a779--------------------------------&embedable=true But before we do that, we should create a small service with Go and GRPC as a good test service. Prepare a small proto file: syntax = "proto3";

option go_package = "stock-grpc-service/stocks";

package stocks;

service StocksService {
  rpc Save(SaveRequest) returns (SaveResponse) {}
  rpc Find(FindRequest) returns (FindResponse) {}
}

message SaveRequest {
  Stock stock = 1;
}

message SaveResponse {
  string code = 1;
}

message Stock {
  string name = 1;
  float price = 2;
  string description = 3;
}

message FindRequest {
  enum Type {
    INVALID = 0;
    BY_NAME = 1;
  }
  message ByName {
    string name = 1;
  }
  Type type = 1;

  oneof body {
    ByName by_name = 2;
  }
}

message FindResponse {
  Stock stock = 1;
} And generate it! (also, we should install ) protoc protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative stocks.proto Our results: Coding Time! Next steps: Create services as fast as we can. Create dto (stock entity for db layer) package models

// Stock – base dto
type Stock struct {
 ID          *int64  `json:"Id"`
 Price       float32 `json:"Price"`
 Name        string  `json:"Name"`
 Description string  `json:"Description"`
} Implement server // Server is used to implement stocks.UnimplementedStocksServiceServer.
type Server struct {
 pb.UnimplementedStocksServiceServer
 stockUC stock.UseCase
}

// NewStockGRPCService stock gRPC service constructor
func NewStockGRPCService(emailUC stock.UseCase) *Server {
 return &Server{stockUC: emailUC}
}

func (e *Server) Save(ctx context.Context, request *stocks.SaveRequest) (*stocks.SaveResponse, error) {
 model := request.Stock

 stockDto := &models.Stock{
  ID:          nil,
  Price:       model.Price,
  Name:        model.Name,
  Description: model.Description,
 }

 err := e.stockUC.Create(ctx, stockDto)
 if err != nil {
  return nil, err
 }

 return &stocks.SaveResponse{Code: "ok"}, nil
}

func (e *Server) Find(ctx context.Context, request *stocks.FindRequest) (*stocks.FindResponse, error) {
 code := request.GetByName().GetName()

 model, err := e.stockUC.GetByID(ctx, code)
 if err != nil {
  return nil, err
 }

 response := &stocks.FindResponse{Stock: &stocks.Stock{
  Name:        model.Name,
  Price:       model.Price,
  Description: model.Description,
 }}

 return response, nil
} Full code here: click, please! Test It! Install GHz with brew (as usual): link Let’s check a simple example: link Now, we should change it a little bit: move to the folder with the proto files. add method: . stocks.StocksService.Save add simple body: ‘{“stock”: { “name”:”APPL”, “price”: “1.3”, “description”: “apple stocks”} }’. connections will be shared among goroutine workers. Each pair of goroutines will share a single connection. 10 20 2 set service’s port and the result: cd .. && cd stock-grpc-service/proto

ghz --insecure \
  --proto ./stocks.proto \
  --call stocks.StocksService.Save \
  -d '{"stock": { "name":"APPL", "price": "1.3", "description": "apple stocks"} }' \
  -n 2000 \
  -c 20 \
  --connections=10 \
  0.0.0.0:5007 Run it! Summary:
  Count:        2000
  Total:        995.93 ms
  Slowest:      30.27 ms
  Fastest:      3.11 ms
  Average:      9.19 ms
  Requests/sec: 2008.16

Response time histogram:
  3.111  [1]   |
  5.827  [229] |∎∎∎∎∎∎∎∎∎∎∎
  8.542  [840] |∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎
  11.258 [548] |∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎
  13.973 [190] |∎∎∎∎∎∎∎∎∎
  16.689 [93]  |∎∎∎∎
  19.405 [33]  |∎∎
  22.120 [29]  |∎
  24.836 [26]  |∎
  27.551 [6]   |
  30.267 [5]   |

Latency distribution:
  10 % in 5.68 ms 
  25 % in 6.67 ms 
  50 % in 8.27 ms 
  75 % in 10.49 ms 
  90 % in 13.88 ms 
  95 % in 16.64 ms 
  99 % in 24.54 ms 

Status code distribution:
  [OK]   2000 responses And what, stare at everything in the terminal again? No, with ghz, you can also generate a report, but unlike Yandex, it will be generated locally and can be opened in the browser. Just set it: ghz --insecure -O html -o reports_find.html \
... -O + html → output format -o filename Conclusion In summary, when you need a swift assessment of your service's ability to handle a load of 100+ requests per second or identify potential weaknesses, there's no need to initiate intricate processes involving teams, seeking assistance from AQA, or relying on the infrastructure team. More often than not, developers have capable laptops and computers that can execute a small load test. So, go ahead and give it a shot—save yourself some time! I trust you found this brief article beneficial. Valuable Documentation I Recommend Reading: Yandex Tank: docs link Yandex Tank GitHub: GitHub link Yandex Tank Setting: link ghz official page: link ghz setting: ghz config: link link May the Force Be With You! Thanks once again, and best of luck! 🍀🕵🏻

Turbocharge Load Testing: YandexTank + ghz Combo for Lightning–Fast Code Checks!

টার্বোচার্জ লোড টেস্টিং: লাইটনিং-ফাস্ট কোড চেকের জন্য ইয়ানডেক্সট্যাঙ্ক + গিগাহার্টজ কম্বো!

Turbolader-Lasttest: YandexTank + GHz-Kombination für blitzschnelle Codeprüfungen!

Prueba de carga de turbocompresor: combinación YandexTank + ghz para verificaciones de códigos ultrarrápidas.

Test de charge Turbocharge : YandexTank + ghz Combo pour des vérifications de code ultra-rapides !

टर्बोचार्ज लोड परीक्षण: लाइटनिंग-फास्ट कोड जांच के लिए YandexTank + ghz कॉम्बो!

ターボチャージ負荷テスト: YandexTank + ghz コンボによる超高速コード チェック!

터보차지 부하 테스트: 매우 빠른 코드 검사를 위한 YandexTank + ghz 콤보!

Teste de carga turboalimentada: combinação YandexTank + ghz para verificações de código extremamente rápidas!

Турбо-нагрузочное тестирование: комбинация ЯндексТанк + ghz для молниеносной проверки кода!

Turboşarj Yük Testi: Hızlı Kod Kontrolleri için YandexTank + ghz Kombinasyonu!

Kiểm tra tải tăng áp: Combo YandexTank + ghz để kiểm tra mã nhanh như chớp!

涡轮增压负载测试：YandexTank + ghz 组合可实现闪电般的快速代码检查！

https://www.youtube.com/watch?v=az-va7ofef8&embedable=true Introduction For those not familiar with Ambient TVs, it’s a way to soften the jump from the edge of the TV screen and its immediate surroundings to provide a more immersive experience. I had some LED lights lying around and decided to see if it was possible to control the lights through code and, in turn, make my computer screen an ambient monitor. Whilst I wanted to use it for my monitor, it can be used anywhere and with whatever colors you can send it, including other features your lights may have, such as audio reactions or random patterns. I’ve been meaning to write this post for a while as I’ve been using it on an earlier monitor, but I never got around to adding it to my new monitor, so I documented it as I went along for anyone who might find it useful. So let’s get to it! (Please note, LED lights are likely to be Bluetooth Low Energy (BLE), so your computer will need to support BLE in order to interact with them). The full code is on . GitHub High Level Steps Find out what commands the LED light’s Bluetooth receiver accepts Send commands to the LED lights via my computer’s Bluetooth Obtain the dominant color of the current screen Send the dominant color to the LED lights Prerequisites Bluetooth-supported RGB LED lights and accompanying app (I’m using Android, iOS would likely require an alternative approach than the one described here, but it should be possible to use Wireshark directly to monitor Bluetooth traffic). I've attached these lights to the back of my monitor Wireshark (specifically adb.exe) Android’s SDK tools Developer tools (I’ll be using Python 3.10, though any 3.x versions should work, but the principles should be the same whatever for language you prefer) A device to send BLE commands from (e.g. a laptop that supports BLE) Getting Bluetooth data The first step we need to do is to ensure that the app that comes with the lights is working as expected. This can easily be tested by running the light’s original app and making sure that the lights react accordingly depending on the on/off/lighting buttons you’re pressing on your app. We do this because we will shortly be pressing and detecting the specific codes sent to the Bluetooth receiver on the lights. There are two approaches that I could take. One was to decompile the app’s JAR file and find the codes that were being sent, but I wanted to learn more about the Bluetooth protocol, so I opted to log all Bluetooth activity on my Android and extract it from there. Here’s how: Enable on your Android device. Developer Options Enable Bluetooth HCI snoop log (HCI stands for Host-Controller Interface). You can find this option in or search for it in settings as in the image below. Settings > System > Developer We now need to perform specific actions so we can identify what each action sends to the light’s Bluetooth receiver. I’m going to keep it simple to On/Red/Green/Blue/Off, in that order, but if your lights support other features, you can toy around with those too. Run the app and press On, Red, Green, Blue, and Off. It may also be useful to keep an eye on the approximate time to make it easier to filter if you have a lot of Bluetooth activity on your device. Turn Bluetooth off so we don’t get any more noise. In the following steps, we’ll analyze the Bluetooth commands and, as we know the order of what we pressed, we can find out which values correspond to which button press. We now need to access the Bluetooth logs on the phone. There are several ways to do this, but I will generate and export a bug report. To do this, enable USB Debugging in the phone’s Settings, connect the phone to the computer, and use the adb.exe command line tool. adb bugreport led_bluetooth_report This will generate a zip file on your computer’s local directory with the filename “ ”. You can specify a path if you prefer (e.g. C:\MyPath\led_bluetooth_report”) led_bluetooth_report.zip Within this zip are the logs that we need. This may vary from device to device (please comment if you found it elsewhere on your device). On my Google Pixel phone, it was in FS\data\misc\bluetooth\logs\btsnoop_hci.log Now we have the log files, let’s analyze them! To do this, I decided to use Wireshark so start Wireshark and go to File...Open... and select the btsnoop_hci log file. Whilst it may look daunting, let’s make it easy for ourselves to find what we’re looking for by filtering the on which is the Attribute Protocol in the . The attribute protocol defines the way two BLE devices talk to each other, so this is what we need to help find how the app talks to the lights. You can filter the logs in Wireshark by typing in the “ ” bar near the top and press Enter BTL2CAP 0x0004, Wireshark source code btl2cap.cid == 0x0004 Apply a display filter Now we have filtered the log; it should make looking for the commands easier. We can look at the timestamps (Go to View…Time Display Format…Time of Day to convert the time if it’s the wrong format). We want to look at the Sent Write Command logs as those are the ones where we sent a value to the lights. Assuming your most recent time is at the bottom, scroll down to the last five events. These should be On, Red, Green, Blue, and Off in that order, with Off being last. Take note of the Destination BD_ADDR, as we'll need that shortly, and put on your Sherlock Holmes hat, as this is where we need to unlock the pattern of how the colors and on/off commands are encoded within the message. This will vary depending on the light manufacturer but here’s the list of values I got for my device: On: 7e0404f00001ff00ef Red: 7e070503ff000010ef Green: 7e07050300ff0010ef Blue: 7e0705030000ff10ef Off: 7e0404000000ff00ef These are clearly hexadecimal values and if you look carefully, you’ll see there are some fixed patterns. Let’s split the patterns out as this should make things much clearer. On: 7e0404 ff00ef f00001 Red: 7e070503 10ef ff0000 Green: 7e070503 10ef 00ff00 Blue: 7e070503 10ef 0000ff Off: 7e0404 ff00ef 000000 For those familiar with hexadecimal values of pure red, green, and blue, you’ll know that the values are #FF000, #00FF00, and #0000FF, respectively, which is exactly what we can see above. This means we now know the format to change the colors to whatever we want! (or at least to what the lights themselves are capable of). We can also see that On and Off have a different format from the colors and are similar to each other, with On having f00001 and Off having 00000. That’s it! We now have enough information to start coding and interacting with the lights. Connecting to LED lights There are three key things we need: The address of the device (this is the Destination BD_ADDR from above) The values to send to the device (the hexadecimal values obtained above) The characteristic we want to change. A Bluetooth LE characteristic is a data structure that essentially defines data that can be sent between a host and client Bluetooth devices. We need to find the characteristic (a 16-bit or 128-bit UUID) that refers to the lights. There are some commonly used assigned numbers that can be found here but unless the device conforms to those, they could be using a custom UUID. As my lights aren’t in the assigned numbers list, let’s find it via code. I’m using Python 3.10 and . Ensure Bluetooth on your computer is turned on (no need to pair with the device, we’ll connect to it through code). Bleak 0.20.1 # Function to create a BleakClient and connect it to the address of the light's Bluetooth reciever
async def init_client(address: str) -> BleakClient:
    client =  BleakClient(address)  
    print("Connecting")
    await client.connect()
    print(f"Connected to {address}")
    return client

# Function we can call to make sure we disconnect properly otherwise there could be caching and other issues if you disconnect and reconnect quickly
async def disconnect_client(client: Optional[BleakClient] = None) -> None:
    if client is not None :
        print("Disconnecting")
        if characteristic_uuid is not None:
            print(f"charUUID: {characteristic_uuid}")
            await toggle_off(client, characteristic_uuid)
        await client.disconnect()
        print("Client Disconnected")
    print("Exited")

# Get the characteristic UUID of the lights. You don't need to run this every time
async def get_characteristics(client: BleakClient) -> None:
    # Get all the services the device (lights in this case) 
    services = await client.get_services() 
    # Iterate the services. Each service will have characteristics
    for service in services: 
        # Iterate and subsequently print the characteristic UUID
        for characteristic in service.characteristics: 
            print(f"Characteristic: {characteristic.uuid}") 
    print("Please test these characteristics to identify the correct one")
    await disconnect_client(client) I’ve commented on the code, so it should be self-explanatory but essentially, we connect to the lights and find all the characteristics it exposes. My output was: Characteristic: 00002a00-0000-1000-8000-00805f9b34fb
Characteristic: 00002a01-0000-1000-8000-00805f9b34fb
Characteristic: 0000fff3-0000-1000-8000-00805f9b34fb
Characteristic: 0000fff4-0000-1000-8000-00805f9b34fb A quick Google of the first two UUIDs shows this refers to the name and appearance of the service, which is irrelevant for us. However, the third and fourth seem the most suitable with the third ( ) being the write characteristic according to . Excellent, we now have the characteristic we need for this particular device to write to with a value (the color hexadecimal). 0000fff3-0000-1000-8000-00805f9b34fb this page Controlling LED lights We finally have all the pieces this we need. At this stage, you can get creative with what color input you’d like to use. You could, for example, connect the lights to a trading market API to change colors according to how your portfolio is doing. In this case, we want to make our monitors ambient aware, so we need to obtain the dominant color of the screen and send that through. There are many ways to do this, so feel free to experiment with whatever algorithms you would like. One of the simplest approaches would be to iterate every X number of pixels across the screen and take an average while more complicated solutions would look for colors human eyes perceive to be more dominant. Feel free to comment on any findings you’d like to share! For the sake of this blog post, I’m going to keep it simple by using the library’s get_dominant_color method. fast_colorthief '''
Instead of taking the whole screensize into account, I'm going to take a 640x480 resolution from the middle. 
This should make it faster but you can toy around depending on what works for you. You may, for example, want
to take the outer edge colours instead so it the ambience blends to the outer edges and not the main screen colour 
'''
screen_width, screen_height = ImageGrab.grab().size #get the overall resolution size 
region_width = 640
region_height = 480
region_left = (screen_width - region_width) // 2
region_top = (screen_height - region_height) // 2
screen_region = (region_left, region_top, region_left + region_width, region_top + region_height)

screenshot_memory = io.BytesIO(b"")

# Method to get the dominant colour on screen. You can change this method to return whatever colour you like
def get_dominant_colour() -> str:
    # Take a screenshot of the region specified earlier
    screenshot = ImageGrab.grab(screen_region)
    '''
    The fast_colorthief library doesn't work directly with PIL images but we can use an in memory buffer (BytesIO) to store the picture
    This saves us writing then reading from the disk which is costly
    '''
    
    # Save screenshot region to in-memory bytes buffer (instead of to disk)
    # Seeking and truncating fo performance rather than using "with" and creating/closing BytesIO object
    screenshot_memory.seek(0)
    screenshot_memory.truncate(0)
    screenshot.save(screenshot_memory, "PNG") 
    # Get the dominant colour
    dominant_color = fast_colorthief.get_dominant_color(screenshot_memory, quality=1) 
    # Return the colour in the form of hex (without the # prefix as our Bluetooth device doesn't use it)
    return '{:02x}{:02x}{:02x}'.format(*dominant_color) The code is commented, so hopefully, it should be clear as to what’s happening, but we’re taking a smaller region of the screen from the middle and then getting the dominant color from that region. The reason I’m taking a smaller region is for performance; fewer pixels would need to be analyzed. We’re almost there! We now know what to send it and where to send it. Let’s finish the last major part of this challenge which is to actually send it. Fortunately, with the Bleak library, this is quite straightforward. async def send_colour_to_device(client: BleakClient, uuid: str, value: str) -> None:
    #write to the characteristic we found, in the format that was obtained from the Bluetooth logs
    await client.write_gatt_char(uuid, bytes.fromhex(f"7e070503{value}10ef"))

async def toggle_on(client: BleakClient, uuid: str) -> None:
    await client.write_gatt_char(uuid, bytes.fromhex(ON_HEX))
    print("Turned on")

async def toggle_off(client: BleakClient, uuid: str) -> None:
    await client.write_gatt_char(uuid, bytes.fromhex(OFF_HEX))
    print("Turned off") As we discovered from the logs, each color has a fixed template, so we can use f-strings to hardcode the common part and simply pass a hexadecimal of a color for the value in the middle. This can be called from our loop. On and Off had unique hexademicals so I created individual functions and passed in a constant value that contained the relevant hex. while True: 
    # send the dominant colour to the device
    await send_colour_to_device(client, characteristic_uuid, get_dominant_colour())
    # allow a small amount of time before update
    time.sleep(0.1) And there we have it; our Bluetooth LED lights are now controlled by the colors on the screen, creating our own Ambient Monitor. You can see the full code on , which has a small amount of infrastructure code that wasn't specific to this post. I’ve tried to comment the code to be self-explanatory but feel free to ask any questions or make suggestions. GitHub Hopefully, this gives you an idea on how you can start getting creative with your LED lights. Future Improvements - My light strips can only have one color at a time, but I have another set that can have four quadrants, each with its own colors. This means it could be possible to have sections of the monitor match four sections on screen giving an even more accurate ambiance setting. Those lights run on Wifi instead of Bluetooth and could be a future project. Multi-colour – to keep it simple, I just looked for the color changing and the on-and-off commands. However, this can easily be improved by detecting the brightness control commands and throwing that into the color algorithm. Brightness - As we want to get the lights to change in realtime, performance is critical. There are some complex algorithms to detect which color would be considered the most dominant, especially when perceived by humans (which leads to a whole world of color conversions). However, since this needs to run quite quickly, there needs to be a balance between performance and accuracy. A future improvement could be to try and access the graphics card directly to read from the buffer rather than analyzing the pixels on the screen directly. If this is possible, you would also eliminate the time taken from the graphics buffer to the screen which could optimize the reaction of the lights. Performance Feel free to comment below if you have any feedback or questions. Also Published Here

Reverse Engineer LED Lights with Python to Convert your Computer Monitor to an Ambient Monitor

আপনার কম্পিউটার মনিটরকে অ্যাম্বিয়েন্ট মনিটরে রূপান্তর করতে পাইথনের সাথে বিপরীত প্রকৌশলী এলইডি লাইট

Reverse Engineer von LED-Leuchten mit Python, um Ihren Computermonitor in einen Umgebungsmonitor umzuwandeln

Ingeniería inversa de luces LED con Python para convertir el monitor de su computadora en un monitor ambiental

Reverse Engineering LED Lights avec Python pour convertir votre écran d'ordinateur en un moniteur ambiant

अपने कंप्यूटर मॉनिटर को एक एम्बिएंट मॉनिटर में बदलने के लिए पायथन के साथ रिवर्स इंजीनियर एलईडी लाइट्स

Python で LED ライトをリバース エンジニアリングして、コンピューター モニターをアンビエント モニターに変換する

Python을 사용하여 LED 조명을 리버스 엔지니어링하여 컴퓨터 모니터를 주변 모니터로 변환

Luzes LED de engenharia reversa com Python para converter seu monitor de computador em um monitor ambiente

Bilgisayar Monitörünüzü Ortam Monitörüne Dönüştürmek için Python ile Tersine Mühendislik LED Işıkları

Kỹ sư đảo ngược đèn LED với Python để chuyển đổi màn hình máy tính của bạn thành màn hình xung quanh

使用 Python 对 LED 灯进行逆向工程，将您的计算机显示器转换为环境显示器

At my job, I am evaluating some microservices platform options. A good way to test them is doing some benchmarks. Everybody likes benchmarks. So, why not? although I tried to make conditions fair and "scientific", it's an and I'm making this for fun. Please, don't take it too seriously. Disclaimer: amateur benchmark Why Quarkus? It's the "supersonic subatomic Java" framework, sponsored by Red Hat. My work place is a Red Hat shop and we have many subscriptions from them. So, Quarkus is not only a good fit, but we already use it on some projects. It promises a better startup time and memory footprint. Tested version: 1.6.1. Why Phoenix Well, personal preference. I like Elixir, it is a powerful and fun language. When you discover Erlang and what problems it was made to solve, you will find it amazing. WhatsApp, Discord and many others use it. The framework of choice for the Elixir language is Phoenix. Achieving is really impressive too. Tested version: 1.5.4. 2 million connections in a single machine The benchmark I couldn't find any real benchmarks on these technologies. There is , which are the technologies behind these frameworks, but using a "sleep" to simulate load is not ok. These frameworks handle databases and connection pools differently. Acquiring a database connection from a pool can timeout and throw an exception. A "sleep" command won't timeout. Serializing data to JSON also impose memory and CPU usage. this benchmark on Netty and Cowboy does something different, but it uses good hardware and low load. Its focus is on how many requests per second a framework can handle, and this is not ok too. So, speed isn't a concern at this point. Techempower I need to know what framework can handle more requests within constrained hardware, like a Heroku dyno. In this benchmark, I decided to use my work development database and data. It's an Oracle database and my test data is on a table with 5 columns and 6000 rows. Yes, it is a lot of JSON, so it can force some timeouts, CPU and memory usage. Although Oracle JDBC driver is well tested and supported, in Phoenix we must rely on package. It works well and it is maintained, but it's not "official". Oracle database driver is not a first class citizen on Quarkus either, and we can not compile it to a native image using GraalVM out of the box. jamdb_oracle We are going to use the tool. Quarkus will run on OpenJDK 11 by Red Hat and Phoenix on Erlang OTP 22, both on a Red Hat Linux 8 with 4 cores and 8 GB of RAM. But, we are pretending to be inside a Heroku dyno or docker container, so the memory limit will be 512 MB. siege On Heroku or docker, any memory allocation beyond this will use disk swap, reducing perfomance. Keep that in mind! Comparing Apples to Oranges Before we start, we have to remember this. We can not use these frameworks as they come out of the box. To compare apples to apples (and not to oranges) and make things fair, I will configure both frameworks with the same connection pool size and timeout. In Phoenix, the default connection timeout and pool size are very low, so it can fail fast and use less memory. In Quarkus, the connection timeout is longer and pool size bigger, so it can serve more requests at the cost of memory. Well, that is what I think, but I might be wrong. For the test, we had to impose some limits to the JVM, as suggested by Heroku: java -Xss512k -Xmx300m -jar <my-app>.jar We will use to hit the REST endpoint with 25, 50, 100 e 250 concurrent connections, 5 times each. siege siege -d1 -r5 -c250 http://<my-server> Here are the results: CPU Winner: Quarkus Both frameworks have a similar CPU usage profile and "warmup" peak. Quarkus and JVM peaked at 56% of CPU usage while Phoenix and Erlang VM peaked at 79% of CPU usage. OpenJDK uses less CPU over time and is the clear winner. Memory Winner: Phoenix (x2) Phoenix peaked at 364 MB and Quarkus peaked at 807 MB. Here we can see Quarkus and JVM problem on microservices. Java refuses to stay within the 512 MB limit. Actually, it uses more than twice the memory Phoenix used. As stated above, at Heroku or docker with a 512 MB of RAM limit, any memory beyond that will use disk swap, reducing performance. In this benchmark, I could simulate this, because I had memory available. not Why Phoenix won 2 times? I could not show it on the graph, but another thing to notice is that Erlang/Elixir gives back unused memory to the operating system. It peaked at 364 MB, but after the test, it was using only 152 MB. JVM, on the other hand, never return unused memory back to the operating system, it peaked at 807 MB and stayed there. So, Quarkus lost twice here. If you run your own cloud, like me, this is an important and desired behaviour. Speed Winner: Quarkus Quarkus took, at most, 34 secs to respond to all requests. Phoenix took 60 secs. Not much to argue here. Quarkus and JVM are faster. And in this benchmark, they are almost twice as fast than Phoenix. Quarkus is the clear winner. If your microservice have any speed requirement, Quarkus is a better fit than Phoenix. Timeouts Winner: Draw What? Why a draw? Well, handling 250 simultaneous connections, Quarkus timed out 110 times while Phoenix timed out 155 times. Quarkus should be the winner. The problem is the difference is not so big. As stated above, Quarkus used more memory than it was available. If it was at Heroku or docker, it would be using disk swap, having perfomance penalties and leading to more timeouts. But, I could not simulate that and Quarkus had this "advantage". So, I will consider it a draw. Conclusion As I said in the introduction, I was looking for a framework that could handle more simultaneous connections using less memory. If you are like me and need to deploy your microservices on premise hardware or on Heroku, memory usage comes first. And the ability to return unused memory back to the cluster is desirable. Requirements like speed and CPU usage comes after. Phoenix is the clear winner under this circuntances. Quarkus, on the other hand, shines where speed is a requirement and memory consumption is acceptable. The cool thing about a microservices archtecture is that you can use the best tool for the job. So, use both frameworks. They are new, comparable and capable. Also published at https://medium.com/@hlalvesbr/quarkus-vs-phoenix-62f6b1965037

Performance Battle: Quarkus vs Phoenix

The Best 75 Evernote Alternatives:  Complete Review

Keep up with the latest and best practices to build spring boot docker images. As a Java Developer I am sure you must have heard of spring boot and probably Docker as well. Docker is phenomenon that has taken DevOps world by a storm. Every new project and old one’s too are migrating to containers. In this tutorial I will cover brief description of Docker containers and the essential tips that will help you get most out of Docker with Spring Boot. Source code of the demo project is at https://github.com/avinash10584/spring-boot-docker-demo.git So what are these containers ? Many view containers as virtual machines. They’re not. Well, kind of not. A container is a virtual walled environment for your application. It’s literally a ‘container’ inside the host OS. Thus your application works like it is in its own self contained environment, but Because of this, containers are more resource efficient than full-blown virtual machines. it’s actually sharing operating system resources of the host computer. Clearly, this is more efficient computing than running a full blown Virtual Machine. Docker is an open-source project for automating the deployment of applications as portable, self-sufficient containers that can run on the cloud or on-premises. Because containers require far fewer resources (for example, they don’t need a full OS), they’re easy to deploy and they start fast. This allows you to have higher density, meaning that it allows you to run more services on the same hardware unit, thereby reducing costs. This efficient mechanism is used by most cloud providers to save them of resources. Google, Amazon and Microsoft deploy millions of containers every day. Let’s begin this tutorial of deploying spring boot app on docker and 5 awesome tips for your docker build, Step 1: Create a Hello World App Spring Boot application Our first step is to create a demo hello world application. I will be using below git repository for the spring boot app. https://github.com/avinash10584/spring-boot-docker-demo.git If you are interested in learning about creating a beginner’s spring boot app have a look at this article. https://medium.com/codingfullstack/spring-boot-microservice-on-cloud-create-shopping-list-service-part-1-9ea531054be5 Step 2 : Adding Dockerfile If you have downloaded github repo above, you would notice that we are using Spring Boot 2.3.0 comes with several changes in it’s support for docker. Spring Boot 2.3.0 The most important one is using the layered design of docker to avoid large size of spring boot apps. We will look at that in tips section of this tutorial. Let’s add a sample , Dockerfile openjdk: -jdk-slim JAR_FILE=target/*.jar FROM 15 ARG COPY app.jar ${JAR_FILE} ENTRYPOINT [ , , ] "java" "-jar" "/app.jar" Run mvn package from your IDE or terminal to generate the spring boot fat jar. Make sure you have spring boot maven plugin added to generate the fat jar. org.springframework.boot spring-boot-maven-plugin < > build < > plugins < > plugin < > groupId </ > groupId < > artifactId </ > artifactId </ > plugin </ > plugins </ > build Now let’s run below docker command to build the image, -t learnings/spring- docker build boot-docker-demo This will create an image in Docker registry, Let’s run this Docker image as a container, docker -p 3050:3050 --name spring- -docker-demo -t learnings/spring- -docker-demo run boot boot Docker layers allows us to keep our build images small in size as we make changes to our application. If our application code is changed then only application/application layer is affected and other layers stay cached. You can verify it by making changes to the RestController and running the docker build. -t learnings/spring- . docker build boot-docker-demo Check the history of your image to notice that the newly created images are in KB’s, docker learnings/docker-spring-boot-demo history Tip 3 # : Build docker image from Maven Wrapper Our docker build seems to be working but it is missing one key part, We are creating our fat jar files manually and then going to terminal to run docker build This will not work with your CI/CD pipelines as you would need to do your maven build in your CI/CD tool. We can combine these two steps in either direction, We can use a maven plugin to generate the docker image during maven build Or, We can use maven wrapper to call maven build from inside our Dockerfile. I prefer using maven wrapper so I will use that here, Make sure you have Maven before below steps, go to your project directory and run mvn -N io.takari:maven: wrapper This will install the maven wrapper in your project. Maven 3.7 plans to integrate this to Maven by default. Add maven wrapper instructions to Dockerfile and build again, openjdk: -jdk-slim as bulid openjdk: -jdk-slim FROM 15 WORKDIR application COPY mvnw . COPY .mvn .mvn COPY pom.xml . COPY src src RUN ./mvnw  install -DskipTests RUN cp /application/target/*.jar app.jar RUN java -Djarmode=layertools -jar app.jar extract FROM 15 WORKDIR application COPY --from=bulid application/dependencies/ ./ COPY --from=bulid application/spring-boot-loader/ ./ COPY --from=bulid application/snapshot-dependencies/ ./ COPY --from=bulid application/application/ ./ ENTRYPOINT [ , ] "java" "org.springframework.boot.loader.JarLauncher" No need to run maven build anymore before bjuilding your docker images. Tip 4 # : Use a separete docker user Docker runs it’s command in container as a root user, Just as in classic VM-deployments, processes should not be run with root permissions. Instead the image should contain a non-root user that runs the app. In a Dockerfile, this can be achieved by adding another layer that adds a (system) user and group, then set it as the current user (instead of the default, root): addgroup demogroup && adduser  --ingroup demogroup --disabled-password demo demo RUN USER Tip 5 # : Caching build process using Docker build cache We have added maven build process to our Dockerfile but there is one performance concern. Each time we run , it runs and downloads the maven packages as it creates a new container every time. docker bulid Docker has an experimental feature to avoid this, You can add below as your first line in Dockerfile to enable experimental features. # syntax=docker/dockerfile:experimental We need to also add below to specify that we want to cache the mount before we run maven build =type=cache,target=/root/.m2 ./mvnw install -DskipTests RUN --mount Our final Dockerfile loos like below, openjdk: -jdk-slim as bulid demo openjdk: -jdk-slim # syntax = docker/dockerfile:experimental FROM 15 RUN addgroup demogroup &amp;&amp; adduser  --ingroup demogroup --disabled-password demo USER WORKDIR application COPY mvnw . COPY .mvn .mvn COPY pom.xml . COPY src src RUN --mount= =cache,target=/root/.m2 ./mvnw  install -DskipTests type RUN cp /application/target/*.jar app.jar RUN java -Djarmode=layertools -jar app.jar extract FROM 15 WORKDIR application COPY --from=bulid application/dependencies/ ./ COPY --from=bulid application/spring-boot-loader/ ./ COPY --from=bulid application/snapshot-dependencies/ ./ COPY --from=bulid application/application/ ./ ENTRYPOINT [ , ] "java" "org.springframework.boot.loader.JarLauncher" If you run it you will probably see the error, Error response from daemon: Dockerfile parse error line 13: Unknown flag: mount We need to run the docker build with a special command to enable experimental features, docker -t learnings/spring- . DOCKER_BUILDKIT =1 build boot-docker-demo First time I ran this, my maven build step took almost a minute, => [bulid / ] COPY src src s
 => [bulid / ] RUN --mount= =cache,target=/root/. ./mvnw  install -DskipTests                ** s**
 => [bulid / ] RUN cp /application/target/*.jar app.jar 7 10 0.2 8 10 type m2 57.3 9 10 On the next run I could see the builds running almost instantaneously, => CACHED [bulid / ] RUN --mount= =cache,target=/root/. ./mvnw  install -DskipTests s
 => CACHED [bulid / ] RUN cp /application/target/*.jar app.jar s
 => CACHED [bulid / ] RUN java -Djarmode=layertools -jar app.jar extract s s 8 10 type m2 0.0 9 10 0.0 10 10 0.0 0.0 We have successfully reduced build time in our docker images. That’s all folks, as you can see we have implemented a spring boot app from scratch and learned the tips that will help ypu take your build with Docker to next level. If you have any questions or feedback don’t hesitate to write your thoughts in the comments/responses section. For issues related to code, feel free please create an issue directly in GitHub repository. https://github.com/avinash10584/spring-boot-docker-demo.git Thank you for reading! If you enjoyed it, please share/comment for it. Previously published at https://medium.com/codingfullstack/5-essential-docker-tips-for-your-spring-boot-images-8f570270d9ba

5 Tips for Creating Docker Images with Spring Boot

Scientific American, Volume XLIII., No. 25, December 18, 1880, by Various, is part of the HackerNoon Books Series. You can jump to any chapter in this book . APPARATUS FOR REMOVING ICE FROM RAILROADS. here APPARATUS FOR REMOVING ICE FROM RAILROADS. The engraving shows an improved apparatus for removing snow and ice from railroads and streets by means of heat. The invention consists of a double furnace mounted on wheels, which are incased in the fire boxes of the furnace, so that in use the entire apparatus, including the wheels, will become highly heated, so that the snow and ice will not only be melted by radiant heat, but by the actual contact of the hot surfaces of the furnace and wheels. This apparatus was recently patented by the late E. H. Angamar, of New Orleans, La. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Various (2007). Scientific American, Volume XLIII., No. 25, December 18, 1880. Urbana, Illinois: Project Gutenberg. Retrieved https://www.gutenberg.org/cache/epub/21081/pg21081-images.html This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at , located at . www.gutenberg.org https://www.gutenberg.org/policy/license.html

APPARATUS FOR REMOVING ICE FROM RAILROADS

Characterizing Cable News Bias: Related Research You Should Know About

Are DEXs Finally Become the Bedrock of Crypto Trading?

Welcome, As a Spammer of the registry (pun intended), I want to explain to you what's going on with the NPM registry and its management. At first, I felt the title `It's Party Time For NPM Spammers🥳` was offensive, unlawful, or disrespectful, and I also asked for help from an AI chatbot. I got the following results, but I purposefully stayed with the same to get attention from both NPM and the dev community. AI Chatbot: Certainly! Here are some alternative titles for your blog post on spammers in the NPM registry: “Navigating the Murky Waters: A Deep Dive into NPM Registry Spam”
“Guarding the NPM Gates: Strategies to Combat Registry Spam”
“Unmasking the Shadows: Inside the World of NPM Registry Spammers” Let's start with some basics. I request that you take a close look at the forthcoming screenshots. What is NPM? It is the world's largest software registry and a Node Package Manager for the JavaScript programming language maintained by Microsoft's npm, Inc. Types of Spam Let's list out some with my experience and a few real examples currently living in the registry. Keyword Stuffing:
Packages using irrelevant keywords to appear in more search results.



Malicious Code:
Packages containing harmful code or backdoors.


Rewarding decentralized protocol (New Type):
These packages were created to get some incentives from the OSS blockchain technology. You can learn more from here.




Fake Packages:
Impersonating popular packages to deceive users.


Low-Quality Packages:
Flooded with typos, irrelevant content, or empty functionality.



Bot-Generated Packages:
Automated spam submissions.



Phishing Attempts:
Packages designed to steal sensitive information.


Dependency Spam:
Malicious packages as dependencies of legitimate ones.


Hello World Packages (Low priority issue):
The students & learners try their first-time packages.



Weird Packages:
There are many packages with index.js file containing a comment which says something like the below and I try to understand with the google translator, no luck, if you got it, please let me know in the comments. Fancy Packages Control:
These kinds of users acquire short package names. NOTE: This list excludes security related malicious packages as they are often reported by the experts. Some notable past incidents: https://www.sonatype.com/resources/blog/npm-flooded-with-748-packages-that-store-movies
https://thehackernews.com/2023/09/fresh-wave-of-malicious-npm-packages.html
https://thehackernews.com/2023/08/malicious-npm-packages-found.html Some Spammers List Here, I am going to list some of them because it is simply not possible to list all of them here, also, with the number of packages published by each one. https://www.npmjs.com/\~onedionysc - 6931


https://www.npmjs.com/\~shivamkalsi2024 - 997


https://www.npmjs.com/\~79w - 551


https://www.npmjs.com/\~ellentea - 599


https://www.npmjs.com/\~uirewikilabs - 323


https://www.npmjs.com/\~quinterochris100 - 361


https://www.npmjs.com/\~vanthuanbt26 - 250


https://www.npmjs.com/\~tiengiangb47 - 230


https://www.npmjs.com/\~swenkertreanpm - 227


https://www.npmjs.com/\~loandinhb931 - 224 These are my random picks, and who knows how many of them are. The Team's Response The Problem The problem is not the spammers, as they always will be, but the real problem is within the management. Take, for example: If someone reports this via one of your support forums, the reply they get is simply redirection; they are redirecting you to fill out their respective forms for spam submissions. What if the reporter did not want to do extra work here? The important thing to note here is that the spammers and their packages live happily, even after we provide the absolute spam users and their package links. Conclusion I am writing this blog because I waited too long for them to fix it. Justice delayed is justice denied
- William Blackstone Please don't forget to check out our important Articles: Introducing Our New JavaScript Standard Library
You Don’t Need JavaScript Native Methods! Happy coding! 🚀 🙏 Thanks for reading. Welcome, As a Spammer of the registry (pun intended) , I want to explain to you what's going on with the NPM registry and its management. Spammer ( pun intended ) pun intended At first, I felt the title ` It's Party Time For NPM Spammers🥳 ` was offensive, unlawful, or disrespectful, and I also asked for help from an AI chatbot. I got the following results, but I purposefully stayed with the same to get attention from both NPM and the dev community. It's Party Time For NPM Spammers🥳 AI Chatbot : Certainly! Here are some alternative titles for your blog post on spammers in the NPM registry: AI Chatbot “Navigating the Murky Waters: A Deep Dive into NPM Registry Spam” “Guarding the NPM Gates: Strategies to Combat Registry Spam” “Unmasking the Shadows: Inside the World of NPM Registry Spammers” “Navigating the Murky Waters: A Deep Dive into NPM Registry Spam” “Navigating the Murky Waters: A Deep Dive into NPM Registry Spam” “Guarding the NPM Gates: Strategies to Combat Registry Spam” “Guarding the NPM Gates: Strategies to Combat Registry Spam” “Unmasking the Shadows: Inside the World of NPM Registry Spammers” “Unmasking the Shadows: Inside the World of NPM Registry Spammers” Let's start with some basics. I request that you take a close look at the forthcoming screenshots. What is NPM? It is the world's largest software registry and a Node Package Manager for the JavaScript programming language maintained by Microsoft's npm, Inc. Types of Spam Types of Spam Let's list out some with my experience and a few real examples currently living in the registry. Keyword Stuffing:
Packages using irrelevant keywords to appear in more search results. Malicious Code:
Packages containing harmful code or backdoors. Rewarding decentralized protocol (New Type):
These packages were created to get some incentives from the OSS blockchain technology. You can learn more from here. Fake Packages:
Impersonating popular packages to deceive users. Low-Quality Packages:
Flooded with typos, irrelevant content, or empty functionality. Bot-Generated Packages:
Automated spam submissions. Phishing Attempts:
Packages designed to steal sensitive information. Dependency Spam:
Malicious packages as dependencies of legitimate ones. Hello World Packages (Low priority issue):
The students & learners try their first-time packages. Weird Packages:
There are many packages with index.js file containing a comment which says something like the below and I try to understand with the google translator, no luck, if you got it, please let me know in the comments. Keyword Stuffing: Packages using irrelevant keywords to appear in more search results. Keyword Stuffing : Keyword Stuffing Packages using irrelevant keywords to appear in more search results. Malicious Code: Packages containing harmful code or backdoors. Malicious Code : Malicious Code Packages containing harmful code or backdoors. Rewarding decentralized protocol (New Type): These packages were created to get some incentives from the OSS blockchain technology. You can learn more from here. Rewarding decentralized protocol (New Type) : Rewarding decentralized protocol (New Type) These packages were created to get some incentives from the OSS blockchain technology. You can learn more from here . learn more from here Fake Packages: Impersonating popular packages to deceive users. Fake Packages : Fake Packages Impersonating popular packages to deceive users. Low-Quality Packages: Flooded with typos, irrelevant content, or empty functionality. Low-Quality Packages : Low-Quality Packages Flooded with typos, irrelevant content, or empty functionality. Bot-Generated Packages: Automated spam submissions. Bot-Generated Packages : Bot-Generated Packages Automated spam submissions. Phishing Attempts: Packages designed to steal sensitive information. Phishing Attempts : Phishing Attempts Packages designed to steal sensitive information. Dependency Spam: Malicious packages as dependencies of legitimate ones. Dependency Spam : Dependency Spam Malicious packages as dependencies of legitimate ones. Hello World Packages (Low priority issue): The students & learners try their first-time packages. Hello World Packages (Low priority issue) : Hello World Packages (Low priority issue) The students & learners try their first-time packages. Weird Packages: There are many packages with index.js file containing a comment which says something like the below and I try to understand with the google translator, no luck, if you got it, please let me know in the comments. Weird Packages: Weird Packages: There are many packages with index.js file containing a comment which says something like the below and I try to understand with the google translator, no luck, if you got it, please let me know in the comments. Fancy Packages Control:
These kinds of users acquire short package names. Fancy Packages Control: These kinds of users acquire short package names. Fancy Packages Control : Fancy Packages Control These kinds of users acquire short package names. NOTE : This list excludes security related malicious packages as they are often reported by the experts. NOTE Some notable past incidents: https://www.sonatype.com/resources/blog/npm-flooded-with-748-packages-that-store-movies https://thehackernews.com/2023/09/fresh-wave-of-malicious-npm-packages.html https://thehackernews.com/2023/08/malicious-npm-packages-found.html https://www.sonatype.com/resources/blog/npm-flooded-with-748-packages-that-store-movies https://www.sonatype.com/resources/blog/npm-flooded-with-748-packages-that-store-movies https://thehackernews.com/2023/09/fresh-wave-of-malicious-npm-packages.html https://thehackernews.com/2023/09/fresh-wave-of-malicious-npm-packages.html https://thehackernews.com/2023/08/malicious-npm-packages-found.html https://thehackernews.com/2023/08/malicious-npm-packages-found.html Some Spammers List Here, I am going to list some of them because it is simply not possible to list all of them here, also, with the number of packages published by each one. https://www.npmjs.com/\~onedionysc - 6931 https://www.npmjs.com/\~shivamkalsi2024 - 997 https://www.npmjs.com/\~79w - 551 https://www.npmjs.com/\~ellentea - 599 https://www.npmjs.com/\~uirewikilabs - 323 https://www.npmjs.com/\~quinterochris100 - 361 https://www.npmjs.com/\~vanthuanbt26 - 250 https://www.npmjs.com/\~tiengiangb47 - 230 https://www.npmjs.com/\~swenkertreanpm - 227 https://www.npmjs.com/\~loandinhb931 - 224 https://www.npmjs.com/\~onedionysc - 6931 https://www.npmjs.com/\~onedionysc - 6931 https://www.npmjs.com/\~onedionysc 6931 https://www.npmjs.com/\~shivamkalsi2024 - 997 https://www.npmjs.com/\~shivamkalsi2024 - 997 https://www.npmjs.com/\~shivamkalsi2024 https://www.npmjs.com/\~79w - 551 https://www.npmjs.com/\~79w - 551 https://www.npmjs.com/\~79w https://www.npmjs.com/\~ellentea - 599 https://www.npmjs.com/\~ellentea - 599 https://www.npmjs.com/\~ellentea https://www.npmjs.com/\~uirewikilabs - 323 https://www.npmjs.com/\~uirewikilabs - 323 https://www.npmjs.com/\~uirewikilabs https://www.npmjs.com/\~quinterochris100 - 361 https://www.npmjs.com/\~quinterochris100 - 361 https://www.npmjs.com/\~quinterochris100 https://www.npmjs.com/\~vanthuanbt26 - 250 https://www.npmjs.com/\~vanthuanbt26 - 250 https://www.npmjs.com/\~vanthuanbt26 https://www.npmjs.com/\~tiengiangb47 - 230 https://www.npmjs.com/\~tiengiangb47 - 230 https://www.npmjs.com/\~tiengiangb47 https://www.npmjs.com/\~swenkertreanpm - 227 https://www.npmjs.com/\~swenkertreanpm - 227 https://www.npmjs.com/\~swenkertreanpm https://www.npmjs.com/\~loandinhb931 - 224 https://www.npmjs.com/\~loandinhb931 - 224 https://www.npmjs.com/\~loandinhb931 These are my random picks, and who knows how many of them are. The Team's Response The Problem The problem is not the spammers, as they always will be, but the real problem is within the management. Take, for example: If someone reports this via one of your support forums, the reply they get is simply redirection; they are redirecting you to fill out their respective forms for spam submissions. What if the reporter did not want to do extra work here? extra The important thing to note here is that the spammers and their packages live happily, even after we provide the absolute spam users and their package links. Conclusion I am writing this blog because I waited too long for them to fix it. Justice delayed is justice denied - William Blackstone Justice delayed is justice denied Justice delayed is justice denied - William Blackstone Please don't forget to check out our important Articles: important Introducing Our New JavaScript Standard Library You Don’t Need JavaScript Native Methods! Introducing Our New JavaScript Standard Library Introducing Our New JavaScript Standard Library Introducing Our New JavaScript Standard Library You Don’t Need JavaScript Native Methods! You Don’t Need JavaScript Native Methods! You Don’t Need JavaScript Native Methods! Happy coding! 🚀 🙏 Thanks for reading.

It's Party Time For NPM Spammers🥳

Code Book for Annotation of Diverse Cross-Document Coreference: Annotation Tool

Fortify Your Digital Defenses: Top Home Cybersecurity Strategies for Personal Protection

These 6 Factors Are the Difference Between Success and Failure

Intro In today's world, where cybercrimes are becoming increasingly widespread, it is important to have access to effective tools for investigation and counteraction against these threats. One such tool is the CSI Linux operating system, specially designed for the needs of cybersecurity and cyber investigations. CSI Linux aims to provide users with tools for fast and accurate detection of digital traces and evidence that can be used for criminal investigations or for ensuring cybersecurity in organizations. The developers of this operating system claim that it simplifies the process of collecting, analyzing, and interpreting digital data, making it an important tool for professionals in the field of cybersecurity and cyber investigations. But is it really so? Let's find out... Basic information To begin with, I would like to provide some basic information about this distribution. Official website: https://csilinux.com/ As of the writing of this article, CSI Linux uses Ubuntu 22.04 LTS as its base platform. CSI Linux is an open-source project, so anyone interested can contribute to making it better. The installation process is quite simple, and there are many videos on this topic, such as this one. Although the process has changed slightly now, after downloading the disk image, you simply need to add (Machine -> Add) the virtual disk file in Vbox format to VirtualBox for it to run. To log into the system by default, use the username "CSI" and the password "CSI." There is also a whole book dedicated to working with CSI Linux, which can be purchased here. The terminology, list of all available software in CSI Linux, and other documentation are available at this link. Previously, CSI Linux had three separate packages on the CSI Linux Investigator platform, but now CSI Linux Gateway and CSI Linux Analyst are merged into one package, while CSI Linux SIEM is available as a separate image on the official website. All distributions can also be downloaded from the official website. For a better understanding, let me describe the three components of CSI Linux mentioned above: CSI Linux SIEM: This is a virtual machine included in the CSI Linux Investigator distribution. In fact, it is an Ubuntu distribution that includes a configured Zeek IDS and ELK Stack (Elasticsearch, Logstash, and Kibana). It is used as an intrusion detection system to protect other virtual machines (CSI Linux Analyst and CSI Linux Gateway), process logs, and display data on the management panels of CSI Linux Analyst. CSI Linux Gateway: This is a TOR user gateway that operates in a "sandbox" using utilities such as AppArmor, Jailbreak, and Shorewall Firewall. When using CSI Linux Analyst + CSI Linux Gateway, all traffic will pass through the TOR node. CSI Linux Analyst: This is the "core" of this distribution. It is a virtual machine running Ubuntu with a large amount of pre-installed software grouped by categories. We will discuss the list of categories later. It's worth noting that in the Incident Response menu, there is a section for CSI SIEM, but it is not active and displays "CSI SIEM Installer and Launch utility coming soon…" indicating a likely intention to integrate it with the third distribution. However, in any case, you can install and run SIEM separately using virtualization in VirtualBox, allowing you to have the full set of packages on the same server. Functionality review Now, let's get a bit closer to the mentioned operating system. To start working, we create a case (click on the "Start a Case" icon on the desktop or go to Menu -> CSI Linux Tools -> Start a Case). Then, all subsequent operations can be performed within the created case, where the results will be stored. Upon creation, you are immediately prompted to start work, and there are several options in the CSI Case Management Menu. It's important to know that most of the software is not pre-installed, and an automatic installation script is launched when selecting a program. Now, let's quickly go through the list of programs (both pre-installed and not) in each available category: CSI Linux Tools: A set of programs for system updates, management of CSI Tor VPN and Whonix Gateway for traffic routing, working with API resources used in CSI Linux, downloading videos, creating screenshots from various online resources, and much more. Secure Comms: This category includes "secure" online messengers. Encryption: Everything for decrypting hashes, password cracking, storing passwords, and personal data. OSINT/Online Investigations: A fairly large category where everyone can find the necessary tools for OSINT tasks. Among the most interesting are social media searches, phone and email searches. Dark Web: If the investigator encounters connection problems, this category is suitable. 'TOR > VPN,’ 'WHONIX'’ and so on, all for pleasant surfing. Incident Response: Everything for incident investigation, malware scanners, network analysis (Wireshark), and more. Computer Forensics: Computer forensics (data recovery and file analysis). Mobile Forensics: Mobile forensics tools for analysis and work with mobile phones. Vehicle Forensics: A set of utilities for working with the CAN (Controller Area Network) protocol. CAN is a network technology widely used in automation, embedded devices, and the automotive industry. Malware Analysis and Reverse Engineering: For the analysis of malicious scripts and programs, reverse engineering. SIGINT: A set of programs for radio channel analysis, hacking, and programming (FM, WiFi, etc.). Virtualization: A set of managers for virtualization. Threat Intelligence: Threat reconnaissance, cybercrime maps worldwide, and more. Practice Below are some screenshots of CSI Linux in action, demonstrating several tools and functionalities. You'll find attempts to search for individuals by username and email, showcasing the system's capabilities in gathering information from various sources. Conclusion After a basic introduction to the system and conducting several tests searching by phone, email, and username, I can say that CSI Linux partially works out of the box, but in most cases, you need to configure the software you're trying to investigate. There's an issue with blocking bots, through which criminalization occurs, as Tor VPN IP addresses have a poor reputation, or maybe sites identify it as bot activity and quickly block connections. The system is noticeably geared towards working with the world's most famous resources and social networks, but it lacks "out-of-the-box" support for local ones, which may be the most significant in a particular country. The set of programs is quite interesting, although not everything works right away, as already noted. For example, when I searched for data using my email, Buster found an article from 15 years ago on "Economic Truth" mentioning my address and Skype account. However, a simple Google search can find the same and even more. Furthermore, a search by username produced a bunch of irrelevant and unreliable information, which theoretically could be useful if filtered manually. Now I would like to add a little comparison with a competing system to CSI Linux and a more well-known operating system. Kali Linux, a Linux distribution, is popular in the cybersecurity community and is a basic tool for many cybersecurity specialists. However, comparing these two systems, we can say that the software offered by default in each of them is quite different. It's essential to understand that all the software presented in CSI Linux can be installed on Kali Linux and vice versa, as both are based on Ubuntu/Debian and are essentially extensions of the base. As the developers themselves claim, Kali Linux, with its set of programs, is more geared towards tasks such as penetration testing, security research, computer forensics, and reverse engineering. As soon as you log in and look at the main menu, you'll find mostly software for testing websites, social networks, or servers for vulnerabilities or hacking. There are many different bots, attackers, network analysis programs, and so on. So, these two systems are based on the same foundation but are created and configured for different tasks, although they can replace each other. CSI Linux has the right to exist, and it is definitely improving, but much needs to be "fine-tuned" to fit its needs, and one should be prepared for that. The "breakthrough" through the set of programs exists, but it lacks a wow effect and has quite a few inconsistencies. I hope you found this article interesting. By the way, I should mention that the CSI community has its own academy where you can take a course on various aspects of the project. Details are available at the CSI Linux Academy. Intro In today's world, where cybercrimes are becoming increasingly widespread, it is important to have access to effective tools for investigation and counteraction against these threats. One such tool is the CSI Linux operating system, specially designed for the needs of cybersecurity and cyber investigations. CSI Linux aims to provide users with tools for fast and accurate detection of digital traces and evidence that can be used for criminal investigations or for ensuring cybersecurity in organizations. The developers of this operating system claim that it simplifies the process of collecting, analyzing, and interpreting digital data, making it an important tool for professionals in the field of cybersecurity and cyber investigations. But is it really so? Let's find out... Basic information To begin with, I would like to provide some basic information about this distribution. Official website: https://csilinux.com/ As of the writing of this article, CSI Linux uses Ubuntu 22.04 LTS as its base platform. CSI Linux is an open-source project, so anyone interested can contribute to making it better. The installation process is quite simple, and there are many videos on this topic, such as this one. this Although the process has changed slightly now, after downloading the disk image, you simply need to add (Machine -> Add) the virtual disk file in Vbox format to VirtualBox for it to run. To log into the system by default, use the username "CSI" and the password "CSI." There is also a whole book dedicated to working with CSI Linux, which can be purchased here . here The terminology, list of all available software in CSI Linux, and other documentation are available at this link . link Previously, CSI Linux had three separate packages on the CSI Linux Investigator platform, but now CSI Linux Gateway and CSI Linux Analyst are merged into one package, while CSI Linux SIEM is available as a separate image on the official website. All distributions can also be downloaded from the official website. For a better understanding, let me describe the three components of CSI Linux mentioned above: CSI Linux SIEM: This is a virtual machine included in the CSI Linux Investigator distribution. In fact, it is an Ubuntu distribution that includes a configured Zeek IDS and ELK Stack (Elasticsearch, Logstash, and Kibana). It is used as an intrusion detection system to protect other virtual machines (CSI Linux Analyst and CSI Linux Gateway), process logs, and display data on the management panels of CSI Linux Analyst. CSI Linux SIEM: CSI Linux Gateway: This is a TOR user gateway that operates in a "sandbox" using utilities such as AppArmor, Jailbreak, and Shorewall Firewall. When using CSI Linux Analyst + CSI Linux Gateway, all traffic will pass through the TOR node. CSI Linux Gateway: CSI Linux Analyst: This is the "core" of this distribution. It is a virtual machine running Ubuntu with a large amount of pre-installed software grouped by categories. We will discuss the list of categories later. CSI Linux Analyst: It's worth noting that in the Incident Response menu, there is a section for CSI SIEM, but it is not active and displays "CSI SIEM Installer and Launch utility coming soon…" indicating a likely intention to integrate it with the third distribution. However, in any case, you can install and run SIEM separately using virtualization in VirtualBox, allowing you to have the full set of packages on the same server. Functionality review Now, let's get a bit closer to the mentioned operating system. To start working, we create a case (click on the "Start a Case" icon on the desktop or go to Menu -> CSI Linux Tools -> Start a Case). Then, all subsequent operations can be performed within the created case, where the results will be stored. Upon creation, you are immediately prompted to start work, and there are several options in the CSI Case Management Menu. It's important to know that most of the software is not pre-installed, and an automatic installation script is launched when selecting a program. Now, let's quickly go through the list of programs (both pre-installed and not) in each available category: CSI Linux Tools: CSI Linux Tools: CSI Linux Tools: A set of programs for system updates, management of CSI Tor VPN and Whonix Gateway for traffic routing, working with API resources used in CSI Linux, downloading videos, creating screenshots from various online resources, and much more. Secure Comms: Secure Comms: Secure Comms: This category includes "secure" online messengers. Encryption: Encryption: Encryption: Everything for decrypting hashes, password cracking, storing passwords, and personal data. OSINT/Online Investigations: OSINT/Online Investigations: OSINT/Online Investigations: A fairly large category where everyone can find the necessary tools for OSINT tasks. Among the most interesting are social media searches, phone and email searches. Dark Web: Dark Web: Dark Web: If the investigator encounters connection problems, this category is suitable. 'TOR > VPN,’ 'WHONIX'’ and so on, all for pleasant surfing. Incident Response: Incident Response: Incident Response: Everything for incident investigation, malware scanners, network analysis (Wireshark), and more. Computer Forensics: Computer Forensics: Computer Forensics: Computer forensics (data recovery and file analysis). Mobile Forensics: Mobile Forensics: Mobile Forensics: Mobile forensics tools for analysis and work with mobile phones. Vehicle Forensics: Vehicle Forensics: Vehicle Forensics: A set of utilities for working with the CAN (Controller Area Network) protocol. CAN is a network technology widely used in automation, embedded devices, and the automotive industry. Malware Analysis and Reverse Engineering: Malware Analysis and Reverse Engineering: Malware Analysis and Reverse Engineering: For the analysis of malicious scripts and programs, reverse engineering. SIGINT: SIGINT: SIGINT: A set of programs for radio channel analysis, hacking, and programming (FM, WiFi, etc.). Virtualization: Virtualization: Virtualization: A set of managers for virtualization. Threat Intelligence: Threat Intelligence: Threat Intelligence: Threat reconnaissance, cybercrime maps worldwide, and more. Practice Below are some screenshots of CSI Linux in action, demonstrating several tools and functionalities. You'll find attempts to search for individuals by username and email, showcasing the system's capabilities in gathering information from various sources. Conclusion After a basic introduction to the system and conducting several tests searching by phone, email, and username, I can say that CSI Linux partially works out of the box, but in most cases, you need to configure the software you're trying to investigate. There's an issue with blocking bots, through which criminalization occurs, as Tor VPN IP addresses have a poor reputation, or maybe sites identify it as bot activity and quickly block connections. The system is noticeably geared towards working with the world's most famous resources and social networks, but it lacks "out-of-the-box" support for local ones, which may be the most significant in a particular country. The set of programs is quite interesting, although not everything works right away, as already noted. For example, when I searched for data using my email, Buster found an article from 15 years ago on "Economic Truth" mentioning my address and Skype account. However, a simple Google search can find the same and even more. Furthermore, a search by username produced a bunch of irrelevant and unreliable information, which theoretically could be useful if filtered manually. Now I would like to add a little comparison with a competing system to CSI Linux and a more well-known operating system. Kali Linux , a Linux distribution, is popular in the cybersecurity community and is a basic tool for many cybersecurity specialists. However, comparing these two systems, we can say that the software offered by default in each of them is quite different. It's essential to understand that all the software presented in CSI Linux can be installed on Kali Linux and vice versa, as both are based on Ubuntu/Debian and are essentially extensions of the base. As the developers themselves claim, Kali Linux, with its set of programs, is more geared towards tasks such as penetration testing, security research, computer forensics, and reverse engineering. As soon as you log in and look at the main menu, you'll find mostly software for testing websites, social networks, or servers for vulnerabilities or hacking. There are many different bots, attackers, network analysis programs, and so on. Kali Linux So, these two systems are based on the same foundation but are created and configured for different tasks, although they can replace each other. CSI Linux has the right to exist, and it is definitely improving, but much needs to be "fine-tuned" to fit its needs, and one should be prepared for that. The "breakthrough" through the set of programs exists, but it lacks a wow effect and has quite a few inconsistencies. I hope you found this article interesting. By the way, I should mention that the CSI community has its own academy where you can take a course on various aspects of the project. Details are available at the CSI Linux Academy . CSI Linux Academy

CSI Linux: Linux Distribution for Cyber and OSINT Investigation

Feature Engineering for Machine Learning Models: Everything You Need to Know 

মেশিন লার্নিং এর জন্য ফিচার ইঞ্জিনিয়ারিং

Feature Engineering für maschinelles Lernen

Ingeniería de funciones para el aprendizaje automático

Ingénierie des fonctionnalités pour l’apprentissage automatique

मशीन लर्निंग के लिए फ़ीचर इंजीनियरिंग

機械学習のための特徴エンジニアリング

기계 학습을 위한 특성 엔지니어링

Engenharia de recursos para aprendizado de máquina

Разработка функций для машинного обучения

Makine Öğrenimi için Özellik Mühendisliği

Kỹ thuật tính năng cho Machine Learning

机器学习的特征工程

Google Analytics 4 (GA4) for Beginners—Part 3: Mastering Data Filters, Comparisons, and Explorations

Encryption is not just for larger enterprises. Small businesses also need data encryption to protect their valuable data from the prying eyes of threat actors. Reason: Unencrypted business data, files, or emails invite unwelcome guests to your home, i.e., your business. And you wouldn’t want that, would you? So, all said and done, let’s first understand what Encryption is and why it is important for your small business. What is Encryption? Encryption has long been used by defense and governments. Today, businesses encrypt their data at rest and in motion. But what is encryption? Encryption is the process of converting plain text information into secret code. This secret code hides sensitive information from unauthorized prying eyes. In simple words, encryption is a process of concealing sensitive information by altering it so it appears as random data. Why Does Your Small Business Require It? Your small business requires encryption for various reasons, but here are a few that I think will satisfy your curiosity. 📍Cyber threats are real and pervasive. Threat actors love small businesses as they are the low-hanging fruits. Reason: They don’t have the proper line of defense in place. 📍The trust of your clients and customers is crucial for you to stay in business, and encryption helps you gain that trust by protecting your data against unauthorized prying eyes. 📍 As regulatory bodies tighten their noose on data protection policies, compliance is not an option but a necessity. Encryption ensures that while you are protecting the data, you are also following the legal standards to prevent fines. 📍With data encryption, small businesses can ensure that their business ideas remain theirs. Federal Trade Commission Guidelines on Encryption The Federal Trade Commission (FTC) guidelines on Encryption are simple and clear. FTC wants businesses, especially small businesses, to strengthen their defenses against cyber threats. Small businesses are part of larger enterprises and have sensitive data, which, in the wrong hands, can prove disastrous. So, the FTC’s goal is to encrypt data to prevent theft or unauthorized access. Benefits of Encryption for Your Small Business Here are some prominent benefits of encryption for your small business. ✅ Encryption adds additional security to your data and protects it against cyber threats. ✅ As a small business owner, encryption is recommended or encouraged by certain laws and regulatory compliance requirements that are applicable to your business. ✅ When you encrypt your data, you demonstrate your commitment to protecting it. Your clients trust you with their data and have confidence in your business. ✅ It also nullifies brute-force attacks, as guessing the correct password can take a long time with encrypted data. ✅ Encryption protects your data not only from theft but from all sorts of tampering. ✅ As a small business owner, encryption helps you maintain your data’s integrity. Final Words Small businesses are lucrative targets for threat actors to exploit any vulnerability or entry point they can get. As an SMB owner, follow basic cyber hygiene and stay updated and alerted about threats. Encryption is not just for larger enterprises. Small businesses also need data encryption to protect their valuable data from the prying eyes of threat actors. Reason: Unencrypted business data, files, or emails invite unwelcome guests to your home, i.e., your business. And you wouldn’t want that, would you? So, all said and done, let’s first understand what Encryption is and why it is important for your small business. What is Encryption? Encryption has long been used by defense and governments. Today, businesses encrypt their data at rest and in motion. But what is encryption? Encryption is the process of converting plain text information into secret code. This secret code hides sensitive information from unauthorized prying eyes. In simple words, encryption is a process of concealing sensitive information by altering it so it appears as random data. Why Does Your Small Business Require It? Your small business requires encryption for various reasons, but here are a few that I think will satisfy your curiosity. 📍Cyber threats are real and pervasive. Threat actors love small businesses as they are the low-hanging fruits. Reason: They don’t have the proper line of defense in place. 📍The trust of your clients and customers is crucial for you to stay in business, and encryption helps you gain that trust by protecting your data against unauthorized prying eyes. 📍 As regulatory bodies tighten their noose on data protection policies, compliance is not an option but a necessity. Encryption ensures that while you are protecting the data, you are also following the legal standards to prevent fines. 📍With data encryption, small businesses can ensure that their business ideas remain theirs. Federal Trade Commission Guidelines on Encryption The Federal Trade Commission (FTC) guidelines on Encryption are simple and clear. FTC wants businesses, especially small businesses, to strengthen their defenses against cyber threats. Small businesses are part of larger enterprises and have sensitive data, which, in the wrong hands, can prove disastrous. So, the FTC’s goal is to encrypt data to prevent theft or unauthorized access. Benefits of Encryption for Your Small Business Here are some prominent benefits of encryption for your small business. ✅ Encryption adds additional security to your data and protects it against cyber threats. ✅ As a small business owner, encryption is recommended or encouraged by certain laws and regulatory compliance requirements that are applicable to your business. ✅ When you encrypt your data, you demonstrate your commitment to protecting it. Your clients trust you with their data and have confidence in your business. ✅ It also nullifies brute-force attacks, as guessing the correct password can take a long time with encrypted data. ✅ Encryption protects your data not only from theft but from all sorts of tampering. ✅ As a small business owner, encryption helps you maintain your data’s integrity. Final Words Small businesses are lucrative targets for threat actors to exploit any vulnerability or entry point they can get. As an SMB owner, follow basic cyber hygiene and stay updated and alerted about threats.

Protect Your Small Business On The Encryption Frontlines

This paper is available on arxiv under CC 4.0 license.
Authors:
(1) J´anos Pintz, Supported by the National Research Development and Innovation Office, NKFIH, KKP 133819, ELKH Alfr´ed R´enyi Mathematical Institute H-1053 Budapest Realtanoda u. 13–15. Hungary and e-mail: pintz@renyi.hu Table of Links 1
2
3 Proof of Theorem 1
References References [BL1914] Bohr, H., Landau, E., Sur les zeros de la fonction ζ(s) de Riemann, Comptes Rendus de l’Acad. des Sciences (Paris) 158 (1914), 106–110. [Bom1971] Bombieri, Enrico, Density theorems for the zeta function, Number Theory Institute (Proc. Sympos. Pure Math., Vol. XX, State Univ. New York, Stony Brook, N.Y., 1969), pp. 352–358. Amer. Math. Soc., Providence, R.I., 1971. [Bou1] J. Bourgain, Remarks on Hal´asz–Montgomery type inequalities, in: Geometric aspects of functional analysis (Israel, 1992–1994), Oper. Theory Adv. Appl. 77, Birkh¨auser, Basel, 1995, 25–39. [Bou2000] Bourgain, J., On large values estimates for Dirichlet polynomials and the density hypothesis for the Riemann zeta function, Internat. Math. Res. Notices (2000), no. 3, 133–146. [BGD2016] Bourgain, J., Demeter, C., Guth, L., Proof of the main conjecture in Vinogradov’s mean value theorem for degrees higher than three, Ann. of Math. (2) 184 (2016), no. 2, 633-–682. [Car1920] Carlson, F., Uber die Nullstellen der Dirichletschen Reihen und der ¨ Riemannschen ζ-Funktion, Arkiv f¨ur Math. Astron. Fys. 15 (20) (1920), 1–18. [Cor1921] van der Corput, J. G., Zahlentheoretische Absch¨atzungen, Math. Ann. 84 (1921), 53–79. [Cor1922] van der Corput, J. G., Versch¨arfung der Absch¨atzungen beim Teilerproblem, Math. Ann. 87 (1922), 39–65. [Cra1921] Cram´er, H., Some theorems concerning prime numbers, Ark. Mat. Astron. Fys. 15(5 (1921), 1–33. [Hal1968] Hal´asz, G., Uber die Mittelwerte multiplikativer zahlentheoretische ¨ r Funktionen, Acta Math. Hungar. 19 (1968), No. 3-4, 365–404. [HT1969] Hal´asz, G. and P. Tur´an, P., On the distribution of roots of Riemann zeta and allied functions, I, Journal of Number Theory 1 (1969), 121–137. [Hea2017] Heath-Brown, D. R., A new kth derivative estimate for a trigonometric sum via Vinogradov’s integral (in Russian). English version published in Proc. Steklov Inst. Math. 296 (2017), 88–103. [Hoh1930] Hoheisel, G., Primzahlprobleme in der Analysis, S.-B. Preuss. Akad. Wiss. Phys.-Math. Kl. (1930), 580–588. [Hux1972] Huxley, M. N., On the difference between consecutive primes, Invent. Math. 15 (1972), 164–170. [Ing1937] Ingham, A. E., On the difference between consecutive primes, Quart. J. Math. Oxford Ser. 8 (1937), 255–266. [Ing1940] Ingham, A. E., On the estimation of N(σ, T), Quart. J. Math. Oxford Ser. 11 (1940), 291–292. [Ivi1985] Ivic, A., The Riemann Zeta-function, Wiley, 1985. [Jut1977] Jutila, Matti, Zero-density estimates for L-functions, Acta Arithmetica 32 (1977), no. 1, 55–62. [Lan1913] Landau, E., Gel¨oste und ungel¨oste Probleme aus der Theorie der Primzahlverteilung und der Riemannschen Zetafunktion. In: Proc. 5th Internat. Congress of Math., Vol. 1, 93–108. Cambridge University Press, Cambridge 1913. [Lan1924] Landau, E., Uber die ¨ ζ-Funktion und die L-funktionen, Math. Z. 20 (1924), 98–104. [Lit1922] Littlewood, J. E., Researches in the theory of the Riemann ζ-function, Proc. London Math. Soc. (2) 20 (1922), Records xxii–xxviii. [Mon1969] Montgomery, H. L., Zeros of L-functions, Invent. Math. 8 (1969), 346– 354. [Mon1971] Montgomery, Hugh L., Topics in multiplicative number theory, Lecture Notes in Mathematics, Vol. 227, Springer-Verlag, Berlin–New York, 1971. ix+178 pp. [Per1908] Perron, O., Zur Theorie der Dirichletschen L-Reihen, J. Reine Angew. Math. 134 (1908), 95–143. [Pin2022] Pintz, J., On the density theorem of Hal´asz and Tur´an, Acta Math. Hungar. 166 (2022), no. 1, 48–56. [Pin2023] Pintz, J., Density theorems for Riemann’s zeta-function near the line Re s = 1, Acta Arithmetica, to appear (online first version DOI: 10.4064/aa210824-10-5). [Tit1951] Titchmarsh, E. C., The theory of the Riemann zeta-function, Oxford, Clarendon Press (2nd edition), 1951. [Tur1953] Tur´an P´al, Az anal´ızis egy ´uj m´odszer´er˝ol ´es annak egyes alkalmaz´asair´ol (in Hungarian) [On a new method in analysis and on some of its applications], Akad´emiai Kiad´o, Budapest, 1953. 197 pp. [Tur1954] Tur´an P´al, On the roots of the Riemann zeta function (in Hungarian), Magyar Tud. Akad. Mat. Fiz. Oszt. K¨ozl. 4 (1954), 357–368. [Tur1984] P. Tur´an, On a new method of analysis and its applications, John Wiley & Sons, Inc., New York, 1984. xvi+584 pp. This paper is available on arxiv under CC 4.0 license. Authors: (1) J´anos Pintz, Supported by the National Research Development and Innovation Office, NKFIH, KKP 133819, ELKH Alfr´ed R´enyi Mathematical Institute H-1053 Budapest Realtanoda u. 13–15. Hungary and e-mail: pintz@renyi.hu This paper is available on arxiv under CC 4.0 license. Authors: Authors: (1) J´anos Pintz, Supported by the National Research Development and Innovation Office, NKFIH, KKP 133819, ELKH Alfr´ed R´enyi Mathematical Institute H-1053 Budapest Realtanoda u. 13–15. Hungary and e-mail: pintz@renyi.hu Table of Links 1 2 3 Proof of Theorem 1 References 1 1 2 2 3 Proof of Theorem 1 3 Proof of Theorem 1 References References References [BL1914] Bohr, H., Landau, E., Sur les zeros de la fonction ζ(s) de Riemann, Comptes Rendus de l’Acad. des Sciences (Paris) 158 (1914), 106–110. [Bom1971] Bombieri, Enrico, Density theorems for the zeta function, Number Theory Institute (Proc. Sympos. Pure Math., Vol. XX, State Univ. New York, Stony Brook, N.Y., 1969), pp. 352–358. Amer. Math. Soc., Providence, R.I., 1971. [Bou1] J. Bourgain, Remarks on Hal´asz–Montgomery type inequalities, in: Geometric aspects of functional analysis (Israel, 1992–1994), Oper. Theory Adv. Appl. 77, Birkh¨auser, Basel, 1995, 25–39. [Bou2000] Bourgain, J., On large values estimates for Dirichlet polynomials and the density hypothesis for the Riemann zeta function, Internat. Math. Res. Notices (2000), no. 3, 133–146. [BGD2016] Bourgain, J., Demeter, C., Guth, L., Proof of the main conjecture in Vinogradov’s mean value theorem for degrees higher than three, Ann. of Math. (2) 184 (2016), no. 2, 633-–682. [Car1920] Carlson, F., Uber die Nullstellen der Dirichletschen Reihen und der ¨ Riemannschen ζ-Funktion, Arkiv f¨ur Math. Astron. Fys. 15 (20) (1920), 1–18. [Cor1921] van der Corput, J. G., Zahlentheoretische Absch¨atzungen, Math. Ann. 84 (1921), 53–79. [Cor1922] van der Corput, J. G., Versch¨arfung der Absch¨atzungen beim Teilerproblem, Math. Ann. 87 (1922), 39–65. [Cra1921] Cram´er, H., Some theorems concerning prime numbers, Ark. Mat. Astron. Fys. 15(5 (1921), 1–33. [Hal1968] Hal´asz, G., Uber die Mittelwerte multiplikativer zahlentheoretische ¨ r Funktionen, Acta Math. Hungar. 19 (1968), No. 3-4, 365–404. [HT1969] Hal´asz, G. and P. Tur´an, P., On the distribution of roots of Riemann zeta and allied functions, I, Journal of Number Theory 1 (1969), 121–137. [Hea2017] Heath-Brown, D. R., A new kth derivative estimate for a trigonometric sum via Vinogradov’s integral (in Russian). English version published in Proc. Steklov Inst. Math. 296 (2017), 88–103. [Hoh1930] Hoheisel, G., Primzahlprobleme in der Analysis, S.-B. Preuss. Akad. Wiss. Phys.-Math. Kl. (1930), 580–588. [Hux1972] Huxley, M. N., On the difference between consecutive primes, Invent. Math. 15 (1972), 164–170. [Ing1937] Ingham, A. E., On the difference between consecutive primes, Quart. J. Math. Oxford Ser. 8 (1937), 255–266. [Ing1940] Ingham, A. E., On the estimation of N(σ, T), Quart. J. Math. Oxford Ser. 11 (1940), 291–292. [Ivi1985] Ivic, A., The Riemann Zeta-function, Wiley, 1985. [Jut1977] Jutila, Matti, Zero-density estimates for L-functions, Acta Arithmetica 32 (1977), no. 1, 55–62. [Lan1913] Landau, E., Gel¨oste und ungel¨oste Probleme aus der Theorie der Primzahlverteilung und der Riemannschen Zetafunktion. In: Proc. 5th Internat. Congress of Math., Vol. 1, 93–108. Cambridge University Press, Cambridge 1913. [Lan1924] Landau, E., Uber die ¨ ζ-Funktion und die L-funktionen, Math. Z. 20 (1924), 98–104. [Lit1922] Littlewood, J. E., Researches in the theory of the Riemann ζ-function, Proc. London Math. Soc. (2) 20 (1922), Records xxii–xxviii. [Mon1969] Montgomery, H. L., Zeros of L-functions, Invent. Math. 8 (1969), 346– 354. [Mon1971] Montgomery, Hugh L., Topics in multiplicative number theory, Lecture Notes in Mathematics, Vol. 227, Springer-Verlag, Berlin–New York, 1971. ix+178 pp. [Per1908] Perron, O., Zur Theorie der Dirichletschen L-Reihen, J. Reine Angew. Math. 134 (1908), 95–143. [Pin2022] Pintz, J., On the density theorem of Hal´asz and Tur´an, Acta Math. Hungar. 166 (2022), no. 1, 48–56. [Pin2023] Pintz, J., Density theorems for Riemann’s zeta-function near the line Re s = 1, Acta Arithmetica, to appear (online first version DOI: 10.4064/aa210824-10-5). [Tit1951] Titchmarsh, E. C., The theory of the Riemann zeta-function, Oxford, Clarendon Press (2nd edition), 1951. [Tur1953] Tur´an P´al, Az anal´ızis egy ´uj m´odszer´er˝ol ´es annak egyes alkalmaz´asair´ol (in Hungarian) [On a new method in analysis and on some of its applications], Akad´emiai Kiad´o, Budapest, 1953. 197 pp. [Tur1954] Tur´an P´al, On the roots of the Riemann zeta function (in Hungarian), Magyar Tud. Akad. Mat. Fiz. Oszt. K¨ozl. 4 (1954), 357–368. [Tur1984] P. Tur´an, On a new method of analysis and its applications, John Wiley & Sons, Inc., New York, 1984. xvi+584 pp.

A Remark on Density Theorems for Riemann’s Zeta-function: Reference

This paper is available on arxiv under CC 4.0 license.
Authors:
(1) J´anos Pintz, Supported by the National Research Development and Innovation Office, NKFIH, KKP 133819, ELKH Alfr´ed R´enyi Mathematical Institute H-1053 Budapest Realtanoda u. 13–15. Hungary and e-mail: pintz@renyi.hu Table of Links 1
2
3 Proof of Theorem 1
References Keywords and phrases: Riemann’s zeta function, density hypothesis, density theorems. 2020 Mathematics Subject Classification: Primary 11M26, Secondary 11M06. 1 The plausibility of the Riemann Hypothesis (RH) is supported (among others) by results of type (1.1) valid for all σ > 1/2 as T → ∞. (1.1) was first shown by Bohr and Landau in 1914 ([BL1914]). The first estimate of type was shown few years later by Carlson [Car1920] with It was Hoheisel [Hoh1930] who first observed that such estimates lead to arithmetic consequences about the difference of consecutive primes. He proved the first approximation towards the famous conjecture that there exists always a prime between two consecutive squares. This conjecture was characterised by Landau [Lan1913] in his plenary talk at ICM1912 in Cambridge as one of the four main problems of the distribution of primes, besides the Riemann Hypothesis. Hoheisel [Hoh1930] could show (pn denotes the nth prime) In the proof important role was played by Carlson’s density theorem (1.2)– (1.3). Later it was realized that a uniform estimate of the form yields (combined with a slightly better zero-free region than the classical one of de la Vall´ee Poussin) In particular, the best possible estimate A = 2 would almost imply Landau’s conjecture. This is especially remarkable in light of the fact that even assuming the Riemann Hypothesis the best estimate we know is (with C = 2 easily by the Riemann–Von Mangoldt explicit formula, with C = 1 by a deeper argument of Cram´er [Cra1921]). This explains the significance of the Density Hypothesis (DH) which states or, in a slightly weaker form, using the notation (1.2), The Riemann Hypothesis clearly implies the Density Hypothesis. However, Ingham [Ing1937] showed that also the Lindel¨of Hypothesis (LH) (1.10) implies DH. In 1954 Tur´an [Tur1954] used his celebrated power-sum method [Tur1953], [Tur1984] to give a different proof of Ingham’s result that LH implies DH. In the same work he came very close to breaking the DH in the vicinity of the boundary line σ = 1. In the following we will use the notation: His result was with a small constant c1 [Tur1954] or with our new notation It was 16 years later when G. Hal´asz and Tur´an succeeded to break the DH [HT1969], that is, to prove (in the refined form appearing as Theorem 38.2 of Tur´an’s book [Tur1984]) with the notation (1.1)–(1.2), (1.11) The proof was based on (i) Vinogradov’s estimate µ(1 − η) ≪ η 3/2, (ii) Tur´an’s power-sum method; (iii) a simple but ingenious idea of Hal´asz [Hal1968]. Soon after this Bombieri [Bom1971] gave a different proof using ideas from the large sieve coupled with (i) and (iii). Further, Montgomery has shown the DH for σ ≥ 9/10, i.e. η ≤ 1/10 ([Mon1969], [Mon1971]). Using another simple but ingenious idea Huxley [Hux1972] (with a refinement of Montgomery) reached the DH for η ≤ 1/6 and proved that The DH was shown for larger and larger ranges, until improving the result σ > 11/14 of Jutila [Jut1977] Bourgain proved its validity [Bou2000] for Another direction of the research was to give strong density estimates for small values of η (often especially for η → 0). In this direction the most important results were reached (in alphabetical order) by Bourgain, Ford, Heath-Brown, Huxley, Ivic, Jutila and Montgomery. All these results use the large sieve and in some form the mentioned idea of Hal´asz, which needs η ≤ 1/4. This is also the reason that they cannot give improvements of the classical zero-density theorem of Ingham [Ing1940], A(σ) ≤ 3/(2 − σ), which is still the best today in the whole range Recently I gave two alternative variants for proving the DH for small values of η. In [Pin2022] the goal was to reach a possibly simple proof while in [Pin2023] to show the strongest possible result both in specific ranges of η < 1/12 and for η → 0. Both proofs were based on Vinogradov’s method and Hal´asz’s idea. However, in the second [Pin2023] it was important to use recent deep results of Heath-Brown [Hea2017], further of Bourgain, Demeter and Guth [BGD2016]. This paper is available on arxiv under CC 4.0 license. Authors: (1) J´anos Pintz, Supported by the National Research Development and Innovation Office, NKFIH, KKP 133819, ELKH Alfr´ed R´enyi Mathematical Institute H-1053 Budapest Realtanoda u. 13–15. Hungary and e-mail: pintz@renyi.hu This paper is available on arxiv under CC 4.0 license. Authors: Authors: (1) J´anos Pintz, Supported by the National Research Development and Innovation Office, NKFIH, KKP 133819, ELKH Alfr´ed R´enyi Mathematical Institute H-1053 Budapest Realtanoda u. 13–15. Hungary and e-mail: pintz@renyi.hu Table of Links 1 2 3 Proof of Theorem 1 References 1 1 2 2 3 Proof of Theorem 1 3 Proof of Theorem 1 References References Keywords and phrases: Riemann’s zeta function, density hypothesis, density theorems. Keywords and phrases: 2020 Mathematics Subject Classification: Primary 11M26, Secondary 11M06. 1 The plausibility of the Riemann Hypothesis (RH) is supported (among others) by results of type (1.1) valid for all σ > 1/2 as T → ∞. (1.1) was first shown by Bohr and Landau in 1914 ([BL1914]). The first estimate of type was shown few years later by Carlson [Car1920] with It was Hoheisel [Hoh1930] who first observed that such estimates lead to arithmetic consequences about the difference of consecutive primes. He proved the first approximation towards the famous conjecture that there exists always a prime between two consecutive squares. This conjecture was characterised by Landau [Lan1913] in his plenary talk at ICM1912 in Cambridge as one of the four main problems of the distribution of primes, besides the Riemann Hypothesis. Hoheisel [Hoh1930] could show (pn denotes the nth prime) In the proof important role was played by Carlson’s density theorem (1.2)– (1.3). Later it was realized that a uniform estimate of the form yields (combined with a slightly better zero-free region than the classical one of de la Vall´ee Poussin) In particular, the best possible estimate A = 2 would almost imply Landau’s conjecture. This is especially remarkable in light of the fact that even assuming the Riemann Hypothesis the best estimate we know is (with C = 2 easily by the Riemann–Von Mangoldt explicit formula, with C = 1 by a deeper argument of Cram´er [Cra1921]). This explains the significance of the Density Hypothesis (DH) which states or, in a slightly weaker form, using the notation (1.2), The Riemann Hypothesis clearly implies the Density Hypothesis. However, Ingham [Ing1937] showed that also the Lindel¨of Hypothesis (LH) (1.10) implies DH. In 1954 Tur´an [Tur1954] used his celebrated power-sum method [Tur1953], [Tur1984] to give a different proof of Ingham’s result that LH implies DH. In the same work he came very close to breaking the DH in the vicinity of the boundary line σ = 1. In the following we will use the notation: His result was with a small constant c1 [Tur1954] or with our new notation It was 16 years later when G. Hal´asz and Tur´an succeeded to break the DH [HT1969], that is, to prove (in the refined form appearing as Theorem 38.2 of Tur´an’s book [Tur1984]) with the notation (1.1)–(1.2), (1.11) The proof was based on (i) Vinogradov’s estimate µ(1 − η) ≪ η 3/2, (ii) Tur´an’s power-sum method; (iii) a simple but ingenious idea of Hal´asz [Hal1968]. Soon after this Bombieri [Bom1971] gave a different proof using ideas from the large sieve coupled with (i) and (iii). Further, Montgomery has shown the DH for σ ≥ 9/10, i.e. η ≤ 1/10 ([Mon1969], [Mon1971]). Using another simple but ingenious idea Huxley [Hux1972] (with a refinement of Montgomery) reached the DH for η ≤ 1/6 and proved that The DH was shown for larger and larger ranges, until improving the result σ > 11/14 of Jutila [Jut1977] Bourgain proved its validity [Bou2000] for Another direction of the research was to give strong density estimates for small values of η (often especially for η → 0). In this direction the most important results were reached (in alphabetical order) by Bourgain, Ford, Heath-Brown, Huxley, Ivic, Jutila and Montgomery. All these results use the large sieve and in some form the mentioned idea of Hal´asz, which needs η ≤ 1/4. This is also the reason that they cannot give improvements of the classical zero-density theorem of Ingham [Ing1940], A(σ) ≤ 3/(2 − σ), which is still the best today in the whole range Recently I gave two alternative variants for proving the DH for small values of η. In [Pin2022] the goal was to reach a possibly simple proof while in [Pin2023] to show the strongest possible result both in specific ranges of η < 1/12 and for η → 0. Both proofs were based on Vinogradov’s method and Hal´asz’s idea. However, in the second [Pin2023] it was important to use recent deep results of Heath-Brown [Hea2017], further of Bourgain, Demeter and Guth [BGD2016].

A Remark on Density Theorems for Riemann’s Zeta-function: 1

Stories, News & Mentions about APPJAR

Appjar’s Stories on HackerNoon