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

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

Scientific American Supplement, No. 365, December 30, 1882 by Various, is part of the HackerNoon Books Series. You can jump to any chapter in this book . APPARATUS FOR MEASURING ELECTRICITY AT THE UPPER SCHOOL OF TELEGRAPHY. here APPARATUS FOR MEASURING ELECTRICITY AT THE UPPER SCHOOL OF TELEGRAPHY. —On a former occasion I described an instrument to which, in 1873, I gave the name , and which is nothing else than a tuning fork whose motion is kept up electrically in such a way as to last indefinitely, provided that the elements of the pile are renewed gradually, and that from time to time the metallic contact is changed, which causes, at every oscillation, the current to pass from the pile into the magnet, which keeps up the vibration. Electro Tuning Forks and their Uses. Electro-Tuning Fork We reproduce herewith, in Fig. 1, a cut showing in projection one of the simplest forms of the apparatus. If we imagine the platinum or steel style, , of the figure to be done away with, as well as the platinized plate, I, and its communication with the negative pole of the pile, P, we shall have the ordinary instrument kept in operation electrically by the aid of the electro-magnet, E, the style, , the interrupting plate, I, and the pile. s s If we preserve the parts above mentioned, the instrument will possess the property of having vibrations of a constant amplitude if sufficient energy be kept up in the pile. In fact, when the amplitude is sufficiently great to cause the style, , to touch the plate, I, it will be seen that at such a moment the current no longer passes through the electromagnet, and the vibration is no longer maintained. The amplitude cannot exceed an extent which shall permit the style, , to touch I. s s Under such conditions, the duration of the vibrations remains exactly constant, as does also the vibratory intensity of the entire instrument. The measurement of time, then, by an instrument of this kind is, indeed, as perfect as it could well be. This complication in the arrangement of the apparatus has no importance as regards those tuning forks the number of whose vibrations exceeds a hundred per second, for in such a case these are given an amplitude of a few millimeters only; but it would be of importance with regard to instruments whose number of vibrations is very small, and to which it might be desirable to give great amplitude; for then, as I have long ago shown, the duration of the oscillation would depend a little on the amplitude, but a very little, it is true. I shall not refer now to the applications of these instruments in chronography, but will rather point out first the applications in which they are destined to produce an effective power. For this purpose it is necessary to make them pretty massive. The number of the vibrations depends upon such massiveness, and it is necessity to know the relation which exists between these two quantities in order to be able to construct an instrument under determinate conditions. I made in former years such a research with regard to tuning forks of prismatic form, that is to say, of a constant rectangular section continuing even into the bent portion where the parallel branches are united by a semicylinder, at the middle of which is the wrought iron rod as well as the branches. The of the instrument is the dimension parallel to the vibrations; its is the dimension which is perpendicular to them, and its is reckoned from the extremity of the branches up to the middle of the curved portion. thickness width length It is found that the number of vibrations is independent of the width, proportional to the thickness, and very nearly inverse ratio of the square of the length, provided the latter exceeds ten centimeters. If we represent the length by , the thickness by , and the number of vibrations by , we shall have the following formula: l e n = × ( / 2) n k e l in which is a constant quantity whose value depends upon the nature of the metal of which the tuning fork is made. k This constant varies very little from steel to malleable cast iron, and it may be taken as equal to 818270. Thus, then, we have a means of constructing a tuning fork in which two of the three quantities, , , , are given in advance. Experience proves that no errors are committed exceeding one or two per cent. n e l It is seen from this that there is a means of increasing the mass of the instrument without changing anything in the thickness, the length or, consequently, the number of vibrations, and this is by increasing the . breadth It is in this way that I have succeeded in having long massive tuning forks made of malleable iron, giving no more than 12 to 15 vibrations per second, and vibrating with perfect regularity. Fig. 2, annexed, shows one of these instruments of about 55 centimeters length, whose breadth, E, is from 5 to 6 centimeters, and which makes about fifteen double vibrations per second only. This number might be still further reduced, but at the expense of our being led to exaggerate the longitudinal dimensions of the apparatus in such a way as to make it inconvenient. The object may be attained more simply by loading the branches with slides supporting leaden weights, M, of 500 grammes each. By fixing these slides at different points on the branches, the number of vibrations can be made to vary from simple to double, and even triple. Thus, by fixing them at the extremity of the branches the number of the vibrations is reduced to 5 or 6. There will be seen in the figure the electro-magnet which keeps up the vibration. This is formed of three simple electro-magnets, whose bobbins have a resistance of no more than 10 ohms, and which are united in series. The interrupting plate, P, against which the style, , rests at each vibration, is capable of a forward movement, or one of recoil, by the aid of a screw, V, and of an eccentric movement which is produced by a small handle, , and during which its plane remains invariable. This arrangement permits the point of contact of the style and plate to be varied without changing the precision with which the contact takes place, and all the points of the plate to be slowly used in succession before replacing it. The motion is produced by means of a relatively weak pile, whose poles are connected to the terminals, A and A'. Three Callaud elements of triple surface, renewed one after the other every month at the most, are sufficient to keep up the vibrations continuously, day and night, without interruption, and that too even when the instrument is employed in producing a small mechanical power, as we shall see further on. s m We have now seen how electro-tuning forks may be constructed of large dimensions, of large mass, and giving a small number of vibrations per second. Such instruments are well fitted to perform the role of electrical interrupters, and it was in such a character that one of them figured in the Exhibition of the Upper School of Telegraphy as a type of an interrupter for testing piles. When it is desired to test a pile to ascertain the practicability of employing it in telegraphy, it is necessary to make it perform a work which shall be as nearly as possible identical with that which it will be called on to do, until it is used up, to estimate the duration of such work, to measure regularly the constants of the pile, the electro-motive power, and the internal resistance. Usually, in telegraphy, this work consists in sending over a line of a certain resistance intermittent currents, through the intermedium of suitable manipulators. It suffices then to cause the branches of the electro tuning fork to play the role of one of these manipulators. For doing this the tuning fork carries two insulating ebonite or ivory strips, B B (Fig. 3), which, at every oscillation, abut against vertical brass springs, . Each of these latter is located in front of the platinized point of a screw, , which is affixed to a small metallic tongue. The springs and tongues are insulated from each other, and are mounted on a piece which may be moved by a screw, V, so as to cause the springs of the strips, B B', to approach or recede according to the amplitude of the instrument's vibrations. Each spring and tongue is connected with terminals affixed to the base of the apparatus. One of the poles of one element, P, of the pile is connected with the tongue and corresponding screw, while the other pole is connected with the screw in front of it through the intermedium of a galvanometer, 2, which gives the intensity of the intermittent current, and of a resistance coil, 2, which performs the role of an artificial telegraph line. The apparatus being set in operation, it will be seen that the current from the pile is emitted once at every vibration. r v g b Thus there may be exhausted as many pile elements as there are springs, and that, too, simultaneously; and the contacts of the screws and springs can be regulated in such a way that the duration of the emissions shall be the same for all. At the laboratory of the School of Telegraphy one of these instruments has operated without interruption, day and night, during eighteen months. The apparatus shown in Fig. 4 is also an interrupting electro-tuning fork, but it makes a much greater number of vibrations than the preceding, and may serve for other electric tests. The operation of the tuning fork is kept up electrically by the aid of the screw, , and the corresponding plate; of the style, , and of the fine wire spiral spring, , both insulated from the fork, from the electro-magnet, N, and from the two wires, F F', which communicate with a pile. v s f The interrupting system is symmetrical with the first. It consists of the style, , of the spiral spring, , of the screw, , and of the plate that this carries at its extremity. The terminal, B, which carries the spring, , and the rod which carries the screw being insulated from each other, it is only necessary to cause to terminate therein the extremities of a circuit comprising one pile, in order to produce in the circuit a number of interruptions equal to that of the tuning fork's vibrations. Provided the lengths of the springs, and , are proper, such vibrations will not be altered. s f v f f f' Moreover, the instrument is so arranged as to produce vibrations whose during the whole time the experiments last. This is done by modifying the of the vibrations; for the greater the amplitude, the longer likewise the duration of the contact of the style, , on the corresponding plate, and the shorter the duration of the interruption. In order to modify the amplitude, the action of the electro-magnet on the branches of the apparatus is made to vary. To effect this, the electro-magnet is made movable perpendicularly by the aid of a screw, V, between two slides, so that the core, N, may be moved with respect to the median line of the branches, and even be raised above them. Its action diminishes, necessarily, while it is being raised, and the amplitude of the vibrations likewise diminishes gradually and continuously. It may thus be made, without difficulty, to vary from two to three tenths of a millimeter to three or four millimeters or more. duration can be varied at pleasure and kept constant amplitude s But it is not sufficient to cause the amplitude to vary; it is necessary to measure it and to keep it constant at the value desired. The measurement is effected by the aid of a very simple apparatus that I have before described under the name of the . This is a small square of paper carrving a design like that shown in Fig. 5, and which is seen in Fig. 4 glued to one of the masses, M, which serve to vary the number of the instrument's vibrations. This figure is in fact, an angle, one of whose sides is graduated into millimeters, for example, and the other forms the edge of a wide black band. The apex of the angle is above and the divided side is perpendicular to the direction of the vibrations. vibrating micrometer Under such conditions, when the fork is vibrating, the apex of the angle, by virtue of the persistence of impressions upon the retina, to advance along the graduation in measure as the amplitude of the vibrations increases. If an angle has been drawn such that the slope of one of its sides to the other is one-tenth, it is easy to see that for each millimeter passed over by the apex of the angle, the amplitude will increase by two-tenths of a millimeter. seems apparently This is the way, then, that the amplitude is measured. On another hand, it suffices to keep the apex of the angle of the micrometer immovable, in order to be sure of the constancy of the tuning fork's amplitude; and this is done, when necessary, by causing the screw, V, to move slightly. The instrument represented in Fig. 4 is, moreover, fixed to a support devised by Mr. A. Duboscq, so as to make it possible to give the tuning fork every position possible with respect to a vertical plane; to raise it or lower it, and to move it backward or forward so that it may be employed for chimography, and in all those experiments in which electro-tuning folks are used. E. MERCADIER. 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 (2006). Scientific American Supplement, No. 365, December 30, 1882. Urbana, Illinois: Project Gutenberg. Retrieved https://www.gutenberg.org/cache/epub/18763/pg18763-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 MEASURING ELECTRICITY AT THE UPPER SCHOOL OF TELEGRAPHY

Your small business faces various challenges and threats. However, the most significant threat it faces is identity theft, which is one of the most under-recognized threats. When a threat actor steals an individual’s information that validates them as themselves and not some fake personality, it is referred to as identity theft. Let’s examine identity theft and why it is disastrous for your small business. What is Identity Theft? Identity theft is defined as a type of crime where a threat actor procures personal information and uses that information to deploy malicious attacks. The stolen data may include: 👉 Personal Information of your clients, customers, and employees. It includes name, address, date of birth, Social Security number, and government-issued identification numbers. 👉 Financial Information of your customers, clients, and employees: It includes credit card details, bank account numbers, or other financial account information. 👉 Online Credentials such as usernames, passwords, and security questions used to access online accounts. Cybercriminals may use this information in various ways; here are a few of the scariest. 📌 Open new accounts: Cybercriminals can open new accounts using stolen identities, such as your employee, client, or customer. They can also apply for credit cards, loans, or other financial services. 📌 Make fraudulent purchases: They can also make fraudulent purchases in the name of stolen credentials. Unauthorized transactions are also part of financial crimes. 📌 Obtain government benefits: With this stolen data, cybercriminals can apply for all government benefits and leave your clients, customers, and employees high and dry. Cybercriminals commit other crimes, such as filing false tax returns or engaging in illegal activities under the victim's identity. Impact of Identity Theft on Your Small Business There are various ways identity theft can affect your small business; here are a few of them. 📍Financial losses: Unauthorized transactions, fraudulent loans, or stolen funds can lead to significant financial losses. 📍Reputational damage: Business reputation and customer trust can be severely undermined if confidential information is compromised. 📍Operational disruption: Dealing with identity theft can be time-consuming and divert attention away from core business activities. 📍Damaged credit: When your business’ credit is compromised, it affects your ability to secure loans or favorable terms with vendors. The Scope of the Threat Over the years, small businesses have become a favorite target of cybercriminals. Reason: They have loads of data, including 📌 Customer information 📌 Employee records 📌 Financial details 📌 Proprietary data This data is lucrative for threat actors seeking access to personal information for malicious purposes. Common Attack Tactics To Steal Your Identity Threat actors use numerous tactics to steal your identity, the most prominent ones being the most common ones we keep warning you about. Yes, you read that right. Phishing Emails Phishing is one of the most common techniques for stealing information. It involves sending deceptive emails or messages to trick your employees into divulging sensitive information. The emails and messages appear to be from reputable sources and often have a certain urgency about them. In simple words, they have Malware and Ransomware Malware implies malicious software. It infiltrates your network or systems and wreaks significant damage to your systems. Ransomware is a type of malware where the threat actors encrypt your data and ask for ransom for the decryption key to release your data. Threat actors can deploy malware/ransomware in your network in various ways. Some common ways include – infected email attachments, compromised websites, or vulnerable software. Once in your systems/networks, they can 🎯 Steal your sensitive information about your clients, customers, or even business data. 🎯 Disrupt operations by running malicious code in the background that can slow your network connection. 🎯 Extort ransom to release your data and can threaten to sell the data on the dark web. Social Engineering Attacks It is one of the most common tactics used by cybercriminals to manipulate individuals into revealing sensitive and confidential information. It can also manipulate them to take specific actions that compromise security. Social engineering attacks rely on human psychology more than technical vulnerabilities in your business. Fake Websites As a small business owner, you must be careful about fake websites that appear legitimate. These websites are meant to steal your sensitive data and your clients' and customers' personally identifiable information. The moment you enter your personal details, they are captured and stolen to be used fraudulently. Data Breaches Breaches are the most common way to obtain personal information or credentials that can be manipulated for malicious purposes. It is essential to be mindful of data breaches and have an incident response plan to avoid any mishaps. How to Mitigate Identity Theft Threats You can mitigate identity theft threats by deploying these proactive security measures. ✅ Train your employees: Educating your employees on best cybersecurity practices. This training must also include how to recognize phishing attempts and how your employees can safeguard sensitive information. ✅ Handle your data securely by encrypting it: Use encryption for both data at rest and in transition. Data handling must be a mandate even while making payments, so use secure payment gateways. Practice the principle of Least privilege and restrict the access to confidential information to authorized people. ✅ Continuous and regular monitoring: Continuous monitoring helps identify suspicious activities around the network. Regular monitoring of your system and network can help you and your team quickly catch any anomalies. ✅ Incident response plan: Having an incident response plan also helps you quickly and efficiently respond to breaches. Final Words Identity theft can have serious consequences for your business, including financial losses and reputational damages. It can also cause emotional distress along with damage to your credit scores. Stay vigilant and practice mindfulness to avoid identity theft. Your small business faces various challenges and threats. However, the most significant threat it faces is identity theft, which is one of the most under-recognized threats. When a threat actor steals an individual’s information that validates them as themselves and not some fake personality, it is referred to as identity theft. Let’s examine identity theft and why it is disastrous for your small business. What is Identity Theft? Identity theft is defined as a type of crime where a threat actor procures personal information and uses that information to deploy malicious attacks. The stolen data may include: 👉 Personal Information of your clients, customers, and employees. It includes name, address, date of birth, Social Security number, and government-issued identification numbers. 👉 Financial Information of your customers, clients, and employees: It includes credit card details, bank account numbers, or other financial account information. 👉 Online Credentials such as usernames, passwords, and security questions used to access online accounts. Cybercriminals may use this information in various ways; here are a few of the scariest. 📌 Open new accounts: Cybercriminals can open new accounts using stolen identities, such as your employee, client, or customer. They can also apply for credit cards, loans, or other financial services. 📌 Make fraudulent purchases: They can also make fraudulent purchases in the name of stolen credentials. Unauthorized transactions are also part of financial crimes. 📌 Obtain government benefits: With this stolen data, cybercriminals can apply for all government benefits and leave your clients, customers, and employees high and dry. Cybercriminals commit other crimes, such as filing false tax returns or engaging in illegal activities under the victim's identity. Impact of Identity Theft on Your Small Business There are various ways identity theft can affect your small business; here are a few of them. 📍Financial losses: Unauthorized transactions, fraudulent loans, or stolen funds can lead to significant financial losses. 📍Reputational damage: Business reputation and customer trust can be severely undermined if confidential information is compromised. 📍Operational disruption: Dealing with identity theft can be time-consuming and divert attention away from core business activities. 📍Damaged credit: When your business’ credit is compromised, it affects your ability to secure loans or favorable terms with vendors. The Scope of the Threat Over the years, small businesses have become a favorite target of cybercriminals. Reason: They have loads of data, including 📌 Customer information 📌 Employee records 📌 Financial details 📌 Proprietary data This data is lucrative for threat actors seeking access to personal information for malicious purposes. Common Attack Tactics To Steal Your Identity Threat actors use numerous tactics to steal your identity, the most prominent ones being the most common ones we keep warning you about. Yes, you read that right. Phishing Emails Phishing is one of the most common techniques for stealing information. It involves sending deceptive emails or messages to trick your employees into divulging sensitive information. The emails and messages appear to be from reputable sources and often have a certain urgency about them. In simple words, they have Malware and Ransomware Malware implies malicious software. It infiltrates your network or systems and wreaks significant damage to your systems. Ransomware is a type of malware where the threat actors encrypt your data and ask for ransom for the decryption key to release your data. Threat actors can deploy malware/ransomware in your network in various ways. Some common ways include – infected email attachments, compromised websites, or vulnerable software. Once in your systems/networks, they can 🎯 Steal your sensitive information about your clients, customers, or even business data. 🎯 Disrupt operations by running malicious code in the background that can slow your network connection. 🎯 Extort ransom to release your data and can threaten to sell the data on the dark web. Social Engineering Attacks It is one of the most common tactics used by cybercriminals to manipulate individuals into revealing sensitive and confidential information. It can also manipulate them to take specific actions that compromise security. Social engineering attacks rely on human psychology more than technical vulnerabilities in your business. Fake Websites As a small business owner, you must be careful about fake websites that appear legitimate. These websites are meant to steal your sensitive data and your clients' and customers' personally identifiable information. The moment you enter your personal details, they are captured and stolen to be used fraudulently. Data Breaches Breaches are the most common way to obtain personal information or credentials that can be manipulated for malicious purposes. It is essential to be mindful of data breaches and have an incident response plan to avoid any mishaps. How to Mitigate Identity Theft Threats You can mitigate identity theft threats by deploying these proactive security measures. ✅ Train your employees: Educating your employees on best cybersecurity practices. This training must also include how to recognize phishing attempts and how your employees can safeguard sensitive information. ✅ Handle your data securely by encrypting it: Use encryption for both data at rest and in transition. Data handling must be a mandate even while making payments, so use secure payment gateways. Practice the principle of Least privilege and restrict the access to confidential information to authorized people. ✅ Continuous and regular monitoring: Continuous monitoring helps identify suspicious activities around the network. Regular monitoring of your system and network can help you and your team quickly catch any anomalies. ✅ Incident response plan: Having an incident response plan also helps you quickly and efficiently respond to breaches. Final Words Identity theft can have serious consequences for your business, including financial losses and reputational damages. It can also cause emotional distress along with damage to your credit scores. Stay vigilant and practice mindfulness to avoid identity theft.

Identity Theft Could Ruin Your Small Business, Stay Ahead With These Tips

APPJAR

appjar.io

-- employees

Since n.d.

COMPANY RANKING

APPJAR

EVERGREEN INDEX #1328

Representing this company? Click here to claim and customize this page!

Appjar WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

APPJAR

appjar.io

-- employees

Since n.d.

COMPANY RANKING

APPJAR

EVERGREEN INDEX #1328

RELATED COMPANIESRANK

STORIES ABOUT APPJAR

Representing this company? Click here to claim and customize this page!

Appjar WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!